From fe02d153f1195d94d659c78f5cd0177ee7012610 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Wed, 21 Oct 2026 01:03:39 +0100 Subject: [PATCH] Preserve saved schedule run-level write scope --- internal/pipeline/run_scope.go | 44 ++++++++ internal/pipeline/run_scope_test.go | 94 ++++++++++++++++ internal/pipeline/saved_schedules.go | 3 + internal/protocol/schedules.go | 2 + internal/server/runner.go | 28 +---- internal/server/schedule_scope_test.go | 123 +++++++++++++++++++++ internal/server/schedule_websocket_test.go | 11 +- internal/server/scheduler.go | 2 +- 8 files changed, 279 insertions(+), 28 deletions(-) create mode 100644 internal/pipeline/run_scope.go create mode 100644 internal/pipeline/run_scope_test.go create mode 100644 internal/server/schedule_scope_test.go diff --git a/internal/pipeline/run_scope.go b/internal/pipeline/run_scope.go new file mode 100644 index 00000000..1bb957bc --- /dev/null +++ b/internal/pipeline/run_scope.go @@ -0,0 +1,44 @@ +package pipeline + +import ( + "fmt" + "os" + "path/filepath" + "strings" +) + +// ValidateRunWritePaths validates optional exact run-relative paths against an +// already resolved server workspace. Saves and manual/scheduled admission share +// this policy; admission rechecks it in case filesystem links changed since save. +// An omitted or empty list retains the existing run-level default, not a grant +// beyond the pinned workflow's own tool permissions. +func ValidateRunWritePaths(workspace string, paths []string) error { + if len(paths) > 20 { + return fmt.Errorf("too many write paths") + } + for _, path := range paths { + if filepath.IsAbs(path) || filepath.Clean(path) != path || path == ".." || strings.HasPrefix(path, ".."+string(os.PathSeparator)) || strings.ContainsAny(path, "*?\\") { + return fmt.Errorf("optional write paths must be exact run-directory-relative paths") + } + parent := filepath.Join(workspace, path) + for { + _, err := os.Lstat(parent) + if err == nil { + break + } + if !os.IsNotExist(err) { + return err + } + next := filepath.Dir(parent) + if next == parent { + return fmt.Errorf("write path is unavailable") + } + parent = next + } + resolved, err := filepath.EvalSymlinks(parent) + if err != nil || (resolved != workspace && !strings.HasPrefix(resolved, workspace+string(os.PathSeparator))) { + return fmt.Errorf("write path must stay within the run directory") + } + } + return nil +} diff --git a/internal/pipeline/run_scope_test.go b/internal/pipeline/run_scope_test.go new file mode 100644 index 00000000..22d54d9d --- /dev/null +++ b/internal/pipeline/run_scope_test.go @@ -0,0 +1,94 @@ +package pipeline + +import ( + "context" + "os" + "path/filepath" + "slices" + "testing" + "time" +) + +func TestValidateRunWritePaths(t *testing.T) { + workspace, err := ResolveRunWorkspace(t.TempDir(), true) + if err != nil { + t.Fatal(err) + } + if err = os.Mkdir(filepath.Join(workspace, "internal"), 0700); err != nil { + t.Fatal(err) + } + if err = os.Symlink(t.TempDir(), filepath.Join(workspace, "escape")); err != nil { + t.Fatal(err) + } + if err = os.Symlink(filepath.Join(workspace, "internal"), filepath.Join(workspace, "inside")); err != nil { + t.Fatal(err) + } + for _, paths := range [][]string{nil, {}, {"."}, {"new.go", "internal/another/new.go"}, {"inside/new.go"}} { + if err = ValidateRunWritePaths(workspace, paths); err != nil { + t.Fatal("valid scope rejected", paths, err) + } + } + for _, paths := range invalidRunWritePaths(workspace) { + if err = ValidateRunWritePaths(workspace, paths); err == nil { + t.Fatal("invalid scope accepted", paths) + } + } +} + +func invalidRunWritePaths(workspace string) [][]string { + return [][]string{{""}, {".."}, {"../outside.go"}, {"internal/../outside.go"}, {"./one.go"}, {"one//two.go"}, {"*.go"}, {"file?.go"}, {`one\two.go`}, {filepath.Join(workspace, "absolute.go")}, {"escape/new.go"}, slices.Repeat([]string{"new.go"}, 21)} +} + +func TestSavedScheduleWriteScopeValidationAndIdempotency(t *testing.T) { + s, pid, spec, now := savedStoreFixture(t) + ctx := context.Background() + if err := os.Symlink(t.TempDir(), filepath.Join(spec.Workspace, "escape")); err != nil { + t.Fatal(err) + } + spec.WritePaths = []string{"internal/one.go", "README.md"} + spec.AllowTools = true + a, err := s.SaveSchedule(ctx, spec, now, "restricted-create") + if err != nil { + t.Fatal(err) + } + if !a.AllowTools || !slices.Equal(a.WritePaths, spec.WritePaths) { + t.Fatal("scope omitted on save", a) + } + for _, paths := range invalidRunWritePaths(spec.Workspace) { + bad := spec + bad.WritePaths = paths + if _, err = s.SaveSchedule(ctx, bad, now, "invalid-create"); err == nil { + t.Fatal("invalid scope created a schedule", paths) + } + bad.ID = a.ID + bad.Revision = a.Revision + if _, err = s.SaveSchedule(ctx, bad, now.Add(time.Minute)); err == nil { + t.Fatal("invalid scope edited a schedule", paths) + } + } + for _, change := range []string{"paths", "allow_tools"} { + bad := spec + if change == "paths" { + bad.WritePaths = []string{"different.go"} + } else { + bad.AllowTools = false + } + if _, err = s.SaveSchedule(ctx, bad, now, "restricted-create"); err == nil { + t.Fatal("scope missing from create payload hash", change) + } + } + other, err := Open(s.path) + if err != nil { + t.Fatal(err) + } + defer other.Close() + entries, err := other.ListSchedules(ctx, pid) + if err != nil || len(entries) != 1 || entries[0].Revision != a.Revision || entries[0].NextDue != a.NextDue || !entries[0].AllowTools || !slices.Equal(entries[0].WritePaths, spec.WritePaths) { + t.Fatal("scope changed or invalid save mutated state", entries, err) + } + // Rejected saves did not reserve their request key or consume an ID. + b, err := s.SaveSchedule(ctx, spec, now, "invalid-create") + if err != nil || b.ID != a.ID+1 { + t.Fatal(b, err) + } +} diff --git a/internal/pipeline/saved_schedules.go b/internal/pipeline/saved_schedules.go index 1ff9e129..624acb9c 100644 --- a/internal/pipeline/saved_schedules.go +++ b/internal/pipeline/saved_schedules.go @@ -212,6 +212,9 @@ func (s *Store) SaveSchedule(ctx context.Context, spec protocol.SavedSchedule, n return nil, err } spec.Workspace = workspace + if err = ValidateRunWritePaths(workspace, spec.WritePaths); err != nil { + return nil, err + } if prompt, ok := spec.Input["prompt"].(string); !ok || strings.TrimSpace(prompt) == "" { return nil, fmt.Errorf("a nonempty user prompt is required in input.prompt") } diff --git a/internal/protocol/schedules.go b/internal/protocol/schedules.go index 2640f42b..3f87fa1b 100644 --- a/internal/protocol/schedules.go +++ b/internal/protocol/schedules.go @@ -20,6 +20,8 @@ type SavedSchedule struct { Enabled bool `json:"enabled"` Input map[string]any `json:"input"` Workspace string `json:"workspace"` + WritePaths []string `json:"write_paths,omitempty"` + AllowTools bool `json:"allow_tools,omitempty"` Model string `json:"model,omitempty"` StageModels map[string]string `json:"stage_models,omitempty"` NotifyMode string `json:"notify_mode,omitempty"` diff --git a/internal/server/runner.go b/internal/server/runner.go index e42bd8b8..0aa69732 100644 --- a/internal/server/runner.go +++ b/internal/server/runner.go @@ -152,32 +152,8 @@ func (r *runner) startWithSchedule(request protocol.Message, origin *pipeline.Sc if err != nil { return nil, err } - if len(request.WritePaths) > 20 { - return nil, fmt.Errorf("too many write paths") - } - for _, path := range request.WritePaths { - if filepath.IsAbs(path) || filepath.Clean(path) != path || path == ".." || strings.HasPrefix(path, ".."+string(os.PathSeparator)) || strings.ContainsAny(path, "*?\\") { - return nil, fmt.Errorf("optional write paths must be exact run-directory-relative paths") - } - parent := filepath.Join(workspace, path) - for { - _, err := os.Lstat(parent) - if err == nil { - break - } - if !os.IsNotExist(err) { - return nil, err - } - next := filepath.Dir(parent) - if next == parent { - return nil, fmt.Errorf("write path is unavailable") - } - parent = next - } - resolved, err := filepath.EvalSymlinks(parent) - if err != nil || (resolved != workspace && !strings.HasPrefix(resolved, workspace+string(os.PathSeparator))) { - return nil, fmt.Errorf("write path must stay within the run directory") - } + if err = pipeline.ValidateRunWritePaths(workspace, request.WritePaths); err != nil { + return nil, err } request.Input = maps.Clone(request.Input) if request.Input == nil { diff --git a/internal/server/schedule_scope_test.go b/internal/server/schedule_scope_test.go new file mode 100644 index 00000000..fb53033e --- /dev/null +++ b/internal/server/schedule_scope_test.go @@ -0,0 +1,123 @@ +package server + +import ( + "context" + "os" + "path/filepath" + "slices" + "strings" + "testing" + "time" + + "git.a-wan.net/alan/pipelines/internal/pipeline" + "git.a-wan.net/alan/pipelines/internal/protocol" + "git.a-wan.net/alan/pipelines/internal/stage" + "git.a-wan.net/alan/pipelines/internal/summarise" +) + +func TestScheduledRunPreservesWriteScopeAndWorkflowPermissions(t *testing.T) { + for _, test := range []struct { + name string + allowTools bool + declaredTools string + }{ + {"restricted coding", true, "edit"}, + {"no tools", false, ""}, + {"run flag does not grant undeclared tools", true, ""}, + {"workflow tools remain authoritative", false, "edit"}, + } { + t.Run(test.name, func(t *testing.T) { + ctx, s, r, pid := scheduleFixture(t) + version := 1 + if test.declaredTools != "" { + source := strings.Replace(pipeline.Template([]string{"one"}, true), "```tools\n```", "```tools\n"+test.declaredTools+"\n```", 1) + var err error + version, err = s.Submit(ctx, "research", source) + if err != nil { + t.Fatal(err) + } + } + spec := protocol.SavedSchedule{Name: "restricted run", PipelineID: pid, Version: version, Enabled: true, Workspace: t.TempDir(), Input: map[string]any{"prompt": "scoped coding", "pwd": "/untrusted/input/folder"}, WritePaths: []string{"internal/one.go", "README.md"}, AllowTools: test.allowTools, Rule: protocol.Schedule{Every: "1m"}, NotifyMode: "off", Title: "Scoped task"} + entry, err := s.SaveSchedule(ctx, spec, time.Now()) + if err != nil { + t.Fatal(err) + } + entries, err := s.ListSchedules(ctx, pid) + if err != nil || len(entries) != 1 || entries[0].AllowTools != test.allowTools || !slices.Equal(entries[0].WritePaths, spec.WritePaths) { + t.Fatal("saved scope roundtrip", entries, err) + } + calls := 0 + r.execute = func(_ context.Context, def stage.Definition, input stage.Values) (stage.Result, error) { + calls++ + if input["pwd"] != entry.Workspace { + t.Error("saved input.pwd overrode server workspace", input["pwd"]) + } + tools, explicit, err := stage.ToolNames(def) + if err != nil || !explicit || strings.Join(tools, ",") != test.declaredTools { + t.Error("run flag widened stage permissions", tools, explicit, err) + } + // Scope is runtime policy, not prompt input: verify the committed run + // request at the fake executor boundary, before any native/model work. + runs, err := s.ListRuns(ctx) + if err != nil || len(runs) != 1 { + t.Error(runs, err) + return stage.Result{}, nil + } + detail, err := s.GetRun(ctx, runs[0].ID) + expectedTools := test.allowTools || test.declaredTools != "" + if err != nil || detail.AllowTools != expectedTools || !slices.Equal(detail.WritePaths, spec.WritePaths) || detail.Workspace != entry.Workspace || detail.Input["pwd"] != entry.Workspace { + t.Error("dispatch dropped scope", detail, err) + } + return stage.Result{Outcome: "success", Output: stage.Values{"done": true}}, nil + } + if err = r.scheduleTick(dueOf(t, entry), false); err != nil { + t.Fatal(err) + } + r.wg.Wait() + runs, err := s.ListRuns(ctx) + if err != nil || len(runs) != 1 || runs[0].Status != "succeeded" || calls != 1 { + t.Fatal(runs, calls, err) + } + }) + } +} + +func TestScheduleRechecksWriteScopeBeforeTitleOrExecution(t *testing.T) { + ctx, s, r, pid := scheduleFixture(t) + workspace := t.TempDir() + if err := os.Mkdir(filepath.Join(workspace, "allowed"), 0700); err != nil { + t.Fatal(err) + } + spec := protocol.SavedSchedule{Name: "restricted", PipelineID: pid, Version: 1, Enabled: true, Workspace: workspace, Input: map[string]any{"prompt": "task"}, WritePaths: []string{"allowed/new.go"}, AllowTools: true, Rule: protocol.Schedule{Every: "1m"}, NotifyMode: "off"} + entry, err := s.SaveSchedule(ctx, spec, time.Now()) + if err != nil { + t.Fatal(err) + } + // A scope valid when saved can become unsafe before dispatch. + if err = os.Rename(filepath.Join(workspace, "allowed"), filepath.Join(workspace, "original")); err != nil { + t.Fatal(err) + } + if err = os.Symlink(t.TempDir(), filepath.Join(workspace, "allowed")); err != nil { + t.Fatal(err) + } + r.title = func(context.Context, string) summarise.Title { + t.Error("invalid scope reached title model") + return summarise.Title{} + } + r.execute = func(context.Context, stage.Definition, stage.Values) (stage.Result, error) { + t.Error("invalid scope reached executor") + return stage.Result{}, nil + } + if err = r.scheduleTick(dueOf(t, entry), false); err != nil { + t.Fatal(err) + } + r.wg.Wait() + // The exact same shared policy rejects manual admission as well. + if _, err = r.start(protocol.Message{PipelineID: pid, Version: 1, Workspace: workspace, Input: spec.Input, WritePaths: spec.WritePaths, AllowTools: true, RequestKey: "manual-unsafe"}); err == nil { + t.Fatal("manual path validation diverged") + } + runs, err := s.ListRuns(ctx) + if err != nil || len(runs) != 0 { + t.Fatal("invalid scope admitted work", runs, err) + } +} diff --git a/internal/server/schedule_websocket_test.go b/internal/server/schedule_websocket_test.go index e18a3ad9..515846cf 100644 --- a/internal/server/schedule_websocket_test.go +++ b/internal/server/schedule_websocket_test.go @@ -4,6 +4,7 @@ import ( "context" "net/http/httptest" "path/filepath" + "slices" "strings" "testing" "time" @@ -55,12 +56,15 @@ func TestScheduleAPIOverWebSocket(t *testing.T) { return response } // Saving run information is not definition authoring, and works on run-only servers. - spec := protocol.SavedSchedule{Name: "first", PipelineID: items[0].ID, Version: 1, Enabled: true, Workspace: t.TempDir(), Input: map[string]any{"prompt": "first research", "arbitrary": "retained"}, Rule: protocol.Schedule{Every: "15m"}, Model: "openai/gpt", NotifyMode: "off", Title: "Research"} + spec := protocol.SavedSchedule{Name: "first", PipelineID: items[0].ID, Version: 1, Enabled: true, Workspace: t.TempDir(), Input: map[string]any{"prompt": "first research", "arbitrary": "retained"}, WritePaths: []string{"internal/one.go"}, AllowTools: true, Rule: protocol.Schedule{Every: "15m"}, Model: "openai/gpt", NotifyMode: "off", Title: "Research"} response := rpc(protocol.Message{Type: protocol.SaveSchedule, Schedule: &spec, RequestKey: "editor-first"}) if response.Type != protocol.SavedScheduleReply || response.Schedule == nil || response.Schedule.ID == 0 || response.Schedule.Revision != 1 { t.Fatal(response) } a := *response.Schedule + if !a.AllowTools || !slices.Equal(a.WritePaths, spec.WritePaths) { + t.Fatal("scope omitted from save reply", a) + } response = rpc(protocol.Message{Type: protocol.SaveSchedule, Schedule: &spec, RequestKey: "editor-first"}) if response.Schedule == nil || response.Schedule.ID != a.ID || response.Schedule.Revision != a.Revision { t.Fatal("lost reply duplicated timer", response) @@ -82,6 +86,9 @@ func TestScheduleAPIOverWebSocket(t *testing.T) { if response.Type != protocol.Schedules || len(response.Schedules) != 2 { t.Fatal(response) } + if !response.Schedules[0].AllowTools || !slices.Equal(response.Schedules[0].WritePaths, spec.WritePaths) { + t.Fatal("scope omitted from list reply", response) + } a.Enabled = false response = rpc(protocol.Message{Type: protocol.SaveSchedule, Schedule: &a}) if response.Schedule == nil || response.Schedule.Enabled || response.Schedule.Revision != 2 { @@ -121,6 +128,8 @@ func TestScheduleAPIOverWebSocket(t *testing.T) { func(s *protocol.SavedSchedule) { s.Model = "invalid" }, func(s *protocol.SavedSchedule) { s.NotifyMode = "invalid" }, func(s *protocol.SavedSchedule) { s.OutputFormat = "invalid" }, + func(s *protocol.SavedSchedule) { s.WritePaths = []string{"../outside.go"} }, + func(s *protocol.SavedSchedule) { s.WritePaths = []string{"*.go"} }, } { bad := spec mutate(&bad) diff --git a/internal/server/scheduler.go b/internal/server/scheduler.go index 99ea06e1..bdcfc14c 100644 --- a/internal/server/scheduler.go +++ b/internal/server/scheduler.go @@ -72,7 +72,7 @@ func (r *runner) scheduleTick(now time.Time, recovery bool) error { if !claimed || status != "claimed" { continue } - request := protocol.Message{PipelineID: item.PipelineID, Version: item.Version, RequestKey: fmt.Sprintf("saved-schedule:%d:%d", item.ID, due.UnixNano()), Input: item.Input, Workspace: item.Workspace, Model: item.Model, StageModels: item.StageModels, NotifyMode: item.NotifyMode, Title: item.Title, OutputFormat: item.OutputFormat} + request := protocol.Message{PipelineID: item.PipelineID, Version: item.Version, RequestKey: fmt.Sprintf("saved-schedule:%d:%d", item.ID, due.UnixNano()), Input: item.Input, Workspace: item.Workspace, WritePaths: item.WritePaths, AllowTools: item.AllowTools, Model: item.Model, StageModels: item.StageModels, NotifyMode: item.NotifyMode, Title: item.Title, OutputFormat: item.OutputFormat} run, err := r.startWithSchedule(request, &pipeline.ScheduleAdmission{ID: item.ID, Revision: item.Revision, Due: due, Name: item.Name}) diagnostic := "" status = "started"