diff --git a/cmd/archied/bootstrap.go b/cmd/archied/bootstrap.go index e270a6ae3..f7f67ecb4 100644 --- a/cmd/archied/bootstrap.go +++ b/cmd/archied/bootstrap.go @@ -485,6 +485,11 @@ func (b *boot) setupLLMAndChat(ctx context.Context) { tasks: b.st.TaskByID, taskLogs: b.taskLogs, }, + ChatTaskActor: chatTaskActorAdapter{ + tasks: b.st.TaskByID, + handler: b.web.Handler(), + token: func() string { return b.web.Token }, + }, DefaultChatIdentity: b.defaultChatIdentity, SessionStore: b.chatSessionStore, Bus: b.bus, Log: log, } @@ -517,6 +522,11 @@ func (b *boot) setupGateways(ctx context.Context, cfgPath, overlayPath string) b tasks: b.st.TaskByID, taskLogs: b.taskLogs, }, + ChatTaskActor: chatTaskActorAdapter{ + tasks: b.st.TaskByID, + handler: b.web.Handler(), + token: func() string { return b.web.Token }, + }, DefaultChatIdentity: b.defaultChatIdentity, SessionStore: b.chatSessionStore, Updates: b.updateService, Bus: b.bus, RegisterRestart: func(request func() error) { b.restartTelegram = request }, Log: log, diff --git a/cmd/archied/main.go b/cmd/archied/main.go index f4aa1b584..d069afd7e 100644 --- a/cmd/archied/main.go +++ b/cmd/archied/main.go @@ -5,6 +5,7 @@ package main import ( + "bytes" "context" "crypto/sha256" "encoding/json" @@ -13,6 +14,8 @@ import ( "log/slog" "maps" "net" + "net/http" + "net/http/httptest" "os" "os/signal" "path/filepath" @@ -43,6 +46,7 @@ import ( "github.com/samcharles93/archie-core/internal/storage" "github.com/samcharles93/archie-core/internal/store" "github.com/samcharles93/archie-core/internal/storerpc" + "github.com/samcharles93/archie-core/internal/taskstate" "github.com/samcharles93/archie-core/internal/tools" "github.com/samcharles93/archie-core/internal/tools/mcp" toolprovider "github.com/samcharles93/archie-core/internal/tools/provider" @@ -597,6 +601,73 @@ func (a chatTaskLogReaderAdapter) ReadChatTaskLogs( }, nil } +// chatTaskActorAdapter executes operator actions on a task via the same +// action path the dashboard uses, ensuring chat and webui cannot diverge. +// It enforces identity scoping so an identity cannot mutate another +// identity's tasks. +type chatTaskActorAdapter struct { + tasks func(context.Context, int64) (*store.Task, error) + handler http.Handler + token func() string +} + +func (a chatTaskActorAdapter) ApplyChatTaskAction( + ctx context.Context, identity string, taskID int64, action taskstate.Action, +) (gateway.TaskActionResult, error) { + if a.tasks == nil || a.handler == nil { + return gateway.TaskActionResult{}, fmt.Errorf("task actions are not configured") + } + task, err := a.tasks(ctx, taskID) + if err != nil { + return gateway.TaskActionResult{}, err + } + if task == nil { + return gateway.TaskActionResult{}, fmt.Errorf("task %d not found", taskID) + } + // Match the filter chatTaskListerAdapter and chatTaskLogReaderAdapter apply: + // a model bound to one identity must not mutate another identity's tasks, + // and tasks with no identity (forge-sourced) are not actionable through a + // chat tool at all — they belong to the daemon, not a particular identity. + if task.Identity != identity { + return gateway.TaskActionResult{}, fmt.Errorf("task %d belongs to %q, not %q", taskID, task.Identity, identity) + } + if err := taskstate.CheckAction(task.Status, action); err != nil { + return gateway.TaskActionResult{}, err + } + + body, err := json.Marshal(map[string]any{"action": string(action)}) + if err != nil { + return gateway.TaskActionResult{}, fmt.Errorf("marshal action request: %w", err) + } + req := httptest.NewRequestWithContext(ctx, http.MethodPost, + fmt.Sprintf("/api/tasks/%d/action", taskID), + bytes.NewReader(body), + ) + req.Header.Set("Content-Type", "application/json") + req.Header.Set("X-Archie-CSRF", "1") + if a.token != nil { + if tok := a.token(); tok != "" { + req.Header.Set("Authorization", "Bearer "+tok) + } + } + rec := httptest.NewRecorder() + a.handler.ServeHTTP(rec, req) + + if rec.Code != http.StatusOK { + errMsg := strings.TrimSpace(rec.Body.String()) + if errMsg == "" { + errMsg = fmt.Sprintf("HTTP %d", rec.Code) + } + return gateway.TaskActionResult{}, fmt.Errorf("action %s on task %d failed: %s", action, taskID, errMsg) + } + + return gateway.TaskActionResult{ + TaskID: taskID, + Action: string(action), + Message: fmt.Sprintf("Applied %s to task %d.", action, taskID), + }, nil +} + func chatTaskProfiles(cfg config.Config) ([]gateway.TaskProfile, string) { if len(cfg.Identities) > 0 { profiles := make([]gateway.TaskProfile, 0, len(cfg.Identities)) diff --git a/cmd/archied/task_action_adapter_test.go b/cmd/archied/task_action_adapter_test.go new file mode 100644 index 000000000..5ad1e8488 --- /dev/null +++ b/cmd/archied/task_action_adapter_test.go @@ -0,0 +1,340 @@ +package main + +import ( + "context" + "path/filepath" + "strings" + "testing" + + "github.com/samcharles93/archie-core/internal/config" + "github.com/samcharles93/archie-core/internal/store" + "github.com/samcharles93/archie-core/internal/taskstate" + "github.com/samcharles93/archie-core/internal/webui" +) + +func TestChatTaskActorAdapterCrossIdentityRefused(t *testing.T) { + ctx := context.Background() + st, err := store.Open(ctx, filepath.Join(t.TempDir(), "tasks.db")) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = st.Close() }) + + task, err := st.EnqueueChatTask(ctx, "acme", "widget", "parked job", "", "", "identity-owner") + if err != nil { + t.Fatal(err) + } + if err := st.Transition(ctx, task.ID, store.StatusQueued, store.StatusParked, "needs help"); err != nil { + t.Fatal(err) + } + + srv := &webui.Server{Store: st, Cfg: config.NewHolder(config.Config{})} + adapter := chatTaskActorAdapter{ + tasks: st.TaskByID, + handler: srv.Handler(), + token: func() string { return srv.Token }, + } + + tests := []struct { + name string + actorIdentity string + action taskstate.Action + }{ + { + name: "different identity cannot abandon", + actorIdentity: "identity-attacker", + action: taskstate.ActionAbandon, + }, + { + name: "different identity cannot retry", + actorIdentity: "identity-attacker", + action: taskstate.ActionRetry, + }, + { + name: "different identity cannot archive", + actorIdentity: "identity-attacker", + action: taskstate.ActionArchive, + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + _, err := adapter.ApplyChatTaskAction(ctx, tc.actorIdentity, task.ID, tc.action) + if err == nil { + t.Fatalf("ApplyChatTaskAction() allowed cross-identity action %s by %q on task owned by %q", + tc.action, tc.actorIdentity, task.Identity) + } + if !strings.Contains(err.Error(), "identity-owner") || !strings.Contains(err.Error(), tc.actorIdentity) { + t.Errorf("error = %q, want mention of both identities", err.Error()) + } + + // Confirm store state was NOT mutated. + current, err := st.TaskByID(ctx, task.ID) + if err != nil || current == nil { + t.Fatalf("TaskByID = (%+v, %v)", current, err) + } + if current.Status != store.StatusParked { + t.Errorf("task status mutated to %q despite cross-identity refusal", current.Status) + } + }) + } +} + +func TestChatTaskActorAdapterRefusesDisallowedStateAction(t *testing.T) { + ctx := context.Background() + st, err := store.Open(ctx, filepath.Join(t.TempDir(), "tasks.db")) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = st.Close() }) + + srv := &webui.Server{Store: st, Cfg: config.NewHolder(config.Config{})} + adapter := chatTaskActorAdapter{ + tasks: st.TaskByID, + handler: srv.Handler(), + token: func() string { return srv.Token }, + } + + tests := []struct { + name string + initialStatus string + attemptAction taskstate.Action + }{ + { + name: "cannot abandon running task", + initialStatus: store.StatusRunning, + attemptAction: taskstate.ActionAbandon, + }, + { + name: "cannot archive parked task", + initialStatus: store.StatusParked, + attemptAction: taskstate.ActionArchive, + }, + { + name: "cannot retry queued task", + initialStatus: store.StatusQueued, + attemptAction: taskstate.ActionRetry, + }, + { + name: "cannot approve running task", + initialStatus: store.StatusRunning, + attemptAction: taskstate.ActionApprove, + }, + { + name: "cannot reject queued task", + initialStatus: store.StatusQueued, + attemptAction: taskstate.ActionReject, + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + task, err := st.EnqueueChatTask(ctx, "acme", "widget", "test task", "", "", "archie") + if err != nil { + t.Fatal(err) + } + if tc.initialStatus != store.StatusQueued { + if err := st.Transition(ctx, task.ID, store.StatusQueued, tc.initialStatus, "setup"); err != nil { + t.Fatal(err) + } + } + + _, err = adapter.ApplyChatTaskAction(ctx, "archie", task.ID, tc.attemptAction) + if err == nil { + t.Fatalf("expected error attempting %s on %s task, got nil", tc.attemptAction, tc.initialStatus) + } + + // Assert error matches taskstate rules. + wantErr := taskstate.CheckAction(tc.initialStatus, tc.attemptAction) + if wantErr != nil && !strings.Contains(err.Error(), wantErr.Error()) { + t.Errorf("error = %q, want substring %q", err.Error(), wantErr.Error()) + } + + // Ensure task status did not change. + current, err := st.TaskByID(ctx, task.ID) + if err != nil || current == nil { + t.Fatalf("TaskByID = (%+v, %v)", current, err) + } + if current.Status != tc.initialStatus { + t.Errorf("task status changed to %q, want %q", current.Status, tc.initialStatus) + } + }) + } +} + +func TestChatTaskActorAdapterTaskNotFound(t *testing.T) { + ctx := context.Background() + st, err := store.Open(ctx, filepath.Join(t.TempDir(), "tasks.db")) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = st.Close() }) + + srv := &webui.Server{Store: st, Cfg: config.NewHolder(config.Config{})} + adapter := chatTaskActorAdapter{ + tasks: st.TaskByID, + handler: srv.Handler(), + token: func() string { return srv.Token }, + } + + _, err = adapter.ApplyChatTaskAction(ctx, "archie", 999999, taskstate.ActionAbandon) + if err == nil { + t.Fatal("expected error for non-existent task, got nil") + } + if !strings.Contains(err.Error(), "not found") { + t.Errorf("error = %q, want 'not found'", err.Error()) + } +} + +func TestChatTaskActorAdapterAppliesActionsToStore(t *testing.T) { + tests := []struct { + name string + initialStatus string + action taskstate.Action + wantStatus string + wantArchived bool + }{ + { + name: "abandon parked task closes it won't do", + initialStatus: store.StatusParked, + action: taskstate.ActionAbandon, + wantStatus: store.StatusClosedWontDo, + }, + { + name: "retry parked task requeues it", + initialStatus: store.StatusParked, + action: taskstate.ActionRetry, + wantStatus: store.StatusQueued, + }, + { + name: "cancel queued task closes it", + initialStatus: store.StatusQueued, + action: taskstate.ActionCancel, + wantStatus: store.StatusClosedWontDo, + }, + { + name: "approve waiting_human task queues it", + initialStatus: store.StatusWaitingHuman, + action: taskstate.ActionApprove, + wantStatus: store.StatusQueued, + }, + { + name: "reject waiting_human task closes it", + initialStatus: store.StatusWaitingHuman, + action: taskstate.ActionReject, + wantStatus: store.StatusClosedWontDo, + }, + { + name: "archive dead task removes it from store", + initialStatus: store.StatusDead, + action: taskstate.ActionArchive, + wantArchived: true, + }, + { + name: "archive closed_wont_do task removes it from store", + initialStatus: store.StatusClosedWontDo, + action: taskstate.ActionArchive, + wantArchived: true, + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + ctx := context.Background() + st, err := store.Open(ctx, filepath.Join(t.TempDir(), "tasks.db")) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = st.Close() }) + + srv := &webui.Server{Store: st, Cfg: config.NewHolder(config.Config{MaxRetries: 3})} + adapter := chatTaskActorAdapter{ + tasks: st.TaskByID, + handler: srv.Handler(), + token: func() string { return srv.Token }, + } + + task, err := st.EnqueueChatTask(ctx, "acme", "widget", "actionable task", "", "", "archie") + if err != nil { + t.Fatal(err) + } + if tc.initialStatus != store.StatusQueued { + if err := st.Transition(ctx, task.ID, store.StatusQueued, tc.initialStatus, "setup"); err != nil { + t.Fatal(err) + } + } + + result, err := adapter.ApplyChatTaskAction(ctx, "archie", task.ID, tc.action) + if err != nil { + t.Fatalf("ApplyChatTaskAction(%s) error = %v", tc.action, err) + } + if result.TaskID != task.ID { + t.Errorf("result.TaskID = %d, want %d", result.TaskID, task.ID) + } + if result.Action != string(tc.action) { + t.Errorf("result.Action = %q, want %q", result.Action, tc.action) + } + + current, err := st.TaskByID(ctx, task.ID) + if err != nil { + t.Fatal(err) + } + if tc.wantArchived { + if current != nil { + t.Errorf("task %d still exists in store after archive: %+v", task.ID, current) + } + } else { + if current == nil { + t.Fatalf("task %d not found in store", task.ID) + } + if current.Status != tc.wantStatus { + t.Errorf("task status = %q, want %q", current.Status, tc.wantStatus) + } + } + }) + } +} + +func TestChatTaskActorAdapterWithTokenAuth(t *testing.T) { + ctx := context.Background() + st, err := store.Open(ctx, filepath.Join(t.TempDir(), "tasks.db")) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = st.Close() }) + + srv := &webui.Server{ + Store: st, + Cfg: config.NewHolder(config.Config{MaxRetries: 3}), + Token: "secret-token-12345", + } + adapter := chatTaskActorAdapter{ + tasks: st.TaskByID, + handler: srv.Handler(), + token: func() string { return srv.Token }, + } + + task, err := st.EnqueueChatTask(ctx, "acme", "widget", "auth task", "", "", "archie") + if err != nil { + t.Fatal(err) + } + if err := st.Transition(ctx, task.ID, store.StatusQueued, store.StatusParked, "park"); err != nil { + t.Fatal(err) + } + + result, err := adapter.ApplyChatTaskAction(ctx, "archie", task.ID, taskstate.ActionAbandon) + if err != nil { + t.Fatalf("ApplyChatTaskAction with token auth failed: %v", err) + } + if result.TaskID != task.ID { + t.Errorf("result.TaskID = %d, want %d", result.TaskID, task.ID) + } + + current, err := st.TaskByID(ctx, task.ID) + if err != nil || current == nil { + t.Fatalf("TaskByID = (%+v, %v)", current, err) + } + if current.Status != store.StatusClosedWontDo { + t.Errorf("status = %q, want %q", current.Status, store.StatusClosedWontDo) + } +} diff --git a/cmd/archied/telegram_setup.go b/cmd/archied/telegram_setup.go index 2567f73b2..f8e5ccef2 100644 --- a/cmd/archied/telegram_setup.go +++ b/cmd/archied/telegram_setup.go @@ -46,6 +46,7 @@ type telegramSetup struct { ChatController gateway.TaskController ChatTaskLister gateway.ChatTaskLister ChatTaskLogs gateway.ChatTaskLogReader + ChatTaskActor gateway.ChatTaskActor DefaultChatIdentity string SessionStore gateway.SessionStore Updates telegram.UpdateService @@ -301,6 +302,7 @@ func newChatTurnRunner( TaskLister: s.ChatTaskLister, Tasks: s.ChatTasks, TaskLogs: s.ChatTaskLogs, + TaskActor: s.ChatTaskActor, TaskIdentity: s.DefaultChatIdentity, Bus: s.Bus, BotUser: cfg.BotUser, diff --git a/internal/gateway/task_action_tool_test.go b/internal/gateway/task_action_tool_test.go new file mode 100644 index 000000000..416986ddf --- /dev/null +++ b/internal/gateway/task_action_tool_test.go @@ -0,0 +1,265 @@ +package gateway + +import ( + "context" + "errors" + "fmt" + "strings" + "testing" + + "github.com/samcharles93/archie-core/internal/taskstate" + "github.com/samcharles93/archie-core/internal/tools" +) + +type fakeActor struct { + result TaskActionResult + err error + + gotIdentity string + gotTaskID int64 + gotAction taskstate.Action +} + +func (f *fakeActor) ApplyChatTaskAction(_ context.Context, identity string, taskID int64, action taskstate.Action) (TaskActionResult, error) { + f.gotIdentity = identity + f.gotTaskID = taskID + f.gotAction = action + return f.result, f.err +} + +func TestTaskActionToolProperties(t *testing.T) { + actor := &fakeActor{} + entry := toolNamed(t, TaskTools(nil, nil, nil, actor, "archie"), "task_action") + + if err := entry.Validate(); err != nil { + t.Fatalf("entry.Validate() = %v", err) + } + if entry.Name != "task_action" { + t.Errorf("Name = %q, want task_action", entry.Name) + } + if entry.Toolset != "tasks" { + t.Errorf("Toolset = %q, want tasks", entry.Toolset) + } + wantClass := tools.ClassMutating | tools.RequiresApproval + if entry.Classification != wantClass { + t.Errorf("Classification = %v, want %v", entry.Classification, wantClass) + } + if entry.BuildApprovalDescription == nil { + t.Fatal("BuildApprovalDescription is nil, want a description builder for confirmation") + } +} + +func TestTaskActionOmittedWhenActorIsNil(t *testing.T) { + entries := TaskTools(&fakeLister{}, &fakeCreator{}, &fakeLogReader{}, nil, "archie") + for _, e := range entries { + if e.Name == "task_action" { + t.Fatal("task_action is present when actor is nil -- a tool that cannot run must not be advertised") + } + } +} + +func TestTaskActionAppearsWhenActorIsNonNil(t *testing.T) { + entries := TaskTools(nil, nil, nil, &fakeActor{}, "archie") + toolNamed(t, entries, "task_action") // fails if absent +} + +func TestTaskActionUsesBoundIdentity(t *testing.T) { + actor := &fakeActor{result: TaskActionResult{TaskID: 42, Action: "abandon", Message: "abandoned"}} + entry := toolNamed(t, TaskTools(nil, nil, nil, actor, "archie"), "task_action") + + _, err := entry.Handler(context.Background(), map[string]any{ + "task_id": float64(42), + "action": "abandon", + "identity": "other-identity", + }) + if err != nil { + t.Fatal(err) + } + if actor.gotIdentity != "archie" { + t.Errorf("identity = %q, want bound %q", actor.gotIdentity, "archie") + } +} + +func TestTaskActionInputValidation(t *testing.T) { + tests := []struct { + name string + input map[string]any + actor *fakeActor + wantErr bool + wantTaskID int64 + wantAction taskstate.Action + }{ + { + name: "valid float64 task_id", + input: map[string]any{"task_id": float64(10), "action": "abandon"}, + actor: &fakeActor{result: TaskActionResult{TaskID: 10, Action: "abandon"}}, + wantTaskID: 10, + wantAction: taskstate.ActionAbandon, + }, + { + name: "valid int task_id", + input: map[string]any{"task_id": 11, "action": "archive"}, + actor: &fakeActor{result: TaskActionResult{TaskID: 11, Action: "archive"}}, + wantTaskID: 11, + wantAction: taskstate.ActionArchive, + }, + { + name: "valid int64 task_id", + input: map[string]any{"task_id": int64(12), "action": "retry"}, + actor: &fakeActor{result: TaskActionResult{TaskID: 12, Action: "retry"}}, + wantTaskID: 12, + wantAction: taskstate.ActionRetry, + }, + { + name: "normalizes action casing and whitespace", + input: map[string]any{"task_id": float64(13), "action": " ABANDON "}, + actor: &fakeActor{result: TaskActionResult{TaskID: 13, Action: "abandon"}}, + wantTaskID: 13, + wantAction: taskstate.ActionAbandon, + }, + { + name: "missing task_id", + input: map[string]any{"action": "abandon"}, + actor: &fakeActor{}, + wantErr: true, + }, + { + name: "invalid task_id type", + input: map[string]any{"task_id": "not-a-number", "action": "abandon"}, + actor: &fakeActor{}, + wantErr: true, + }, + { + name: "missing action", + input: map[string]any{"task_id": float64(10)}, + actor: &fakeActor{}, + wantErr: true, + }, + { + name: "blank action", + input: map[string]any{"task_id": float64(10), "action": " "}, + actor: &fakeActor{}, + wantErr: true, + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + entry := toolNamed(t, TaskTools(nil, nil, nil, tc.actor, "archie"), "task_action") + out, err := entry.Handler(context.Background(), tc.input) + if tc.wantErr { + if err == nil { + t.Fatalf("Handler(%v) = nil error, want error", tc.input) + } + return + } + if err != nil { + t.Fatalf("Handler(%v) = %v, want nil error", tc.input, err) + } + if tc.actor.gotTaskID != tc.wantTaskID { + t.Errorf("task_id = %d, want %d", tc.actor.gotTaskID, tc.wantTaskID) + } + if tc.actor.gotAction != tc.wantAction { + t.Errorf("action = %q, want %q", tc.actor.gotAction, tc.wantAction) + } + res, ok := out.(TaskActionResult) + if !ok { + t.Fatalf("Handler output = %T, want TaskActionResult", out) + } + if res.TaskID != tc.wantTaskID { + t.Errorf("res.TaskID = %d, want %d", res.TaskID, tc.wantTaskID) + } + }) + } +} + +func TestTaskActionAllActions(t *testing.T) { + actions := []struct { + action taskstate.Action + input string + }{ + {action: taskstate.ActionAbandon, input: "abandon"}, + {action: taskstate.ActionArchive, input: "archive"}, + {action: taskstate.ActionRetry, input: "retry"}, + {action: taskstate.ActionStop, input: "stop"}, + {action: taskstate.ActionCancel, input: "cancel"}, + {action: taskstate.ActionApprove, input: "approve"}, + {action: taskstate.ActionReject, input: "reject"}, + } + + for _, tc := range actions { + t.Run(string(tc.action), func(t *testing.T) { + actor := &fakeActor{result: TaskActionResult{ + TaskID: 99, + Action: string(tc.action), + Message: fmt.Sprintf("Applied %s to task 99.", tc.action), + }} + entry := toolNamed(t, TaskTools(nil, nil, nil, actor, "archie"), "task_action") + out, err := entry.Handler(context.Background(), map[string]any{ + "task_id": float64(99), + "action": tc.input, + }) + if err != nil { + t.Fatalf("Handler(%s) error = %v", tc.input, err) + } + res, ok := out.(TaskActionResult) + if !ok { + t.Fatalf("Handler output = %T, want TaskActionResult", out) + } + if res.Action != string(tc.action) { + t.Errorf("res.Action = %q, want %q", res.Action, tc.action) + } + }) + } +} + +func TestTaskActionPropagatesActorError(t *testing.T) { + actor := &fakeActor{err: errors.New("action not available while task is running")} + entry := toolNamed(t, TaskTools(nil, nil, nil, actor, "archie"), "task_action") + + _, err := entry.Handler(context.Background(), map[string]any{ + "task_id": float64(42), + "action": "abandon", + }) + if err == nil { + t.Fatal("expected error, got nil") + } + if !strings.Contains(err.Error(), "action not available while task is running") { + t.Errorf("error = %v, want substring %q", err, "action not available while task is running") + } +} + +func TestTaskActionBuildApprovalDescription(t *testing.T) { + tests := []struct { + name string + input map[string]any + want string + }{ + { + name: "abandon parked task", + input: map[string]any{"task_id": float64(42), "action": "abandon"}, + want: "Apply action \"abandon\" to task 42.", + }, + { + name: "archive dead task", + input: map[string]any{"task_id": int64(101), "action": "archive"}, + want: "Apply action \"archive\" to task 101.", + }, + { + name: "missing fields fallback cleanly", + input: map[string]any{}, + want: "Apply action \"\" to task 0.", + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + actor := &fakeActor{} + entry := toolNamed(t, TaskTools(nil, nil, nil, actor, "archie"), "task_action") + got := entry.BuildApprovalDescription(tc.input) + if got != tc.want { + t.Errorf("BuildApprovalDescription(%v) = %q, want %q", tc.input, got, tc.want) + } + }) + } +} diff --git a/internal/gateway/task_tools.go b/internal/gateway/task_tools.go index 40144588f..8643c0cc6 100644 --- a/internal/gateway/task_tools.go +++ b/internal/gateway/task_tools.go @@ -6,6 +6,7 @@ import ( "strings" "time" + "github.com/samcharles93/archie-core/internal/taskstate" "github.com/samcharles93/archie-core/internal/tools" ) @@ -55,6 +56,22 @@ type TaskSpawnResult struct { Message string `json:"message"` } +// TaskActionResult is what task_action returns. +type TaskActionResult struct { + TaskID int64 `json:"task_id"` + Action string `json:"action"` + Message string `json:"message"` +} + +// ChatTaskActor is the mutation surface task_action needs. It mirrors the +// ChatTaskLister pattern: gateway states what it needs and the daemon +// supplies an adapter over the store and runtime, so this package keeps its +// independence from internal/store. +type ChatTaskActor interface { + // ApplyChatTaskAction executes action on taskID, scoped to identity's own tasks. + ApplyChatTaskAction(ctx context.Context, identity string, taskID int64, action taskstate.Action) (TaskActionResult, error) +} + // ChatTaskLogEntry is one log line as task_logs returns it. It mirrors // internal/logging.Entry's shape without importing that package: gateway // keeps its independence from internal/logging the same way it already does @@ -98,24 +115,17 @@ type ChatTaskLogReader interface { ReadChatTaskLogs(ctx context.Context, identity string, taskID int64, attempt int, q ChatTaskLogQuery) (ChatTaskLogResult, error) } -// TaskTools builds the chat tools that let Archie see and add to its own work +// TaskTools builds the chat tools that let Archie see, add to, and manage its own work // queue. Until these existed, /spawn and the task list were slash commands only // a human could type, so "what are you working on?" had no tool path at all. // -// Both tools are bound to identity at construction. The model never supplies -// it: a model that could name an identity could read or file work belonging to -// another instance on the same host. +// All tools are bound to identity at construction. The model never supplies +// it: a model that could name an identity could read, mutate or file work +// belonging to another instance on the same host. // // A nil backend omits its tool rather than registering one that always fails, // so a daemon without chat task support advertises nothing. -// -// Deliberately absent: task_approve and task_cancel. waiting_human is the one -// point in the task lifecycle where a person must act, and /approve is that -// gate. The text reaching a chat turn is untrusted -- a forge issue body or an -// inbound email can be quoted into it -- so a tool that approves Archie's own -// work would remove the only human checkpoint in the lifecycle. Cancel is -// destructive on the same untrusted path. Both remain slash commands. -func TaskTools(lister ChatTaskLister, creator TaskCreator, logs ChatTaskLogReader, identity string) []tools.ToolEntry { +func TaskTools(lister ChatTaskLister, creator TaskCreator, logs ChatTaskLogReader, actor ChatTaskActor, identity string) []tools.ToolEntry { var entries []tools.ToolEntry if lister != nil { entries = append(entries, taskListTool(lister, identity)) @@ -126,6 +136,9 @@ func TaskTools(lister ChatTaskLister, creator TaskCreator, logs ChatTaskLogReade if logs != nil { entries = append(entries, taskLogsTool(logs, identity)) } + if actor != nil { + entries = append(entries, taskActionTool(actor, identity)) + } return entries } @@ -228,6 +241,52 @@ func taskSpawnTool(creator TaskCreator, identity string) tools.ToolEntry { } } +func taskActionTool(actor ChatTaskActor, identity string) tools.ToolEntry { + return tools.ToolEntry{ + Name: "task_action", + Toolset: "tasks", + Description: "Perform an operator action on a task (e.g. abandon, archive, retry, stop, cancel, approve, reject). " + + "Use it when the user asks to close, abandon, archive, retry, stop or approve a task.", + Classification: tools.ClassMutating | tools.RequiresApproval, + BuildApprovalDescription: func(input map[string]any) string { + action := strings.TrimSpace(asString(input["action"])) + taskID, _ := asInt64(input["task_id"]) + return fmt.Sprintf("Apply action %q to task %d.", action, taskID) + }, + Schema: tools.JSONSchema{ + "type": "object", + "properties": map[string]any{ + "task_id": map[string]any{ + "type": "integer", + "description": "ID of the task to act on.", + }, + "action": map[string]any{ + "type": "string", + "description": "The action to perform: abandon, archive, retry, stop, cancel, approve, reject.", + }, + }, + "required": []any{"task_id", "action"}, + }, + Handler: func(ctx context.Context, input map[string]any) (any, error) { + taskID, ok := asInt64(input["task_id"]) + if !ok { + return nil, fmt.Errorf("task_action: task_id is required") + } + actionStr := strings.TrimSpace(strings.ToLower(asString(input["action"]))) + if actionStr == "" { + return nil, fmt.Errorf("task_action: action is required") + } + + // The bound identity, never input["identity"]. + result, err := actor.ApplyChatTaskAction(ctx, identity, taskID, taskstate.Action(actionStr)) + if err != nil { + return nil, fmt.Errorf("task_action: %w", err) + } + return result, nil + }, + } +} + func taskLogsTool(reader ChatTaskLogReader, identity string) tools.ToolEntry { return tools.ToolEntry{ Name: "task_logs", diff --git a/internal/gateway/task_tools_test.go b/internal/gateway/task_tools_test.go index 227d8cf12..12982759b 100644 --- a/internal/gateway/task_tools_test.go +++ b/internal/gateway/task_tools_test.go @@ -48,7 +48,7 @@ func toolNamed(t *testing.T, entries []tools.ToolEntry, name string) tools.ToolE } func TestTaskToolsValidate(t *testing.T) { - entries := TaskTools(&fakeLister{}, &fakeCreator{}, nil, "archie") + entries := TaskTools(&fakeLister{}, &fakeCreator{}, nil, nil, "archie") if len(entries) == 0 { t.Fatal("TaskTools() returned nothing") } @@ -76,7 +76,7 @@ func TestTaskToolsOmitNilBackends(t *testing.T) { for _, tc := range tests { t.Run(tc.name, func(t *testing.T) { - entries := TaskTools(tc.lister, tc.creator, nil, "archie") + entries := TaskTools(tc.lister, tc.creator, nil, nil, "archie") var got []string for _, e := range entries { got = append(got, e.Name) @@ -93,7 +93,7 @@ func TestTaskToolsOmitNilBackends(t *testing.T) { // that could name an identity could read another instance's work. func TestTaskListUsesBoundIdentity(t *testing.T) { lister := &fakeLister{tasks: []ChatTaskSummary{{ID: 7, Title: "wire the thing", Status: "running"}}} - entry := toolNamed(t, TaskTools(lister, nil, nil, "archie"), "task_list") + entry := toolNamed(t, TaskTools(lister, nil, nil, nil, "archie"), "task_list") // The model supplies an identity; it must be ignored. if _, err := entry.Handler(context.Background(), map[string]any{"identity": "someone-else"}); err != nil { @@ -120,7 +120,7 @@ func TestTaskListLimit(t *testing.T) { for _, tc := range tests { t.Run(tc.name, func(t *testing.T) { lister := &fakeLister{} - entry := toolNamed(t, TaskTools(lister, nil, nil, "archie"), "task_list") + entry := toolNamed(t, TaskTools(lister, nil, nil, nil, "archie"), "task_list") if _, err := entry.Handler(context.Background(), tc.input); err != nil { t.Fatal(err) } @@ -137,7 +137,7 @@ func TestTaskListFiltersByStatus(t *testing.T) { {ID: 2, Status: "queued"}, {ID: 3, Status: "running"}, }} - entry := toolNamed(t, TaskTools(lister, nil, nil, "archie"), "task_list") + entry := toolNamed(t, TaskTools(lister, nil, nil, nil, "archie"), "task_list") out, err := entry.Handler(context.Background(), map[string]any{"status": "running"}) if err != nil { @@ -160,7 +160,7 @@ func TestTaskListFiltersByStatus(t *testing.T) { // TestTaskListEmptyIsNotAnError guards against the model reading an empty // queue as a broken tool and retrying. func TestTaskListEmptyIsNotAnError(t *testing.T) { - entry := toolNamed(t, TaskTools(&fakeLister{}, nil, nil, "archie"), "task_list") + entry := toolNamed(t, TaskTools(&fakeLister{}, nil, nil, nil, "archie"), "task_list") out, err := entry.Handler(context.Background(), map[string]any{}) if err != nil { @@ -177,7 +177,7 @@ func TestTaskListEmptyIsNotAnError(t *testing.T) { func TestTaskListPropagatesStoreError(t *testing.T) { lister := &fakeLister{err: errors.New("database is gone")} - entry := toolNamed(t, TaskTools(lister, nil, nil, "archie"), "task_list") + entry := toolNamed(t, TaskTools(lister, nil, nil, nil, "archie"), "task_list") if _, err := entry.Handler(context.Background(), map[string]any{}); err == nil { t.Fatal("handler error = nil, want the store failure surfaced") @@ -228,7 +228,7 @@ func TestTaskSpawn(t *testing.T) { for _, tc := range tests { t.Run(tc.name, func(t *testing.T) { - entry := toolNamed(t, TaskTools(nil, tc.creator, nil, "archie"), "task_spawn") + entry := toolNamed(t, TaskTools(nil, tc.creator, nil, nil, "archie"), "task_spawn") out, err := entry.Handler(context.Background(), tc.input) if tc.wantErr { if err == nil { @@ -264,7 +264,7 @@ func TestTaskSpawn(t *testing.T) { // model must not be able to file work under another instance's identity. func TestTaskSpawnIgnoresModelIdentity(t *testing.T) { creator := &fakeCreator{id: 1} - entry := toolNamed(t, TaskTools(nil, creator, nil, "archie"), "task_spawn") + entry := toolNamed(t, TaskTools(nil, creator, nil, nil, "archie"), "task_spawn") if _, err := entry.Handler(context.Background(), map[string]any{ "title": "sneaky", @@ -282,7 +282,7 @@ func TestTaskSpawnIgnoresModelIdentity(t *testing.T) { // an untrusted input path. If these are ever added they must be a considered // decision, not an accident. func TestTaskToolsExcludeApprovalTools(t *testing.T) { - entries := TaskTools(&fakeLister{}, &fakeCreator{}, nil, "archie") + entries := TaskTools(&fakeLister{}, &fakeCreator{}, nil, nil, "archie") for _, e := range entries { switch e.Name { case "task_approve", "task_cancel": @@ -313,7 +313,7 @@ func (f *fakeLogReader) ReadChatTaskLogs(_ context.Context, identity string, tas func TestTaskLogsUsesBoundIdentity(t *testing.T) { reader := &fakeLogReader{result: ChatTaskLogResult{Attempt: 1}} - entry := toolNamed(t, TaskTools(nil, nil, reader, "archie"), "task_logs") + entry := toolNamed(t, TaskTools(nil, nil, reader, nil, "archie"), "task_logs") if _, err := entry.Handler(context.Background(), map[string]any{ "task_id": float64(7), "identity": "someone-else", @@ -327,7 +327,7 @@ func TestTaskLogsUsesBoundIdentity(t *testing.T) { func TestTaskLogsRequiresTaskID(t *testing.T) { reader := &fakeLogReader{} - entry := toolNamed(t, TaskTools(nil, nil, reader, "archie"), "task_logs") + entry := toolNamed(t, TaskTools(nil, nil, reader, nil, "archie"), "task_logs") if _, err := entry.Handler(context.Background(), map[string]any{}); err == nil { t.Error("expected error for missing task_id, got nil") @@ -336,7 +336,7 @@ func TestTaskLogsRequiresTaskID(t *testing.T) { func TestTaskLogsDefaultsAttemptToZero(t *testing.T) { reader := &fakeLogReader{result: ChatTaskLogResult{Attempt: 0}} - entry := toolNamed(t, TaskTools(nil, nil, reader, "archie"), "task_logs") + entry := toolNamed(t, TaskTools(nil, nil, reader, nil, "archie"), "task_logs") if _, err := entry.Handler(context.Background(), map[string]any{ "task_id": float64(7), @@ -350,7 +350,7 @@ func TestTaskLogsDefaultsAttemptToZero(t *testing.T) { func TestTaskLogsHonoursExplicitAttempt(t *testing.T) { reader := &fakeLogReader{result: ChatTaskLogResult{Attempt: 2}} - entry := toolNamed(t, TaskTools(nil, nil, reader, "archie"), "task_logs") + entry := toolNamed(t, TaskTools(nil, nil, reader, nil, "archie"), "task_logs") if _, err := entry.Handler(context.Background(), map[string]any{ "task_id": float64(7), "attempt": float64(2), @@ -377,7 +377,7 @@ func TestTaskLogsLimit(t *testing.T) { for _, tc := range tests { t.Run(tc.name, func(t *testing.T) { reader := &fakeLogReader{result: ChatTaskLogResult{}} - entry := toolNamed(t, TaskTools(nil, nil, reader, "archie"), "task_logs") + entry := toolNamed(t, TaskTools(nil, nil, reader, nil, "archie"), "task_logs") if _, err := entry.Handler(context.Background(), tc.input); err != nil { t.Fatal(err) } @@ -390,7 +390,7 @@ func TestTaskLogsLimit(t *testing.T) { func TestTaskLogsForwardsComponentAndContains(t *testing.T) { reader := &fakeLogReader{result: ChatTaskLogResult{}} - entry := toolNamed(t, TaskTools(nil, nil, reader, "archie"), "task_logs") + entry := toolNamed(t, TaskTools(nil, nil, reader, nil, "archie"), "task_logs") if _, err := entry.Handler(context.Background(), map[string]any{ "task_id": float64(7), "component": "gate", "q": "build failed", @@ -406,7 +406,7 @@ func TestTaskLogsForwardsComponentAndContains(t *testing.T) { } func TestTaskLogsOmittedWhenReaderIsNil(t *testing.T) { - entries := TaskTools(&fakeLister{}, &fakeCreator{}, nil, "archie") + entries := TaskTools(&fakeLister{}, &fakeCreator{}, nil, nil, "archie") for _, e := range entries { if e.Name == "task_logs" { t.Fatal("task_logs is in the tool set when reader is nil -- a tool that always fails must not be advertised") @@ -415,6 +415,6 @@ func TestTaskLogsOmittedWhenReaderIsNil(t *testing.T) { } func TestTaskLogsAppearsWhenReaderIsNonNil(t *testing.T) { - entries := TaskTools(nil, nil, &fakeLogReader{}, "archie") + entries := TaskTools(nil, nil, &fakeLogReader{}, nil, "archie") toolNamed(t, entries, "task_logs") // fails the test if absent } diff --git a/internal/gateway/turn.go b/internal/gateway/turn.go index 52c8593c4..379375ca2 100644 --- a/internal/gateway/turn.go +++ b/internal/gateway/turn.go @@ -75,6 +75,7 @@ type TurnRunnerConfig struct { TaskLister ChatTaskLister Tasks TaskCreator TaskLogs ChatTaskLogReader + TaskActor ChatTaskActor TaskIdentity string Bus TurnEventPublisher BotUser string @@ -247,7 +248,7 @@ func (r *TurnRunner) Run(ctx context.Context, msg Message, stream TurnStream) (s compressed := compressTurnHistory(history, r.BotUser) extraTools := append( - TaskTools(r.TaskLister, r.Tasks, r.TaskLogs, r.TaskIdentity), + TaskTools(r.TaskLister, r.Tasks, r.TaskLogs, r.TaskActor, r.TaskIdentity), SessionTools(r.Sessions, r.Router.SessionTracker(), r.Channel, msg)..., ) modelName := r.Models.ActiveModel()