cloving 1.0.1 → 1.2.0

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

@@ -0,0 +1,201 @@
+import { saveQuestion } from "./chats-question.js";
+import { saveAcceptedAnalysis, saveFollowUp, } from "./chats-follow-up.js";
+import { record } from "../protocol.js";
+import { validateAnalysis } from "../chats/analysis.js";
+import { analysisDocumentBytes, analysisEvidence, analysisSaveInput, validAnalysisImportId, } from "../chats/analysis-input.js";
+import { analysisBatchData, prepareAnalysisBatch, } from "../chats/analysis-batches.js";
+import { captureAnalysisSnapshot, readCapturedAnalysisSnapshot, findAnalysisCapture, } from "./chats-capture.js";
+import { operationKey } from "./operation-journal.js";
+import { analysisDirectory } 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) {
+    const { importId } = call;
+    let directory;
+    try {
+        directory = await analysisDirectory(settings.runtimeDirectory, importId);
+    }
+    catch (error) {
+        if (Reflect.get(Object(error), "code") === "ENOENT")
+            throw new Error("redaction-required", { cause: error });
+        throw error;
+    }
+    const capture = await captureAnalysisSnapshot(directory, {
+        importId,
+        runId: call.intent.runId,
+    });
+    const snapshot = await readCapturedAnalysisSnapshot(directory, capture);
+    const batch = prepareAnalysisBatch(snapshot, {
+        nextRecordIndex: 0,
+        completedBatchCount: 0,
+        previousResult: null,
+    });
+    if (batch.kind === "refused")
+        throw new Error(batch.code);
+    const result = analysisBatchData(batch, { digest: capture.digest, snapshot });
+    bounded(JSON.stringify(result));
+    return completed(call.intent, result);
+}
+async function saveInput(settings, call) {
+    if ("snapshot" in call.payload)
+        return analysisSaveInput(call.payload);
+    const importId = String(call.payload["importId"]);
+    const directory = await analysisDirectory(settings.runtimeDirectory, importId);
+    const capture = await findAnalysisCapture(directory, {
+        runId: call.intent.runId,
+        importId,
+    });
+    if (capture === undefined)
+        throw new Error("analysis-output-failed");
+    const snapshot = await readCapturedAnalysisSnapshot(directory, capture);
+    return analysisSaveInput({ ...call.payload, snapshot });
+}
+async function save(settings, call) {
+    const input = await saveInput(settings, call);
+    const { snapshot, candidate } = input;
+    if ("followUp" in call.payload)
+        return saveFollowUp(settings.runtimeDirectory, { ...call, input });
+    if ("batch" in call.payload &&
+        Object.hasOwn(record(candidate) ?? {}, "openQuestion"))
+        return saveQuestion(settings, { ...call, input });
+    const validation = "batch" in call.payload
+        ? undefined
+        : validateAnalysis(candidate, analysisEvidence(snapshot));
+    if (validation === undefined)
+        return saveAcceptedAnalysis(settings.runtimeDirectory, { ...call, input });
+    if (!validation.accepted)
+        return refused(validation.codes[0] ?? "analysis-input-refused", validation.codes);
+    const question = validation.result.openQuestion;
+    if (question !== undefined)
+        return saveQuestion(settings, { ...call, input });
+    return saveAcceptedAnalysis(settings.runtimeDirectory, { ...call, input });
+}
+const reasons = new Set([
+    "analysis-too-large",
+    "redaction-required",
+    "invalid-import-id",
+    "analysis-invalid-json",
+    "analysis-follow-up-refused",
+    "analysis-input-refused",
+    "analysis-output-failed",
+    "analysis-batch-limit",
+    "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

@@ -1,22 +1,32 @@
+import { type WorkerUsage, type WorkerAttemptUsage } from "../worker-usage.ts";
 export type Worker = "claude" | "codex";
 export interface StreamResult {
+    readonly attempts?: readonly WorkerAttemptUsage[];
+    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 {
@@ -24,5 +34,6 @@ export interface RunningTurn {
     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

@@ -2,6 +2,9 @@ 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);
@@ -17,6 +20,13 @@ function numberOf(value) {
 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;
@@ -25,9 +35,17 @@ export function streamResult(line) {
     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: numberOf(field("total_cost_usd")),
+        costUsd: priceOf(field("total_cost_usd")),
+        usage: usageOf(field("usage")),
+        model: textOf(field("model")),
         sessionId: textOf(field("session_id")),
         turns: numberOf(field("num_turns")),
     };
@@ -38,6 +56,11 @@ function ended(stream) {
     });
 }
 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",
@@ -56,7 +79,7 @@ function turnEnvironment(configuration, start) {
 }
 function spawnTurn(start) {
     const configuration = mkdtempSync(join(start.folder, "gh-config-"));
-    const [executable = "", ...fixed] = start.command;
+    const [executable = "", ...fixed] = start.mode === "analysis" ? analysisCommand() : start.command;
     try {
         const child = spawn(executable, fixed, {
             cwd: start.directory,
@@ -70,43 +93,101 @@ function spawnTurn(start) {
         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 = createWriteStream(join(start.folder, "turn.jsonl"));
+    const output = activityOutput(start);
     const codex = start.worker === "codex" ? codexStream() : undefined;
-    const stream = { pending: "", result: 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`);
-        stream.result = lines.map(streamResult).findLast(Boolean) ?? stream.result;
+            output?.write(`${line}\n`);
+        received(lines);
     };
     stdout.setEncoding("utf8");
     stdout.on("data", (chunk) => {
         if (codex === undefined)
-            output.write(chunk);
+            output?.write(chunk);
         const lines = `${stream.pending}${chunk}`.split("\n");
         stream.pending = lines.pop() ?? "";
         if (codex !== undefined) {
             written(lines.flatMap(codex.line));
             return;
         }
-        stream.result = lines.map(streamResult).findLast(Boolean) ?? stream.result;
+        received(lines);
     });
     return async (exitCode) => {
         if (codex !== undefined) {
             written(codex.line(stream.pending));
             written([codex.result(exitCode)]);
         }
-        await ended(output);
-        return codex === undefined
-            ? (streamResult(stream.pending) ?? stream.result)
-            : stream.result;
+        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);
-    const errors = createWriteStream(join(start.folder, "turn.stderr.log"));
-    child.stderr.pipe(errors);
+    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) => {
@@ -121,7 +202,7 @@ export function startTurn(start) {
             timers.forEach(clearTimeout);
             return {
                 exitCode,
-                result: await output(exitCode),
+                result: withoutAnalysisToken(start, await output(exitCode)),
             };
         })
             .finally(() => {

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

@@ -1,8 +1,9 @@
 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 {
+export interface ClaudeWorkerSettings extends RetrySettings {
     readonly worker?: Worker;
     readonly profiles?: TurnProfiles;
     readonly workflowId?: (runId: string) => Promise<string | undefined>;