From 44834e91f097c392bb897ce77cd355d5eb2fe992 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Tue, 20 Oct 2026 15:40:43 +0100 Subject: [PATCH] runs: reconcile uncertain browser launches with a persistent intent key --- docs/system-hardening.md | 11 +++++++ internal/server/run_websocket_test.go | 8 +++++ internal/server/websocket.go | 10 +++++- web/src/repository.js | 11 +++++-- web/src/runIntent.js | 34 ++++++++++++++++++++ web/src/views/pipelines.js | 45 +++++++++++++++++++++++---- web/test/repository.test.mjs | 14 +++++++++ web/test/runIntent.test.mjs | 22 +++++++++++++ 8 files changed, 146 insertions(+), 9 deletions(-) create mode 100644 web/src/runIntent.js create mode 100644 web/test/runIntent.test.mjs diff --git a/docs/system-hardening.md b/docs/system-hardening.md index 974693bb..848cc0c8 100644 --- a/docs/system-hardening.md +++ b/docs/system-hardening.md @@ -42,6 +42,17 @@ can use the host user's permissions, credentials, and network. Use a dedicated unprivileged account, VM, or container with an explicit workspace mount for untrusted definitions. Do not advertise prompt instructions as sandboxing. +## Lost run-start replies + +The web Run dialog saves one immutable launch payload and request key in tab +storage before sending it. An uncertain launch is not automatically replayed. +`Check / retry` first uses the read-only `get_run` command with `request_key`; +if admitted, it opens that exact run, even if it already finished. Otherwise it +resends the original intent with the same key. Changing the task requires first +resolving admission; an explicit refusal is editable only after that lookup +confirms no run exists. A page reload and reopening the same pipeline/version +recovers the pending intent on the same endpoint. + ## Delivery discipline Checks and browser probes use scratch databases and loopback ports. Installing diff --git a/internal/server/run_websocket_test.go b/internal/server/run_websocket_test.go index eaffbddc..9c38944e 100644 --- a/internal/server/run_websocket_test.go +++ b/internal/server/run_websocket_test.go @@ -76,6 +76,14 @@ func TestRunWebSocketRemainsResponsiveAndAuditable(t *testing.T) { t.Fatal("started run omitted pinned graph") } <-entered + lookup := request(protocol.Message{Type: protocol.GetRun, ID: "reconcile", RequestKey: "ws-once"}) + if lookup.Type != protocol.Run || lookup.RunDetail == nil || lookup.RunDetail.ID != started.RunDetail.ID { + t.Fatalf("read-only admission lookup failed: %+v", lookup) + } + absent := request(protocol.Message{Type: protocol.GetRun, ID: "absent", RequestKey: "not-admitted"}) + if absent.Type != protocol.Run || absent.RunDetail != nil { + t.Fatalf("absent lookup must not invent a run: %+v", absent) + } if response := request(protocol.Message{Type: protocol.Ping, ID: "ping"}); response.Type != protocol.Pong { t.Fatal("active run blocked ping") } diff --git a/internal/server/websocket.go b/internal/server/websocket.go index 68c2c64b..fe14bf78 100644 --- a/internal/server/websocket.go +++ b/internal/server/websocket.go @@ -302,7 +302,15 @@ func HandlerWithOptions(ctx context.Context, options Options, stores ...*pipelin } case protocol.GetRun: response.Type = protocol.Run - response.RunDetail, err = runs.getRun(request.RunID) + if request.RunID == 0 && request.RequestKey != "" { + var id int64 + id, err = stores[0].RunByKey(connCtx, request.RequestKey) + if err == nil && id != 0 { + response.RunDetail, err = runs.getRun(id) + } + } else { + response.RunDetail, err = runs.getRun(request.RunID) + } case protocol.CancelRun: response.Type = protocol.Run err = runs.cancel(request.RunID) diff --git a/web/src/repository.js b/web/src/repository.js index 84a8e2da..1c4db410 100644 --- a/web/src/repository.js +++ b/web/src/repository.js @@ -185,12 +185,12 @@ export class PipelinesRepository { * Starts a fresh run of one pipeline version. `notifyMode` is auto, on or off; * auto omits the field so the pipeline definition applies. */ - async runPipeline({ pipelineId, version, prompt, workspace, notifyMode = "auto", title = "" } = {}) { + async runPipeline({ pipelineId, version, prompt, workspace, notifyMode = "auto", title = "", requestKey = newChatOperationId() } = {}) { const request = { type: Protocol.RUN_PIPELINE, pipeline_id: Number(pipelineId), version: Number(version), - request_key: newChatOperationId(), + request_key: requestKey, workspace: String(workspace ?? "").trim(), input: { prompt: String(prompt ?? "") }, }; @@ -204,6 +204,13 @@ export class PipelinesRepository { return response.run_detail; } + /** Read-only admission reconciliation after a lost launch response. */ + async runByRequestKey(requestKey) { + if (!String(requestKey ?? "").trim()) throw new ProtocolError("A launch request key is required."); + const response = await this.#client.call({ type: Protocol.GET_RUN, request_key: requestKey }); + return response.run_detail ?? null; + } + async cancelRun(id) { const response = await this.#client.call({ type: Protocol.CANCEL_RUN, run_id: id }); if (!response.run_detail) { diff --git a/web/src/runIntent.js b/web/src/runIntent.js new file mode 100644 index 00000000..9d2b781c --- /dev/null +++ b/web/src/runIntent.js @@ -0,0 +1,34 @@ +// A launch intent survives a lost response and a page reload. It is never +// replayed automatically; the operator explicitly checks/retries the same key. +import { newChatOperationId } from "./repository.js"; + +function storageKey(endpoint, pipelineId, version) { + return `pipelines.web.pendingRun.v1:${endpoint}:${pipelineId}:${version}`; +} + +export function pendingRun(storage, endpoint, pipelineId, version) { + try { + const item = JSON.parse(storage?.getItem(storageKey(endpoint, pipelineId, version)) ?? "null"); + if (!item || typeof item.requestKey !== "string" || typeof item.prompt !== "string" || typeof item.workspace !== "string") return null; + if (item.pipelineId !== pipelineId || item.version !== version) return null; + return item; + } catch { + return null; + } +} + +export function createRunIntent(payload) { + return { ...payload, requestKey: newChatOperationId() }; +} + +export function saveRunIntent(storage, endpoint, intent) { + try { + storage?.setItem(storageKey(endpoint, intent.pipelineId, intent.version), JSON.stringify(intent)); + } catch { /* In-memory identity still protects retries when storage is unavailable. */ } +} + +export function clearRunIntent(storage, endpoint, intent) { + try { + storage?.removeItem(storageKey(endpoint, intent.pipelineId, intent.version)); + } catch { /* Storage failure must not turn a completed launch into another run. */ } +} diff --git a/web/src/views/pipelines.js b/web/src/views/pipelines.js index 5f4a5821..38ef753a 100644 --- a/web/src/views/pipelines.js +++ b/web/src/views/pipelines.js @@ -27,6 +27,8 @@ import { import { PIPELINE_GRAPH_EMPTY, layoutGraph, mount as mountGraph } from "../graph.js"; import { statusIcon } from "../statusIcon.js"; import { writeGraphExpanded } from "../graphPrefs.js"; +import { pendingRun, createRunIntent, saveRunIntent, clearRunIntent } from "../runIntent.js"; +import { ProtocolError } from "../client.js"; export function createPipelinesView(rt) { const { state, repo, modal } = rt; @@ -391,6 +393,13 @@ async function openRunDialog(pipeline) { sending: false, error: "", }; + start.intent = pendingRun(globalThis.sessionStorage, state.url, start.pipelineId, start.version); + if (start.intent) { + start.prompt = start.intent.prompt; + start.workspace = start.intent.workspace; + start.notifyMode = start.intent.notifyMode; + start.error = "A previous launch has an unknown result. Check/retry reconciles that same request; it will not start a duplicate."; + } state.runStart = start; renderContent(); try { @@ -428,9 +437,9 @@ async function startRun() { } start.sending = true; start.error = ""; - renderContent(); - try { - const run = await repo.runPipeline({ + const recovering = start.intent != null; + if (!start.intent) { + start.intent = createRunIntent({ pipelineId: start.pipelineId, version: start.version, prompt, @@ -438,12 +447,34 @@ async function startRun() { notifyMode: start.notifyMode, title: "", }); + } + saveRunIntent(globalThis.sessionStorage, state.url, start.intent); + renderContent(); + try { + const existing = recovering ? await repo.runByRequestKey(start.intent.requestKey) : null; + const run = existing ?? await repo.runPipeline(start.intent); + clearRunIntent(globalThis.sessionStorage, state.url, start.intent); state.runStart = null; await applyRoute({ kind: "run", id: run.id }); } catch (error) { if (state.runStart !== start) return; + // A confirmed refusal can be corrected, but only after a read proves no + // run was admitted. A generic transport failure remains uncertain. + if (error instanceof ProtocolError) { + try { + const existing = await repo.runByRequestKey(start.intent.requestKey); + if (existing) { + clearRunIntent(globalThis.sessionStorage, state.url, start.intent); + state.runStart = null; + await applyRoute({ kind: "run", id: existing.id }); + return; + } + clearRunIntent(globalThis.sessionStorage, state.url, start.intent); + start.intent = null; + } catch { /* Keep the launch immutable until admission can be checked. */ } + } start.sending = false; - start.error = describeError(error); + start.error = describeError(error) + (start.intent ? ". Admission may be unknown. Check/retry uses the same request key." : ""); renderContent(); } } @@ -470,6 +501,7 @@ function renderRunStartDialog() { rows: "5", placeholder: "What should this run do?", spellcheck: "false", + disabled: start.intent != null, oninput: (event) => { start.prompt = event.target.value; }, }); prompt.value = start.prompt; @@ -486,6 +518,7 @@ function renderRunStartDialog() { type: "text", list: listId, value: start.workspace, + disabled: start.intent != null, spellcheck: "false", autocomplete: "off", placeholder: "/absolute/path/on/the/server", @@ -497,7 +530,7 @@ function renderRunStartDialog() { const notifyField = h("label", { class: "run-start-field", for: "runNotify" }); notifyField.append(h("span", { class: "run-start-label", text: "Notifications for this run" })); - const notify = h("select", { id: "runNotify", onchange: (event) => { start.notifyMode = event.target.value; } }); + const notify = h("select", { id: "runNotify", disabled: start.intent != null, onchange: (event) => { start.notifyMode = event.target.value; } }); for (const [value, label] of [ ["auto", "Pipeline default"], ["on", "Notify me"], @@ -525,7 +558,7 @@ function renderRunStartDialog() { h("button", { class: "primary run-start-confirm", type: "button", - text: start.sending ? "Starting…" : "Run", + text: start.sending ? "Starting…" : start.intent ? "Check / retry" : "Run", disabled: start.sending, onclick: startRun, }), diff --git a/web/test/repository.test.mjs b/web/test/repository.test.mjs index ccd1a16c..2d8ed4a4 100644 --- a/web/test/repository.test.mjs +++ b/web/test/repository.test.mjs @@ -332,6 +332,20 @@ test("a run action throws when the reply has no run detail", async () => { // ---- The composer's own commands (C8/C9) ---------------------------------- +test("run retries preserve one admission key and can reconcile without execution", async () => { + const { repo, ws } = connected(); + ws.reply = (frame) => ({ id: frame.id, type: "run", run_detail: { id: 42 } }); + const intent = { pipelineId: 7, version: 1, prompt: "task", workspace: "/work", requestKey: "same-intent" }; + await repo.runPipeline(intent); + await repo.runPipeline(intent); + assert.deepEqual(ws.sent.map((frame) => frame.request_key), ["same-intent", "same-intent"]); + assert.equal((await repo.runByRequestKey("same-intent")).id, 42); + assert.equal(lastFrame(ws).type, "get_run"); + assert.equal(lastFrame(ws).request_key, "same-intent"); + ws.reply = (frame) => ({ id: frame.id, type: "run" }); + assert.equal(await repo.runByRequestKey("not-admitted"), null); +}); + test("chatPrompt trims the text, sends the operation and native message ids, and omits files when empty", async () => { const { repo, ws } = connected(); ws.reply = (frame) => ({ id: frame.id, type: "chat_prompt" }); diff --git a/web/test/runIntent.test.mjs b/web/test/runIntent.test.mjs new file mode 100644 index 00000000..20e9934f --- /dev/null +++ b/web/test/runIntent.test.mjs @@ -0,0 +1,22 @@ +import { test } from "node:test"; +import assert from "node:assert/strict"; +import { createRunIntent, saveRunIntent, pendingRun, clearRunIntent } from "../src/runIntent.js"; + +test("pending launch identity and payload survive reload and stay endpoint-scoped", () => { + const values = new Map(); + const storage = { getItem: (key) => values.get(key), setItem: (key, value) => values.set(key, value), removeItem: (key) => values.delete(key) }; + const payload = { pipelineId: 7, version: 3, prompt: "report", workspace: "/work", notifyMode: "off" }; + const intent = createRunIntent(payload); + assert.ok(intent.requestKey); + saveRunIntent(storage, "ws://server/connect", intent); + assert.deepEqual(pendingRun(storage, "ws://server/connect", 7, 3), intent); + assert.equal(pendingRun(storage, "ws://other/connect", 7, 3), null); + assert.equal(pendingRun(storage, "ws://server/connect", 7, 4), null); + clearRunIntent(storage, "ws://server/connect", intent); + assert.equal(pendingRun(storage, "ws://server/connect", 7, 3), null); +}); + +test("malformed or unavailable pending-run storage never invents an intent", () => { + assert.equal(pendingRun({ getItem: () => "not json" }, "ws://s", 1, 1), null); + assert.equal(pendingRun({ getItem: () => { throw Error("disabled"); } }, "ws://s", 1, 1), null); +});