cloving 1.3.0 → 1.4.0

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-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;

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>;

package/dist/src/daemon/claude-recovery.js

@@ -0,0 +1,204 @@
+import { usageOf, priceOf } from "../worker-usage.js";
+import { located, readRecord, writeRecord, interrupted, replied, reportOf, } from "./operation-journal.js";
+import { turnHarness } from "../harness-defaults.js";
+import { selectedProfile } from "./worker-profile.js";
+import { recordedProcessDirectory } from "./worktree-processes.js";
+import { resumeWorktree } from "./resume-worktree.js";
+export 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 function turnIntent(intent) {
+    return (intent.capability === "claude" &&
+        intent.method !== "run-turn:analyze-chats" &&
+        (intent.method === "run-turn" ||
+            /^run-turn:[A-Za-z0-9_-]{1,119}$/.test(intent.method ?? "")) &&
+        intent.target !== undefined &&
+        intent.payload !== undefined &&
+        intent.leaseGeneration !== undefined);
+}
+export function resumableHarness(harness) {
+    return harness === "claude" || harness === "codex";
+}
+export function resumedCommand(request) {
+    const { worker = "claude", command, sessionId } = request;
+    if (worker === "codex")
+        return codexResume(command, sessionId);
+    if (worker !== "claude")
+        return undefined;
+    const separator = command.indexOf("--");
+    const boundary = separator < 0 ? command.length : separator;
+    return [
+        ...command.slice(0, boundary),
+        "--resume",
+        sessionId,
+        ...command.slice(boundary),
+    ];
+}
+function codexResume(command, sessionId) {
+    const exec = command.indexOf("exec");
+    if (exec < 0)
+        return undefined;
+    return [
+        ...command.slice(0, exec + 1),
+        "resume",
+        sessionId,
+        ...command.slice(exec + 1),
+    ];
+}
+export function recordedField(value, name) {
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    return Reflect.get(value, name);
+}
+export function processAlive(processId) {
+    if (typeof processId !== "number")
+        return false;
+    try {
+        process.kill(processId, 0);
+        return true;
+    }
+    catch (error) {
+        return recordedField(error, "code") === "EPERM";
+    }
+}
+export async function uncertainProcess(started) {
+    const processId = recordedField(started, "processId");
+    if (typeof processId !== "number" || !processAlive(processId))
+        return false;
+    return (!resumableHarness(recordedField(started, "harness")) ||
+        (await recordedProcessDirectory(processId)) === undefined);
+}
+export function recordedTree(started) {
+    const path = recordedField(started, "worktree");
+    const branch = recordedField(started, "branch");
+    const startCommit = recordedField(started, "startCommit");
+    return typeof path === "string" &&
+        typeof branch === "string" &&
+        typeof startCommit === "string"
+        ? { path, branch, startCommit }
+        : undefined;
+}
+export async function resumePlan(settings, request) {
+    const { folder, started, intent, signal } = request;
+    const resume = await readResume(folder, started);
+    const tree = recordedTree(started);
+    if (resume === undefined || tree === undefined)
+        return "claude-turn-interrupted";
+    const profile = await selectedProfile(settings, intent);
+    if (typeof profile === "string")
+        return "claude-turn-interrupted";
+    const harness = turnHarness(settings, profile);
+    if (recordedField(started, "harness") !== harness.worker ||
+        resumedCommand({
+            worker: harness.worker,
+            command: harness.command,
+            sessionId: resume.sessionId,
+        }) === undefined)
+        return "claude-turn-interrupted";
+    const locked = await resumeWorktree({
+        ...settings,
+        directory: tree.path,
+        folder,
+        signal,
+    });
+    return locked === null ? { resume, tree, profile, harness } : locked.reason;
+}
+function priorEnd(record) {
+    const field = (name) => recordedField(record, name);
+    const sessionId = field("sessionId");
+    const model = field("model");
+    const retryKind = field("retryKind");
+    return {
+        ...(retryKind === "capacity" ||
+            retryKind === "network" ||
+            retryKind === null
+            ? { retryKind }
+            : {}),
+        ...(field("resumedAfter") === "daemon-restart"
+            ? { resumedAfter: "daemon-restart" }
+            : {}),
+        exitCode: null,
+        result: {
+            sessionId: typeof sessionId === "string" ? sessionId : null,
+            model: typeof model === "string" ? model : null,
+            text: "",
+            failed: true,
+            costUsd: recordedSessionCost(record),
+            turns: typeof field("turns") === "number" ? Number(field("turns")) : null,
+            usage: usageOf(field("usage")),
+        },
+    };
+}
+function recordedSessionCost(record) {
+    const fields = typeof record === "object" && record !== null ? record : {};
+    const name = Object.hasOwn(fields, "sessionCostUsd")
+        ? "sessionCostUsd"
+        : "costUsd";
+    return priceOf(Reflect.get(fields, name));
+}
+function resumeHeader(started) {
+    if (recordedField(started, "phase") === "waiting")
+        return undefined;
+    const attempt = recordedField(started, "attempt");
+    const startedAt = recordedField(started, "startedAt");
+    const head = recordedField(started, "turnStartCommit");
+    if (typeof attempt !== "number" ||
+        !Number.isSafeInteger(attempt) ||
+        attempt < 1 ||
+        attempt > 5 ||
+        typeof startedAt !== "string")
+        return undefined;
+    return {
+        attempt,
+        startedAt,
+        turnStartCommit: typeof head === "string" ? head : null,
+    };
+}
+export async function readResume(folder, started) {
+    const header = resumeHeader(started);
+    if (header === undefined)
+        return undefined;
+    const records = [];
+    for (let number = 1; number <= header.attempt; number += 1)
+        records.push(await readRecord(folder, `attempt-${String(number)}.json`));
+    const sessionId = recordedField(records.at(-1), "sessionId");
+    if (typeof sessionId !== "string" ||
+        sessionId === "" ||
+        records.filter((record) => recordedField(record, "resumedAfter") === "daemon-restart").length >= 2)
+        return undefined;
+    return {
+        sessionId,
+        ends: records.map(priorEnd),
+        startedAt: header.startedAt,
+        turnStartCommit: header.turnStartCommit,
+    };
+}
+export async function recordedHarness(journal, operationId) {
+    const { folder } = located(journal, operationId);
+    const started = await readRecord(folder, "started.json").catch(() => undefined);
+    const harness = recordedField(started, "harness");
+    return typeof harness === "string" ? harness : undefined;
+}
+export async function interruptedReply(place, reason) {
+    const ending = interrupted(reason);
+    await writeRecord(place.folder, { name: "result.json", value: ending });
+    return replied({ receipt: place.key, worker: "claude" }, ending);
+}
+export async function recoverTurn(operation, reconcile) {
+    const { intent, journal, report } = operation;
+    if (!resumableHarness(await recordedHarness(journal, intent.operationId)))
+        return;
+    const result = await reconcile();
+    if (operation.signal.aborted)
+        return;
+    if (result.kind === "completed" ||
+        result.kind === "failed" ||
+        result.kind === "stopped")
+        await report(reportOf({
+            intent,
+            worker: "claude",
+            commandId: `claude-turn:${located(journal, intent.operationId).key}`,
+        }, {
+            ...result,
+            outcome: result.kind,
+            endedAt: new Date().toISOString(),
+        }));
+}

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

