Merge branch 'main' into web-search

# Conflicts:
#	web/src/app.js
#	web/src/protocol.js
#	web/src/repository.js
#	web/styles.css
#	web/test/repository.test.mjs
#	web/test/ui-smoke.mjs
This commit is contained in:
2026-10-19 04:44:54 +01:00
9 changed files with 1536 additions and 9 deletions
+494 -5
View File
@@ -152,6 +152,39 @@ import {
searchTarget,
sortSearchResults,
} from "./search.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";
@@ -241,6 +274,20 @@ const state = {
searchLoaded: false,
searchFocusPending: false,
searchSequencer: new SearchSequencer(),
// 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;
@@ -1279,6 +1326,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",
@@ -1307,6 +1360,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;
}
@@ -1348,7 +1405,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 }));
@@ -2007,6 +2064,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;
@@ -2867,6 +3331,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 {
@@ -2967,13 +3441,28 @@ 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).
// Once no pane is open, Escape closes the omni-search field. Registered once;
// every branch is a no-op when nothing relevant is open.
// The stage pane, the decision sheet, the confirm/Action-failed dialogs and the
// omni-search field 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") 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();