cloving 0.3.20 → 1.1.0

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

package/dist/src/daemon/chats-files.js

@@ -0,0 +1,113 @@
+import { lstat } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { openInput } from "../chats/input-file.js";
+import { createPrivateFile, validateDestination, } from "../chats/destination.js";
+import { analysisDocumentBytes, } from "../chats/analysis-input.js";
+export async function analysisDirectory(runtime, importId) {
+    if (process.platform !== "darwin")
+        throw new Error("platform-unsupported");
+    const directory = resolve(runtime, "chats", importId);
+    await checkedDirectory(directory);
+    return directory;
+}
+async function checkedDirectory(directory) {
+    try {
+        if (!(await lstat(directory)).isDirectory())
+            throw new Error("analysis-input-refused");
+    }
+    catch (error) {
+        if (Reflect.get(Object(error), "code") !== "ENOENT")
+            throw error;
+        const parent = dirname(directory);
+        if (parent === directory)
+            throw error;
+        await checkedDirectory(parent);
+        throw error;
+    }
+    await validateDestination(directory);
+}
+export async function boundedAnalysisFile(path, options = {}) {
+    const handle = await openInput(path);
+    try {
+        if (options.permissions !== undefined &&
+            ((await handle.stat()).mode & 0o777) !== options.permissions)
+            throw new Error("analysis-output-failed");
+        const buffer = Buffer.alloc(analysisDocumentBytes + 1);
+        let size = 0;
+        while (size < buffer.length) {
+            const { bytesRead } = await handle.read(buffer, size, buffer.length - size, null);
+            if (bytesRead === 0)
+                break;
+            size += bytesRead;
+        }
+        if (size > analysisDocumentBytes)
+            throw new Error("analysis-too-large");
+        return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(buffer.subarray(0, size));
+    }
+    finally {
+        await handle.close();
+    }
+}
+export async function readAnalysisSnapshot(directory, importId) {
+    const required = async (name) => {
+        try {
+            return await boundedAnalysisFile(join(directory, name));
+        }
+        catch (error) {
+            if (Reflect.get(Object(error), "code") === "ENOENT")
+                throw new Error("redaction-required", { cause: error });
+            throw error;
+        }
+    };
+    return {
+        importId,
+        redaction: await required("redaction.json"),
+        corpus: await required("redacted.jsonl"),
+        structure: await boundedAnalysisFile(join(directory, "structure.json")),
+    };
+}
+export async function matchingPrivateFile(path, text) {
+    try {
+        const existing = await boundedAnalysisFile(path, { permissions: 0o600 });
+        if (existing !== text)
+            throw new Error("analysis-output-failed");
+        return;
+    }
+    catch (error) {
+        if (Reflect.get(Object(error), "code") !== "ENOENT")
+            throw error;
+    }
+    const handle = await createPrivateFile(path);
+    try {
+        await handle.writeFile(text);
+    }
+    finally {
+        await handle.close();
+    }
+}
+export async function inspectAnalysisFiles(directory, output) {
+    const proposal = join(directory, `proposal-${output.cycleId}.txt`);
+    const analysis = join(directory, `analysis-${output.cycleId}.json`);
+    const marker = await boundedAnalysisFile(analysis, {
+        permissions: 0o600,
+    }).catch((error) => {
+        if (Reflect.get(Object(error), "code") === "ENOENT")
+            return undefined;
+        throw error;
+    });
+    if (marker === undefined)
+        return "absent";
+    if (marker !== output.analysis ||
+        (await boundedAnalysisFile(proposal, { permissions: 0o600 })) !==
+            output.proposal)
+        throw new Error("analysis-output-failed");
+    return "complete";
+}
+export async function saveAnalysisFiles(directory, output) {
+    if ((await inspectAnalysisFiles(directory, output)) === "complete")
+        return;
+    const proposal = join(directory, `proposal-${output.cycleId}.txt`);
+    const analysis = join(directory, `analysis-${output.cycleId}.json`);
+    await matchingPrivateFile(proposal, output.proposal);
+    await matchingPrivateFile(analysis, output.analysis);
+}

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

@@ -0,0 +1,12 @@
+import type { AdapterOutcome, DeliveryIntent } from "../broker/actor/delivery-intents.ts";
+import type { EffectDelivery } from "./delivery-router.ts";
+export interface ChatsWorkerSettings {
+    readonly runtimeDirectory: string;
+    readonly document: (digest: string) => Promise<string | undefined>;
+    readonly workflowId: (runId: string) => Promise<string | undefined>;
+}
+export interface ChatsWorker extends EffectDelivery {
+    readonly deliver: (intent: DeliveryIntent, signal: AbortSignal) => Promise<AdapterOutcome>;
+    readonly close: () => Promise<void>;
+}
+export declare function chatsWorker(settings: ChatsWorkerSettings): ChatsWorker;