cloving 0.3.20 → 1.1.0

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

@@ -0,0 +1,200 @@
+import { record } from "../protocol.js";
+import { validateAnalysis } from "../chats/analysis.js";
+import { analysisDocumentBytes, analysisEvidence, analysisModelInput, isAnalysisSnapshot, validAnalysisImportId, } from "../chats/analysis-input.js";
+import { analysisProposal } from "../chats/analysis-proposal.js";
+import { operationKey } from "./operation-journal.js";
+import { analysisDirectory, readAnalysisSnapshot, saveAnalysisFiles, inspectAnalysisFiles, } from "./chats-files.js";
+function completed(intent, result) {
+    return {
+        kind: "completed",
+        worker: "chats",
+        receipt: operationKey(intent.operationId),
+        result: JSON.stringify(result),
+    };
+}
+function refused(code, codes = [code]) {
+    return {
+        kind: "failed",
+        reason: code,
+        result: JSON.stringify({ kind: "blocked", codes }),
+    };
+}
+function bounded(text) {
+    if (Buffer.byteLength(text) > analysisDocumentBytes)
+        throw new Error("analysis-too-large");
+}
+function ownIntent(intent) {
+    return (intent.kind === "protected-effect" &&
+        intent.capability === "chats" &&
+        ["read-analysis", "save-analysis"].includes(intent.method ?? "") &&
+        intent.payload !== undefined &&
+        intent.leaseGeneration !== undefined);
+}
+async function payloadOf(settings, intent) {
+    if (!ownIntent(intent) || intent.payload === undefined)
+        throw new Error("unsupported-effect");
+    if ((await settings.workflowId(intent.runId)) !== "analyze-chats")
+        throw new Error("workflow-not-allowed");
+    const text = await settings.document(intent.payload);
+    if (text === undefined)
+        throw new Error("payload-not-available");
+    bounded(text);
+    const payload = record(JSON.parse(text));
+    if (payload === undefined)
+        throw new Error("analysis-input-refused");
+    const importId = payload["importId"];
+    if (typeof importId !== "string" || importId === "")
+        throw new Error("analysis-input-refused");
+    if (!validAnalysisImportId(importId))
+        throw new Error("invalid-import-id");
+    if (intent.target !== importId)
+        throw new Error("analysis-input-refused");
+    return payload;
+}
+async function read(settings, call) {
+    let directory;
+    try {
+        directory = await analysisDirectory(settings.runtimeDirectory, call.importId);
+    }
+    catch (error) {
+        if (Reflect.get(Object(error), "code") === "ENOENT")
+            throw new Error("redaction-required", { cause: error });
+        throw error;
+    }
+    const snapshot = await readAnalysisSnapshot(directory, call.importId);
+    bounded(JSON.stringify(snapshot));
+    bounded(JSON.stringify({ prompt: analysisModelInput(snapshot) }));
+    analysisEvidence(snapshot);
+    const result = { snapshot };
+    bounded(JSON.stringify(result));
+    return completed(call.intent, result);
+}
+function saveInput(payload) {
+    const snapshot = payload["snapshot"];
+    const cycleId = payload["cycleId"];
+    if (!isAnalysisSnapshot(snapshot) ||
+        snapshot.importId !== payload["importId"] ||
+        typeof cycleId !== "string" ||
+        !/^[A-Za-z0-9_-]{1,128}$/.test(cycleId) ||
+        typeof payload["reply"] !== "string")
+        throw new Error("analysis-input-refused");
+    let candidate;
+    try {
+        candidate = JSON.parse(payload["reply"]);
+    }
+    catch {
+        throw new Error("analysis-invalid-json");
+    }
+    return { snapshot, cycleId, candidate };
+}
+async function save(settings, call) {
+    const { snapshot, cycleId, candidate } = saveInput(call.payload);
+    const validation = validateAnalysis(candidate, analysisEvidence(snapshot));
+    if (!validation.accepted)
+        return refused(validation.codes[0] ?? "analysis-input-refused", validation.codes);
+    if (validation.result.openQuestion !== undefined)
+        return refused("analysis-input-refused");
+    try {
+        const directory = await analysisDirectory(settings.runtimeDirectory, snapshot.importId);
+        const output = {
+            cycleId,
+            analysis: JSON.stringify(validation.result) + "\n",
+            proposal: analysisProposal(validation.result),
+        };
+        if (call.mode === "reconcile" &&
+            (await inspectAnalysisFiles(directory, output)) === "absent")
+            return { kind: "absent" };
+        if (call.mode === "deliver")
+            await saveAnalysisFiles(directory, output);
+    }
+    catch {
+        throw new Error("analysis-output-failed");
+    }
+    return completed(call.intent, {
+        kind: "handoff_requested",
+        cycleId,
+        promotionId: `analysis:${snapshot.importId}:${cycleId}`,
+    });
+}
+const reasons = new Set([
+    "analysis-too-large",
+    "redaction-required",
+    "invalid-import-id",
+    "analysis-invalid-json",
+    "analysis-input-refused",
+    "analysis-output-failed",
+    "unsupported-effect",
+    "workflow-not-allowed",
+    "payload-not-available",
+]);
+async function delivered(settings, call) {
+    const { intent, mode } = call;
+    try {
+        if (call.signal?.aborted)
+            return { kind: "stopped" };
+        const payload = await payloadOf(settings, intent);
+        if (call.signal?.aborted)
+            return { kind: "stopped" };
+        if (intent.method === "read-analysis" && mode === "reconcile")
+            return { kind: "absent" };
+        if (intent.method === "read-analysis")
+            return await read(settings, {
+                intent,
+                importId: String(payload["importId"]),
+            });
+        return await save(settings, { intent, payload, mode });
+    }
+    catch (error) {
+        const message = String(Reflect.get(Object(error), "message"));
+        return refused(reasons.has(message) ? message : "analysis-input-refused");
+    }
+}
+export function chatsWorker(settings) {
+    if (process.platform !== "darwin") {
+        const unsupported = () => Promise.resolve(refused("platform-unsupported"));
+        return {
+            deliver: unsupported,
+            reconcile: unsupported,
+            stop: unsupported,
+            close: () => Promise.resolve(),
+        };
+    }
+    const active = new Map();
+    const lifecycle = { closed: false };
+    const deliver = (intent, signal) => {
+        if (lifecycle.closed || signal.aborted)
+            return Promise.resolve({ kind: "stopped" });
+        const key = operationKey(JSON.stringify([intent.runId, intent.operationId, intent.inputDigest]));
+        const known = active.get(key);
+        if (known !== undefined)
+            return known;
+        const pending = delivered(settings, {
+            intent,
+            mode: "deliver",
+            signal,
+        }).finally(() => active.delete(key));
+        active.set(key, pending);
+        return pending;
+    };
+    const stop = async (intent) => {
+        if (!ownIntent(intent))
+            return refused("unsupported-effect");
+        if ((await settings.workflowId(intent.runId)) !== "analyze-chats")
+            return refused("workflow-not-allowed");
+        const key = operationKey(JSON.stringify([intent.runId, intent.operationId, intent.inputDigest]));
+        const pending = active.get(key);
+        if (pending !== undefined)
+            return await pending;
+        const result = await delivered(settings, { intent, mode: "reconcile" });
+        return result.kind === "absent" ? { kind: "stopped" } : result;
+    };
+    return {
+        deliver,
+        reconcile: (intent) => delivered(settings, { intent, mode: "reconcile" }),
+        stop,
+        close: async () => {
+            lifecycle.closed = true;
+            await Promise.all(active.values());
+        },
+    };
+}

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

