cloving 1.0.1 → 1.1.0

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

@@ -1,8 +1,10 @@
+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 { Board, WorkflowList } from "./watch-board-view.js";
+import { Board, 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";
 export const clove = {
     viewBox: "0.6625858545303345 0.6630800366401672 46.674827575683594 46.673831939697266",
     paths: [
@@ -140,6 +142,16 @@ export function Run(props) {
     ];
     return [
         component(Banner, { run, now }),
+        element("section", {
+            class: "run-usage",
+            children: [
+                element("h3", { children: `Run totals${totalsSuffix(run.state)}` }),
+                element("p", { children: usageText(run.usage) }),
+                element("p", {
+                    children: priceText(run.claudeCostUsd, run.estimatedCostUsd),
+                }),
+            ],
+        }),
         component(Phases, { phases: run.phases, now }),
         component(PullRequest, { run }),
         run.decisions.map((decision) => component(Decision, { decision, turn, copying })),
@@ -173,6 +185,16 @@ export function Header(props) {
                 ],
             }),
             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",
+                }),
         ],
     });
 }
@@ -203,21 +225,43 @@ export function Page(props) {
                 : component(Run, { key: run.runId, run, now, copying }),
         ];
     }
+    return component(BoardPage, { ...props, model, workflowId, down });
+}
+export function BoardPage(props) {
+    const { model, workflowId, down, now, stale, copying } = props;
     const workflow = model.workflows.find((item) => item.workflowId === workflowId);
-    return [
-        head,
-        down,
-        element("div", {
-            class: "workspace",
-            children: [
-                component(WorkflowList, {
-                    workflows: model.workflows,
-                    selected: workflowId,
-                }),
-                workflow === undefined
-                    ? text("meta", "No workflows registered.")
-                    : component(Board, { workflow, now }),
-            ],
-        }),
-    ];
+    const start = props.start ?? { shown: false, onToggle: () => undefined };
+    return element("div", {
+        class: "board-page",
+        children: [
+            component(Header, { model, stale, start }),
+            down,
+            component(StartRun, {
+                workflows: model.workflows,
+                copying,
+                shown: start.shown,
+            }),
+            component(WorkflowList, {
+                workflows: model.workflows,
+                selected: workflowId,
+            }),
+            element("div", {
+                class: "workspace",
+                children: [
+                    workflow === undefined
+                        ? element("p", {
+                            class: "meta",
+                            children: "No workflows registered.",
+                        })
+                        : component(Board, {
+                            workflow,
+                            now,
+                            controls: props.columns,
+                            cardForm: model.cardForms?.find((form) => form.workflowId === workflowId),
+                            cards: props.cards,
+                        }),
+                ],
+            }),
+        ],
+    });
 }

package/dist/src/cli.js

@@ -1,11 +1,48 @@
 #!/usr/bin/env node
-import { spawn } from "node:child_process";
+import { addAbortListener } from "node:events";
+import { execFile, spawn } from "node:child_process";
 import { delimiter, dirname, extname, join } from "node:path";
 import { main } from "./cli/main.js";
 import { clientCommand, runtimeDirectory } from "./cli/runtime-directory.js";
 import { commandUsage } from "./cli/usage.js";
 const [command, ...options] = process.argv.slice(2);
