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:
+15
-4
@@ -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 |
|
||||
| --- | --- | --- | --- |
|
||||
|
||||
@@ -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
@@ -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();
|
||||
}
|
||||
|
||||
@@ -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",
|
||||
});
|
||||
|
||||
@@ -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
@@ -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; }
|
||||
|
||||
@@ -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");
|
||||
});
|
||||
@@ -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);
|
||||
});
|
||||
|
||||
@@ -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) {
|
||||
|
||||
Reference in New Issue
Block a user