@@ -0,0 +1,38 @@
+import { type WorkerUsage } from "../worker-usage.ts";
+export type Worker = "claude" | "codex";
+export interface StreamResult {
+    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 interface TurnEnd {
+    readonly stopped?: boolean;
+    readonly exitCode: number | null;
+    readonly result: StreamResult | undefined;
+}
+export interface TurnStart {
+    readonly mode?: "analysis";
+    readonly analysisToken?: string;
+    readonly worker?: Worker;
+    readonly turnId?: string;
+    readonly environment?: Readonly<Record<string, string>>;
+    readonly command: readonly string[];
+    readonly directory: string;
+    readonly folder: string;
+    readonly activityFolder?: string;
+    readonly prompt: string;
+}
+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 streamResult(line: string): StreamResult | undefined;
+export declare function startTurn(start: TurnStart): RunningTurn;

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

@@ -0,0 +1,216 @@
+import { spawn } from "node:child_process";
+import { createWriteStream, mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { codexStream } from "./codex-stream.js";
+import { priceOf, usageOf } from "../worker-usage.js";
+import { commandModel } from "../token-prices.js";
+import { analysisCommand, analysisEnvironment } from "./analysis-launch.js";
+function parsed(line) {
+    try {
+        const value = JSON.parse(line);
+        return value;
+    }
+    catch {
+        return undefined;
+    }
+}
+function numberOf(value) {
+    return typeof value === "number" ? value : null;
+}
+function textOf(value) {
+    return typeof value === "string" ? value : null;
+}
+export function capacityRefusal(result) {
+    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 streamResult(line) {
+    if (!line.includes('"result"'))
+        return undefined;
+    const record = parsed(line);
+    const field = (name) => Reflect.get(Object(record), name);
+    if (field("type") !== "result")
+        return undefined;
+    return {
+        ...(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")),
+    };
+}
+function ended(stream) {
+    return new Promise((settle) => {
+        stream.end(settle);
+    });
+}
+function turnEnvironment(configuration, start) {
+    if (start.mode === "analysis")
+        return {
+            ...analysisEnvironment(start.folder),
+            CLAUDE_CODE_OAUTH_TOKEN: start.analysisToken,
+        };
+    const excluded = new Set([
+        "GH_TOKEN",
+        "GITHUB_TOKEN",
+        "GH_ENTERPRISE_TOKEN",
+        "GITHUB_ENTERPRISE_TOKEN",
+    ]);
+    const supplied = Object.fromEntries(Object.entries(start.environment ?? {}).map(([name, value]) => [
+        name,
+        value.replaceAll("{turn}", start.turnId ?? ""),
+    ]));
+    const environment = Object.fromEntries(Object.entries({ ...process.env, ...supplied }).filter(([name]) => !excluded.has(name)));
+    if (start.turnId !== undefined)
+        environment["CLOVING_TURN_ID"] = start.turnId;
+    environment["GH_CONFIG_DIR"] = configuration;
+    return environment;
+}
+function spawnTurn(start) {
+    const configuration = mkdtempSync(join(start.folder, "gh-config-"));
+    const [executable = "", ...fixed] = start.mode === "analysis" ? analysisCommand() : start.command;
+    try {
+        const child = spawn(executable, fixed, {
+            cwd: start.directory,
+            env: turnEnvironment(configuration, start),
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        return { child, configuration };
+    }
+    catch (error) {
+        rmSync(configuration, { recursive: true, force: true });
+        throw error;
+    }
+}
+function receivedLines(stream, lines) {
+    for (const line of lines) {
+        const event = parsed(line);
+        const field = (name) => Reflect.get(Object(event), name);
+        const type = field("type");
+        if (type === "assistant" && field("parent_tool_use_id") == null)
+            stream.errorType = textOf(field("error"));
+        if (type === "system" || type === "result")
+            stream.model = textOf(field("model")) ?? stream.model;
+        const result = streamResult(line);
+        if (result !== undefined) {
+            const errorType = result.errorType ?? stream.errorType;
+            stream.result = {
+                ...result,
+                ...(errorType === null ? {} : { errorType }),
+            };
+        }
+    }
+}
+function activityOutput(start) {
+    if (start.mode === "analysis")
+        return undefined;
+    const output = createWriteStream(join(start.activityFolder ?? start.folder, "turn.jsonl"), { flags: start.activityFolder === undefined ? "w" : "a" });
+    if (start.activityFolder !== undefined)
+        output.write("\n");
+    return output;
+}
+function turnOutput(start, stdout) {
+    const output = activityOutput(start);
+    const codex = start.worker === "codex" ? codexStream() : undefined;
+    const stream = {
+        pending: "",
+        result: undefined,
+        model: null,
+        errorType: null,
+    };
+    const received = (lines) => {
+        receivedLines(stream, lines);
+    };
+    const written = (lines) => {
+        for (const line of lines)
+            output?.write(`${line}\n`);
+        received(lines);
+    };
+    stdout.setEncoding("utf8");
+    stdout.on("data", (chunk) => {
+        if (codex === undefined)
+            output?.write(chunk);
+        const lines = `${stream.pending}${chunk}`.split("\n");
+        stream.pending = lines.pop() ?? "";
+        if (codex !== undefined) {
+            written(lines.flatMap(codex.line));
+            return;
+        }
+        received(lines);
+    });
+    return async (exitCode) => {
+        if (codex !== undefined) {
+            written(codex.line(stream.pending));
+            written([codex.result(exitCode)]);
+        }
+        if (output !== undefined)
+            await ended(output);
+        if (codex === undefined)
+            received([stream.pending]);
+        const result = stream.result;
+        return result === undefined
+            ? undefined
+            : {
+                ...result,
+                model: result.model ??
+                    stream.model ??
+                    commandModel(start.mode === "analysis" ? analysisCommand() : start.command),
+            };
+    };
+}
+function withoutAnalysisToken(start, result) {
+    const token = start.mode === "analysis" ? start.analysisToken : undefined;
+    if (token === undefined || result === undefined)
+        return result;
+    const redact = (value) => value === null ? null : value.replaceAll(token, "[redacted]");
+    return {
+        ...result,
+        text: redact(result.text) ?? "",
+        model: redact(result.model),
+        sessionId: redact(result.sessionId),
+    };
+}
+export function startTurn(start) {
+    const { child, configuration } = spawnTurn(start);
+    const output = turnOutput(start, child.stdout);
+    if (start.mode === "analysis")
+        child.stderr.resume();
+    else
+        child.stderr.pipe(createWriteStream(join(start.folder, "turn.stderr.log")));
+    child.stdin.on("error", () => undefined);
+    child.stdin.end(start.prompt);
+    const closed = new Promise((settle) => {
+        child.once("error", () => undefined);
+        child.once("close", settle);
+    });
+    const timers = [];
+    return {
+        processId: child.pid ?? null,
+        ended: closed
+            .then(async (exitCode) => {
+            timers.forEach(clearTimeout);
+            return {
+                exitCode,
+                result: withoutAnalysisToken(start, await output(exitCode)),
+            };
+        })
+            .finally(() => {
+            rmSync(configuration, { recursive: true, force: true });
+        }),
+        stop: (graceMilliseconds) => {
+            child.kill("SIGTERM");
+            timers.push(setTimeout(() => child.kill("SIGKILL"), graceMilliseconds).unref());
+        },
+    };
+}

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

@@ -0,0 +1,29 @@
+import { type TokenPrices } from "../token-prices.ts";
+import { type TurnProfiles } from "../turn-profile.ts";
+import type { Delivery } from "../broker/actor/delivery-intents.ts";
+import { type Worker } from "./claude-turn.ts";
+import { type RetrySettings } from "./retrying-turn.ts";
+import { type WorkerReport } from "./operation-journal.ts";
+export interface ClaudeWorkerSettings extends RetrySettings {
+    readonly tokenPrices?: TokenPrices;
+    readonly worker?: Worker;
+    readonly profiles?: TurnProfiles;
+    readonly workflowId?: (runId: string) => Promise<string | undefined>;
+    readonly repository: string;
+    readonly worktrees: string;
+    readonly journal: string;
+    readonly command: readonly string[];
+    readonly document: (digest: string) => Promise<string | undefined>;
+    readonly report: (report: WorkerReport) => Promise<unknown>;
+    readonly stopMilliseconds?: number;
+}
+export interface ClaudeWorker extends Delivery {
+    readonly stop: NonNullable<Delivery["stop"]>;
+    readonly close: () => Promise<void>;
+}
+export declare const claudeLimits: {
+    summaryCharacters: number;
+    resultBytes: number;
+    stopMilliseconds: number;
+};
+export declare function claudeWorker(settings: ClaudeWorkerSettings): ClaudeWorker;