@@ -0,0 +1,27 @@
+import type { ReviewVerdict } from "../review-subject.ts";
+import type { TicketStatus } from "../ticket-status.ts";
+import { type WorkerUsage, type WorkerAttemptUsage, type WorkerModelUsage, type RetryKind } from "../worker-usage.ts";
+export type Worker = string;
+export interface StreamResult {
+    readonly reviewFeedback?: string;
+    readonly reviewVerdict?: ReviewVerdict | null;
+    readonly models?: readonly WorkerModelUsage[];
+    readonly ticketStatusTooLarge?: true;
+    readonly ticketStatus?: TicketStatus;
+    readonly attempts?: readonly WorkerAttemptUsage[];
+    readonly pricingModel?: string | null;
+    readonly subtype?: string;
+    readonly errorType?: string;
+    readonly model: string | null;
+    readonly text: string;
+    readonly failed: boolean;
+    readonly costUsd: number | null;
+    readonly usage: WorkerUsage;
+    readonly sessionId: string | null;
+    readonly turns: number | null;
+}
+export declare function parsed(line: string): unknown;
+export declare function textOf(value: unknown): string | null;
+export declare function capacityRefusal(result: StreamResult | undefined): boolean;
+export declare function retryKind(result: StreamResult | undefined): RetryKind | null;
+export declare function streamResult(line: string, worker?: Worker): StreamResult | undefined;

package/dist/src/daemon/claude-stream.js

