cloving 1.2.0 → 1.4.0

package/dist/src/cli/watch-usage.js

@@ -1,5 +1,5 @@
 import { record } from "../protocol.js";
-import { priceOf, usageOf } from "../worker-usage.js";
+import { priceOf, usageOf, attemptFields } from "../worker-usage.js";
 function text(value) {
     return typeof value === "string" ? value : "";
 }
@@ -41,6 +41,10 @@ export function statusTurns(turns, status) {
             emptyTurn(operationId, runId);
         return {
             ...known,
+            ...attemptFields(fields["attempts"]),
+            ...(typeof fields["harness"] === "string"
+                ? { harness: fields["harness"] }
+                : {}),
             runId,
             operationId,
             outcome: known.outcome === "in work" ? "ended" : known.outcome,

package/dist/src/cli/watch-view.d.ts

@@ -1,18 +1,14 @@
 import type { CardControls } from "./watch-card-view.ts";
+import type { PhoneControls } from "./watch-phone-view.ts";
+export { clove, Header } from "./watch-header-view.ts";
 import { type Shown } from "./watch-element.ts";
 import { type Copying, type WatchModel, type WatchPhase, type WatchRun } from "./watch-render.ts";
 import { type ColumnControls } from "./watch-board-view.ts";
-export declare function Queue(props: {
-    readonly model: WatchModel;
-}): Shown;
+export { PullRequest } from "./watch-turn.ts";
 interface Timed {
     readonly run: WatchRun;
     readonly now: string;
 }
-export declare const clove: {
-    viewBox: string;
-    paths: string[];
-};
 export declare function BannerDetail(props: Timed): Shown;
 export declare function Banner(props: Timed): Shown;
 export declare function Phases(props: {
@@ -23,21 +19,9 @@ export declare function Review(props: {
     readonly run: WatchRun;
     readonly round: number;
 }): Shown;
-export declare function PullRequest(props: {
-    readonly run: WatchRun;
-}): Shown;
 export declare function Run(props: Timed & {
     readonly copying: Copying;
 }): Shown;
-export interface StartControls {
-    readonly shown: boolean;
-    readonly onToggle: () => void;
-}
-export declare function Header(props: {
-    readonly model: WatchModel | null;
-    readonly stale: boolean;
-    readonly start?: StartControls;
-}): Shown;
 export interface PageProps {
     readonly cards?: CardControls;
     readonly model: WatchModel | null;
@@ -47,7 +31,7 @@ export interface PageProps {
     readonly stale: boolean;
     readonly copying: Copying;
     readonly columns?: ColumnControls;
-    readonly start?: StartControls;
+    readonly phone?: PhoneControls | undefined;
 }
 export declare function RefusedWorkflows(props: {
     readonly model: WatchModel;
@@ -58,4 +42,3 @@ export declare function BoardPage(props: PageProps & {
     readonly workflowId: string | null;
     readonly down: Shown;
 }): Shown;
-export {};

package/dist/src/cli/watch-view.js

@@ -1,45 +1,15 @@
+import { scheduledText } from "./schedule-render.js";
+import { CommandWaits, effectBudgetText } from "./command-waits.js";
+import { Header, Queue } from "./watch-header-view.js";
+export { clove, Header } from "./watch-header-view.js";
 import { priceText, usageText, totalsSuffix } from "./usage-render.js";
 import { component, element } from "./watch-element.js";
-import { clockTime, completedDetail, counted, elapsed, phaseTime, runName, runTone, waitingDetail, } from "./watch-render.js";
+import { completedDetail, counted, elapsed, phaseTime, runName, runTone, waitingDetail, } from "./watch-render.js";
 import { Board, HandoffLinks, WorkflowList, } from "./watch-board-view.js";
 import { boardWorkflow, watchHash, watchLocation } from "./watch-navigation.js";
-import { Decision, Events, Turn } from "./watch-turn.js";
-import { StartRun } from "./watch-start-view.js";
-import { record } from "../protocol.js";
-export function Queue(props) {
-    const queue = props.model.queue;
-    if (queue === undefined)
-        return null;
-    const skipped = Array.isArray(queue["skipped"])
-        ? queue["skipped"]
-        : [];
-    return [
-        element("p", {
-            class: "meta",
-            children: `Queue: ${String(queue["busy"])} of ${String(queue["lanes"])} lanes busy`,
-        }),
-        ...skipped.map((value) => {
-            const ticket = record(value) ?? {};
-            const dependencies = ticket["dependencies"];
-            const needs = Array.isArray(dependencies)
-                ? `; needs ${dependencies.map(String).join(", ")}`
-                : "";
-            return element("p", {
-                class: "meta",
-                children: `Skipped ticket ${String(ticket["ticketId"])}: ${String(ticket["reason"])}${needs}`,
-            });
-        }),
-    ];
-}
-export const clove = {
-    viewBox: "0.6625858545303345 0.6630800366401672 46.674827575683594 46.673831939697266",
-    paths: [
-        "M41.47315,11.48535c-1.20117-0.12305-2.16211-1.08398-2.28418-2.28516c-0.17676-1.7334-1.01758-3.29492-2.36865-4.39648s-3.05078-1.61719-4.7832-1.43359c-3.34277,0.34082-5.86377,3.13086-5.86377,6.49121v14.13867c0,0.27637,0.22363,0.5,0.5,0.5H40.8125c3.59766,0,6.52441-2.92676,6.52441-6.52441C47.33692,14.61523,44.81592,11.82422,41.47315,11.48535z M35.56543,15.81543l-5.85791,5.85742c-0.09766,0.09766-0.22559,0.14648-0.35352,0.14648s-0.25586-0.04883-0.35352-0.14648c-0.19531-0.19531-0.19531-0.51172,0-0.70703l5.85791-5.85742c0.19531-0.19531,0.51172-0.19531,0.70703,0C35.76073,15.30372,35.76074,15.62011,35.56543,15.81543z",
-        "M15.30225,0.66308c-3.36035,0-6.15088,2.52051-6.49121,5.86328C8.68897,7.72852,7.72852,8.68945,6.52686,8.81152c-1.7334,0.17578-3.29492,1.01758-4.396,2.36816s-1.61035,3.0498-1.43408,4.7832c0.34033,3.34277,3.13086,5.86328,6.49121,5.86328h14.13867c0.27637,0,0.5-0.22363,0.5-0.5V7.18751C21.82666,3.58984,18.8999,0.66308,15.30225,0.66308z M18.99951,19.00001c-0.09766,0.09766-0.22559,0.14648-0.35352,0.14648s-0.25586-0.04883-0.35352-0.14648l-5.85742-5.8584c-0.19531-0.19531-0.19531-0.51172,0-0.70703c0.19531-0.19531,0.51172-0.19531,0.70703,0l5.85742,5.8584C19.19482,18.48829,19.19482,18.80469,18.99951,19.00001z",
-        "M24,26.17383H9.86133c-3.59766,0-6.52441,2.92676-6.52441,6.52441c0,3.35938,2.52051,6.14941,5.86377,6.49023c1.20117,0.12207,2.16211,1.08301,2.28418,2.28418c0.17676,1.7334,1.01758,3.29492,2.36865,4.39648c1.17529,0.95801,2.61377,1.46777,4.11035,1.46777c0.22314,0,0.44775-0.01074,0.67285-0.03418C21.97949,46.96189,24.5,44.17186,24.5,40.81248V26.67383C24.5,26.39746,24.27637,26.17383,24,26.17383z M21.67334,29.70704l-5.85791,5.8584c-0.09766,0.09766-0.22559,0.14648-0.35352,0.14648s-0.25586-0.04883-0.35352-0.14648c-0.19531-0.19531-0.19531-0.51172,0-0.70703L20.9663,29c0.19531-0.19531,0.51172-0.19531,0.70703,0S21.86865,29.51172,21.67334,29.70704z",
-        "M47.30322,32.03711c-0.34033-3.34277-3.13086-5.86328-6.49072-5.86328H26.67334c-0.27637,0-0.5,0.22363-0.5,0.5V40.8125c0,3.59766,2.92676,6.52441,6.52442,6.52441c3.36035,0,6.15088-2.52148,6.49121-5.86426c0.12207-1.20117,1.08301-2.16211,2.28418-2.28418c1.7334-0.17578,3.29492-1.01758,4.396-2.36816S47.47949,33.7705,47.30322,32.03711z M35.56543,35.56543c-0.09766,0.09766-0.22559,0.14648-0.35352,0.14648s-0.25586-0.04883-0.35352-0.14648l-5.85791-5.8584c-0.19531-0.19531-0.19531-0.51172,0-0.70703s0.51172-0.19531,0.70703,0l5.85791,5.8584C35.76074,35.05371,35.76074,35.37011,35.56543,35.56543z",
-    ],
-};
+import { Decision, Events, Turn, PullRequest } from "./watch-turn.js";
+import { Commands } from "./command-effects.js";
+export { PullRequest } from "./watch-turn.js";
 export function BannerDetail(props) {
     const { run, now } = props;
     const turn = run.turns.at(-1);
@@ -54,8 +24,9 @@ export function BannerDetail(props) {
         ? ""
         : ` · last output ${elapsed(turn.activeAt, now)} ago`;
     const last = turn.activity.at(-1)?.text ?? "The worker starts.";
+    const worker = turn.harness === undefined ? "The worker" : `The ${turn.harness} worker`;
     return [
-        `Claude works for ${elapsed(turn.startedAt, now)} · ${counted(calls, "tool call")}${quiet}`,
+        `${worker} works for ${elapsed(turn.startedAt, now)} · ${counted(calls, "tool call")}${quiet}`,
         element("span", { class: "now", children: last }),
     ];
 }
@@ -115,41 +86,10 @@ export function Review(props) {
         }),
     });
 }
-export function PullRequest(props) {
-    const { pullRequest, reviews, mergeCommit } = props.run;
-    if (pullRequest === null)
-        return null;
-    const link = element("a", {
-        href: pullRequest.url,
-        children: `#${String(pullRequest.number)}`,
-    });
-    const scores = reviews.map((review) => element("li", {
-        children: `Round ${String(review.round)} · Review ${String(review.score)}/5 · commit ${review.commit.slice(0, 7)}`,
-    }));
-    const merge = mergeCommit === null
-        ? null
-        : element("p", {
-            class: "meta",
-            children: [
-                "Merge commit ",
-                element("code", { children: mergeCommit }),
-            ],
-        });
-    return element("section", {
-        class: "pull",
-        children: [
-            element("h3", { children: ["Pull request ", link] }),
-            element("ul", { class: "reviews", children: scores }),
-            merge,
-        ],
-    });
-}
 export function Run(props) {
     const { run, now, copying } = props;
     const turn = run.turns.at(-1);
-    const budget = run.spent === null || run.limit === null
-        ? ""
-        : ` · ${String(run.spent)} of ${String(run.limit)} effect units`;
+    const budget = effectBudgetText(run.spent, run.limit);
     const none = "No agent turn for this run.";
     const turns = run.turns.length === 0
         ? element("p", { class: "meta", children: none })
@@ -162,13 +102,17 @@ export function Run(props) {
             }),
         ]);
     const foot = [
-        `${run.workflowId} · ${run.runId}${budget}`,
+        `${run.workflowId} · ${run.runId}${budget === "" ? "" : ` · ${budget}`}`,
         element("br", {}),
         `${run.code}: ${run.detail}`,
     ];
     return [
         component(Banner, { run, now }),
+        run.scheduled === undefined
+            ? null
+            : element("p", { class: "meta", children: scheduledText(run.scheduled) }),
         component(HandoffLinks, { run }),
+        component(CommandWaits, { waits: run.commandWaits ?? [] }),
         element("section", {
             class: "run-usage",
             children: [
@@ -181,50 +125,17 @@ export function Run(props) {
         }),
         component(Phases, { phases: run.phases, now }),
         component(PullRequest, { run }),
+        (run.ciReruns ?? []).map((rerun) => element("p", {
+            class: "meta",
+            children: `CI rerun after a failed check: workflow ${rerun.run}, commit ${rerun.commit.slice(0, 7)}`,
+        })),
         run.decisions.map((decision) => component(Decision, { decision, turn, copying })),
         turns,
+        component(Commands, { effects: run.commandEffects ?? [] }),
         component(Events, { events: run.events }),
         element("p", { class: "meta foot", children: foot }),
     ];
 }
-export function Header(props) {
-    const { model, stale } = props;
-    const updated = model === null ? "" : `updated ${clockTime(model.updatedAt)}`;
-    const stamp = stale
-        ? element("span", {
-            class: "bad",
-            children: "The watch tool does not answer.",
-        })
-        : element("span", { children: updated });
-    return element("header", {
-        children: [
-            element("strong", {
-                class: "brand",
-                children: [
-                    element("svg", {
-                        xmlns: "http://www.w3.org/2000/svg",
-                        "aria-hidden": "true",
-                        focusable: "false",
-                        viewBox: clove.viewBox,
-                        children: clove.paths.map((d) => element("path", { fill: "currentColor", d })),
-                    }),
-                    "cloving",
-                ],
-            }),
-            stamp,
-            props.start === undefined
-                ? null
-                : element("button", {
-                    type: "button",
-                    class: "start-toggle",
-                    "aria-controls": "start-run",
-                    "aria-expanded": String(props.start.shown),
-                    onClick: props.start.onToggle,
-                    children: "Start a run",
-                }),
-        ],
-    });
-}
 export function RefusedWorkflows(props) {
     const refusals = props.model.workflowRefusals ?? [];
     if (refusals.length === 0)
@@ -273,21 +184,18 @@ export function Page(props) {
     return component(BoardPage, { ...props, model, workflowId, down });
 }
 export function BoardPage(props) {
-    const { model, workflowId, down, now, stale, copying } = props;
+    const { model, workflowId, down, now, stale } = props;
     const workflow = model.workflows.find((item) => item.workflowId === workflowId);
-    const start = props.start ?? { shown: false, onToggle: () => undefined };
     return element("div", {
         class: "board-page",
         children: [
-            component(Header, { model, stale, start }),
+            component(Header, { model, stale, phone: props.phone, now }),
             component(Queue, { model }),
             down,
+            model.schedules !== undefined && "status" in model.schedules
+                ? element("p", { class: "meta", children: "Schedules: unavailable" })
+                : null,
             component(RefusedWorkflows, { model }),
-            component(StartRun, {
-                workflows: model.workflows,
-                copying,
-                shown: start.shown,
-            }),
             component(WorkflowList, {
                 workflows: model.workflows,
                 selected: workflowId,

package/dist/src/cli.js

@@ -1,11 +1,29 @@
 #!/usr/bin/env node
+import { createProbeRunner } from "./cli/probe-command.js";
+import { terminateHarness } from "./cli/harness-processes.js";
+import { settingsEnvironment } from "./cli/project-settings.js";
+import { constants as systemConstants } from "node:os";
 import { addAbortListener } from "node:events";
-import { execFile, spawn } from "node:child_process";
-import { delimiter, dirname, extname, join } from "node:path";
+import { execFile, execFileSync, spawn } from "node:child_process";
+import { existsSync, realpathSync } from "node:fs";
+import { parseArgs } from "node:util";
+import { delimiter, dirname, extname, join, resolve } from "node:path";
 import { main } from "./cli/main.js";
-import { clientCommand, runtimeDirectory } from "./cli/runtime-directory.js";
+import { parseInvocation } from "./cli/arguments.js";
+import { adoptionRecordPath, clientCommand, legacyRuntimeDirectory, runtimeDirectory, } from "./cli/runtime-directory.js";
 import { commandUsage } from "./cli/usage.js";
 const [command, ...options] = process.argv.slice(2);
+function repositoryDirectory(directory) {
+    try {
+        return realpathSync(execFileSync("git", ["-C", resolve(directory), "rev-parse", "--show-toplevel"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim());
+    }
+    catch {
+        return undefined;
+    }
+}
 const watchCommand = async (request) => {
     const [command = "", ...argumentsList] = request.command;
     const completed = Promise.withResolvers();
@@ -14,7 +32,7 @@ const watchCommand = async (request) => {
         cwd: request.directory,
         signal: request.signal,
         killSignal: "SIGKILL",
-        maxBuffer: 1024 * 1024,
+        maxBuffer: request.outputBytes ?? 1024 * 1024,
         encoding: "utf8",
     }, (error, stdout) => {
         const code = error === null ? 0 : error.code;
@@ -42,18 +60,73 @@ const watchCommand = async (request) => {
         listener[Symbol.dispose]();
     }
 };
-function started(runtime, argumentsList) {
-    const program = join(import.meta.dirname, "..", "tools", `self-host${extname(import.meta.filename)}`);
+function startHarness(request) {
+    return new Promise((settle) => {
+        try {
+            const child = spawn(request.executable, request.arguments, {
+                cwd: request.directory,
+                env: request.environment,
+                stdio: "inherit",
+            });
+            const interrupt = () => undefined;
+            const terminate = () => {
+                terminateHarness(child.pid, {
+                    snapshot: () => execFileSync("/bin/ps", ["-axo", "pid=,ppid="], {
+                        encoding: "utf8",
+                        timeout: 1000,
+                    }),
+                    kill: (identifier, signal) => process.kill(identifier, signal),
+                });
+            };
+            const cleanup = () => {
+                process.off("SIGINT", interrupt);
+                process.off("SIGTERM", terminate);
+            };
+            process.on("SIGINT", interrupt);
+            process.on("SIGTERM", terminate);
+            child.once("error", () => {
+                cleanup();
+                settle(null);
+            });
+            child.once("close", (status, signal) => {
+                cleanup();
+                settle(status ??
+                    (signal === null ? 1 : 128 + systemConstants.signals[signal]));
+            });
+        }
+        catch {
+            settle(null);
+        }
+    });
+}
+function startArguments(input) {
+    const { runtime, repository, argumentsList } = input;
     const located = [
         "--runtime",
-        runtime,
+        runtimeDirectory(process.env, repository) ?? runtime,
         "--repository",
-        process.cwd(),
+        repository ?? process.cwd(),
         "--client",
-        clientCommand(process.env),
+        clientCommand(process.env, repository),
     ];
-    const child = spawn(process.execPath, [program, ...located, ...argumentsList], {
-        stdio: "inherit",
+    const record = repository === undefined
+        ? undefined
+        : adoptionRecordPath(process.env, repository);
+    const legacy = legacyRuntimeDirectory(process.env);
+    if (!process.env["CLOVING_RUNTIME_DIR"] &&
+        record !== undefined &&
+        !existsSync(record) &&
+        legacy !== undefined)
+        located.push("--legacy-runtime", resolve(legacy), "--adoption-record", resolve(record));
+    return [...located, ...argumentsList];
+}
+function toolProcess(input) {
+    const program = join(import.meta.dirname, "..", "tools", `${input.tool}${extname(import.meta.filename)}`);
+    const child = spawn(process.execPath, [program, ...input.argumentsList], {
+        detached: input.tool === "red-green-command",
+        stdio: input.tool === "red-green-command"
+            ? ["inherit", "inherit", "inherit", "ipc"]
+            : "inherit",
         env: {
             ...process.env,
             PATH: [dirname(process.execPath), process.env["PATH"]].join(delimiter),
@@ -72,33 +145,97 @@ function started(runtime, argumentsList) {
     process.on("SIGTERM", terminate);
     return new Promise((settle) => {
         child.once("close", (status) => {
-            process.off("SIGINT", interrupt);
-            process.off("SIGTERM", terminate);
-            settle(stopping && status === 75 ? 0 : (status ?? 1));
+            setImmediate(() => {
+                setImmediate(() => {
+                    process.off("SIGINT", interrupt);
+                    process.off("SIGTERM", terminate);
+                    settle(stopping && status === 75 ? 0 : (status ?? 1));
+                });
+            });
         });
     });
 }
+function started(input) {
+    return toolProcess({
+        tool: "self-host",
+        argumentsList: startArguments(input),
+    });
+}
 async function start() {
     if (options.includes("--help")) {
         process.stdout.write(String(commandUsage["start"]));
         return 0;
     }
-    const runtime = runtimeDirectory(process.env);
-    if (runtime !== undefined) {
-        let status = await started(runtime, options);
-        const restarting = options.filter((option) => option !== "--reset-queue");
-        while (status === 75)
-            status = await started(runtime, restarting);
-        return status === 0 ? 0 : 1;
+    const parsed = parseArgs({
+        args: options,
+        options: { repository: { type: "string" } },
+        strict: false,
+        allowPositionals: true,
+    });
+    const selected = parsed.values["repository"];
+    if (Object.hasOwn(parsed.values, "repository") &&
+        (typeof selected !== "string" || selected === "")) {
+        process.stderr.write("missing-value: --repository needs a directory.\n");
+        return 1;
+    }
+    if (parsed.positionals.length > 0) {
+        process.stderr.write("unexpected-argument: run cloving start --help for usage.\n");
+        return 1;
+    }
+    const repository = repositoryDirectory(typeof selected === "string" ? selected : process.cwd());
+    const runtime = runtimeDirectory(process.env, repository);
+    if (runtime === undefined) {
+        process.stderr.write("repository-unknown: Change to the service repository, use --repository <directory>, or set CLOVING_RUNTIME_DIR.\n");
+        return 1;
     }
-    process.stderr.write("runtime-directory-unknown: Set CLOVING_RUNTIME_DIR to the runtime directory of the service.\n");
-    return 1;
+    let status = await started({ runtime, argumentsList: options, repository });
+    const restarting = options.filter((option) => option !== "--reset-queue");
+    while (status === 75)
+        status = await started({
+            runtime,
+            argumentsList: restarting,
+            repository,
+        });
+    return status === 0 ? 0 : 1;
 }
-if (command === "start")
+if (command === "workflows" && ["list", "test"].includes(options[0] ?? ""))
+    process.exitCode = await toolProcess({
+        tool: "workflow-command",
+        argumentsList: options,
+    });
+else if (command === "templates")
+    process.exitCode = await toolProcess({
+        tool: "template-command",
+        argumentsList: options,
+    });
+else if (command === "red-green")
+    process.exitCode = await toolProcess({
+        tool: "red-green-command",
+        argumentsList: options,
+    });
+else if (command === "start")
     process.exitCode = await start();
-else
+else {
+    const invocation = parseInvocation(process.argv.slice(2));
+    const repository = repositoryDirectory("repository" in invocation
+        ? (invocation.repository ?? process.cwd())
+        : process.cwd());
+    const settingsRepository = process.env["CLOVING_WATCH_REPOSITORY"] ?? repository;
+    const environment = invocation.kind === "watch" && settingsRepository !== undefined
+        ? settingsEnvironment(process.env, settingsRepository)
+        : process.env;
     await main(process.argv.slice(2), {
-        repository: process.env["CLOVING_WATCH_REPOSITORY"],
-        githubCommand: process.env["CLOVING_GH_COMMAND"],
-        execute: watchCommand,
+        repository,
+        environment,
+        startHarness,
+        doctorProbe: createProbeRunner({
+            spawn: (input) => spawn(input.executable, input.arguments, input.options),
+            kill: (identifier, signal) => process.kill(identifier, signal),
+        }),
+        watchPr: {
+            repository: process.env["CLOVING_WATCH_REPOSITORY"],
+            githubCommand: environment["CLOVING_GH_COMMAND"],
+            execute: watchCommand,
+        },
     });
+}

package/dist/src/command-settings.d.ts

@@ -0,0 +1,16 @@
+export type LocalCommands = Readonly<Record<string, readonly string[]>>;
+export declare const commandLimits: {
+    stdoutBytes: number;
+    stderrBytes: number;
+    resultBytes: number;
+};
+export interface CommandEffect {
+    readonly operationId: string;
+    readonly name: string;
+    readonly state: string;
+    readonly exitCode: number | null;
+    readonly durationMilliseconds: number | null;
+}
+export type CommandEffects = (effects: readonly CommandEffect[]) => Promise<readonly CommandEffect[]>;
+export declare function parseCommands(text: string | undefined): LocalCommands;
+export declare function parseCommandSeconds(text: string | undefined): number;

package/dist/src/command-settings.js

@@ -0,0 +1,42 @@
+import { record } from "./protocol.js";
+export const commandLimits = {
+    stdoutBytes: 1_048_576,
+    stderrBytes: 65_536,
+    resultBytes: 3_145_728,
+};
+function argumentsList(value) {
+    return (Array.isArray(value) &&
+        typeof value[0] === "string" &&
+        value[0].startsWith("/") &&
+        Array.from(value).every((argument) => typeof argument === "string" && !argument.includes("\u0000")));
+}
+export function parseCommands(text) {
+    if (text === undefined)
+        return {};
+    try {
+        const fields = record(JSON.parse(text));
+        if (fields === undefined)
+            throw new Error("invalid-commands");
+        const commands = {};
+        for (const [name, argumentList] of Object.entries(fields)) {
+            if (!/^[A-Za-z0-9-]{1,64}$/.test(name) || !argumentsList(argumentList))
+                throw new Error("invalid-commands");
+            commands[name] = [...argumentList];
+        }
+        return commands;
+    }
+    catch {
+        throw new Error("invalid-commands");
+    }
+}
+export function parseCommandSeconds(text) {
+    if (text === undefined)
+        return 60;
+    const seconds = Number(text);
+    if (!/^\d+$/.test(text) ||
+        !Number.isInteger(seconds) ||
+        seconds < 1 ||
+        seconds > 3600)
+        throw new Error("invalid-command-seconds");
+    return seconds;
+}

package/dist/src/command-wait.d.ts

@@ -0,0 +1,4 @@
+import type { HandoffValue, CommandWaitRequest } from "./step-bridge.ts";
+export type { CommandWaitRequest, CommandWaitOutcome, CommandWaitProgress, } from "./step-bridge.ts";
+export declare function isCommandWaitRequest(value: unknown): value is CommandWaitRequest;
+export declare function commandWaitValue(value: unknown, ancestors?: ReadonlySet<unknown>): value is HandoffValue;

package/dist/src/command-wait.js

@@ -0,0 +1,45 @@
+export function isCommandWaitRequest(value) {
+    if (!dataFields(value, ["name", "input"]))
+        return false;
+    const name = Reflect.get(value, "name");
+    return (typeof name === "string" &&
+        name.length > 0 &&
+        commandWaitValue(Reflect.get(value, "input")));
+}
+function dataFields(value, keys) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return false;
+    return (Reflect.ownKeys(value).length === keys.length &&
+        keys.every((key) => {
+            const field = Object.getOwnPropertyDescriptor(value, key);
+            return field?.enumerable === true && Object.hasOwn(field, "value");
+        }));
+}
+export function commandWaitValue(value, ancestors = new Set()) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return true;
+    if (typeof value === "number")
+        return Number.isFinite(value);
+    if (typeof value !== "object" || ancestors.has(value))
+        return false;
+    return commandWaitObject(value, ancestors);
+}
+function commandWaitObject(value, ancestors) {
+    const prototype = Object.getPrototypeOf(value);
+    const expectedPrototype = Object.getPrototypeOf(Array.isArray(value) ? [] : {});
+    if (prototype !== expectedPrototype && prototype !== null)
+        return false;
+    const keys = Array.isArray(value)
+        ? Array.from({ length: value.length }, (_, index) => String(index))
+        : Object.keys(value);
+    const ownKeys = Reflect.ownKeys(value).filter((key) => !Array.isArray(value) || key !== "length");
+    if (keys.length !== ownKeys.length)
+        return false;
+    const seen = new Set([...ancestors, value]);
+    return keys.every((key) => {
+        const field = Object.getOwnPropertyDescriptor(value, key);
+        return (field?.enumerable === true &&
+            Object.hasOwn(field, "value") &&
+            commandWaitValue(field.value, seen));
+    });
+}

package/dist/src/configuration-change.d.ts

@@ -0,0 +1,18 @@
+import { type Configuration } from "./configuration-schema.ts";
+export interface SettingChange {
+    readonly field: string;
+    readonly action: "set" | "unset";
+    readonly value?: string;
+    readonly scope: "project" | "private";
+}
+export type HarnessSelection = Required<Pick<NonNullable<Configuration["harness"]>, "name" | "kind" | "path">>;
+export interface HarnessChange {
+    readonly harness: HarnessSelection;
+    readonly scope: "private";
+}
+export declare function selectedHarnessConfiguration(contents: string | undefined, selection: HarnessSelection): string;
+export type JsonValue = null | boolean | number | string | readonly JsonValue[] | {
+    readonly [name: string]: JsonValue;
+};
+export declare function settingValue(text: string): JsonValue;
+export declare function changedConfiguration(contents: string | undefined, change: SettingChange): string;