-function started(runtime) {
+const watchCommand = async (request) => {
+    const [command = "", ...argumentsList] = request.command;
+    const completed = Promise.withResolvers();
+    const stderr = { text: "" };
+    const execution = execFile(command, argumentsList, {
+        cwd: request.directory,
+        signal: request.signal,
+        killSignal: "SIGKILL",
+        maxBuffer: 1024 * 1024,
+        encoding: "utf8",
+    }, (error, stdout) => {
+        const code = error === null ? 0 : error.code;
+        completed.resolve({
+            stdout,
+            stderr: stderr.text,
+            status: typeof code === "number" ? code : null,
+            errorCode: typeof code === "string" ? code : null,
+        });
+    });
+    execution.stderr?.on("data", (chunk) => {
+        stderr.text += chunk.toString();
+    });
+    const closed = new Promise((resolve) => execution.once("close", () => {
+        resolve();
+    }));
+    const listener = addAbortListener(request.signal, () => {
+        execution.kill("SIGKILL");
+    });
+    try {
+        await closed;
+        return await completed.promise;
+    }
+    finally {
+        listener[Symbol.dispose]();
+    }
+};
+function started(runtime, argumentsList) {
     const program = join(import.meta.dirname, "..", "tools", `self-host${extname(import.meta.filename)}`);
     const located = [
         "--runtime",
@@ -15,7 +52,7 @@ function started(runtime) {
         "--client",
         clientCommand(process.env),
     ];
-    const child = spawn(process.execPath, [program, ...located, ...options], {
+    const child = spawn(process.execPath, [program, ...located, ...argumentsList], {
         stdio: "inherit",
         env: {
             ...process.env,
@@ -48,9 +85,10 @@ async function start() {
     }
     const runtime = runtimeDirectory(process.env);
     if (runtime !== undefined) {
-        let status = await started(runtime);
+        let status = await started(runtime, options);
+        const restarting = options.filter((option) => option !== "--reset-queue");
         while (status === 75)
-            status = await started(runtime);
+            status = await started(runtime, restarting);
         return status === 0 ? 0 : 1;
     }
     process.stderr.write("runtime-directory-unknown: Set CLOVING_RUNTIME_DIR to the runtime directory of the service.\n");
@@ -59,4 +97,8 @@ async function start() {
 if (command === "start")
     process.exitCode = await start();
 else
-    await main(process.argv.slice(2));
+    await main(process.argv.slice(2), {
+        repository: process.env["CLOVING_WATCH_REPOSITORY"],
+        githubCommand: process.env["CLOVING_GH_COMMAND"],
+        execute: watchCommand,
+    });

package/dist/src/daemon/analysis-launch.d.ts

@@ -0,0 +1,5 @@
+export { analysisInstruction } from "../chats/analysis-prompt.ts";
+export declare const analysisMethod = "run-turn:analyze-chats";
+export declare function analysisCommand(): readonly string[];
+export declare function analysisEnvironment(folder: string): NodeJS.ProcessEnv;
+export declare function analysisAvailable(folder: string): Promise<boolean>;

package/dist/src/daemon/analysis-launch.js

@@ -0,0 +1,81 @@
+import { execFile } from "node:child_process";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { analysisInstruction } from "../chats/analysis-prompt.js";
+export { analysisInstruction } from "../chats/analysis-prompt.js";
+export const analysisMethod = "run-turn:analyze-chats";
+const controls = [
+    "--safe-mode",
+    "--restricted",
+    "--strict-mcp-config",
+    "--disable-slash-commands",
+    "--no-chrome",
+    "--no-session-persistence",
+];
+export function analysisCommand() {
+    return [
+        "claude",
+        ...controls,
+        "--print",
+        "--output-format",
+        "stream-json",
+        "--verbose",
+        "--tools",
+        "",
+        "--disallowedTools",
+        "mcp__*",
+        "--mcp-config",
+        '{"mcpServers":{}}',
+        "--setting-sources",
+        "",
+        "--settings",
+        '{"disableAllHooks":true}',
+        "--permission-prompts",
+        "none",
+        "--max-turns",
+        "1",
+        "--max-budget-usd",
+        "5",
+        "--model",
+        "sonnet",
+        "--system-prompt",
+        analysisInstruction,
+    ];
+}
+export function analysisEnvironment(folder) {
+    return {
+        PATH: process.env["PATH"],
+        HOME: join(folder, "configuration"),
+        CLAUDE_CONFIG_DIR: join(folder, "configuration"),
+        TMPDIR: join(folder, "configuration"),
+        CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1",
+    };
+}
+function supportedVersion(line) {
+    const match = /^2\.(0|[1-9]\d*)\.(0|[1-9]\d*) \(Claude Code\)$/.exec(line.trim());
+    if (match?.[1] === undefined || match[2] === undefined)
+        return false;
+    const minor = BigInt(match[1]);
+    return minor > 1n || (minor === 1n && BigInt(match[2]) >= 302n);
+}
+export async function analysisAvailable(folder) {
+    const probe = (flag) => promisify(execFile)("claude", [flag], {
+        cwd: folder,
+        env: analysisEnvironment(folder),
+        timeout: 5_000,
+        maxBuffer: 131_072,
+    });
+    try {
+        const version = await probe("--version");
+        if (!supportedVersion(version.stdout))
+            return false;
+        const help = await probe("--help");
+        const advertised = new Set(help.stdout.match(/--[a-zA-Z][a-zA-Z0-9-]*/g) ?? []);
+        return analysisCommand()
+            .filter((argument) => argument.startsWith("--"))
+            .every((flag) => advertised.has(flag));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/daemon/analysis-token.d.ts

@@ -0,0 +1,6 @@
+export type AnalysisToken = {
+    readonly token: string;
+} | {
+    readonly error: string;
+};
+export declare function analysisToken(folder: string, signal?: AbortSignal): Promise<AnalysisToken>;

package/dist/src/daemon/analysis-token.js

@@ -0,0 +1,88 @@
+import { spawn } from "node:child_process";
+function failed(category) {
+    return { error: "analysis-token-command-" + category };
+}
+function commandOf(setting) {
+    try {
+        const parsed = JSON.parse(setting);
+        if (!Array.isArray(parsed) || parsed.length === 0)
+            return undefined;
+        const entries = parsed;
+        if (entries.every((entry) => typeof entry === "string" && entry.length > 0))
+            return entries;
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function tokenOf(chunks) {
+    const token = Buffer.concat(chunks)
+        .toString("utf8")
+        .replace(/(?:\r\n|[\r\n])$/, "");
+    return /^[!-~]{1,512}$/.test(token) ? { token } : failed("output-invalid");
+}
+function captured(command, request) {
+    return new Promise((settle) => {
+        const [program = "", ...arguments_] = command;
+        const child = spawn(program, arguments_, {
+            cwd: request.folder,
+            shell: false,
+            stdio: ["ignore", "pipe", "pipe"],
+            signal: request.signal,
+            killSignal: "SIGKILL",
+        });
+        const chunks = [];
+        let bytes = 0;
+        let stopped = false;
+        const stop = (category) => {
+            stopped = true;
+            clearTimeout(timer);
+            child.kill("SIGKILL");
+            child.stdout.destroy();
+            child.stderr.destroy();
+            settle(failed(category));
+        };
+        const timer = setTimeout(() => {
+            stop("timeout");
+        }, 10_000);
+        const received = (chunk, output) => {
+            if (stopped)
+                return;
+            bytes += chunk.length;
+            if (bytes > 4_096) {
+                stop("output-too-large");
+                return;
+            }
+            output?.push(chunk);
+        };
+        child.stdout.on("data", (chunk) => {
+            received(chunk, chunks);
+        });
+        child.stderr.on("data", (chunk) => {
+            received(chunk);
+        });
+        child.once("error", () => {
+            stop("failed");
+        });
+        child.once("close", (code) => {
+            clearTimeout(timer);
+            if (!stopped)
+                settle(code === 0 ? tokenOf(chunks) : failed("failed"));
+        });
+    });
+}
+export async function analysisToken(folder, signal) {
+    const setting = process.env["CLOVING_ANALYSIS_TOKEN_COMMAND"];
+    if (setting === undefined)
+        return failed("unset");
+    const command = commandOf(setting);
+    if (command === undefined)
+        return failed("invalid");
+    try {
+        return await captured(command, { folder, signal });
+    }
+    catch {
+        return failed("failed");
+    }
+}

package/dist/src/daemon/analysis-worker.d.ts

@@ -0,0 +1,22 @@
+import type { AdapterOutcome, DeliveryIntent } from "../broker/actor/delivery-intents.ts";
+import { type TokenPrices } from "../token-prices.ts";
+import { type RetrySettings } from "./retrying-turn.ts";
+import { type WorkerReport } from "./operation-journal.ts";
+interface Settings extends RetrySettings {
+    readonly tokenPrices?: TokenPrices;
+    readonly journal: string;
+    readonly document: (digest: string) => Promise<string | undefined>;
+    readonly report: (report: WorkerReport) => Promise<unknown>;
+    readonly stopMilliseconds?: number;
+}
+interface AnalysisWorker {
+    readonly deliver: (intent: DeliveryIntent, signal: AbortSignal) => Promise<AdapterOutcome | {
+        readonly receipt: string;
+        readonly worker: string;
+    }>;
+    readonly reconcile: (intent: DeliveryIntent, signal: AbortSignal) => Promise<AdapterOutcome>;
+    readonly stop: (intent: DeliveryIntent, signal: AbortSignal) => Promise<AdapterOutcome>;
+    readonly close: () => Promise<void>;
+}
+export declare function analysisWorker(settings: Settings): AnalysisWorker;
+export {};

package/dist/src/daemon/analysis-worker.js

@@ -0,0 +1,219 @@
+import { mkdir, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { analysisPrompt } from "../chats/analysis-prompt.js";
+import { isAnalysisSnapshot } from "../chats/analysis-input.js";
+import { record } from "../protocol.js";
+import { estimatedCostUsd, priceForModel, } from "../token-prices.js";
+import { startRetriedTurn } from "./retrying-turn.js";
+import { analysisAvailable, analysisMethod } from "./analysis-launch.js";
+import { analysisToken } from "./analysis-token.js";
+import { located, readRecord, writeRecord, replied, reportOf, interrupted, } from "./operation-journal.js";
+function own(intent) {
+    return (intent.kind === "protected-effect" &&
+        intent.capability === "claude" &&
+        intent.method === analysisMethod &&
+        intent.target !== undefined &&
+        intent.payload !== undefined &&
+        intent.leaseGeneration !== undefined);
+}
+function failed(reason) {
+    return { kind: "failed", reason };
+}
+function snapshotOf(text) {
+    try {
+        return record(JSON.parse(text ?? "null"))?.["snapshot"];
+    }
+    catch {
+        return undefined;
+    }
+}
+async function cleaned(folder) {
+    await Promise.all(["configuration", "working"].map((name) => rm(join(folder, name), { recursive: true, force: true })));
+}
+async function privateRecord(folder, entry) {
+    await writeRecord(folder, { ...entry, permissions: "private" });
+}
+function outcome(end, prices) {
+    const endedAt = new Date().toISOString();
+    if (end.stopped)
+        return { outcome: "stopped", endedAt };
+    const result = end.result;
+    if (result === undefined)
+        return { ...interrupted("analysis-turn-failed"), endedAt };
+    const fields = {
+        costUsd: result.costUsd,
+        usage: result.usage,
+        model: result.model,
+        sessionId: result.sessionId,
+        turns: result.turns,
+        estimatedCostUsd: estimatedCostUsd(result.usage, {
+            worker: "claude",
+            price: priceForModel(prices, result.model),
+        }),
+    };
+    if (end.exitCode !== 0 || result.failed)
+        return {
+            outcome: "failed",
+            reason: "analysis-turn-failed",
+            endedAt,
+            result: JSON.stringify(fields),
+        };
+    if (Buffer.byteLength(result.text, "utf8") > 16_000)
+        return {
+            outcome: "failed",
+            reason: "analysis-reply-too-large",
+            endedAt,
+            result: JSON.stringify(fields),
+        };
+    return {
+        outcome: "completed",
+        endedAt,
+        result: JSON.stringify({ ...fields, reply: result.text }),
+    };
+}
+function running(processId) {
+    if (typeof processId !== "number")
+        return false;
+    try {
+        process.kill(processId, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function reconcile(parts, intent) {
+    if (!own(intent))
+        return failed("unsupported-effect");
+    const { key, folder } = located(parts.settings.journal, intent.operationId);
+    const result = await readRecord(folder, "result.json");
+    if (result !== undefined) {
+        await cleaned(folder);
+        return replied({ receipt: key, worker: "claude" }, result);
+    }
+    if (parts.active.has(key))
+        return { kind: "accepted", receipt: key, worker: "claude" };
+    const started = await readRecord(folder, "started.json");
+    if (started === undefined)
+        return { kind: "absent" };
+    if (running(record(started)?.["processId"]))
+        return { kind: "unknown", evidence: key };
+    const ending = interrupted("analysis-turn-failed");
+    await privateRecord(folder, { name: "result.json", value: ending });
+    await cleaned(folder);
+    return replied({ receipt: key, worker: "claude" }, ending);
+}
+async function begun(parts, opening) {
+    const { intent, folder, key, directory, prompt } = opening;
+    const started = {
+        operationId: intent.operationId,
+        target: intent.target,
+        mode: "analysis",
+        startedAt: new Date().toISOString(),
+    };
+    const turn = await startRetriedTurn({
+        mode: "analysis",
+        analysisToken: opening.token,
+        command: [],
+        folder,
+        directory,
+        prompt,
+    }, { ...parts.settings, metadata: started });
+    const done = turn.ended
+        .then(async (end) => {
+        const result = outcome(end, parts.settings.tokenPrices ?? {});
+        await privateRecord(folder, { name: "result.json", value: result });
+        await cleaned(folder);
+        await parts.settings.report(reportOf({ intent, worker: "claude", commandId: `analysis-turn:${key}` }, result));
+    })
+        .catch(() => undefined)
+        .finally(() => parts.active.delete(key));
+    parts.active.set(key, { turn, done });
+}
+function cancelled(parts, signal) {
+    return signal.aborted || parts.stopping.signal.aborted;
+}
+async function deliver(parts, call) {
+    const { intent, signal } = call;
+    if (!own(intent))
+        return failed("unsupported-effect");
+    const known = await reconcile(parts, intent);
+    if (known.kind !== "absent")
+        return known;
+    const { key, folder } = located(parts.settings.journal, intent.operationId);
+    const text = await parts.settings.document(intent.payload);
+    const snapshot = snapshotOf(text);
+    if (!isAnalysisSnapshot(snapshot) || snapshot.importId !== intent.target)
+        return failed("analysis-input-refused");
+    await mkdir(join(folder, "configuration"), { recursive: true, mode: 0o700 });
+    if (!(await analysisAvailable(folder))) {
+        await cleaned(folder);
+        return failed("analysis-worker-unavailable");
+    }
+    if (cancelled(parts, signal)) {
+        await cleaned(folder);
+        return failed("analysis-turn-failed");
+    }
+    const credential = await analysisToken(folder, signal);
+    if (cancelled(parts, signal)) {
+        await cleaned(folder);
+        return failed("analysis-turn-failed");
+    }
+    if ("error" in credential) {
+        await cleaned(folder);
+        return {
+            ...failed("analysis-worker-unavailable"),
+            result: JSON.stringify({ error: credential.error }),
+        };
+    }
+    const directory = join(folder, "working");
+    await mkdir(directory, { mode: 0o700 });
+    await begun(parts, {
+        intent,
+        key,
+        folder,
+        directory,
+        prompt: analysisPrompt(snapshot),
+        token: credential.token,
+    });
+    return { receipt: key, worker: "claude" };
+}
+async function halted(parts, active) {
+    active.turn.stop(parts.settings.stopMilliseconds ?? 2_000);
+    await active.done;
+}
+function delivered(parts, call) {
+    if (cancelled(parts, call.signal))
+        return Promise.resolve(failed("analysis-turn-failed"));
+    const key = call.intent.operationId;
+    const known = parts.preparing.get(key);
+    if (known !== undefined)
+        return known;
+    const signal = AbortSignal.any([call.signal, parts.stopping.signal]);
+    const pending = deliver(parts, { ...call, signal }).finally(() => parts.preparing.delete(key));
+    parts.preparing.set(key, pending);
+    return pending;
+}
+export function analysisWorker(settings) {
+    const parts = {
+        settings,
+        active: new Map(),
+        preparing: new Map(),
+        stopping: new AbortController(),
+    };
+    return {
+        deliver: (intent, signal) => delivered(parts, { intent, signal }),
+        reconcile: (intent) => reconcile(parts, intent),
+        stop: async (intent) => {
+            const active = parts.active.get(located(settings.journal, intent.operationId).key);
+            if (active !== undefined)
+                await halted(parts, active);
+            return reconcile(parts, intent);
+        },
+        close: async () => {
+            parts.stopping.abort();
+            await Promise.all(parts.preparing.values());
+            await Promise.all([...parts.active.values()].map((active) => halted(parts, active)));
+        },
+    };
+}

package/dist/src/daemon/chats-files.d.ts

@@ -0,0 +1,15 @@
+import { type AnalysisSnapshot } from "../chats/analysis-input.ts";
+export declare function analysisDirectory(runtime: string, importId: string): Promise<string>;
+export declare function boundedAnalysisFile(path: string, options?: {
+    readonly permissions?: number;
+}): Promise<string>;
+export declare function readAnalysisSnapshot(directory: string, importId: string): Promise<AnalysisSnapshot>;
+export declare function matchingPrivateFile(path: string, text: string): Promise<void>;
+interface AnalysisOutput {
+    readonly cycleId: string;
+    readonly analysis: string;
+    readonly proposal: string;
+}
+export declare function inspectAnalysisFiles(directory: string, output: AnalysisOutput): Promise<"complete" | "absent">;
+export declare function saveAnalysisFiles(directory: string, output: AnalysisOutput): Promise<void>;
+export {};