From 1b5b581de8ec7950b4c7b22e2a5006be417edef7 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Sun, 18 Oct 2026 21:48:22 +0100 Subject: [PATCH 1/7] chore: preserve notifications clear-all preparation From dad89493de033f5dfdc0ec21a2928bc3037eda4b Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Sun, 18 Oct 2026 23:22:28 +0100 Subject: [PATCH 2/7] Preserve reviewed Clear all change for leased UI verification --- .../src/main/java/net/awan/pipelines/ui/Attention.kt | 6 ++++++ .../awan/pipelines/ui/components/AttentionSurface.kt | 11 +++++++++++ .../test/java/net/awan/pipelines/ui/AttentionTest.kt | 10 ++++++++++ docs/notes/notifications-clear-all.md | 10 ++++++++++ 4 files changed, 37 insertions(+) create mode 100644 docs/notes/notifications-clear-all.md diff --git a/android/app/src/main/java/net/awan/pipelines/ui/Attention.kt b/android/app/src/main/java/net/awan/pipelines/ui/Attention.kt index 4e2b1d6d..69870c4b 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/Attention.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/Attention.kt @@ -179,6 +179,12 @@ internal fun attentionHeadline(entries: List): String = when { else -> "${entries.size} runs need you" } +/** + * Captures the entries shown when the attention sheet opens. Bulk dismissal uses + * this snapshot so entries that arrive while the sheet is open are not removed. + */ +internal fun attentionDismissalSnapshot(entries: List): List = entries.toList() + /** * Parses the run id from a `pipelines://run/` deep link, or null for * anything else. Pure and total, so a malformed link simply opens nothing rather diff --git a/android/app/src/main/java/net/awan/pipelines/ui/components/AttentionSurface.kt b/android/app/src/main/java/net/awan/pipelines/ui/components/AttentionSurface.kt index 8ca63a3e..b8c1f895 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/components/AttentionSurface.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/components/AttentionSurface.kt @@ -17,8 +17,10 @@ import androidx.compose.material3.MaterialTheme import androidx.compose.material3.ModalBottomSheet import androidx.compose.material3.Surface import androidx.compose.material3.Text +import androidx.compose.material3.TextButton import androidx.compose.material3.rememberModalBottomSheetState import androidx.compose.runtime.Composable +import androidx.compose.runtime.remember import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.graphics.Color @@ -27,6 +29,7 @@ import androidx.compose.ui.unit.dp import net.awan.pipelines.ui.AttentionEntry import net.awan.pipelines.ui.AttentionKind import net.awan.pipelines.ui.attentionHeadline +import net.awan.pipelines.ui.attentionDismissalSnapshot import net.awan.pipelines.ui.theme.ICON_INLINE_DP import net.awan.pipelines.ui.theme.SPACING_L import net.awan.pipelines.ui.theme.SPACING_M @@ -105,6 +108,7 @@ fun AttentionSheet( onDismiss: () -> Unit, ) { val sheetState = rememberModalBottomSheetState(skipPartiallyExpanded = true) + val dismissalSnapshot = remember { attentionDismissalSnapshot(entries) } ModalBottomSheet(onDismissRequest = onDismiss, sheetState = sheetState) { Column( modifier = Modifier.fillMaxWidth().padding(bottom = SPACING_L), @@ -124,6 +128,13 @@ fun AttentionSheet( ) return@Column } + TextButton( + onClick = { dismissalSnapshot.forEach(onDismissEntry) }, + enabled = dismissalSnapshot.isNotEmpty(), + modifier = Modifier.padding(horizontal = SPACING_L), + ) { + Text("Clear all") + } entries.forEach { entry -> AttentionRow( entry = entry, diff --git a/android/app/src/test/java/net/awan/pipelines/ui/AttentionTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/AttentionTest.kt index 50ed94f0..d4fa3d13 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/AttentionTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/AttentionTest.kt @@ -194,6 +194,16 @@ class AttentionTest { assertEquals("A run failed", attentionHeadline(singleFailed)) } + @Test + fun dismissalSnapshotDoesNotIncludeEntriesThatArriveLater() { + val original = attentionEntries(listOf(run(1, "waiting")), AttentionState()) + val snapshot = attentionDismissalSnapshot(original) + val current = original + attentionEntries(listOf(run(2, "failed")), AttentionState()) + + assertEquals(listOf(1L), snapshot.map { it.runId }) + assertEquals(listOf(1L, 2L), current.map { it.runId }) + } + // --- persistence ----------------------------------------------------------- @Test diff --git a/docs/notes/notifications-clear-all.md b/docs/notes/notifications-clear-all.md new file mode 100644 index 00000000..674600a9 --- /dev/null +++ b/docs/notes/notifications-clear-all.md @@ -0,0 +1,10 @@ +# Needs you: Clear all + +The Needs you bottom sheet now exposes **Clear all** when it has entries. It +dismisses only the entries present when the sheet opened through the existing +individual dismissal path; entries arriving while it is open remain visible. +The action is absent from the empty state. UI verification remains the next +stage's responsibility. + +The packaged author skill/reference documentation should be folded to mention +this user-facing behavior rather than being edited in this item. From 58fa528afc5d28490b64f02fb13e2d3eb0936a5f Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Sun, 18 Oct 2026 23:30:56 +0100 Subject: [PATCH 3/7] test: retain committed stage diffs --- docs/notes/retained-committed-merge-diffs.md | 7 + internal/server/file_changes_test.go | 152 +++++++++++++++++++ 2 files changed, 159 insertions(+) create mode 100644 docs/notes/retained-committed-merge-diffs.md diff --git a/docs/notes/retained-committed-merge-diffs.md b/docs/notes/retained-committed-merge-diffs.md new file mode 100644 index 00000000..7dacd29d --- /dev/null +++ b/docs/notes/retained-committed-merge-diffs.md @@ -0,0 +1,7 @@ +# Committed and merged stage diffs remain retained + +The server captures workspace contents around each stage visit rather than comparing +Git status or HEAD. Regression coverage now exercises a stage that commits its edit, +a later stage that resolves and commits a merge conflict, and an empty commit-only +stage. After reopening SQLite, the first two patches remain available while the final +stage correctly records no source-content change. diff --git a/internal/server/file_changes_test.go b/internal/server/file_changes_test.go index d9ffb6d8..fe1518a5 100644 --- a/internal/server/file_changes_test.go +++ b/internal/server/file_changes_test.go @@ -5,6 +5,7 @@ import ( "errors" "fmt" "os" + "os/exec" "path/filepath" "strings" "testing" @@ -162,3 +163,154 @@ func TestRepeatedStageVisitsRetainIndependentDiffs(t *testing.T) { } } } + +func TestRetainedStageDiffsSurviveCommittedMergeAndNoopVisit(t *testing.T) { + ctx := context.Background() + db := filepath.Join(t.TempDir(), "committed-diffs.db") + store, err := pipeline.Open(db) + if err != nil { + t.Fatal(err) + } + source := pipeline.Template([]string{"commit", "merge", "noop"}, true) + if _, err := store.Submit(ctx, "committed-diffs", source); err != nil { + t.Fatal(err) + } + items, err := store.List(ctx) + if err != nil { + t.Fatal(err) + } + + workspace := t.TempDir() + runGit(t, workspace, "init", "-q") + runGit(t, workspace, "config", "user.email", "test@example.invalid") + runGit(t, workspace, "config", "user.name", "test") + path := filepath.Join(workspace, "source.txt") + if err := os.WriteFile(path, []byte("base\n"), 0600); err != nil { + t.Fatal(err) + } + runGit(t, workspace, "add", "source.txt") + runGit(t, workspace, "commit", "-qm", "base") + branch := runGitOutput(t, workspace, "branch", "--show-current") + + r, err := newRunner(ctx, store) + if err != nil { + t.Fatal(err) + } + git := func(args ...string) error { + cmd := exec.Command("git", append([]string{"-C", workspace}, args...)...) + if output, err := cmd.CombinedOutput(); err != nil { + return fmt.Errorf("git %v: %w: %s", args, err, output) + } + return nil + } + gitOutput := func(args ...string) (string, error) { + cmd := exec.Command("git", append([]string{"-C", workspace}, args...)...) + output, err := cmd.Output() + if err != nil { + return "", fmt.Errorf("git %v: %w", args, err) + } + return strings.TrimSpace(string(output)), nil + } + r.execute = func(_ context.Context, def stage.Definition, _ stage.Values) (stage.Result, error) { + switch def.Key { + case "commit": + if err := os.WriteFile(path, []byte("committed change\n"), 0600); err != nil { + return stage.Result{}, err + } + if err := git("add", "source.txt"); err != nil { + return stage.Result{}, err + } + if err := git("commit", "-qm", "stage commit"); err != nil { + return stage.Result{}, err + } + case "merge": + if err := git("checkout", "-qb", "conflict-side"); err != nil { + return stage.Result{}, err + } + if err := os.WriteFile(path, []byte("side change\n"), 0600); err != nil { + return stage.Result{}, err + } + if err := git("add", "source.txt"); err != nil { + return stage.Result{}, err + } + if err := git("commit", "-qm", "side"); err != nil { + return stage.Result{}, err + } + if err := git("checkout", "-q", branch); err != nil { + return stage.Result{}, err + } + if err := os.WriteFile(path, []byte("main change\n"), 0600); err != nil { + return stage.Result{}, err + } + if err := git("add", "source.txt"); err != nil { + return stage.Result{}, err + } + if err := git("commit", "-qm", "main"); err != nil { + return stage.Result{}, err + } + if err := git("merge", "--no-ff", "conflict-side", "-m", "merge"); err == nil { + return stage.Result{}, errors.New("expected merge conflict") + } + conflicted, err := gitOutput("diff", "--name-only", "--diff-filter=U") + if err != nil || conflicted != "source.txt" { + return stage.Result{}, fmt.Errorf("merge did not leave the expected conflict: %q, %v", conflicted, err) + } + if err := os.WriteFile(path, []byte("resolved merge\n"), 0600); err != nil { + return stage.Result{}, err + } + if err := git("add", "source.txt"); err != nil { + return stage.Result{}, err + } + if err := git("commit", "-qm", "resolve merge"); err != nil { + return stage.Result{}, err + } + case "noop": + if err := git("commit", "--allow-empty", "-qm", "no content change"); err != nil { + return stage.Result{}, err + } + } + return stage.Result{Outcome: "success"}, nil + } + + run, err := r.start(protocol.Message{PipelineID: items[0].ID, Version: 1, RequestKey: "committed-diffs", Workspace: workspace, Input: map[string]any{"prompt": "task"}}) + if err != nil { + t.Fatal(err) + } + r.wg.Wait() + if err := store.Close(); err != nil { + t.Fatal(err) + } + store, err = pipeline.Open(db) + if err != nil { + t.Fatal(err) + } + defer store.Close() + + detail, err := store.GetRun(ctx, run.ID) + if err != nil { + t.Fatal(err) + } + if detail.Status != "succeeded" || len(detail.Steps) != 3 { + t.Fatal(detail) + } + for _, assertion := range []struct { + step int + old string + new string + }{ + {step: 0, old: "base", new: "committed change"}, + {step: 1, old: "committed change", new: "resolved merge"}, + } { + changes := detail.Steps[assertion.step].FileChanges + if changes == nil || len(changes.Files) != 1 || !strings.Contains(changes.Files[0].Patch, "-"+assertion.old) || !strings.Contains(changes.Files[0].Patch, "+"+assertion.new) { + t.Fatalf("committed stage patch was not retained after reopen: %+v", changes) + } + } + if changes := detail.Steps[2].FileChanges; changes == nil || len(changes.Files) != 0 { + t.Fatalf("commit-only stage changed source evidence: %+v", changes) + } + data, err := os.ReadFile(path) + if err != nil || string(data) != "resolved merge\n" { + t.Fatalf("merge resolution was not preserved: %q, %v", data, err) + } +} From 31d78cc065317e4b98d0cbff422d040538198862 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Sun, 18 Oct 2026 23:33:30 +0100 Subject: [PATCH 4/7] stage: expose resource targets to model harnesses --- docs/notes/resource-pool-runner-handoff.md | 6 +- internal/stage/model_prompt.go | 28 ++++-- internal/stage/model_run.go | 3 +- internal/stage/model_test.go | 103 +++++++++++++++++++++ 4 files changed, 128 insertions(+), 12 deletions(-) diff --git a/docs/notes/resource-pool-runner-handoff.md b/docs/notes/resource-pool-runner-handoff.md index d7c9d091..d92d1e47 100644 --- a/docs/notes/resource-pool-runner-handoff.md +++ b/docs/notes/resource-pool-runner-handoff.md @@ -2,8 +2,10 @@ Stage `resources` declarations now accept exactly one of `exclusive` or `pool`. Pool stages wait on the named pool, then receive the selected concrete member and -bounded metadata through explicit runtime context. The model input remains -unchanged and capability tokens remain private to the store. Retained control +bounded metadata through explicit runtime context. Model execution serializes that +server-granted context as a separate `resource_target` runtime field for both +native and plain harnesses; the task input map remains unchanged and cannot select +the target. Capability tokens remain private to the store. Retained control evidence records the concrete target; queued run state names the pool while an active owner names the selected member. diff --git a/internal/stage/model_prompt.go b/internal/stage/model_prompt.go index f6cc3db2..2a0f9f7f 100644 --- a/internal/stage/model_prompt.go +++ b/internal/stage/model_prompt.go @@ -8,6 +8,8 @@ import ( "sort" "strings" "time" + + "git.a-wan.net/alan/pipelines/internal/protocol" ) var ErrInvalidModelResult = errors.New("invalid model stage result") @@ -36,6 +38,13 @@ func harnessUnreachable(err error) error { } func modelPrompt(def Definition, spec ModelSpec, input Values) (string, error) { + return modelPromptForTarget(def, spec, input, nil) +} + +// modelPromptForTarget carries a server-selected resource target separately from +// task input. The target comes only from the runner context; task input remains +// data and cannot select or replace it. +func modelPromptForTarget(def Definition, spec ModelSpec, input Values, target *protocol.ResourceTarget) (string, error) { outcomes := make([]string, 0, len(def.Edges)) for name := range def.Edges { outcomes = append(outcomes, name) @@ -59,15 +68,16 @@ func modelPrompt(def Definition, spec ModelSpec, input Values) (string, error) { toolsLine = "This call has these stage tools: " + strings.Join(tools, ", ") + "." } data, err := json.Marshal(struct { - Key string `json:"stage"` - Instructions string `json:"instructions"` - OutputContract string `json:"output_contract"` - Outcomes []string `json:"allowed_outcomes"` - Input Values `json:"input"` - ReportFileArtifacts bool `json:"report_file_artifacts"` - ExecutionTime string `json:"execution_time"` - Timezone string `json:"timezone"` - }{def.Key, spec.Prompt, spec.Output, outcomes, input, def.ReportFileArtifacts, time.Now().Format(time.RFC3339), time.Local.String()}) + Key string `json:"stage"` + Instructions string `json:"instructions"` + OutputContract string `json:"output_contract"` + Outcomes []string `json:"allowed_outcomes"` + Input Values `json:"input"` + ResourceTarget *protocol.ResourceTarget `json:"resource_target,omitempty"` + ReportFileArtifacts bool `json:"report_file_artifacts"` + ExecutionTime string `json:"execution_time"` + Timezone string `json:"timezone"` + }{def.Key, spec.Prompt, spec.Output, outcomes, input, target, def.ReportFileArtifacts, time.Now().Format(time.RFC3339), time.Local.String()}) if err != nil { return "", fmt.Errorf("model stage input is not JSON-serializable: %w", err) } diff --git a/internal/stage/model_run.go b/internal/stage/model_run.go index 41300243..2bc5ee34 100644 --- a/internal/stage/model_run.go +++ b/internal/stage/model_run.go @@ -16,7 +16,8 @@ func (m ModelStage) Run(ctx context.Context, def Definition, input Values) (Resu return Result{}, err } spec.Config.ResultSchema = resultSchema(def.Edges) - prompt, err := modelPrompt(def, spec, input) + target, _ := ResourceTarget(ctx) + prompt, err := modelPromptForTarget(def, spec, input, target) if err != nil { return Result{}, err } diff --git a/internal/stage/model_test.go b/internal/stage/model_test.go index 0cd1ac04..a0070755 100644 --- a/internal/stage/model_test.go +++ b/internal/stage/model_test.go @@ -9,6 +9,8 @@ import ( "strings" "testing" "time" + + "git.a-wan.net/alan/pipelines/internal/protocol" ) func modelDefinition() Definition { @@ -194,6 +196,107 @@ func TestModelRunUsesInstructionsAndStructuredOutput(t *testing.T) { } } +func TestModelRunForwardsOnlyServerGrantedResourceTarget(t *testing.T) { + target := &protocol.ResourceTarget{Member: "emulator", Metadata: map[string]string{"serial": "emu-5554", "type": "emulator"}} + budget := NewBudget(0, 0) + input := Values{"resource_target": map[string]any{"member": "user-selected"}, "prompt": "task"} + ctx := WithBudget(WithResourceTarget(context.Background(), target), budget) + + var received ModelConfig + client := generatorFunc(func(_ context.Context, config ModelConfig, prompt string) (string, error) { + received = config + assertPromptResourceTarget(t, prompt, target, input) + return `{"outcome":"success","output":{}}`, nil + }) + if _, err := (ModelStage{Client: client}).Run(ctx, modelDefinition(), input); err != nil { + t.Fatal(err) + } + if received.Budget != budget { + t.Fatal("budget context was not preserved with resource target") + } +} + +func TestModelRunForwardsResourceTargetToNativeOpenCode(t *testing.T) { + target := &protocol.ResourceTarget{Member: "phone", Metadata: map[string]string{"serial": "phone-serial"}} + var prompt string + client := &OpenCodeClient{Directory: "/work/repo", command: func(_ context.Context, _ string, args ...string) ([]byte, error) { + switch args[2] { + case "/api/session": + return []byte(`{"data":{"id":"ses_target"}}`), nil + case "/api/session/ses_target/generate": + var body struct { + Prompt string `json:"prompt"` + } + if err := json.Unmarshal([]byte(args[4]), &body); err != nil { + t.Fatal(err) + } + prompt = body.Prompt + return []byte(`{"data":{"text":"{\"outcome\":\"success\",\"output\":{}}"}}`), nil + default: + t.Fatalf("unexpected fake OpenCode endpoint %q", args[2]) + return nil, nil + } + }} + if _, err := (ModelStage{Client: client}).Run(WithResourceTarget(context.Background(), target), modelDefinition(), Values{"prompt": "task"}); err != nil { + t.Fatal(err) + } + assertPromptResourceTarget(t, prompt, target, Values{"prompt": "task"}) +} + +func TestModelPromptWithoutResourceTargetPreservesLegacyInput(t *testing.T) { + input := Values{"prompt": "task", "count": "1"} + spec, err := (ModelStage{}).Spec(modelDefinition()) + if err != nil { + t.Fatal(err) + } + prompt, err := modelPrompt(modelDefinition(), spec, input) + if err != nil { + t.Fatal(err) + } + var payload struct { + Input Values `json:"input"` + ResourceTarget *protocol.ResourceTarget `json:"resource_target"` + } + if _, data, ok := strings.Cut(prompt, "Stage definition and runtime input:\n"); !ok || json.Unmarshal([]byte(data), &payload) != nil { + t.Fatal("could not decode legacy runtime payload") + } + if payload.ResourceTarget != nil || !reflect.DeepEqual(payload.Input, input) { + t.Fatalf("legacy runtime input changed: %#v", payload) + } +} + +func assertPromptResourceTarget(t *testing.T, prompt string, want *protocol.ResourceTarget, wantInput Values) { + t.Helper() + _, data, ok := strings.Cut(prompt, "Stage definition and runtime input:\n") + if !ok { + t.Fatal("missing runtime payload") + } + var payload struct { + Input Values `json:"input"` + ResourceTarget *protocol.ResourceTarget `json:"resource_target"` + } + if err := json.Unmarshal([]byte(data), &payload); err != nil { + t.Fatal(err) + } + if !reflect.DeepEqual(payload.ResourceTarget, want) { + t.Fatalf("resource target = %#v, want %#v", payload.ResourceTarget, want) + } + var fields map[string]json.RawMessage + if err := json.Unmarshal([]byte(data), &fields); err != nil { + t.Fatal(err) + } + var targetFields map[string]json.RawMessage + if err := json.Unmarshal(fields["resource_target"], &targetFields); err != nil { + t.Fatal(err) + } + if len(targetFields) != 2 || targetFields["member"] == nil || targetFields["metadata"] == nil { + t.Fatalf("resource target leaked non-target fields: %s", fields["resource_target"]) + } + if !reflect.DeepEqual(payload.Input, wantInput) { + t.Fatalf("input = %#v, want %#v", payload.Input, wantInput) + } +} + func TestModelResultValidationAndRetryBudget(t *testing.T) { for _, text := range []string{ `not json`, `{"outcome":"missing","output":{}}`, `{"outcome":"success"}`, From 89a2bf1e01543e781cc643240585bbeb48c801c1 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Sun, 18 Oct 2026 23:37:46 +0100 Subject: [PATCH 5/7] Add operator resource pool configuration commands --- docs/notes/resource-pool-operator-config.md | 7 ++ internal/cli/app.go | 63 ++++++++++- internal/cli/commands.go | 113 ++++++++++---------- internal/pipeline/resources.go | 15 +++ internal/protocol/message.go | 5 + internal/protocol/resources.go | 1 + internal/server/resource_cli_test.go | 86 +++++++++++++++ internal/server/websocket.go | 14 ++- 8 files changed, 246 insertions(+), 58 deletions(-) create mode 100644 docs/notes/resource-pool-operator-config.md diff --git a/docs/notes/resource-pool-operator-config.md b/docs/notes/resource-pool-operator-config.md new file mode 100644 index 00000000..555e8ca4 --- /dev/null +++ b/docs/notes/resource-pool-operator-config.md @@ -0,0 +1,7 @@ +# Resource-pool operator configuration — 2026-10-18 + +`resource-pool-configure --yes` replaces one bounded pool declaration +through the loopback-only operator transport. `resource-pool-inspect ` reads +the declared members, enabled/quarantine status, and non-secret metadata. Existing +owners and waiters remain under the store's normal ownership, quarantine, and FIFO +rules; configuration does not release active leases. diff --git a/internal/cli/app.go b/internal/cli/app.go index 571f3e2c..92032422 100644 --- a/internal/cli/app.go +++ b/internal/cli/app.go @@ -49,7 +49,7 @@ type options struct { json, source, noOpen, yes, allow, createOnly, force, wait bool version, expected, limit, recoverySequence, retryVisit int recoveryRun int64 - recoveryStage, resource string + recoveryStage, resource, poolFile string timeout, waitTimeout time.Duration stageModels stageModelFlags } @@ -193,6 +193,11 @@ func (a App) flags(command string) (*flag.FlagSet, *options) { f.StringVar(&o.actor, "actor", "operator", "Bounded operator identity") f.BoolVar(&o.allow, "no-mutating-action", false, "Evidence explicitly records that no mutating action occurred") f.BoolVar(&o.yes, "yes", false, "Confirm reconciliation without prompting") + case "resource-pool-inspect": + f.StringVar(&o.resource, "pool", "", "Resource pool name") + case "resource-pool-configure": + f.StringVar(&o.poolFile, "file", "", "JSON pool declaration, or - for stdin") + f.BoolVar(&o.yes, "yes", false, "Confirm this mutation without prompting") case "debug": f.StringVar(&o.harness, "harness", "", "Debugging harness: configured opencode/pi, or nvim") f.BoolVar(&o.yes, "yes", false, "Approve opening a debugging session without prompting") @@ -479,7 +484,7 @@ func (a App) Run(ctx context.Context, args []string) error { requestTimeout = 30 * time.Second } connectURL := o.url - if command == "resource-inspect" || command == "resource-reconcile" { + if command == "resource-inspect" || command == "resource-reconcile" || command == "resource-pool-inspect" || command == "resource-pool-configure" { var transportErr error connectURL, transportErr = operatorTransportURL(o.url) if transportErr != nil { @@ -966,6 +971,60 @@ func (a App) Run(ctx context.Context, args []string) error { } _, err = fmt.Fprintf(a.Out, "Reconciled resource %s for run #%d\n", pos[0], runID) return err + case "resource-pool-inspect": + if len(pos) > 1 { + return fmt.Errorf("resource-pool-inspect takes one pool name") + } + if o.resource == "" && len(pos) == 1 { + o.resource = pos[0] + } + if strings.TrimSpace(o.resource) == "" { + return fmt.Errorf("resource-pool-inspect requires a pool name") + } + r, err := call(protocol.Message{Type: protocol.InspectResourcePool, Resource: o.resource}) + if err != nil { + return err + } + if r.ResourcePool == nil { + return fmt.Errorf("server did not return resource pool") + } + return a.output(r.ResourcePool) + case "resource-pool-configure": + if len(pos) > 1 { + return fmt.Errorf("resource-pool-configure takes one JSON file") + } + file := o.poolFile + if file == "" && len(pos) == 1 { + file = pos[0] + } + if file == "" { + return fmt.Errorf("resource-pool-configure requires a JSON file") + } + var data []byte + if file == "-" { + data, err = io.ReadAll(a.In) + } else { + data, err = os.ReadFile(file) + } + if err != nil { + return err + } + var pool protocol.ResourcePool + if err := json.Unmarshal(data, &pool); err != nil { + return fmt.Errorf("invalid resource pool JSON: %w", err) + } + if err := a.confirmAction(fmt.Sprintf("Configure resource pool %s?", pool.Name), o.yes); err != nil { + return err + } + r, err := call(protocol.Message{Type: protocol.ConfigureResourcePool, ResourcePool: &pool}) + if err != nil { + return err + } + if o.json { + return a.output(r) + } + _, err = fmt.Fprintf(a.Out, "Configured resource pool %s\n", pool.Name) + return err case "inspect", "cancel", "retry": value, err := one() if err != nil { diff --git a/internal/cli/commands.go b/internal/cli/commands.go index 2759d473..89d3e3fd 100644 --- a/internal/cli/commands.go +++ b/internal/cli/commands.go @@ -2,64 +2,67 @@ package cli // Help is also the public command inventory for agents and parity checks. var usage = map[string]string{ - "provider-check": "provider-check --model PROVIDER/MODEL [--yes] [--json]", - "new": "new [name] [prompt] [--template KEY] [--no-open | --json]", - "edit": "edit [name|id] [prompt] [--version N] [--no-open | --json]", - "drafts": "drafts [--json]", - "draft-delete": "draft-delete [--json]", - "validate": "validate [--json]", - "submit": "submit [--name NAME] [--create-only] [--yes] [--json]", - "list": "list [--json]", - "search": "search QUERY [--type KIND] [--limit N] [--json]", - "show": "show [--version N] [--json]", - "versions": "versions [--json]", - "export": "export [name|id ...] [--output FILE.zip] [--all] [--version N]", - "import": "import [FILE.zip] [--all] [--on-conflict ask|keep|both|import] [--yes] [--json]", - "templates": "templates [--json]", - "template": "template [--source | --json]", - "run": "run [name|id] [prompt] [--title TITLE] [--model PROVIDER/MODEL] [--stage-model STAGE=PROVIDER/MODEL ...] [--json [--wait [--wait-timeout DURATION]]]", - "runs": "runs [--pipeline NAME] [--json]", - "inspect": "inspect [--json]", - "wait": "wait [run-id ...] [--timeout DURATION] [--json]", - "cancel": "cancel [--json]", - "decide": "decide [stage] --option KEY [--feedback TEXT] [--json]", - "retry": "retry [--mode resume|restart] [--stage KEY [--visit N]] [--version N] [--input-file FILE|-] [--json [--wait [--wait-timeout DURATION]]]", - "title": "title \"\" [--json]", - "debug": "debug <run-id> [--json | --no-open]", - "chat-adopt": "chat-adopt <session-id> [--json]", - "connection": "connection [--json]", - "ping": "ping [--json]", - "version": "version [--json]", - "status": "status [--json]", - "stats": "stats [--json]", - "resource-inspect": "resource-inspect <resource> [--json]", - "resource-reconcile": "resource-reconcile <resource> <run-id> <stage> <sequence> --evidence TEXT [--no-mutating-action] [--yes] [--json]", - "rpc": "rpc <request.json|->", - "retention": "retention report|apply [--older-than DURATION] [--keep N] [--db FILE] [--artifacts DIR] [--json] [--yes]", - "tui": "tui", + "provider-check": "provider-check --model PROVIDER/MODEL [--yes] [--json]", + "new": "new [name] [prompt] [--template KEY] [--no-open | --json]", + "edit": "edit [name|id] [prompt] [--version N] [--no-open | --json]", + "drafts": "drafts [--json]", + "draft-delete": "draft-delete <draft.md> [--json]", + "validate": "validate <draft.md> [--json]", + "submit": "submit <draft.md> [--name NAME] [--create-only] [--yes] [--json]", + "list": "list [--json]", + "search": "search QUERY [--type KIND] [--limit N] [--json]", + "show": "show <name|id> [--version N] [--json]", + "versions": "versions <name|id> [--json]", + "export": "export [name|id ...] [--output FILE.zip] [--all] [--version N]", + "import": "import [FILE.zip] [--all] [--on-conflict ask|keep|both|import] [--yes] [--json]", + "templates": "templates [--json]", + "template": "template <key> [--source | --json]", + "run": "run [name|id] [prompt] [--title TITLE] [--model PROVIDER/MODEL] [--stage-model STAGE=PROVIDER/MODEL ...] [--json [--wait [--wait-timeout DURATION]]]", + "runs": "runs [--pipeline NAME] [--json]", + "inspect": "inspect <run-id> [--json]", + "wait": "wait <run-id> [run-id ...] [--timeout DURATION] [--json]", + "cancel": "cancel <run-id> [--json]", + "decide": "decide <run-id> [stage] --option KEY [--feedback TEXT] [--json]", + "retry": "retry <run-id> [--mode resume|restart] [--stage KEY [--visit N]] [--version N] [--input-file FILE|-] [--json [--wait [--wait-timeout DURATION]]]", + "title": "title <run-id> \"<title>\" [--json]", + "debug": "debug <run-id> [--json | --no-open]", + "chat-adopt": "chat-adopt <session-id> [--json]", + "connection": "connection [--json]", + "ping": "ping [--json]", + "version": "version [--json]", + "status": "status [--json]", + "stats": "stats [--json]", + "resource-inspect": "resource-inspect <resource> [--json]", + "resource-reconcile": "resource-reconcile <resource> <run-id> <stage> <sequence> --evidence TEXT [--no-mutating-action] [--yes] [--json]", + "resource-pool-inspect": "resource-pool-inspect <pool> [--json]", + "resource-pool-configure": "resource-pool-configure <pool.json|-> --yes [--json]", + "rpc": "rpc <request.json|->", + "retention": "retention report|apply [--older-than DURATION] [--keep N] [--db FILE] [--artifacts DIR] [--json] [--yes]", + "tui": "tui", } var notes = map[string]string{ - "version": "Identify the local CLI binary without connecting to a server. --version is an alias. Use ping --json to identify the running server separately.", - "ping": "Pong includes the running server's compiled build.version, build.commit and build.dirty (null when unknown). This identifies the server, not the client or runtime workspace. Older servers omit build. The client compares its own build/protocol against the server: a same-protocol build mismatch prints one warning to stderr, a server speaking a newer protocol fails the command, and a response carrying a field this client does not model prints a one-time unrecognized-field notice instead of dropping it silently.", - "connection": "Prints the server endpoint and phone notification endpoints. Like ping, it reports the client/server build relationship and warns or fails rather than silently proceeding against a mismatched server.", - "status": "Reports server, host and ntfy publishing health. The client compares its build/protocol against the server and warns once (or fails on a newer protocol) rather than proceeding silently.", - "export": "Without a name, select pipelines with Space and save a ZIP in the current directory. --output writes a portable definition bundle; --all skips selection. One name without --output prints Markdown as before. No runs, credentials or old versions are exported.", - "import": "Select definitions from a ZIP. Identical existing definitions are skipped. For differing names, choose keep existing, keep both under a new name, or use imported as a new version (history retained). --on-conflict supplies an explicit automation policy; --yes only approves final publication. Schedules may activate; no run history is imported.", - "new": "Create an optional template copy or a one-stage starter. Opens the configured default harness; --harness opencode|pi|nvim overrides it. No submission is performed.", - "edit": "Omit the name to open fuzzy selection. Original immutable source is copied to a private draft. The configured harness edits that draft, never the live definition.", - "validate": "Uses the same server parser as submission. Does not persist or activate schedules. Structural validity does not prove runtime/tool availability.", - "submit": "Confirm publication at the prompt, or use --yes for explicit automation; schedules activate on acceptance. Managed drafts provide the name and base-version guard. --force never bypasses validation.", - "run": "Runs in your current directory after action confirmation (--yes skips it). Select a pipeline and compose a multiline task with Ctrl+S. Stage tools are enabled automatically; no file list or typed RUN confirmation. Cancellation does not undo edits. --title sets an explicit run title; without it the title is derived from the prompt. --model PROVIDER/MODEL overrides the model for every stage of that run; --stage-model STAGE=PROVIDER/MODEL overrides one stage and is repeatable, with a repeated key last-wins. Precedence is per-stage > whole-run > the model pinned in the pipeline version; overrides apply to that run only and never change the pinned definition. An unknown stage key or a malformed provider/model is refused before the run starts, naming the valid stage keys. In JSON mode --wait polls until terminal; --wait-timeout bounds only the client wait after admission and is independent of per-request --timeout. A reached wait limit leaves the run active: inspect read-only with `inspect <run-id> --json`, or reattach with --wait reusing the original --request-key (never an automatic replay or cancel).", - "retry": "Resume a failed stage by default, restoring the completed prefix handoff; use --mode=restart to start at entry. --stage selects a recorded stage (use --visit for repeated stages). --input-file accepts a bounded JSON object, merged with replacement at the selected stage; '-' reads stdin. Original history and pinned identity are retained; --version selects an explicit published version of the same pipeline only. --wait-timeout leaves an active retry for later read-only inspection or reattachment with the original --request-key, rather than starting a duplicate retry.", - "title": "Rename a run's operator-facing title after the fact without touching its input, steps or execution. The title is collapsed to a single bounded line and recorded as explicitly set. `pipelines runs` and `pipelines inspect` then show it.", - "wait": "Block until each named run reaches a terminal status - succeeded, failed, canceled or interrupted, and also through a run waiting on a person - then print one line per run with its id, status and outcome, its stage and how long it took, and exit 0 even for a run that finished unsuccessfully. Several ids wait together in one command. The exit is non-zero only for a client-side failure: an unknown run id, a connection that could not be established, or --timeout expiring while a run is still active; a timeout says so plainly, never cancels, retries or otherwise touches a run, and is never reported as its outcome. Read-only: it needs no workspace, is not refused by the workspace guard and writes nothing. --json prints the final run envelope instead of the line (one envelope for one id, an array for several).", - "decide": "Choose an option for a run waiting on a human stage. The run must be `waiting`; the option must be one of that stage's non-error edges. The stage is inferred from the run's current stage unless named. The choice and optional --feedback are recorded as the step's evidence (visible in inspect and the TUI) and the run resumes along the chosen edge. An unknown option is refused with the valid list; a repeated decision for an already-decided visit does not double-apply. Works across a server restart because the wait is persisted.", - "debug": "Open a fresh configured harness conversation to investigate a run using inspect/show/runs CLI queries. --harness opencode|pi|nvim chooses another configured harness or read-only nvim packet. Does not resume implementation or retry. --json returns the prompt without launching anything.", - "rpc": "Accepts a JSON protocol envelope; '-' reads stdin. Every TUI server operation is available here too. Mutating commands are not dry runs. The omni-search command is `search` (fields query, optional kind and limit) and answers with ranked `search_results`.", - "chat-adopt": "Adopt a session that already exists on the configured OpenCode endpoint so it appears in chat_sessions and can be continued. The id must be one the endpoint reports; its directory and title are taken from the endpoint's own record (never guessed), and a missing id records nothing. Adopting is always explicit and does not change the server's endpoint choice.", - "retention": "Local, explicit run-history retention; never automatic and never a side effect of another command. `report` is strictly read-only and prints what a policy would remove; `apply` removes it after approval (--yes for scripted use). Policy: --older-than DURATION selects runs created before now minus that rolling UTC duration (Go durations plus d/w; not a calendar boundary), --keep N keeps the newest N runs by run id and selects older ranks (--keep 0 keeps none). Both together are the conservative intersection; at least one is required. Protected and never removed: queued/running runs, runs waiting on a person (waiting run or step), runs with an active cleanup agent, and any run referenced by a retained run's retry provenance (transitively). A run that becomes protected before deletion aborts the whole apply. Artifacts at <root>/<run> are removed with their run and kept with protected/retained runs; the database is VACUUMed and its WAL checkpointed, with measured reclaimed bytes. Definitions and versions are immutable and never touched. --db must name an existing database (default: the standard data directory); --artifacts defaults to artifacts/ beside --db. Works without a running server.", - "search": "One read-only query over pipelines, versions, runs, steps, field text and artifacts. QUERY is free text, a bare status word (queued, running, succeeded, failed, canceled, interrupted) selecting those runs, or a lone date expression (today, yesterday, this week [Monday 00:00 local], or YYYY-MM-DD) selecting the runs created in that window. --type is the only narrowing mechanism and takes one kind: pipeline, version, run, step, field or artifact; an unknown kind is an error. Ranking: an exact name match (3) beats a name substring (2) beats a body-text match (1); equal tiers break by recency, then a stable kind/target tie-break, and every hit reports score, matched_field and recency so a client can re-rank. Bounds: the result cap defaults to 50 and clamps to 200 (0 = default); every kind scans at most 2000 rows and field-text scanning is additionally capped at 2000 steps / 1 MiB; Truncated plus scanned_steps, scanned_bytes and scan_bound_bytes report when a bound applied. Targets are stable: pipeline:<id>, pipeline:<id>:v<version>, run:<id>, run:<id>:<sequence>, run:<id>:<sequence>:<field>, or an artifact URL.", + "version": "Identify the local CLI binary without connecting to a server. --version is an alias. Use ping --json to identify the running server separately.", + "ping": "Pong includes the running server's compiled build.version, build.commit and build.dirty (null when unknown). This identifies the server, not the client or runtime workspace. Older servers omit build. The client compares its own build/protocol against the server: a same-protocol build mismatch prints one warning to stderr, a server speaking a newer protocol fails the command, and a response carrying a field this client does not model prints a one-time unrecognized-field notice instead of dropping it silently.", + "connection": "Prints the server endpoint and phone notification endpoints. Like ping, it reports the client/server build relationship and warns or fails rather than silently proceeding against a mismatched server.", + "status": "Reports server, host and ntfy publishing health. The client compares its build/protocol against the server and warns once (or fails on a newer protocol) rather than proceeding silently.", + "export": "Without a name, select pipelines with Space and save a ZIP in the current directory. --output writes a portable definition bundle; --all skips selection. One name without --output prints Markdown as before. No runs, credentials or old versions are exported.", + "import": "Select definitions from a ZIP. Identical existing definitions are skipped. For differing names, choose keep existing, keep both under a new name, or use imported as a new version (history retained). --on-conflict supplies an explicit automation policy; --yes only approves final publication. Schedules may activate; no run history is imported.", + "new": "Create an optional template copy or a one-stage starter. Opens the configured default harness; --harness opencode|pi|nvim overrides it. No submission is performed.", + "edit": "Omit the name to open fuzzy selection. Original immutable source is copied to a private draft. The configured harness edits that draft, never the live definition.", + "validate": "Uses the same server parser as submission. Does not persist or activate schedules. Structural validity does not prove runtime/tool availability.", + "submit": "Confirm publication at the prompt, or use --yes for explicit automation; schedules activate on acceptance. Managed drafts provide the name and base-version guard. --force never bypasses validation.", + "run": "Runs in your current directory after action confirmation (--yes skips it). Select a pipeline and compose a multiline task with Ctrl+S. Stage tools are enabled automatically; no file list or typed RUN confirmation. Cancellation does not undo edits. --title sets an explicit run title; without it the title is derived from the prompt. --model PROVIDER/MODEL overrides the model for every stage of that run; --stage-model STAGE=PROVIDER/MODEL overrides one stage and is repeatable, with a repeated key last-wins. Precedence is per-stage > whole-run > the model pinned in the pipeline version; overrides apply to that run only and never change the pinned definition. An unknown stage key or a malformed provider/model is refused before the run starts, naming the valid stage keys. In JSON mode --wait polls until terminal; --wait-timeout bounds only the client wait after admission and is independent of per-request --timeout. A reached wait limit leaves the run active: inspect read-only with `inspect <run-id> --json`, or reattach with --wait reusing the original --request-key (never an automatic replay or cancel).", + "retry": "Resume a failed stage by default, restoring the completed prefix handoff; use --mode=restart to start at entry. --stage selects a recorded stage (use --visit for repeated stages). --input-file accepts a bounded JSON object, merged with replacement at the selected stage; '-' reads stdin. Original history and pinned identity are retained; --version selects an explicit published version of the same pipeline only. --wait-timeout leaves an active retry for later read-only inspection or reattachment with the original --request-key, rather than starting a duplicate retry.", + "title": "Rename a run's operator-facing title after the fact without touching its input, steps or execution. The title is collapsed to a single bounded line and recorded as explicitly set. `pipelines runs` and `pipelines inspect` then show it.", + "wait": "Block until each named run reaches a terminal status - succeeded, failed, canceled or interrupted, and also through a run waiting on a person - then print one line per run with its id, status and outcome, its stage and how long it took, and exit 0 even for a run that finished unsuccessfully. Several ids wait together in one command. The exit is non-zero only for a client-side failure: an unknown run id, a connection that could not be established, or --timeout expiring while a run is still active; a timeout says so plainly, never cancels, retries or otherwise touches a run, and is never reported as its outcome. Read-only: it needs no workspace, is not refused by the workspace guard and writes nothing. --json prints the final run envelope instead of the line (one envelope for one id, an array for several).", + "decide": "Choose an option for a run waiting on a human stage. The run must be `waiting`; the option must be one of that stage's non-error edges. The stage is inferred from the run's current stage unless named. The choice and optional --feedback are recorded as the step's evidence (visible in inspect and the TUI) and the run resumes along the chosen edge. An unknown option is refused with the valid list; a repeated decision for an already-decided visit does not double-apply. Works across a server restart because the wait is persisted.", + "debug": "Open a fresh configured harness conversation to investigate a run using inspect/show/runs CLI queries. --harness opencode|pi|nvim chooses another configured harness or read-only nvim packet. Does not resume implementation or retry. --json returns the prompt without launching anything.", + "rpc": "Accepts a JSON protocol envelope; '-' reads stdin. Every TUI server operation is available here too. Mutating commands are not dry runs. The omni-search command is `search` (fields query, optional kind and limit) and answers with ranked `search_results`.", + "chat-adopt": "Adopt a session that already exists on the configured OpenCode endpoint so it appears in chat_sessions and can be continued. The id must be one the endpoint reports; its directory and title are taken from the endpoint's own record (never guessed), and a missing id records nothing. Adopting is always explicit and does not change the server's endpoint choice.", + "retention": "Local, explicit run-history retention; never automatic and never a side effect of another command. `report` is strictly read-only and prints what a policy would remove; `apply` removes it after approval (--yes for scripted use). Policy: --older-than DURATION selects runs created before now minus that rolling UTC duration (Go durations plus d/w; not a calendar boundary), --keep N keeps the newest N runs by run id and selects older ranks (--keep 0 keeps none). Both together are the conservative intersection; at least one is required. Protected and never removed: queued/running runs, runs waiting on a person (waiting run or step), runs with an active cleanup agent, and any run referenced by a retained run's retry provenance (transitively). A run that becomes protected before deletion aborts the whole apply. Artifacts at <root>/<run> are removed with their run and kept with protected/retained runs; the database is VACUUMed and its WAL checkpointed, with measured reclaimed bytes. Definitions and versions are immutable and never touched. --db must name an existing database (default: the standard data directory); --artifacts defaults to artifacts/ beside --db. Works without a running server.", + "search": "One read-only query over pipelines, versions, runs, steps, field text and artifacts. QUERY is free text, a bare status word (queued, running, succeeded, failed, canceled, interrupted) selecting those runs, or a lone date expression (today, yesterday, this week [Monday 00:00 local], or YYYY-MM-DD) selecting the runs created in that window. --type is the only narrowing mechanism and takes one kind: pipeline, version, run, step, field or artifact; an unknown kind is an error. Ranking: an exact name match (3) beats a name substring (2) beats a body-text match (1); equal tiers break by recency, then a stable kind/target tie-break, and every hit reports score, matched_field and recency so a client can re-rank. Bounds: the result cap defaults to 50 and clamps to 200 (0 = default); every kind scans at most 2000 rows and field-text scanning is additionally capped at 2000 steps / 1 MiB; Truncated plus scanned_steps, scanned_bytes and scan_bound_bytes report when a bound applied. Targets are stable: pipeline:<id>, pipeline:<id>:v<version>, run:<id>, run:<id>:<sequence>, run:<id>:<sequence>:<field>, or an artifact URL.", + "resource-pool-configure": "Read a bounded full pool declaration from JSON and replace the declaration only after explicit --yes consent. Use '-' for stdin. This is local operator transport only; it never accepts or returns capabilities or credentials. resource-pool-inspect reads the declared members and status.", } var serviceHelp = map[string]string{ diff --git a/internal/pipeline/resources.go b/internal/pipeline/resources.go index 61a1f3a6..d9f6ce1a 100644 --- a/internal/pipeline/resources.go +++ b/internal/pipeline/resources.go @@ -250,6 +250,21 @@ func (s *Store) ConfigureResourcePool(ctx context.Context, pool protocol.Resourc return err } +// InspectResourcePool returns the declared pool, including only bounded, +// non-secret member metadata and status. +func (s *Store) InspectResourcePool(ctx context.Context, name string) (protocol.ResourcePool, error) { + if !ValidResourceKey(name) { + return protocol.ResourcePool{}, fmt.Errorf("invalid resource pool") + } + s.resourceMu.Lock() + defer s.resourceMu.Unlock() + members, err := s.resourcePool(ctx, s.db, name) + if err != nil { + return protocol.ResourcePool{}, err + } + return protocol.ResourcePool{Name: name, Members: members}, nil +} + func (s *Store) resourcePool(ctx context.Context, tx interface { QueryRowContext(context.Context, string, ...any) *sql.Row }, name string) ([]protocol.ResourcePoolMember, error) { diff --git a/internal/protocol/message.go b/internal/protocol/message.go index b5359fbb..eb7a9ac0 100644 --- a/internal/protocol/message.go +++ b/internal/protocol/message.go @@ -20,6 +20,10 @@ const ( ResourceInspectionResult = "resource_inspection" ReconcileResource = "reconcile_resource" ResourceReconciled = "resource_reconciled" + InspectResourcePool = "inspect_resource_pool" + ResourcePoolInspection = "resource_pool_inspection" + ConfigureResourcePool = "configure_resource_pool" + ResourcePoolConfigured = "resource_pool_configured" ) type Stage struct { @@ -212,4 +216,5 @@ type Message struct { Resource string `json:"resource,omitempty"` ResourceInspection *ResourceInspection `json:"resource_inspection,omitempty"` ResourceRecovery *ResourceRecoveryRequest `json:"resource_recovery,omitempty"` + ResourcePool *ResourcePool `json:"resource_pool,omitempty"` } diff --git a/internal/protocol/resources.go b/internal/protocol/resources.go index 8f31867e..704d015d 100644 --- a/internal/protocol/resources.go +++ b/internal/protocol/resources.go @@ -5,6 +5,7 @@ type ResourceInspection struct { Owner *ResourceOwner `json:"owner,omitempty"` Waiters []ResourceWaiter `json:"waiters,omitempty"` Audits []ResourceRecoveryAudit `json:"audits,omitempty"` + Pool *ResourcePool `json:"pool,omitempty"` } // ResourceTarget is bounded, non-secret metadata for the concrete member that diff --git a/internal/server/resource_cli_test.go b/internal/server/resource_cli_test.go index 7147a7f4..e8a593c7 100644 --- a/internal/server/resource_cli_test.go +++ b/internal/server/resource_cli_test.go @@ -365,6 +365,92 @@ func TestResourceOperatorTransportRejectsForgedForwardedPeer(t *testing.T) { } } +func TestResourcePoolOperatorCLIConfigureReadbackAndPreserveLease(t *testing.T) { + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + dbPath := filepath.Join(t.TempDir(), "pool-operator.db") + store, err := pipeline.Open(dbPath) + if err != nil { + t.Fatal(err) + } + defer store.Close() + if err := store.ConfigureResourcePool(ctx, protocol.ResourcePool{Name: "targets", Members: []protocol.ResourcePoolMember{{Member: "phone", Enabled: true, Metadata: map[string]string{"serial": "old"}}}}); err != nil { + t.Fatal(err) + } + if _, err := store.Submit(ctx, "pool-owner", pipeline.Template([]string{"work"}, true)+"```resources\n{\"pool\":\"targets\"}\n```\n"); err != nil { + t.Fatal(err) + } + items, err := store.List(ctx) + if err != nil || len(items) != 1 { + t.Fatal("pool pipeline missing", err) + } + detail, err := store.Get(ctx, items[0].ID, 1) + if err != nil { + t.Fatal(err) + } + runID, _, err := store.CreateRun(ctx, detail, "pool-owner", t.TempDir(), false, nil, nil) + if err != nil { + t.Fatal(err) + } + lease, ready, _, err := store.RequestResourcePool(ctx, "targets", pipeline.ResourceVisit{Resource: "targets", RunID: runID, Stage: "work", Sequence: 1}) + if err != nil || ready != nil { + t.Fatalf("pool lease: ready=%v err=%v", ready, err) + } + + handler := Handler(ctx, store) + srv := httptest.NewServer(handler) + defer srv.Close() + endpoint := "ws" + strings.TrimPrefix(srv.URL, "http") + "/connect" + normal, err := client.Open(ctx, endpoint) + if err != nil { + t.Fatal(err) + } + if _, err := normal.Call(ctx, protocol.Message{Type: protocol.ConfigureResourcePool, ResourcePool: &protocol.ResourcePool{Name: "targets", Members: []protocol.ResourcePoolMember{{Member: "phone", Enabled: true}}}}); err == nil || !strings.Contains(err.Error(), "operator transport") { + t.Fatalf("remote configuration was accepted: %v", err) + } + normal.Close() + + declaration := filepath.Join(t.TempDir(), "pool.json") + if err := os.WriteFile(declaration, []byte(`{"name":"targets","members":[{"member":"phone","enabled":true,"metadata":{"serial":"new"}},{"member":"emulator","enabled":false}]}`), 0600); err != nil { + t.Fatal(err) + } + var out bytes.Buffer + app := cli.App{Out: &out, Err: &out, In: strings.NewReader("")} + if err := app.Run(ctx, []string{"--url", "ws" + strings.TrimPrefix(srv.URL, "http"), "resource-pool-configure", declaration, "--yes", "--json"}); err != nil { + t.Fatalf("configure CLI: %v\n%s", err, out.String()) + } + out.Reset() + app = cli.App{Out: &out, Err: &out, In: strings.NewReader("")} + if err := app.Run(ctx, []string{"--url", "ws" + strings.TrimPrefix(srv.URL, "http"), "resource-pool-inspect", "targets", "--json"}); err != nil { + t.Fatalf("inspect CLI: %v\n%s", err, out.String()) + } + var pool protocol.ResourcePool + if err := json.Unmarshal(out.Bytes(), &pool); err != nil || len(pool.Members) != 2 || pool.Members[0].Metadata["serial"] != "new" { + t.Fatalf("bad pool readback: %s (%v)", out.String(), err) + } + inspection, err := store.InspectResource(ctx, "phone") + if err != nil || inspection.Owner == nil || inspection.Owner.RunID != runID { + t.Fatalf("configuration released active lease: %#v (%v)", inspection, err) + } + if err := store.SetResourceCleanup(ctx, lease, true); err != nil { + t.Fatal(err) + } + if err := store.ReleaseResource(ctx, lease); err != nil { + t.Fatal(err) + } + srv.Close() + store.Close() + reopened, err := pipeline.Open(dbPath) + if err != nil { + t.Fatal(err) + } + defer reopened.Close() + persisted, err := reopened.InspectResourcePool(ctx, "targets") + if err != nil || persisted.Members[0].Metadata["serial"] != "new" { + t.Fatalf("pool did not survive reopen: %#v (%v)", persisted, err) + } +} + func TestResourceAndroidDraftPublishedV3Provenance(t *testing.T) { baseline, err := os.ReadFile("testdata/android-v3-published.md") if err != nil { diff --git a/internal/server/websocket.go b/internal/server/websocket.go index 9003a433..0235281b 100644 --- a/internal/server/websocket.go +++ b/internal/server/websocket.go @@ -270,7 +270,7 @@ func HandlerWithOptions(ctx context.Context, options Options, stores ...*pipelin response.Error = err.Error() } } - } else if (request.Type == protocol.InspectResource || request.Type == protocol.ReconcileResource) && len(stores) > 0 { + } else if (request.Type == protocol.InspectResource || request.Type == protocol.ReconcileResource || request.Type == protocol.InspectResourcePool || request.Type == protocol.ConfigureResourcePool) && len(stores) > 0 { var err error response.Type = protocol.ResourceInspectionResult // Recovery has a separate transport path. A stage/model client may @@ -280,6 +280,18 @@ func HandlerWithOptions(ctx context.Context, options Options, stores ...*pipelin if r.URL.Path != "/operator-connect" || !isLoopbackPeer(r.RemoteAddr) { response.Type = protocol.Error response.Error = "resource recovery requires the local operator transport" + } else if request.Type == protocol.InspectResourcePool { + response.Type = protocol.ResourcePoolInspection + var pool protocol.ResourcePool + pool, err = stores[0].InspectResourcePool(ctx, request.Resource) + response.ResourcePool = &pool + } else if request.Type == protocol.ConfigureResourcePool { + response.Type = protocol.ResourcePoolConfigured + if request.ResourcePool == nil { + err = fmt.Errorf("resource pool declaration is required") + } else { + err = stores[0].ConfigureResourcePool(ctx, *request.ResourcePool) + } } else if request.Type == protocol.InspectResource { var inspection protocol.ResourceInspection inspection, err = stores[0].InspectResource(ctx, request.Resource) From 80a1d1e0ea3d824995ffd15436d0a4308fb3b56f Mon Sep 17 00:00:00 2001 From: Alan Silva <alanfortlink@gmail.com> Date: Sun, 18 Oct 2026 23:43:58 +0100 Subject: [PATCH 6/7] Bound pool declaration reads and document operator commands --- docs/cli.md | 15 +++++++++++++++ internal/cli/app.go | 16 ++++++++++++++-- internal/server/resource_cli_test.go | 16 ++++++++++++++++ 3 files changed, 45 insertions(+), 2 deletions(-) diff --git a/docs/cli.md b/docs/cli.md index 996962c5..b1e9c2ac 100644 --- a/docs/cli.md +++ b/docs/cli.md @@ -16,6 +16,21 @@ service manager directly. Legacy Python-managed installations require an explici For source development, use `go run ./cmd/pipelines help`; start the native server separately. Set `PIPELINES_URL` or pass `--url` to select another server. +## Local resource pools + +`pipelines resource-pool-inspect NAME --json` reads a declared pool's members, +enabled/quarantined status and non-secret metadata. It does not report lease tokens. +`pipelines resource-pool-configure pool.json --yes --json` replaces the full pool +declaration; use `-` instead of a file to read stdin. Input is limited to 256 KiB. +Without `--yes`, interactive confirmation is required. Both commands require the +loopback operator transport; ordinary remote/stage clients are refused. + +Declarations contain `name` and `members`, each with `member`, `enabled`, optional +`quarantined` and bounded string `metadata`. Existing validation limits the member +count to 32 and metadata to 16 fields per member. Configuration does not release +active owners, discard waiters or prove a device is ready; inspect ownership and +verify readiness before activating a target. Never put credentials in metadata. + ## Dashboard and status `pipelines --url ws://HOST:PORT/connect ping --json` returns `pong` with the diff --git a/internal/cli/app.go b/internal/cli/app.go index 92032422..120b0964 100644 --- a/internal/cli/app.go +++ b/internal/cli/app.go @@ -1002,13 +1002,25 @@ func (a App) Run(ctx context.Context, args []string) error { } var data []byte if file == "-" { - data, err = io.ReadAll(a.In) + input := a.In + if input == nil { + input = os.Stdin + } + data, err = io.ReadAll(io.LimitReader(input, 256*1024+1)) } else { - data, err = os.ReadFile(file) + var input *os.File + input, err = os.Open(file) + if err == nil { + data, err = io.ReadAll(io.LimitReader(input, 256*1024+1)) + _ = input.Close() + } } if err != nil { return err } + if len(data) > 256*1024 { + return fmt.Errorf("resource pool input exceeds 262144 bytes") + } var pool protocol.ResourcePool if err := json.Unmarshal(data, &pool); err != nil { return fmt.Errorf("invalid resource pool JSON: %w", err) diff --git a/internal/server/resource_cli_test.go b/internal/server/resource_cli_test.go index e8a593c7..209be052 100644 --- a/internal/server/resource_cli_test.go +++ b/internal/server/resource_cli_test.go @@ -415,6 +415,22 @@ func TestResourcePoolOperatorCLIConfigureReadbackAndPreserveLease(t *testing.T) t.Fatal(err) } var out bytes.Buffer + for _, fromStdin := range []bool{false, true} { + oversized := strings.Repeat(" ", 256*1024+1) + path := filepath.Join(t.TempDir(), "oversized.json") + if err := os.WriteFile(path, []byte(oversized), 0600); err != nil { + t.Fatal(err) + } + if fromStdin { + path = "-" + } + bounded := cli.App{Out: &out, Err: &out, In: strings.NewReader(oversized)} + err := bounded.Run(ctx, []string{"--url", endpoint, "resource-pool-configure", path, "--yes", "--json"}) + if err == nil || !strings.Contains(err.Error(), "exceeds 262144 bytes") { + t.Fatalf("oversized pool input (stdin=%v): %v", fromStdin, err) + } + out.Reset() + } app := cli.App{Out: &out, Err: &out, In: strings.NewReader("")} if err := app.Run(ctx, []string{"--url", "ws" + strings.TrimPrefix(srv.URL, "http"), "resource-pool-configure", declaration, "--yes", "--json"}); err != nil { t.Fatalf("configure CLI: %v\n%s", err, out.String()) From 80f8e2edc4a2a0cc95d54c892dffce6fae61dbae Mon Sep 17 00:00:00 2001 From: Alan Silva <alanfortlink@gmail.com> Date: Sun, 18 Oct 2026 23:43:58 +0100 Subject: [PATCH 7/7] Wait for released workspace cleanup in retry isolation test --- internal/server/concurrency_test.go | 3 +++ 1 file changed, 3 insertions(+) diff --git a/internal/server/concurrency_test.go b/internal/server/concurrency_test.go index 81aa2236..a60bf7e7 100644 --- a/internal/server/concurrency_test.go +++ b/internal/server/concurrency_test.go @@ -370,6 +370,9 @@ func TestRetryConflictsOnlyWithSameWorkspaceActiveRun(t *testing.T) { t.Fatalf("retry did not conflict with same-workspace active run: %v", err) } close(releaseA) + // Execution returning does not instantly remove the workspace reservation. + // Finish A's cleanup before asserting that only the unrelated B is active. + r.wg.Wait() // A different active workspace must not block the retry of the original. if _, err := r.start(protocol.Message{PipelineID: pipelineID, Version: 1, RequestKey: "active-b", Workspace: b, Input: map[string]any{"prompt": "task"}}); err != nil { t.Fatal(err)