web: run-level actions — human decision, cancel, retry and rename (R11–R14)

Add the run-level operator actions to the browser run detail, matching the
Android client's wording and wire frames:

- R11 human decision: pure model in src/actions.js (pendingDecision,
  lastWaitingStep, waitingPrompt/waitingOptions, humanOptions,
  decisionTargetLabel, DecisionDraft) plus the decision card and sheet;
  decide_run sends run_id, the chosen option and trimmed feedback.
- R12 cancel: a Cancel run action offered only while executing; the Android
  confirm copy; cancel_run then a silent get_run refresh.
- R13 retry: offered only for a loaded, non-executing failed run; resume is
  the default (no retry_mode, like Android) with a browser-only
  Restart from start secondary that sends retry_mode:"restart".
- R14 rename: an inline set_run_title field; refreshes the run and its list row.
- One shared Action failed dialog for all of the above.

Add the protocol constants and typed builders, a hand-written dark-palette
section for the card/sheet/dialogs, focused unit tests for the helpers and
request shapes, and ui-smoke captures for the new states. Update PARITY.md:
R11 stays partial (no live waiting run), R12–R14 done with the stated
shown-not-executed and Android-divergence notes.

Also harden openRunDetail() in the UI smoke: the tabstrip already exists from
the previously opened run, so wait for the target run's identity line before
asserting on its actions (review finding).
This commit is contained in:
2026-10-19 04:37:35 +01:00
parent 9555bfe58f
commit 6992ecd4e8
9 changed files with 1534 additions and 14 deletions
+15 -4
View File
@@ -41,10 +41,10 @@ Status legend: `todo` · `partial` (some of it works) · `done` (working + captu
| R8 | Artifacts gallery + full-screen viewer (images inline, others download/open) | `GET /artifacts/…` | done (captured 2026-10-19: `captures/04-run-430-artifacts.png`, `captures/05-artifact-viewer.png`) |
| R9 | Session export link (read-only `session.html`) | `GET /artifacts/…` | done (captured 2026-10-19: `captures/06-session-export-link.png`) |
| R10 | Live run updates: subscribe/unsubscribe + event fold | `subscribe`, `unsubscribe`, `run_event` | todo |
| R11 | Human decision sheet: prompt, options, feedback | `decide_run` | todo |
| R12 | Cancel run | `cancel_run` | todo |
| R13 | Retry failed stage (resume) / restart from start | `retry_run` | todo |
| R14 | Rename a run | `set_run_title` | todo |
| R11 | Human decision sheet: prompt, options, feedback | `decide_run` | partial — the pure model (`src/actions.js`: `pendingDecision`, `lastWaitingStep`, `waitingPrompt`/`waitingOptions`, `humanOptions`, `decisionTargetLabel`, `DecisionDraft`) and the card + sheet are implemented with the Android copy verbatim: card title `Waiting for your decision`, meta `{stage} · run {id} · {runLabel}`, action `Decide`; sheet title `Decide {stage}`, meta `run {id} · {runLabel}`, the recorded instructions verbatim when non-blank, one selectable row per option in author order showing the option and `→ {target}` only when the declared edge resolves, the `Feedback (optional)` field, and `Cancel` / `Confirm decision` (reading `Sending…` while in flight). Selecting a row sends nothing and Confirm is disabled until a non-blank option is chosen; a refusal keeps the sheet open with the server's exact reason and re-reads the run. The request shape is unit-tested (`decide_run` = `{type, run_id, option, stage?, feedback?}`, stage/feedback omitted when blank, feedback trimmed). **No browser capture yet**: the live server had no `waiting` run when `ui-smoke.mjs` ran (only executing/failed/finished runs), so this row stays `partial`; `test/ui-smoke.mjs` now captures the card, the sheet and the selected state automatically (`captures/41-run-<id>-decision-card.png`, `captures/42-run-<id>-decision-sheet.png`, `captures/43-run-<id>-decision-selected.png`) the moment a waiting run exists |
| R12 | Cancel run | `cancel_run` | done — `src/actions.js` `canCancel` offers a `Cancel run` action only while the run is `executing`; the confirm dialog is the Android copy verbatim (title `Cancel run {id}?`, `This asks the server to stop the active run.`, confirm `Cancel run`, dismiss `Keep`), and the request is exactly `{type:'cancel_run',run_id}` followed by a silent `get_run` refresh (unit-tested in `test/repository.test.mjs`). Captured `captures/40-run-459-cancel-confirm.png` on the executing run present at capture time. **Shown, not executed**: the only candidate was another live pipeline's executing run, so the dialog was shown and dismissed with `Keep` — no `cancel_run` was sent (a real cancel is only safe against a run started in a scratch workspace, which this stage did not do) |
| R13 | Retry failed stage (resume) / restart from start | `retry_run` | done — `canRetry` is true only for a loaded, non-executing, `failed` run; the Retry confirm is the Android copy verbatim (title `Retry run {id}?`, `Only failed runs can be retried. The server starts a new run from the same input.`, confirm `Retry`, dismiss `Keep`) and the default send carries only `run_id` + a fresh `request_key` (**no** `retry_mode`, so the server's `resume` default applies exactly like the Android client's mode-less call; unit-tested). Captured `captures/35-run-440-run-actions.png` (failed run 440 offers Retry and no Cancel) and `captures/36-run-440-retry-confirm.png`. **Divergence from the Android UI, stated here**: Android exposes resume only while the protocol has both modes, so the browser adds a clearly-labelled secondary `Restart from start` confirm that states it `replays the whole pipeline from the start instead of resuming the failed stage` and sends `retry_mode:"restart"` (`captures/37-run-440-restart-confirm.png`). Both dialogs were shown and dismissed with `Keep`; no run was started |
| R14 | Rename a run | `set_run_title` | done — an inline field on the Summary title row (pre-filled with the current title, `Rename` / `Save` / `Cancel`) sending exactly `{type:'set_run_title',run_id,title}` and then refreshing the run and the runs-list row (unit-tested). Captured `captures/38-run-440-rename-field.png`. The one shared `Action failed` dialog was exercised by a real refused rename: `captures/39-run-440-action-failed.png` shows the live server's exact reason `a title with usable text is required` (a blank title mutates nothing). **Divergence from the Android UI, stated here**: Android does not surface `set_run_title` at all (its README records the deliberate omission), so this control is browser-only |
| R15 | Attention / "Needs you" surface: counts, open, individual dismiss, clear all | derived from `list_runs` + run events | todo |
Two wording decisions in R3's stage pane, recorded here as the app-authoritative
@@ -62,6 +62,17 @@ empty-capture variants carry the `Changes · ` prefix — while the expanded bod
own summary line repeats the count and stat. The header is rendered verbatim, not
re-composed.
R11–R14 share one `Action failed` dialog (title `Action failed`, the server's own
message, a single `OK`), matching `RunDetailScreen.kt`; every server string is set
with `textContent`, never `innerHTML`. Where a live action was unsafe this stage
says so rather than mutating shared state: the R12 cancel and the R13 retry/restart
sends were shown and dismissed with `Keep` (never executed), and R11 has no live
capture because the server had no waiting run. The request shapes for all four are
unit-tested in `test/repository.test.mjs` and the model in `test/actions.test.mjs`;
`test/ui-smoke.mjs` captures the rendered dialogs, the rename field, the refused
rename's exact server reason and — when a waiting run exists — the decision
card/sheet.
## Search
| # | Feature | Protocol | Status |
| --- | --- | --- | --- |
+245
View File
@@ -0,0 +1,245 @@
// Pure, DOM-free logic for the run-level operator actions the browser client
// offers on a run detail: the pending human decision (R11), cancel (R12), retry
// / restart (R13) and rename (R14). Ported from the Android client so the
// browser asks for and shows exactly the same things:
// ui/Decision.kt PendingDecision, DecisionOption,
// pendingDecision, decisionTargetLabel,
// DecisionDraft
// data/protocol/HumanDecision.kt lastWaitingStep, waitingPrompt,
// waitingOptions, humanOptions
// ui/components/DecisionPrompt.kt the decision card and sheet wording
// ui/screens/RunDetailScreen.kt the cancel/retry dialogs, Action failed
//
// Nothing here touches the DOM or imports the app: the decision model, the
// action eligibility rules and every user-visible string are unit-tested without
// a browser. The caller sets each string with textContent, never innerHTML.
import { nodeLabel, resolveTarget, runLabelFor } from "./runDetail.js";
/** Run status while parked on a person (mirrors protocol.RunStatusWaiting). */
export const RUN_STATUS_WAITING = "waiting";
/** The waiting step's status, i.e. the step a decision answers. */
export const STEP_STATUS_WAITING = "waiting";
/** Run status a retry is offered for. */
export const RUN_STATUS_FAILED = "failed";
/** Waiting evidence keys, the wire contract the server records. */
export const WAITING_PROMPT_KEY = "prompt";
export const WAITING_OPTIONS_KEY = "options";
// ---------------------------------------------------------------------------
// Decision evidence (data/protocol/HumanDecision.kt)
// ---------------------------------------------------------------------------
function str(value) {
return value == null ? "" : String(value);
}
/**
* The most recent step a run is waiting on (the last waiting step), or null when
* no step is waiting. Mirrors `tui.lastWaitingStep` / `HumanDecision.kt`.
*/
export function lastWaitingStep(steps) {
const list = steps ?? [];
for (let index = list.length - 1; index >= 0; index -= 1) {
if (list[index]?.status === STEP_STATUS_WAITING) return list[index];
}
return null;
}
/**
* The recorded operator instructions from a waiting step's output, or "" when
* none were recorded. Mirrors `protocol.WaitingPrompt`.
*/
export function waitingPrompt(output) {
const value = output?.[WAITING_PROMPT_KEY];
return typeof value === "string" ? value : "";
}
/**
* The recorded selectable options from a waiting step's output, in recorded
* order. Strings only, a malformed/blank entry dropped, an absent key yields an
* empty list — exactly like `protocol.WaitingOptions` / `waitingOptions`.
*/
export function waitingOptions(output) {
const value = output?.[WAITING_OPTIONS_KEY];
if (!Array.isArray(value)) return [];
return value.filter((entry) => typeof entry === "string" && entry.trim() !== "");
}
/**
* A stage's selectable outcomes: its non-`error` edges in sorted order. Mirrors
* `stage.HumanOptions`, the fallback when a waiting step recorded no options.
*/
export function humanOptions(edges) {
return Object.keys(edges ?? {})
.filter((key) => key !== "error")
.sort();
}
/**
* The resolved target label for one option: the author's target with the `#`
* shorthand resolved and terminals named as the graph names them. Blank when the
* option's edge is not declared, so the sheet omits the detail.
*/
export function decisionTargetLabel(option, target) {
if (target == null || String(target).trim() === "") return "";
return nodeLabel(resolveTarget(option, target));
}
/**
* The pending decision a run is waiting on, or null when it is not waiting (or
* recorded no selectable options). The waiting step's own evidence wins over the
* pinned graph; the graph only supplies the target labels and, for a step from
* an older server, the option set itself. Mirrors `pendingDecision`.
*/
export function pendingDecision(run) {
if (run == null || run.status !== RUN_STATUS_WAITING) return null;
const step = lastWaitingStep(run.steps ?? []);
const stepStage = str(step?.stage).trim() !== "" ? String(step.stage) : "";
const runStage = str(run.current_stage).trim() !== "" ? String(run.current_stage) : "";
const stageKey = stepStage !== "" ? stepStage : runStage;
if (stageKey === "") return null;
const declared = (run.graph?.stages ?? []).find((candidate) => candidate?.key === stageKey) ?? null;
const recorded = waitingOptions(step?.output);
const keys = recorded.length > 0 ? recorded : humanOptions(declared?.edges);
if (keys.length === 0) return null;
const edges = declared?.edges ?? {};
const options = keys.map((key) => ({ key, target: decisionTargetLabel(key, edges[key]) }));
const stepPrompt = waitingPrompt(step?.output);
const instructions = stepPrompt.trim() !== "" ? stepPrompt : str(declared?.prompt);
return {
runId: run.id,
runLabel: runLabelFor(run),
stageKey,
instructions,
options,
};
}
/**
* The operator's in-progress answer: the chosen option and optional feedback.
* Pure, so the deliberate-confirm rule (nothing is sent until an option is
* chosen and Confirm is pressed) is unit-tested without a device. Mirrors
* `DecisionDraft`.
*/
export class DecisionDraft {
constructor(selected = null, feedback = "") {
this.selected = selected;
this.feedback = feedback;
}
/** A decision is only sendable once the operator has chosen one option. */
get canSubmit() {
return typeof this.selected === "string" && this.selected.trim() !== "";
}
/** Selecting an option is not an answer: it only enables the confirm. */
select(option) {
return new DecisionDraft(option, this.feedback);
}
/** Feedback is optional and carried verbatim (trimmed by the sender). */
withFeedback(text) {
return new DecisionDraft(this.selected, String(text ?? ""));
}
}
// ---------------------------------------------------------------------------
// Action eligibility (RunDetailScreen.kt)
// ---------------------------------------------------------------------------
/** Cancel is offered only while the run is executing. */
export function canCancel(run) {
return Boolean(run?.executing);
}
/** Retry is offered only for a loaded, non-executing, `failed` run. */
export function canRetry(run) {
return run != null && !run.executing && run.status === RUN_STATUS_FAILED;
}
/** The retry modes available for a run: resume (default) and restart. */
export function retryModes(run) {
return canRetry(run) ? ["resume", "restart"] : [];
}
/**
* A fresh idempotency key for a retry request. The server requires one and caps
* it at 128 characters (PipelinesRepository.MAX_REQUEST_KEY); this stays well
* inside that bound and unique per attempt.
*/
export function retryRequestKey(runId, now = Date.now(), random = Math.random) {
const suffix = Math.floor((Number(random()) || 0) * 1e9).toString(36);
return `web-retry-${runId}-${now}-${suffix}`;
}
// ---------------------------------------------------------------------------
// Wording (DecisionPrompt.kt / RunDetailScreen.kt), verbatim
// ---------------------------------------------------------------------------
export const DECISION_CARD_TITLE = "Waiting for your decision";
export const DECISION_ACTION = "Decide";
export const FEEDBACK_LABEL = "Feedback (optional)";
export const DECISION_CANCEL = "Cancel";
export const DECISION_CONFIRM = "Confirm decision";
export const DECISION_SENDING = "Sending…";
export const CANCEL_DIALOG_MESSAGE = "This asks the server to stop the active run.";
export const CANCEL_CONFIRM = "Cancel run";
export const RETRY_DIALOG_MESSAGE =
"Only failed runs can be retried. The server starts a new run from the same input.";
export const RETRY_CONFIRM = "Retry";
export const DISMISS_KEEP = "Keep";
// The restart confirm is browser-only (Android exposes resume alone): it states
// plainly that it replays the whole pipeline instead of resuming the failed
// stage, so the more destructive choice is never ambiguous.
export const RESTART_CONFIRM = "Restart from start";
export const RESTART_DIALOG_MESSAGE =
"This replays the whole pipeline from the start instead of resuming the failed stage.";
export const RENAME_ACTION = "Rename";
export const RENAME_SAVE = "Save";
export const RENAME_CANCEL = "Cancel";
export const RENAME_FIELD_LABEL = "Run title";
export const ACTION_FAILED_TITLE = "Action failed";
export const ACTION_FAILED_OK = "OK";
/** The decision card's meta line: `{stage} · run {id} · {runLabel}`. */
export function decisionCardMeta(decision) {
return `${decision.stageKey} · run ${decision.runId} · ${decision.runLabel}`;
}
/** The sheet title: `Decide {stage}`. */
export function decisionSheetTitle(stageKey) {
return `Decide ${stageKey}`;
}
/** The sheet meta line: `run {id} · {runLabel}`. */
export function decisionSheetMeta(decision) {
return `run ${decision.runId} · ${decision.runLabel}`;
}
/** The option's target line, `→ {target}`, or "" when the target is unknown. */
export function optionTargetText(target) {
return String(target ?? "").trim() === "" ? "" : `→ ${target}`;
}
/** The cancel dialog's title: `Cancel run {id}?`. */
export function cancelDialogTitle(runId) {
return `Cancel run ${runId}?`;
}
/** The retry dialog's title: `Retry run {id}?`. */
export function retryDialogTitle(runId) {
return `Retry run ${runId}?`;
}
/** The restart dialog's title: `Restart run {id}?`. */
export function restartDialogTitle(runId) {
return `Restart run ${runId}?`;
}
+497 -10
View File
@@ -133,6 +133,39 @@ import {
runChangesHeader,
runChangesNote,
} from "./changes.js";
import {
ACTION_FAILED_OK,
ACTION_FAILED_TITLE,
CANCEL_CONFIRM,
CANCEL_DIALOG_MESSAGE,
DECISION_ACTION,
DECISION_CANCEL,
DECISION_CARD_TITLE,
DECISION_CONFIRM,
DECISION_SENDING,
DISMISS_KEEP,
DecisionDraft,
FEEDBACK_LABEL,
RENAME_ACTION,
RENAME_CANCEL,
RENAME_FIELD_LABEL,
RENAME_SAVE,
RESTART_CONFIRM,
RESTART_DIALOG_MESSAGE,
RETRY_CONFIRM,
RETRY_DIALOG_MESSAGE,
canCancel,
canRetry,
cancelDialogTitle,
decisionCardMeta,
decisionSheetMeta,
decisionSheetTitle,
optionTargetText,
pendingDecision,
restartDialogTitle,
retryDialogTitle,
retryRequestKey,
} from "./actions.js";
const STORAGE_KEY = "pipelines.web.serverUrl.v2";
@@ -209,6 +242,20 @@ const state = {
runSections: new Set(),
runStagePane: null,
runStageSections: new Set(),
// Run-level operator actions (R11–R14): the decision the open sheet renders
// (retained across a refused send so the server's own reason can be shown even
// after a refresh), the sheet's draft/sending/error, the action awaiting a
// confirm dialog, the in-progress rename title (null when not editing) and the
// one shared Action-failed dialog.
runDecision: null,
decisionOpen: false,
decisionDraft: new DecisionDraft(),
decisionSending: false,
decisionError: "",
confirmKind: null,
renameValue: null,
renameBusy: false,
actionError: "",
};
let runPoll = null;
@@ -1184,6 +1231,12 @@ function renderRunDetail() {
pane.append(h("div", { class: "muted pad", text: "Select a run." }));
return pane;
}
// A run parked on a person surfaces its decision above the tabs, exactly where
// the Android run detail does, so opening the run is enough — no tab hunt.
const decision = pendingDecision(d);
if (decision) pane.append(renderDecisionCard(decision));
const actions = renderRunActions(d);
if (actions) pane.append(actions);
pane.append(
h(
"div",
@@ -1212,6 +1265,10 @@ function renderRunDetail() {
pane.append(renderRunSummaryTab(d));
}
if (state.runStagePane) pane.append(renderStagePane(d));
if (state.decisionOpen && state.runDecision) pane.append(renderDecisionSheet(state.runDecision));
const confirm = renderConfirmDialog(d);
if (confirm) pane.append(confirm);
if (state.actionError) pane.append(renderActionFailedDialog());
return pane;
}
@@ -1253,7 +1310,7 @@ function latestVisitIndex(d, key) {
/** The Summary tab: identity, chip row, key/value rows, diagnostic and gallery. */
function renderRunSummaryTab(d) {
const wrap = h("div", { class: "run-tab-body" });
wrap.append(h("h2", { class: "run-detail-title", text: runLabelFor(d) }));
wrap.append(renderRunTitleRow(d));
const status = runStateOf(d.status);
const chips = h("div", { class: "run-chip-row" });
chips.append(h("span", { class: `chip chip-${status}`, text: d.status || status }));
@@ -1912,6 +1969,413 @@ function closeStagePane() {
focusTarget?.focus();
}
// --- Run-level operator actions (R11–R14) ----------------------------------
/** The one-line error text of a refused action (the server's own message). */
function describeError(error) {
return error?.message || String(error);
}
/**
* The decision card (R11): a prominent "Waiting for your decision" banner with
* the stage/run identity and a deliberate Decide action. Only rendered when the
* loaded run is genuinely waiting on a person.
*/
function renderDecisionCard(decision) {
const card = h("div", { class: "decision-card" });
card.append(h("span", { class: "decision-card-icon", "aria-hidden": "true", text: "\u270B" }));
const text = h("div", { class: "decision-card-text" });
text.append(h("div", { class: "decision-card-title", text: DECISION_CARD_TITLE }));
text.append(h("div", { class: "decision-card-meta muted", text: decisionCardMeta(decision) }));
card.append(text);
card.append(
h("button", {
class: "decision-open",
type: "button",
text: DECISION_ACTION,
onclick: () => openDecisionSheet(decision),
}),
);
return card;
}
/** Cancel/Retry actions, shown exactly per the app's eligibility rules. */
function renderRunActions(d) {
const buttons = [];
if (canCancel(d)) {
buttons.push(
h("button", {
class: "run-action cancel-run",
type: "button",
text: "Cancel run",
onclick: () => openConfirm({ kind: "cancel", runId: d.id }),
}),
);
}
if (canRetry(d)) {
buttons.push(
h("button", {
class: "run-action retry-run",
type: "button",
text: "Retry",
onclick: () => openConfirm({ kind: "retry", runId: d.id }),
}),
);
}
if (!buttons.length) return null;
return h("div", { class: "run-actions" }, ...buttons);
}
/** Open the decision sheet with a fresh draft; nothing is sent until Confirm. */
function openDecisionSheet(decision) {
state.runDecision = decision;
state.decisionOpen = true;
state.decisionDraft = new DecisionDraft();
state.decisionError = "";
renderContent();
document.querySelector(".decision-sheet .decision-option")?.focus();
}
/** Dismiss the decision sheet (never while a decision is in flight). */
function closeDecisionSheet() {
if (state.decisionSending) return;
const wasOpen = state.decisionOpen;
state.decisionOpen = false;
state.runDecision = null;
state.decisionError = "";
state.decisionDraft = new DecisionDraft();
if (!wasOpen) return;
renderContent();
document.querySelector(".decision-card .decision-open")?.focus();
}
/**
* The decision sheet (R11): the waiting stage, the author's recorded
* instructions, one selectable row per option (with its resolved target when
* declared), the optional feedback field and the deliberate confirm. Selecting a
* row never sends; a refusal keeps the sheet open with the server's exact reason.
*/
function renderDecisionSheet(decision) {
const overlay = h("div", {
class: "decision-sheet",
role: "dialog",
"aria-modal": "true",
"aria-label": decisionSheetTitle(decision.stageKey),
});
overlay.addEventListener("click", (event) => {
if (event.target === overlay) closeDecisionSheet();
});
const sheet = h("div", { class: "decision-sheet-panel" });
sheet.append(h("h2", { class: "decision-sheet-title", text: decisionSheetTitle(decision.stageKey) }));
sheet.append(h("div", { class: "decision-sheet-meta muted", text: decisionSheetMeta(decision) }));
if (String(decision.instructions ?? "").trim() !== "") {
sheet.append(h("p", { class: "decision-instructions", text: decision.instructions }));
}
const options = h("div", { class: "decision-options", role: "radiogroup", "aria-label": "Options" });
for (const option of decision.options) {
const selected = state.decisionDraft.selected === option.key;
const row = h("button", {
class: `decision-option${selected ? " selected" : ""}`,
type: "button",
role: "radio",
"aria-checked": selected ? "true" : "false",
"data-option": option.key,
onclick: () => {
state.decisionDraft = state.decisionDraft.select(option.key);
renderContent();
},
});
row.append(h("span", { class: "decision-radio", "aria-hidden": "true" }));
const body = h("span", { class: "decision-option-body" });
body.append(h("span", { class: "decision-option-key", text: option.key }));
const target = optionTargetText(option.target);
if (target !== "") body.append(h("span", { class: "decision-option-target muted", text: target }));
row.append(body);
options.append(row);
}
sheet.append(options);
const field = h("label", { class: "decision-field" });
field.append(h("span", { class: "decision-field-label", text: FEEDBACK_LABEL }));
field.append(
h("input", {
class: "decision-feedback",
type: "text",
value: state.decisionDraft.feedback,
spellcheck: "false",
oninput: (event) => {
state.decisionDraft = state.decisionDraft.withFeedback(event.target.value);
},
}),
);
sheet.append(field);
if (state.decisionError) sheet.append(h("div", { class: "decision-error bad", text: state.decisionError }));
const actions = h("div", { class: "decision-sheet-actions" });
actions.append(
h("button", {
class: "ghost decision-cancel",
type: "button",
text: DECISION_CANCEL,
disabled: state.decisionSending,
onclick: closeDecisionSheet,
}),
);
actions.append(
h("button", {
class: "decision-confirm",
type: "button",
text: state.decisionSending ? DECISION_SENDING : DECISION_CONFIRM,
disabled: !state.decisionDraft.canSubmit || state.decisionSending,
onclick: () => confirmDecision(decision),
}),
);
sheet.append(actions);
overlay.append(sheet);
return overlay;
}
/** Send the chosen decision; on refusal show the server's reason and re-read. */
async function confirmDecision(decision) {
if (state.decisionSending || !state.decisionDraft.canSubmit) return;
const option = state.decisionDraft.selected;
state.decisionSending = true;
state.decisionError = "";
renderContent();
try {
await repo.decideRun(decision.runId, {
stage: decision.stageKey,
option,
feedback: state.decisionDraft.feedback,
});
state.decisionSending = false;
state.decisionOpen = false;
state.runDecision = null;
state.decisionDraft = new DecisionDraft();
await selectRun(decision.runId, { silent: true });
} catch (error) {
state.decisionSending = false;
state.decisionError = describeError(error);
await selectRun(decision.runId, { silent: true });
}
renderContent();
}
/** Open one of the shared confirm dialogs (cancel / retry / restart). */
function openConfirm(kind) {
state.confirmKind = kind;
renderContent();
}
function dismissConfirm() {
state.confirmKind = null;
renderContent();
}
/**
* The shared confirm dialog: the exact Android title/message for cancel and
* retry (with Keep as the dismiss), plus the browser-only "Restart from start"
* secondary confirm that plainly states the whole-pipeline replay. The dismiss
* button is "Keep".
*/
function renderConfirmDialog(d) {
const kind = state.confirmKind;
if (!kind) return null;
const runId = kind.runId ?? d.id;
let title;
let message;
let confirmLabel;
let secondary = null;
if (kind.kind === "cancel") {
title = cancelDialogTitle(runId);
message = CANCEL_DIALOG_MESSAGE;
confirmLabel = CANCEL_CONFIRM;
} else if (kind.kind === "retry") {
title = retryDialogTitle(runId);
message = RETRY_DIALOG_MESSAGE;
confirmLabel = RETRY_CONFIRM;
secondary = { label: RESTART_CONFIRM, next: { kind: "restart", runId } };
} else {
title = restartDialogTitle(runId);
message = RESTART_DIALOG_MESSAGE;
confirmLabel = RESTART_CONFIRM;
}
const overlay = h("div", {
class: `confirm-dialog confirm-${kind.kind}`,
role: "dialog",
"aria-modal": "true",
"aria-label": title,
});
overlay.addEventListener("click", (event) => {
if (event.target === overlay) dismissConfirm();
});
const panel = h("div", { class: "confirm-panel" });
panel.append(h("h2", { class: "confirm-title", text: title }));
panel.append(h("p", { class: "confirm-message", text: message }));
const actions = h("div", { class: "confirm-actions" });
if (secondary) {
actions.append(
h("button", {
class: "ghost confirm-secondary",
type: "button",
text: secondary.label,
onclick: () => openConfirm(secondary.next),
}),
);
}
actions.append(
h("button", {
class: "ghost confirm-dismiss",
type: "button",
text: DISMISS_KEEP,
onclick: dismissConfirm,
}),
);
actions.append(
h("button", {
class: "confirm-accept",
type: "button",
text: confirmLabel,
onclick: () => acceptConfirm(kind),
}),
);
panel.append(actions);
overlay.append(panel);
return overlay;
}
/**
* Run the confirmed action, then a silent get_run refresh — exactly as the
* Android client does. A server refusal is reported through the one shared
* Action-failed dialog.
*/
async function acceptConfirm(kind) {
const runId = kind.runId ?? state.runDetail?.id;
state.confirmKind = null;
renderContent();
try {
if (kind.kind === "cancel") {
await repo.cancelRun(runId);
} else {
const mode = kind.kind === "restart" ? "restart" : "resume";
await repo.retryRun(runId, { mode, requestKey: retryRequestKey(runId) });
}
} catch (error) {
state.actionError = describeError(error);
}
await selectRun(runId, { silent: true });
renderContent();
}
/** The one shared "Action failed" dialog (title, the server's message, OK). */
function renderActionFailedDialog() {
const overlay = h("div", {
class: "action-failed",
role: "dialog",
"aria-modal": "true",
"aria-label": ACTION_FAILED_TITLE,
});
overlay.addEventListener("click", (event) => {
if (event.target === overlay) dismissActionError();
});
const panel = h("div", { class: "action-failed-panel" });
panel.append(h("h2", { class: "action-failed-title", text: ACTION_FAILED_TITLE }));
panel.append(h("p", { class: "action-failed-message", text: state.actionError }));
panel.append(
h("button", { class: "action-failed-ok", type: "button", text: ACTION_FAILED_OK, onclick: dismissActionError }),
);
overlay.append(panel);
return overlay;
}
function dismissActionError() {
state.actionError = "";
renderContent();
}
/** The Summary title row: the run's label plus the inline rename control (R14). */
function renderRunTitleRow(d) {
const row = h("div", { class: "run-title-row" });
row.append(h("h2", { class: "run-detail-title", text: runLabelFor(d) }));
if (state.renameValue == null) {
row.append(
h("button", {
class: "ghost rename-open",
type: "button",
text: RENAME_ACTION,
onclick: () => {
state.renameValue = String(d.title ?? "");
renderContent();
},
}),
);
return row;
}
const field = h("div", { class: "rename-field" });
field.append(
h("input", {
class: "rename-input",
type: "text",
value: state.renameValue,
"aria-label": RENAME_FIELD_LABEL,
oninput: (event) => {
state.renameValue = event.target.value;
},
}),
);
field.append(
h("button", {
class: "rename-save",
type: "button",
text: RENAME_SAVE,
onclick: () => saveRunTitle(d.id),
}),
);
field.append(
h("button", {
class: "ghost rename-cancel",
type: "button",
text: RENAME_CANCEL,
onclick: () => {
state.renameValue = null;
renderContent();
},
}),
);
row.append(field);
return row;
}
/**
* Rename the run: send `set_run_title`, then update the run detail and the runs
* list row. A refusal (for example a blank title) keeps the field open and shows
* the server's exact reason through the shared Action-failed dialog.
*/
async function saveRunTitle(id) {
if (state.renameBusy) return;
state.renameBusy = true;
try {
const detail = await repo.setRunTitle(id, String(state.renameValue ?? ""));
state.renameValue = null;
applyRunTitle(id, detail);
await selectRun(id, { silent: true });
} catch (error) {
state.actionError = describeError(error);
renderContent();
} finally {
state.renameBusy = false;
}
}
/** Apply a renamed run to the loaded detail and the runs-list row. */
function applyRunTitle(id, detail) {
if (state.runDetail && state.runDetail.id === id && detail) state.runDetail = detail;
const title = String(detail?.title ?? "");
state.runs = state.runs.map((run) => (run.id === id ? { ...run, title } : run));
}
/** Whether the configured server URL can resolve a server-relative artifact. */
function artifactsResolvable() {
return resolveArtifactUrl(state.url, "/artifacts/0/0/probe") != null;
@@ -2441,6 +2905,16 @@ async function selectRun(id, { silent = false } = {}) {
state.runSections = new Set();
state.runStagePane = null;
state.runStageSections = new Set();
// A different run reseeds the run-level action state, so a decision sheet,
// confirm dialog, rename field or failure report never leaks across runs.
state.runDecision = null;
state.decisionOpen = false;
state.decisionDraft = new DecisionDraft();
state.decisionSending = false;
state.decisionError = "";
state.confirmKind = null;
state.renameValue = null;
state.actionError = "";
renderContent();
}
try {
@@ -2541,16 +3015,29 @@ client.addEventListener("state", (event) => {
render();
});
// The stage pane is a modal dialog: Escape closes it (a stacked overlay — the
// artifact viewer or the diff viewer, when either is above — owns Escape first).
// Registered once; it is a no-op when no pane is open.
// The stage pane, the decision sheet and the confirm/Action-failed dialogs are
// modal: Escape closes the topmost one (the artifact viewer or the diff viewer,
// when either is above, owns Escape first via its own listener). Registered
// once; every branch is a no-op when nothing is open.
document.addEventListener("keydown", (event) => {
if (
event.key === "Escape" &&
state.runStagePane &&
!document.querySelector(".artifact-viewer") &&
!document.querySelector(".change-viewer")
) {
if (event.key !== "Escape") return;
if (document.querySelector(".artifact-viewer") || document.querySelector(".change-viewer")) return;
if (state.actionError) {
event.preventDefault();
dismissActionError();
return;
}
if (state.confirmKind) {
event.preventDefault();
dismissConfirm();
return;
}
if (state.decisionOpen) {
event.preventDefault();
closeDecisionSheet();
return;
}
if (state.runStagePane) {
event.preventDefault();
closeStagePane();
}
+8
View File
@@ -21,6 +21,14 @@ export const Protocol = Object.freeze({
GET_RUN: "get_run",
RUN: "run",
// The run-level operator actions (R11–R14). Each replies with a `run` (or
// `run_started` for retry) envelope carrying the updated run detail; mirrors
// internal/protocol/runs.go and Message.kt.
CANCEL_RUN: "cancel_run",
RETRY_RUN: "retry_run",
DECIDE_RUN: "decide_run",
SET_RUN_TITLE: "set_run_title",
SUCCESS_END: "#success",
FAILURE_END: "#failure",
});
+60
View File
@@ -72,4 +72,64 @@ export class PipelinesRepository {
}
return response.run_detail;
}
/**
* Answers a run's waiting human stage with the chosen `option` and optional
* `feedback` (mirrors PipelinesRepository.decideRun). The stage is sent only
* when non-blank and the feedback is trimmed, exactly like the Android client;
* a refused decision rejects with the server's own reason (a ProtocolError).
*/
async decideRun(id, { stage, option, feedback } = {}) {
const request = { type: Protocol.DECIDE_RUN, run_id: id, option };
if (stage != null && String(stage).trim() !== "") request.stage = stage;
const trimmedFeedback = String(feedback ?? "").trim();
if (trimmedFeedback !== "") request.feedback = trimmedFeedback;
const response = await this.#client.call(request);
if (!response.run_detail) {
throw new ProtocolError("The server returned no run detail.");
}
return response.run_detail;
}
/** Cancels a run; mirrors PipelinesRepository.cancelRun (exactly run_id). */
async cancelRun(id) {
const response = await this.#client.call({ type: Protocol.CANCEL_RUN, run_id: id });
if (!response.run_detail) {
throw new ProtocolError("The server returned no run detail.");
}
return response.run_detail;
}
/**
* Retries a terminal failed run. `request_key` is always sent (the retry is
* its own idempotent run); `retry_mode` is sent only for an explicit
* `restart`, so the server's default (resume) applies exactly as the Android
* client's mode-less call.
*/
async retryRun(id, { mode = null, requestKey } = {}) {
const request = {
type: Protocol.RETRY_RUN,
run_id: id,
request_key: requestKey ?? "",
};
if (mode === "restart") request.retry_mode = "restart";
const response = await this.#client.call(request);
if (!response.run_detail) {
throw new ProtocolError("The server returned no run detail.");
}
return response.run_detail;
}
/** Renames a run's stored title; mirrors the set_run_title wire command. */
async setRunTitle(id, title) {
const response = await this.#client.call({
type: Protocol.SET_RUN_TITLE,
run_id: id,
title,
});
if (!response.run_detail) {
throw new ProtocolError("The server returned no run detail.");
}
return response.run_detail;
}
}
+150
View File
@@ -1028,3 +1028,153 @@ code { background: var(--surface-2); padding: 1px 6px; border-radius: 6px; font-
.diff-add { color: var(--ok); }
.diff-remove { color: var(--bad); }
.diff-context { color: var(--muted); }
/* ---------------------------------------------------------------------------
Run-level operator actions (parity R11–R14): the waiting-for-decision card
and sheet, the shared cancel/retry/restart confirm dialogs, the one
Action-failed dialog and the inline rename control. Hand-written, the app's
dark palette; every string is set with textContent.
--------------------------------------------------------------------------- */
.run-actions { display: flex; gap: 8px; flex-wrap: wrap; margin: 0 0 4px; }
.run-action { padding: 4px 12px; font-size: 12px; }
.run-action.cancel-run { border-color: var(--warn); color: var(--warn); }
.run-action.retry-run { border-color: var(--accent); color: var(--accent); }
/* The decision card: a prominent banner above the tabs. */
.decision-card {
display: flex;
gap: 12px;
align-items: center;
padding: 12px 14px;
margin-bottom: 12px;
border: 1px solid #8edff5;
border-radius: 10px;
background: #102329;
}
.decision-card-icon { font-size: 18px; line-height: 1; }
.decision-card-text { flex: 1; min-width: 0; display: grid; gap: 2px; }
.decision-card-title { font-weight: 600; }
.decision-card-meta { font-size: 12px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.decision-open { border-color: #8edff5; color: #8edff5; font-weight: 600; }
/* The decision sheet: a centred modal panel over a dim backdrop. */
.decision-sheet {
position: fixed;
inset: 0;
z-index: 35;
display: flex;
align-items: center;
justify-content: center;
padding: 24px;
background: rgba(0, 0, 0, 0.55);
}
.decision-sheet-panel {
display: grid;
gap: 10px;
width: min(520px, 100%);
max-height: 100%;
overflow-y: auto;
padding: 16px;
background: var(--surface);
border: 1px solid var(--border);
border-radius: 12px;
box-shadow: 0 20px 60px rgba(0, 0, 0, 0.5);
}
.decision-sheet-title { margin: 0; font-size: 16px; }
.decision-sheet-meta { font-size: 12px; }
.decision-instructions { margin: 0; line-height: 1.5; }
.decision-options { display: grid; gap: 6px; }
.decision-option {
display: flex;
gap: 10px;
align-items: center;
width: 100%;
text-align: left;
padding: 8px 10px;
background: var(--surface-2);
border: 1px solid var(--border);
border-radius: 8px;
}
.decision-option:hover { border-color: var(--accent); }
.decision-option.selected { border-color: var(--accent); box-shadow: inset 0 0 0 1px var(--accent); }
.decision-radio {
width: 14px;
height: 14px;
border-radius: 50%;
border: 2px solid var(--muted);
flex: none;
}
.decision-option.selected .decision-radio {
border-color: var(--accent);
box-shadow: inset 0 0 0 3px var(--surface-2), inset 0 0 0 8px var(--accent);
}
.decision-option-body { display: grid; gap: 2px; min-width: 0; }
.decision-option-key { font-weight: 600; }
.decision-option-target { font-size: 12px; }
.decision-field { display: grid; gap: 4px; }
.decision-field-label { font-size: 12px; color: var(--muted); }
.decision-feedback {
width: 100%;
padding: 6px 8px;
background: var(--surface-2);
color: var(--text);
border: 1px solid var(--border);
border-radius: 8px;
font: inherit;
}
.decision-feedback:focus { outline: none; border-color: var(--accent); }
.decision-error { font-size: 13px; }
.decision-sheet-actions { display: flex; gap: 8px; justify-content: flex-end; }
.decision-confirm { border-color: var(--accent); color: var(--accent); font-weight: 600; }
.decision-confirm:disabled, .decision-cancel:disabled { opacity: 0.5; }
/* Shared confirm dialog (cancel / retry / restart) and the Action-failed one. */
.confirm-dialog,
.action-failed {
position: fixed;
inset: 0;
z-index: 40;
display: flex;
align-items: center;
justify-content: center;
padding: 24px;
background: rgba(0, 0, 0, 0.55);
}
.confirm-panel,
.action-failed-panel {
display: grid;
gap: 12px;
width: min(420px, 100%);
padding: 16px;
background: var(--surface);
border: 1px solid var(--border);
border-radius: 12px;
box-shadow: 0 20px 60px rgba(0, 0, 0, 0.5);
}
.confirm-title,
.action-failed-title { margin: 0; font-size: 16px; }
.confirm-message,
.action-failed-message { margin: 0; line-height: 1.5; }
.action-failed-message { color: var(--bad); }
.confirm-actions { display: flex; gap: 8px; align-items: center; }
.confirm-secondary { margin-right: auto; font-size: 12px; }
.confirm-accept { border-color: var(--accent); color: var(--accent); font-weight: 600; }
.action-failed-ok { justify-self: end; }
/* The inline rename control on the Summary title row. */
.run-title-row { display: flex; gap: 10px; align-items: center; flex-wrap: wrap; }
.run-title-row .run-detail-title { margin: 0; }
.rename-field { display: flex; gap: 6px; align-items: center; flex: 1; min-width: 0; }
.rename-input {
flex: 1;
min-width: 0;
padding: 6px 8px;
background: var(--surface-2);
color: var(--text);
border: 1px solid var(--border);
border-radius: 8px;
font: inherit;
}
.rename-input:focus { outline: none; border-color: var(--accent); }
.rename-save { border-color: var(--accent); color: var(--accent); font-weight: 600; }
+260
View File
@@ -0,0 +1,260 @@
// Pure unit tests for the run-level action helpers (R11–R14): the pending human
// decision extracted from a waiting step (with the pinned-graph fallback), the
// option/target wording, the cancel/retry eligibility, the deliberate-confirm
// draft rule and the verbatim Android copy. No server, no DOM.
import { test } from "node:test";
import assert from "node:assert/strict";
import {
ACTION_FAILED_OK,
ACTION_FAILED_TITLE,
CANCEL_CONFIRM,
CANCEL_DIALOG_MESSAGE,
DECISION_ACTION,
DECISION_CANCEL,
DECISION_CARD_TITLE,
DECISION_CONFIRM,
DECISION_SENDING,
DISMISS_KEEP,
DecisionDraft,
FEEDBACK_LABEL,
RESTART_CONFIRM,
RESTART_DIALOG_MESSAGE,
RETRY_CONFIRM,
RETRY_DIALOG_MESSAGE,
canCancel,
canRetry,
cancelDialogTitle,
decisionCardMeta,
decisionSheetMeta,
decisionSheetTitle,
decisionTargetLabel,
humanOptions,
lastWaitingStep,
optionTargetText,
pendingDecision,
retryDialogTitle,
retryModes,
retryRequestKey,
restartDialogTitle,
waitingOptions,
waitingPrompt,
} from "../src/actions.js";
/** A run with the fields pendingDecision reads; overridable per test. */
function run(overrides = {}) {
return {
id: 42,
title: "",
name: "Pipe",
status: "waiting",
current_stage: "review",
executing: false,
steps: [],
...overrides,
};
}
test("lastWaitingStep finds the last waiting step, null when none is waiting", () => {
const steps = [
{ stage: "plan", status: "completed" },
{ stage: "review", status: "waiting" },
{ stage: "review", status: "waiting" },
];
assert.equal(lastWaitingStep(steps)?.stage, "review");
assert.equal(lastWaitingStep(steps), steps[2]);
assert.equal(lastWaitingStep([{ stage: "plan", status: "completed" }]), null);
assert.equal(lastWaitingStep([]), null);
assert.equal(lastWaitingStep(undefined), null);
});
test("waitingPrompt returns the recorded instructions, else empty", () => {
assert.equal(waitingPrompt({ prompt: "Choose a path." }), "Choose a path.");
assert.equal(waitingPrompt({ prompt: 7 }), "");
assert.equal(waitingPrompt({}), "");
assert.equal(waitingPrompt(null), "");
});
test("waitingOptions keeps string entries in recorded order, dropping malformed and blank", () => {
assert.deepEqual(waitingOptions({ options: ["approve", "reject"] }), ["approve", "reject"]);
assert.deepEqual(waitingOptions({ options: ["a", 3, null, " ", "b"] }), ["a", "b"]);
assert.deepEqual(waitingOptions({ options: "approve" }), []);
assert.deepEqual(waitingOptions({}), []);
});
test("humanOptions are a stage's non-error edges, sorted", () => {
assert.deepEqual(humanOptions({ publish: "#success", error: "#failure", revise: "review" }), [
"publish",
"revise",
]);
assert.deepEqual(humanOptions({}), []);
assert.deepEqual(humanOptions(undefined), []);
});
test("decisionTargetLabel resolves declared edges and is blank otherwise", () => {
assert.equal(decisionTargetLabel("publish", "publish"), "publish");
assert.equal(decisionTargetLabel("publish", "#"), "SUCCESS");
assert.equal(decisionTargetLabel("error", "#"), "FAILURE");
assert.equal(decisionTargetLabel("approve", ""), "");
assert.equal(decisionTargetLabel("approve", null), "");
assert.equal(decisionTargetLabel("approve", undefined), "");
assert.equal(optionTargetText("publish"), "→ publish");
assert.equal(optionTargetText(""), "");
assert.equal(optionTargetText(null), "");
});
test("pendingDecision returns null unless the run is waiting", () => {
assert.equal(pendingDecision(null), null);
assert.equal(pendingDecision(run({ status: "failed" })), null);
assert.equal(pendingDecision(run({ status: "running", executing: true })), null);
assert.equal(pendingDecision(run({ status: "succeeded" })), null);
});
test("pendingDecision yields the recorded options in author order and the verbatim prompt", () => {
const decision = pendingDecision(
run({
title: "Review the plan",
current_stage: "review",
steps: [
{ stage: "plan", status: "completed" },
{
stage: "review",
status: "waiting",
output: { prompt: "Ship it or revise it?", options: ["revise", "approve"] },
},
],
graph: {
stages: [
{
key: "review",
prompt: "graph prompt",
edges: { approve: "publish", revise: "review", error: "#failure" },
},
],
},
}),
);
assert.deepEqual(decision.options.map((o) => o.key), ["revise", "approve"]);
assert.equal(decision.instructions, "Ship it or revise it?");
assert.equal(decision.stageKey, "review");
assert.equal(decision.runId, 42);
assert.equal(decision.runLabel, "Review the plan");
assert.deepEqual(decision.options, [
{ key: "revise", target: "review" },
{ key: "approve", target: "publish" },
]);
});
test("pendingDecision falls back to the pinned graph's sorted non-error edges", () => {
const decision = pendingDecision(
run({
current_stage: "review",
steps: [{ stage: "", status: "waiting", output: {} }],
graph: {
stages: [
{ key: "review", prompt: "Graph instructions.", edges: { publish: "#success", error: "#failure", revise: "review" } },
],
},
}),
);
assert.deepEqual(decision.options.map((o) => o.key), ["publish", "revise"]);
assert.equal(decision.instructions, "Graph instructions.");
assert.equal(decision.stageKey, "review");
});
test("pendingDecision keeps a recorded option whose edge is not declared, with a blank target", () => {
const decision = pendingDecision(
run({
steps: [{ stage: "review", status: "waiting", output: { options: ["approve", "legacy"] } }],
graph: { stages: [{ key: "review", edges: { approve: "publish" } }] },
}),
);
assert.deepEqual(decision.options, [
{ key: "approve", target: "publish" },
{ key: "legacy", target: "" },
]);
});
test("pendingDecision is null when no option can be derived", () => {
assert.equal(
pendingDecision(run({ steps: [{ stage: "review", status: "waiting", output: {} }], graph: { stages: [] } })),
null,
);
});
test("DecisionDraft: a blank selection cannot submit and selecting never sends", () => {
const blank = new DecisionDraft();
assert.equal(blank.canSubmit, false);
const selected = blank.select("approve");
assert.equal(selected.canSubmit, true);
assert.equal(selected.selected, "approve");
// Selecting is pure: the original draft is untouched and no side effect fires.
assert.equal(blank.selected, null);
assert.equal(blank.canSubmit, false);
// Feedback is carried verbatim and never changes the submit rule.
const withFeedback = selected.withFeedback(" looks good ");
assert.equal(withFeedback.feedback, " looks good ");
assert.equal(withFeedback.canSubmit, true);
assert.equal(new DecisionDraft(" ").canSubmit, false);
});
test("canCancel is true only while executing; canRetry only for a failed, idle run", () => {
assert.equal(canCancel(run({ executing: true })), true);
assert.equal(canCancel(run({ executing: false })), false);
assert.equal(canCancel(null), false);
assert.equal(canRetry(run({ status: "failed", executing: false })), true);
assert.equal(canRetry(run({ status: "failed", executing: true })), false);
assert.equal(canRetry(run({ status: "succeeded", executing: false })), false);
assert.equal(canRetry(run({ status: "waiting", executing: false })), false);
assert.equal(canRetry(null), false);
assert.equal(canRetry(undefined), false);
});
test("retryModes offers resume and restart for a retryable run, nothing otherwise", () => {
assert.deepEqual(retryModes(run({ status: "failed" })), ["resume", "restart"]);
assert.deepEqual(retryModes(run({ status: "succeeded" })), []);
assert.deepEqual(retryModes(run({ status: "failed", executing: true })), []);
});
test("retryRequestKey is unique, prefixed and within the server's 128-character bound", () => {
const key = retryRequestKey(440, 1_700_000_000_000, () => 0.5);
assert.match(key, /^web-retry-440-1700000000000-/);
assert.ok(key.length <= 128, `key too long: ${key.length}`);
assert.notEqual(
retryRequestKey(440, 1, () => 0.1),
retryRequestKey(440, 1, () => 0.2),
);
});
test("the decision/action copy matches the Android sources verbatim", () => {
assert.equal(DECISION_CARD_TITLE, "Waiting for your decision");
assert.equal(DECISION_ACTION, "Decide");
assert.equal(FEEDBACK_LABEL, "Feedback (optional)");
assert.equal(DECISION_CANCEL, "Cancel");
assert.equal(DECISION_CONFIRM, "Confirm decision");
assert.equal(DECISION_SENDING, "Sending…");
assert.equal(cancelDialogTitle(440), "Cancel run 440?");
assert.equal(CANCEL_DIALOG_MESSAGE, "This asks the server to stop the active run.");
assert.equal(CANCEL_CONFIRM, "Cancel run");
assert.equal(retryDialogTitle(440), "Retry run 440?");
assert.equal(
RETRY_DIALOG_MESSAGE,
"Only failed runs can be retried. The server starts a new run from the same input.",
);
assert.equal(RETRY_CONFIRM, "Retry");
assert.equal(DISMISS_KEEP, "Keep");
assert.equal(RESTART_CONFIRM, "Restart from start");
assert.ok(RESTART_DIALOG_MESSAGE.includes("replays the whole pipeline"));
assert.ok(RESTART_DIALOG_MESSAGE.includes("instead of resuming the failed stage"));
assert.equal(restartDialogTitle(440), "Restart run 440?");
assert.equal(ACTION_FAILED_TITLE, "Action failed");
assert.equal(ACTION_FAILED_OK, "OK");
});
test("the decision card and sheet meta/title render the app's exact shapes", () => {
const decision = { runId: 12, runLabel: "Ship it", stageKey: "review" };
assert.equal(decisionCardMeta(decision), "review · run 12 · Ship it");
assert.equal(decisionSheetTitle(decision.stageKey), "Decide review");
assert.equal(decisionSheetMeta(decision), "run 12 · Ship it");
});
+88
View File
@@ -104,3 +104,91 @@ test("validate throws when the reply has no graph", async () => {
ws.reply = (frame) => ({ id: frame.id, type: "validated" });
await assert.rejects(() => repo.validate("empty"), ProtocolError);
});
/** The run detail a run.action reply carries in these tests. */
const RUN_DETAIL = { id: 440, status: "failed" };
test("decideRun sends exactly {type:'decide_run',run_id,option,feedback} and returns the run detail", async () => {
const { repo, ws } = connected();
ws.reply = (frame) => ({ id: frame.id, type: "run", run_detail: RUN_DETAIL });
const detail = await repo.decideRun(440, { stage: "review", option: "approve", feedback: " yes " });
assert.deepEqual(lastFrame(ws), {
type: "decide_run",
run_id: 440,
stage: "review",
option: "approve",
feedback: "yes",
});
assert.deepEqual(detail, RUN_DETAIL);
});
test("decideRun omits a blank stage and blank feedback", async () => {
const { repo, ws } = connected();
ws.reply = (frame) => ({ id: frame.id, type: "run", run_detail: RUN_DETAIL });
await repo.decideRun(12, { stage: " ", option: "publish", feedback: " " });
assert.deepEqual(lastFrame(ws), { type: "decide_run", run_id: 12, option: "publish" });
});
test("cancelRun sends exactly {type:'cancel_run',run_id} and returns the run detail", async () => {
const { repo, ws } = connected();
ws.reply = (frame) => ({ id: frame.id, type: "run", run_detail: RUN_DETAIL });
const detail = await repo.cancelRun(440);
assert.deepEqual(lastFrame(ws), { type: "cancel_run", run_id: 440 });
assert.deepEqual(detail, RUN_DETAIL);
});
test("retryRun always sends request_key and omits retry_mode for the default resume", async () => {
const { repo, ws } = connected();
ws.reply = (frame) => ({ id: frame.id, type: "run_started", run_detail: RUN_DETAIL });
await repo.retryRun(440, { requestKey: "key-1" });
assert.deepEqual(lastFrame(ws), { type: "retry_run", run_id: 440, request_key: "key-1" });
});
test("retryRun sends retry_mode only for an explicit restart", async () => {
const { repo, ws } = connected();
ws.reply = (frame) => ({ id: frame.id, type: "run_started", run_detail: RUN_DETAIL });
await repo.retryRun(440, { mode: "restart", requestKey: "key-2" });
assert.deepEqual(lastFrame(ws), {
type: "retry_run",
run_id: 440,
request_key: "key-2",
retry_mode: "restart",
});
});
test("setRunTitle sends exactly {type:'set_run_title',run_id,title} and returns the run detail", async () => {
const { repo, ws } = connected();
ws.reply = (frame) => ({ id: frame.id, type: "run", run_detail: RUN_DETAIL });
const detail = await repo.setRunTitle(440, "New title");
assert.deepEqual(lastFrame(ws), { type: "set_run_title", run_id: 440, title: "New title" });
assert.deepEqual(detail, RUN_DETAIL);
});
test("each run action rejects a server error envelope instead of returning a detail", async () => {
const calls = [
(repo) => () => repo.decideRun(440, { option: "approve" }),
(repo) => () => repo.cancelRun(440),
(repo) => () => repo.retryRun(440, { requestKey: "key-3" }),
(repo) => () => repo.setRunTitle(440, ""),
];
for (const makeCall of calls) {
const { repo, ws } = connected();
ws.reply = (frame) => ({ id: frame.id, type: "error", error: "a title with usable text is required" });
await assert.rejects(makeCall(repo), {
name: "ProtocolError",
message: "a title with usable text is required",
});
}
});
test("a run action throws when the reply has no run detail", async () => {
const { repo, ws } = connected();
ws.reply = (frame) => ({ id: frame.id, type: "run" });
await assert.rejects(() => repo.cancelRun(7), ProtocolError);
});
+211
View File
@@ -90,6 +90,17 @@ async function openRunDetail(runId) {
await page.waitForSelector(row, { timeout: 20000 });
await page.click(row);
await page.waitForSelector(".detail .detail-tabs", { timeout: 20000 });
// The tabstrip already exists from the previously opened run, so it is not
// proof this run's detail loaded. Wait for this run's own identity line
// (`run {id} · …`) before returning, or the next assertion can read the
// previous run's actions.
await eventually(
() =>
page.evaluate(
`document.querySelector(".run-detail .run-identity")?.textContent?.startsWith("run ${runId} ") ?? false`,
),
{ timeout: 20000, what: `run ${runId}'s detail to load` },
);
return;
} catch (error) {
if (attempt === 1) throw error;
@@ -1325,6 +1336,206 @@ try {
shots.push(await page.screenshot(`${out}/34-run-${pendingRunId}-changes-pending.png`));
}
// R13/R14: the run-level actions on run 440 (failed, not executing). The
// Retry action is offered; Cancel is not. The Retry confirm and its secondary
// Restart-from-start confirm are captured and dismissed with Keep — no run is
// started here. The rename field is captured pre-filled, then a blank rename is
// actually sent: the live server refuses it without mutating anything, so the
// shared Action-failed dialog shows the server's own reason.
step("R13/R14: run 440 (failed) — Retry eligibility, restart confirm and the rename field");
await openRunDetail(440);
const actions440 = await page.evaluate(`(() => ({
retry: !!document.querySelector(".run-detail .run-actions .retry-run"),
cancel: !!document.querySelector(".run-detail .run-actions .cancel-run"),
}))()`);
if (!actions440.retry) throw new Error("run 440 (failed, not executing) offered no Retry action");
if (actions440.cancel) throw new Error("run 440 (not executing) must not offer a Cancel action");
shots.push(await page.screenshot(`${out}/35-run-440-run-actions.png`));
step("R13: the Retry confirm — resume is the default, Restart from start is secondary");
await page.click(".run-detail .run-actions .retry-run");
await page.waitForSelector(".confirm-dialog.confirm-retry", { timeout: 15000 });
const retryDialog = await page.evaluate(`(() => ({
title: document.querySelector(".confirm-retry .confirm-title")?.textContent ?? "",
message: document.querySelector(".confirm-retry .confirm-message")?.textContent ?? "",
confirm: document.querySelector(".confirm-retry .confirm-accept")?.textContent ?? "",
dismiss: document.querySelector(".confirm-retry .confirm-dismiss")?.textContent ?? "",
secondary: document.querySelector(".confirm-retry .confirm-secondary")?.textContent ?? "",
}))()`);
if (retryDialog.title !== "Retry run 440?") throw new Error(`retry title: ${retryDialog.title}`);
if (retryDialog.message !== "Only failed runs can be retried. The server starts a new run from the same input.") {
throw new Error(`retry message: ${retryDialog.message}`);
}
if (retryDialog.confirm !== "Retry") throw new Error(`retry confirm: ${retryDialog.confirm}`);
if (retryDialog.dismiss !== "Keep") throw new Error(`retry dismiss: ${retryDialog.dismiss}`);
if (retryDialog.secondary !== "Restart from start") {
throw new Error(`retry secondary: ${retryDialog.secondary}`);
}
console.log(` retry dialog: "${retryDialog.title}" — ${retryDialog.message}`);
shots.push(await page.screenshot(`${out}/36-run-440-retry-confirm.png`));
step("R13: the Restart-from-start confirm states the whole-pipeline replay");
await page.click(".confirm-retry .confirm-secondary");
await page.waitForSelector(".confirm-dialog.confirm-restart", { timeout: 15000 });
const restartDialog = await page.evaluate(`(() => ({
title: document.querySelector(".confirm-restart .confirm-title")?.textContent ?? "",
message: document.querySelector(".confirm-restart .confirm-message")?.textContent ?? "",
confirm: document.querySelector(".confirm-restart .confirm-accept")?.textContent ?? "",
dismiss: document.querySelector(".confirm-restart .confirm-dismiss")?.textContent ?? "",
}))()`);
if (restartDialog.title !== "Restart run 440?") throw new Error(`restart title: ${restartDialog.title}`);
if (!restartDialog.message.includes("replays the whole pipeline")) {
throw new Error(`restart message does not state the whole-pipeline replay: ${restartDialog.message}`);
}
if (!restartDialog.message.includes("instead of resuming the failed stage")) {
throw new Error(`restart message does not contrast with resume: ${restartDialog.message}`);
}
if (restartDialog.confirm !== "Restart from start") {
throw new Error(`restart confirm: ${restartDialog.confirm}`);
}
if (restartDialog.dismiss !== "Keep") throw new Error(`restart dismiss: ${restartDialog.dismiss}`);
console.log(` restart dialog: "${restartDialog.title}" — ${restartDialog.message}`);
shots.push(await page.screenshot(`${out}/37-run-440-restart-confirm.png`));
step("R13: dismissing the dialog with Keep sends nothing");
await page.click(".confirm-restart .confirm-dismiss");
await eventually(() => page.evaluate(`!document.querySelector(".confirm-dialog")`), {
timeout: 5000,
what: "the confirm dialog to close",
});
step("R14: the rename field is pre-filled with the current title");
await page.click(".run-detail .rename-open");
await page.waitForSelector(".run-detail .rename-input", { timeout: 15000 });
const renameValue = await page.evaluate(
`document.querySelector(".run-detail .rename-input")?.value ?? ""`,
);
if (!renameValue) throw new Error("the rename field was not pre-filled with the current title");
console.log(` rename field pre-filled with: ${JSON.stringify(renameValue)}`);
shots.push(await page.screenshot(`${out}/38-run-440-rename-field.png`));
step("Action failed: a refused rename shows the server's exact reason");
await page.fill(".run-detail .rename-input", "");
await page.click(".run-detail .rename-save");
await page.waitForSelector(".action-failed", { timeout: 15000 });
const actionFailed = await page.evaluate(`(() => ({
title: document.querySelector(".action-failed .action-failed-title")?.textContent ?? "",
message: document.querySelector(".action-failed .action-failed-message")?.textContent ?? "",
ok: document.querySelector(".action-failed .action-failed-ok")?.textContent ?? "",
}))()`);
if (actionFailed.title !== "Action failed") throw new Error(`action-failed title: ${actionFailed.title}`);
if (actionFailed.ok !== "OK") throw new Error(`action-failed ok: ${actionFailed.ok}`);
if (actionFailed.message !== "a title with usable text is required") {
throw new Error(`action-failed message is not the server's own reason: ${actionFailed.message}`);
}
console.log(` action failed: "${actionFailed.title}" — ${actionFailed.message}`);
shots.push(await page.screenshot(`${out}/39-run-440-action-failed.png`));
await page.click(".action-failed .action-failed-ok");
await eventually(() => page.evaluate(`!document.querySelector(".action-failed")`), {
timeout: 5000,
what: "the Action-failed dialog to close",
});
// Leave the rename field without changing anything.
await page.click(".run-detail .rename-cancel");
// R12: the Cancel confirm on an executing run. Shown and dismissed with Keep —
// no cancel_run is sent (a real cancel is unsafe against a shared live run).
step("R12: the Cancel confirm on an executing run (shown, not executed)");
const cancelRunId = await page.evaluate(`(() => {
const row = [...document.querySelectorAll(".list.runs .run-row")].find((n) => n.querySelector(".chip-running"));
const meta = row?.querySelector(".run-row-meta[data-run-id]");
return meta ? Number(meta.getAttribute("data-run-id")) : null;
})()`);
if (cancelRunId == null) {
console.log(" -- no executing run available; skipped the Cancel confirm capture");
} else {
await openRunDetail(cancelRunId);
const cancelOffered = await page.evaluate(
`!!document.querySelector(".run-detail .run-actions .cancel-run")`,
);
if (!cancelOffered) {
console.log(` -- run ${cancelRunId} stopped before the Cancel action could be shown`);
} else {
await page.click(".run-detail .run-actions .cancel-run");
await page.waitForSelector(".confirm-dialog.confirm-cancel", { timeout: 15000 });
const cancelDialog = await page.evaluate(`(() => ({
title: document.querySelector(".confirm-cancel .confirm-title")?.textContent ?? "",
message: document.querySelector(".confirm-cancel .confirm-message")?.textContent ?? "",
confirm: document.querySelector(".confirm-cancel .confirm-accept")?.textContent ?? "",
dismiss: document.querySelector(".confirm-cancel .confirm-dismiss")?.textContent ?? "",
}))()`);
if (cancelDialog.title !== `Cancel run ${cancelRunId}?`) {
throw new Error(`cancel title: ${cancelDialog.title}`);
}
if (cancelDialog.message !== "This asks the server to stop the active run.") {
throw new Error(`cancel message: ${cancelDialog.message}`);
}
if (cancelDialog.confirm !== "Cancel run") throw new Error(`cancel confirm: ${cancelDialog.confirm}`);
if (cancelDialog.dismiss !== "Keep") throw new Error(`cancel dismiss: ${cancelDialog.dismiss}`);
console.log(` cancel dialog (run ${cancelRunId}, not executed): "${cancelDialog.title}" — ${cancelDialog.message}`);
shots.push(await page.screenshot(`${out}/40-run-${cancelRunId}-cancel-confirm.png`));
await page.click(".confirm-cancel .confirm-dismiss");
await eventually(() => page.evaluate(`!document.querySelector(".confirm-dialog")`), {
timeout: 5000,
what: "the Cancel dialog to close",
});
}
}
// R11: the decision card/sheet, only when the live server actually has a run
// waiting on a person with recorded options. There is normally none (a human
// stage blocks a run until a person answers), so this stays a best-effort
// capture rather than a failure; the model is unit-tested in actions.test.mjs.
step("R11: the human-decision card/sheet (only when a waiting run is present)");
const waitingRunId = await page.evaluate(`(() => {
const row = [...document.querySelectorAll(".list.runs .run-row")].find((n) => n.querySelector(".chip-waiting"));
const meta = row?.querySelector(".run-row-meta[data-run-id]");
return meta ? Number(meta.getAttribute("data-run-id")) : null;
})()`);
if (waitingRunId == null) {
console.log(" -- no waiting run available; skipped the decision card/sheet capture (R11 stays partial)");
} else {
await openRunDetail(waitingRunId);
await page.waitForSelector(".run-detail .decision-card", { timeout: 15000 });
const cardText = await page.evaluate(`(() => ({
title: document.querySelector(".decision-card .decision-card-title")?.textContent ?? "",
meta: document.querySelector(".decision-card .decision-card-meta")?.textContent ?? "",
action: document.querySelector(".decision-card .decision-open")?.textContent ?? "",
}))()`);
if (cardText.title !== "Waiting for your decision") throw new Error(`card title: ${cardText.title}`);
if (cardText.action !== "Decide") throw new Error(`card action: ${cardText.action}`);
console.log(` decision card (run ${waitingRunId}): ${cardText.title} — ${cardText.meta}`);
shots.push(await page.screenshot(`${out}/41-run-${waitingRunId}-decision-card.png`));
await page.click(".decision-card .decision-open");
await page.waitForSelector(".decision-sheet .decision-option", { timeout: 15000 });
const sheet = await page.evaluate(`(() => ({
title: document.querySelector(".decision-sheet-title")?.textContent ?? "",
meta: document.querySelector(".decision-sheet-meta")?.textContent ?? "",
label: document.querySelector(".decision-field-label")?.textContent ?? "",
options: [...document.querySelectorAll(".decision-sheet .decision-option-key")].map((n) => n.textContent),
confirmDisabled: document.querySelector(".decision-confirm")?.disabled ?? null,
}))()`);
if (sheet.label !== "Feedback (optional)") throw new Error(`sheet feedback label: ${sheet.label}`);
if (sheet.confirmDisabled !== true) {
throw new Error("Confirm decision must be disabled until an option is selected");
}
console.log(` decision sheet (run ${waitingRunId}): ${sheet.title} — ${sheet.meta}; options ${sheet.options.join(", ")}`);
shots.push(await page.screenshot(`${out}/42-run-${waitingRunId}-decision-sheet.png`));
// Selecting an option enables the confirm but sends nothing.
await page.click(".decision-sheet .decision-option");
await eventually(
() => page.evaluate(`document.querySelector(".decision-confirm")?.disabled === false`),
{ timeout: 5000, what: "the confirm to enable after selecting an option" },
);
shots.push(await page.screenshot(`${out}/43-run-${waitingRunId}-decision-selected.png`));
// Dismiss with Cancel: no decide_run is sent for a real waiting run here.
await page.click(".decision-sheet .decision-cancel");
await eventually(() => page.evaluate(`!document.querySelector(".decision-sheet")`), {
timeout: 5000,
what: "the decision sheet to close",
});
}
console.log("\nUI SMOKE PASS");
for (const shot of shots) console.log(` ${shot}`);
} catch (error) {