248 lines
9.7 KiB
JavaScript
248 lines
9.7 KiB
JavaScript
// 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;
|
|
if (Number(run.export_pending_sequence) > 0) 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;
|
|
if (declared?.type && declared.type !== "human") return 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) || (run?.status === RUN_STATUS_WAITING && Number(run.export_pending_sequence) > 0)) && !run.cancel_requested && !run.cleanup_unconfirmed;
|
|
}
|
|
|
|
/** 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}?`;
|
|
}
|