cloving 1.3.0 → 1.5.0

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

@@ -1,3 +1,5 @@
+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";
@@ -8,7 +10,6 @@ import { boardWorkflow, watchHash, watchLocation } from "./watch-navigation.js";
 import { Decision, Events, Turn, PullRequest } from "./watch-turn.js";
 import { Commands } from "./command-effects.js";
 export { PullRequest } from "./watch-turn.js";
-import { StartRun } from "./watch-start-view.js";
 export function BannerDetail(props) {
     const { run, now } = props;
     const turn = run.turns.at(-1);
@@ -88,9 +89,7 @@ export function Review(props) {
 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 })
@@ -103,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,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, phone: props.phone, now }),
+            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,8 +1,10 @@
 #!/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, execFileSync, spawn } from "node:child_process";
+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";
@@ -30,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;
@@ -58,6 +60,52 @@ const watchCommand = async (request) => {
         listener[Symbol.dispose]();
     }
 };
+function spawnedHarness(request) {
+    try {
+        return spawn(request.executable, request.arguments, {
+            cwd: request.directory,
+            env: request.environment,
+            stdio: "inherit",
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
+function startHarness(request) {
+    return new Promise((settle) => {
+        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);
+        const child = spawnedHarness(request);
+        if (child === undefined) {
+            cleanup();
+            settle(null);
+            return;
+        }
+        child.once("error", () => {
+            cleanup();
+            settle(null);
+        });
+        child.once("close", (status, signal) => {
+            cleanup();
+            settle(status ?? (signal === null ? 1 : 128 + systemConstants.signals[signal]));
+        });
+    });
+}
 function startArguments(input) {
     const { runtime, repository, argumentsList } = input;
     const located = [
@@ -81,13 +129,6 @@ function startArguments(input) {
 }
 function toolProcess(input) {
     const program = join(import.meta.dirname, "..", "tools", `${input.tool}${extname(import.meta.filename)}`);
-    const child = spawn(process.execPath, [program, ...input.argumentsList], {
-        stdio: "inherit",
-        env: {
-            ...process.env,
-            PATH: [dirname(process.execPath), process.env["PATH"]].join(delimiter),
-        },
-    });
     let stopping = false;
     const interrupt = () => {
         stopping = true;
@@ -99,11 +140,25 @@ function toolProcess(input) {
     };
     process.on("SIGINT", interrupt);
     process.on("SIGTERM", terminate);
+    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),
+        },
+    });
     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));
+                });
+            });
         });
     });
 }