@@ -0,0 +1,63 @@
+import { grokResultFields } from "../grok-result.js";
+import { priceOf, modelUsageOf, usageOf, } from "../worker-usage.js";
+export function parsed(line) {
+    try {
+        const value = JSON.parse(line);
+        return value;
+    }
+    catch {
+        return undefined;
+    }
+}
+function numberOf(value) {
+    return typeof value === "number" ? value : null;
+}
+export function textOf(value) {
+    return typeof value === "string" ? value : null;
+}
+function networkFailure(result) {
+    return (result?.failed === true &&
+        result.text.startsWith("API Error: Can't reach the API server"));
+}
+export function capacityRefusal(result) {
+    if (networkFailure(result))
+        return false;
+    return (result?.failed === true &&
+        ["success", "error_during_execution"].includes(result.subtype ?? "error_during_execution") &&
+        (result.text ===
+            "Selected model is at capacity. Please try a different model." ||
+            result.errorType === "overloaded"));
+}
+export function retryKind(result) {
+    if (networkFailure(result))
+        return "network";
+    return capacityRefusal(result) ? "capacity" : null;
+}
+export function streamResult(line, worker) {
+    if (!line.includes('"result"'))
+        return undefined;
+    const record = parsed(line);
+    if (typeof record !== "object" || record === null)
+        return undefined;
+    const field = (name) => Reflect.get(record, name);
+    if (field("type") !== "result")
+        return undefined;
+    const models = modelUsageOf(field("models"));
+    return {
+        ...(models === undefined ? {} : { models }),
+        ...(typeof field("subtype") === "string"
+            ? { subtype: String(field("subtype")) }
+            : {}),
+        ...(typeof field("error") === "string"
+            ? { errorType: String(field("error")) }
+            : {}),
+        text: textOf(field("result")) ?? "",
+        failed: field("is_error") === true,
+        costUsd: priceOf(field("total_cost_usd")),
+        usage: usageOf(field("usage")),
+        model: textOf(field("model")),
+        sessionId: textOf(field("session_id")),
+        turns: numberOf(field("num_turns")),
+        ...(worker === "grok" ? grokResultFields(record) : {}),
+    };
+}

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

@@ -1,26 +1,10 @@
-import type { ReviewVerdict } from "../review-subject.ts";
-import type { TicketStatus } from "../ticket-status.ts";
-import { type WorkerUsage, type WorkerAttemptUsage, type WorkerModelUsage, type RetryKind } from "../worker-usage.ts";
-export type Worker = string;
-export interface StreamResult {
-    readonly reviewFeedback?: string;
-    readonly reviewVerdict?: ReviewVerdict | null;
-    readonly models?: readonly WorkerModelUsage[];
-    readonly ticketStatusTooLarge?: true;
-    readonly ticketStatus?: TicketStatus;
-    readonly attempts?: readonly WorkerAttemptUsage[];
-    readonly pricingModel?: string | null;
-    readonly subtype?: string;
-    readonly errorType?: string;
-    readonly model: string | null;
-    readonly text: string;
-    readonly failed: boolean;
-    readonly costUsd: number | null;
-    readonly usage: WorkerUsage;
-    readonly sessionId: string | null;
-    readonly turns: number | null;
-}
+import { type Worker, type StreamResult } from "./claude-stream.ts";
+import { type RetryKind } from "../worker-usage.ts";
+export { streamResult, capacityRefusal, retryKind } from "./claude-stream.ts";
+export type { Worker, StreamResult } from "./claude-stream.ts";
 export interface TurnEnd {
+    readonly retryKind?: RetryKind | null;
+    readonly resumedAfter?: "daemon-restart";
     readonly reason?: string;
     readonly detail?: string;
     readonly stopped?: boolean;
@@ -28,6 +12,7 @@ export interface TurnEnd {
     readonly result: StreamResult | undefined;
 }
 export interface TurnStart {
+    readonly progress?: (progress: TurnProgress) => Promise<void>;
     readonly resultBytes?: number;
     readonly output?: "text";
     readonly shell?: string;
@@ -40,14 +25,15 @@ export interface TurnStart {
     readonly activityFolder?: string;
     readonly prompt: string;
 }
+export interface TurnProgress {
+    readonly sessionId: string | null;
+    readonly result: StreamResult | undefined;
+}
 export interface RunningTurn {
     readonly processId: number | null;
     readonly ended: Promise<TurnEnd>;
     readonly stop: (graceMilliseconds: number) => void;
 }
-export declare function capacityRefusal(result: StreamResult | undefined): boolean;
-export declare function retryKind(result: StreamResult | undefined): RetryKind | null;
 export declare function succeeded(end: TurnEnd): boolean;
-export declare function streamResult(line: string, worker?: Worker): StreamResult | undefined;
 export declare function turnEnvironment(configuration: string, start: TurnStart): NodeJS.ProcessEnv;
 export declare function startTurn(start: TurnStart): RunningTurn;