@@ -160,6 +215,11 @@ else if (command === "templates")
         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 {
@@ -174,6 +234,7 @@ else {
     await main(process.argv.slice(2), {
         repository,
         environment,
+        startHarness,
         doctorProbe: createProbeRunner({
             spawn: (input) => spawn(input.executable, input.arguments, input.options),
             kill: (identifier, signal) => process.kill(identifier, signal),

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

@@ -1,9 +1,16 @@
+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;
 };

package/dist/src/configuration-change.js

@@ -1,6 +1,20 @@
 import { configuration, settingScope, validateSetting, } from "./configuration-schema.js";
 import { configurationValues, parseConfiguration } from "./project-settings.js";
 import { record } from "./protocol.js";
+export function selectedHarnessConfiguration(contents, selection) {
+    const previous = parseConfiguration(contents, "private");
+    const harness = previous.harness;
+    const same = harness?.name === selection.name &&
+        harness.kind === selection.kind &&
+        harness.path === selection.path;
+    const next = {
+        version: 1,
+        ...previous,
+        harness: { ...(same ? harness : {}), ...selection },
+    };
+    configuration(next, "private");
+    return JSON.stringify(next, null, 2) + "\n";
+}
 function isJsonValue(value) {
     if (value === null || typeof value === "boolean" || typeof value === "string")
         return true;

package/dist/src/configuration-display.js

@@ -13,6 +13,8 @@ const defaults = {
     "watch.port": 3663,
     "watch.actions": "on",
     "github.command": ["gh"],
+    "retention.days": 30,
+    "retention.action": "archive",
 };
 function effectiveValue(setting) {
     const { field, value } = setting;

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

@@ -1,10 +1,18 @@
 import type { TurnProfiles } from "./turn-profile.ts";
 import type { TokenPrices } from "./token-prices.ts";
+export interface RedGreenSettings {
+    readonly test: readonly string[];
+    readonly testFiles: readonly string[];
+    readonly prepare?: readonly string[];
+    readonly assertionPattern?: string;
+    readonly skipPattern?: string;
+}
 export interface Configuration {
     readonly version: 1;
     readonly checks?: {
         readonly beforeMerge?: readonly string[];
         readonly required?: readonly string[];
+        readonly redGreen?: RedGreenSettings;
     };
     readonly tickets?: {
         readonly command?: readonly string[];
@@ -13,6 +21,7 @@ export interface Configuration {
     readonly queue?: {
         readonly everySeconds?: number;
         readonly lanes?: number;
+        readonly dailySpendLimitUsd?: number;
     };
     readonly harness?: {
         readonly name?: string;
@@ -42,6 +51,11 @@ export interface Configuration {
     readonly workflows?: {
         readonly folder?: string;
     };
+    readonly retention?: {
+        readonly days?: number | null;
+        readonly action?: "archive" | "delete";
+        readonly archiveFolder?: string | null;
+    };
 }
 export declare function configuration(value: unknown, scope: "project" | "private"): Configuration;
 export declare function settingScope(field: string): "project" | "private";

package/dist/src/configuration-schema.js

@@ -88,12 +88,16 @@ function validate(value, checked) {
     scalar(value, checked);
     if (schema.type === "object")
         validateObject(value, checked);
-    if (schema.type !== "array")
-        return;
+    if (schema.type === "array")
+        validateArray(value, checked);
+}
+function validateArray(value, { schema, field }) {
     if (!Array.isArray(value))
         invalid(field);
     if (schema.maxItems !== undefined && value.length > schema.maxItems)
         invalid(field);
+    if (schema.minItems !== undefined && value.length < schema.minItems)
+        invalid(field);
     if (schema.items === undefined)
         return;
     for (const [index, item] of value.entries())

package/dist/src/daemon/attachment-file.d.ts

@@ -0,0 +1,6 @@
+import { type FileHandle } from "node:fs/promises";
+export declare function openedAttachment(place: {
+    readonly folder: string;
+    readonly name: string;
+}): Promise<FileHandle>;
+export declare function copiedAttachment(handle: FileHandle, copy: string): Promise<void>;

package/dist/src/daemon/attachment-file.js

@@ -0,0 +1,86 @@
+import { constants } from "node:fs";
+import { lstat, open, rm } from "node:fs/promises";
+import { dirname, join } from "node:path";
+const maximumBytes = 104_857_600;
+const chunkBytes = 1_048_576;
+const pngSignature = Buffer.from([
+    0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
+]);
+const webmSignature = Buffer.from([0x1a, 0x45, 0xdf, 0xa3]);
+const signatures = new Map([
+    ["mp4", (head) => head.subarray(4, 8).toString("latin1") === "ftyp"],
+    ["webm", (head) => head.subarray(0, 4).equals(webmSignature)],
+    ["png", (head) => head.subarray(0, 8).equals(pngSignature)],
+]);
+function listedStatus(path) {
+    return lstat(path).catch(() => undefined);
+}
+async function realFolder(path) {
+    const status = await listedStatus(path);
+    return (status !== undefined && status.isDirectory() && !status.isSymbolicLink());
+}
+async function realFolders(folder) {
+    return (await realFolder(dirname(folder))) && (await realFolder(folder));
+}
+function sameFile(opened, listed) {
+    return (listed !== undefined &&
+        listed.isFile() &&
+        listed.ino === opened.ino &&
+        listed.dev === opened.dev);
+}
+async function signed(handle, name) {
+    const head = Buffer.alloc(8);
+    const { bytesRead } = await handle.read(head, 0, 8, 0);
+    const check = signatures.get(name.slice(name.lastIndexOf(".") + 1));
+    return bytesRead === 8 && check !== undefined && check(head);
+}
+async function checkedHandle(handle, place) {
+    const opened = await handle.stat();
+    const listed = await listedStatus(join(place.folder, place.name));
+    if (!opened.isFile() || opened.nlink !== 1 || !sameFile(opened, listed))
+        throw new Error("attachment-not-available");
+    if (!(await realFolders(place.folder)))
+        throw new Error("attachment-not-available");
+    if (opened.size > maximumBytes)
+        throw new Error("attachment-too-large");
+    if (!(await signed(handle, place.name)))
+        throw new Error("attachment-not-available");
+}
+export async function openedAttachment(place) {
+    if (!(await realFolders(place.folder)))
+        throw new Error("attachment-not-available");
+    const handle = await open(join(place.folder, place.name), constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK).catch(() => undefined);
+    if (handle === undefined)
+        throw new Error("attachment-not-available");
+    try {
+        await checkedHandle(handle, place);
+        return handle;
+    }
+    catch (error) {
+        await handle.close();
+        throw error;
+    }
+}
+async function copiedChunks(source, target) {
+    const chunk = Buffer.alloc(chunkBytes);
+    let position = 0;
+    for (;;) {
+        const { bytesRead } = await source.read(chunk, 0, chunkBytes, position);
+        if (bytesRead === 0)
+            return;
+        position += bytesRead;
+        if (position > maximumBytes)
+            throw new Error("attachment-too-large");
+        await target.write(chunk, 0, bytesRead);
+    }
+}
+export async function copiedAttachment(handle, copy) {
+    await rm(copy, { force: true });
+    const target = await open(copy, "wx");
+    try {
+        await copiedChunks(handle, target);
+    }
+    finally {
+        await target.close();
+    }
+}

package/dist/src/daemon/attachments.d.ts

@@ -0,0 +1,14 @@
+export declare function attachmentFolder(place: {
+    readonly worktrees: string;
+    readonly target: string;
+}): string;
+export declare function attachmentEnvironment(settings: {
+    readonly worktrees: string;
+}, start: {
+    readonly intent: {
+        readonly target: string;
+    };
+    readonly profile: {
+        readonly env?: Readonly<Record<string, string>>;
+    };
+}): Promise<Readonly<Record<string, string>>>;

package/dist/src/daemon/attachments.js

@@ -0,0 +1,17 @@
+import { mkdir } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { treeName } from "./work-tree.js";
+export function attachmentFolder(place) {
+    return join(dirname(place.worktrees), "attachments", treeName(place.target));
+}
+export async function attachmentEnvironment(settings, start) {
+    const attachments = attachmentFolder({
+        worktrees: settings.worktrees,
+        target: start.intent.target,
+    });
+    await mkdir(attachments, { recursive: true });
+    return {
+        ...(start.profile.env ?? {}),
+        CLOVING_ATTACHMENTS_DIRECTORY: attachments,
+    };
+}

package/dist/src/daemon/claude-recovery.d.ts

@@ -0,0 +1,50 @@
+import type { TurnEnd } from "./claude-turn.ts";
+import { type Located, type WorkerReport } from "./operation-journal.ts";
+import type { WorkTree } from "./work-tree.ts";
+import { type WorkerProfiles } from "./worker-profile.ts";
+import type { AdapterOutcome, DeliveryIntent, ProtectedIntent } from "../broker/actor/delivery-intents.ts";
+export interface TurnResume {
+    readonly startedAt: string;
+    readonly turnStartCommit: string | null;
+    readonly sessionId: string;
+    readonly ends: readonly TurnEnd[];
+}
+export declare const resumePrompt = "This turn stopped because the Cloving daemon restarted. Continue the task from the point where it stopped. Run again each command or subagent that did not end. End with the result line that the task asks for.";
+export declare function turnIntent(intent: DeliveryIntent): intent is ProtectedIntent;
+export declare function resumableHarness(harness: unknown): boolean;
+export declare function resumedCommand(request: {
+    readonly worker: string | undefined;
+    readonly command: readonly string[];
+    readonly sessionId: string;
+}): readonly string[] | undefined;
+export declare function recordedField(value: unknown, name: string): unknown;
+export declare function processAlive(processId: unknown): boolean;
+export declare function uncertainProcess(started: unknown): Promise<boolean>;
+export declare function recordedTree(started: unknown): WorkTree | undefined;
+export declare function resumePlan(settings: WorkerProfiles & {
+    readonly stopMilliseconds?: number;
+}, request: {
+    readonly folder: string;
+    readonly started: unknown;
+    readonly intent: ProtectedIntent;
+    readonly signal: AbortSignal;
+}): Promise<"worktree-index-unknown" | "worktree-index-locked" | "claude-turn-interrupted" | {
+    resume: TurnResume;
+    tree: WorkTree;
+    profile: import("../turn-profile.ts").TurnProfile;
+    harness: {
+        readonly worker: string;
+        readonly command: readonly string[];
+        readonly shell?: string;
+        readonly output?: "text";
+    };
+}>;
+export declare function readResume(folder: string, started: unknown): Promise<TurnResume | undefined>;
+export declare function recordedHarness(journal: string, operationId: string): Promise<string | undefined>;
+export declare function interruptedReply(place: Located, reason: string): Promise<AdapterOutcome>;
+export declare function recoverTurn(operation: {
+    readonly intent: ProtectedIntent;
+    readonly journal: string;
+    readonly report: (report: WorkerReport) => Promise<unknown>;
+    readonly signal: AbortSignal;
+}, reconcile: () => Promise<AdapterOutcome>): Promise<void>;