cloving 1.2.0 → 1.4.0

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

@@ -1,66 +1,29 @@
+import { turnCommand } from "./turn-command.js";
 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 { cursorStream } from "./cursor-stream.js";
+import { opencodeStream } from "./opencode-stream.js";
+import { textOutput } from "./text-output.js";
+import { grokUsageWarnings } from "../grok-result.js";
+import { geminiStream } from "./gemini-stream.js";
+import { parsed, textOf, streamResult, } from "./claude-stream.js";
+import { usageOf } from "../worker-usage.js";
+export { streamResult, capacityRefusal, retryKind } from "./claude-stream.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")),
-    };
+import { shellTurnScript } from "../agent-harness-shell.js";
+export function succeeded(end) {
+    return (end.reason === undefined &&
+        end.exitCode === 0 &&
+        end.result?.failed === false);
 }
 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,
-        };
+export function turnEnvironment(configuration, start) {
     const excluded = new Set([
         "GH_TOKEN",
         "GITHUB_TOKEN",
@@ -75,121 +38,199 @@ function turnEnvironment(configuration, start) {
     if (start.turnId !== undefined)
         environment["CLOVING_TURN_ID"] = start.turnId;
     environment["GH_CONFIG_DIR"] = configuration;
+    if (start.worker === "opencode")
+        environment["OPENCODE_PERMISSION"] = '{"*":"allow"}';
     return environment;
 }
 function spawnTurn(start) {
     const configuration = mkdtempSync(join(start.folder, "gh-config-"));
-    const [executable = "", ...fixed] = start.mode === "analysis" ? analysisCommand() : start.command;
+    const { parts, standardInput } = turnCommand(start);
+    const command = start.shell === undefined
+        ? parts
+        : [
+            start.shell,
+            "-l",
+            "-i",
+            "-c",
+            shellTurnScript,
+            "cloving-harness",
+            configuration,
+            ...parts,
+        ];
+    const [executable = "", ...fixed] = command;
     try {
         const child = spawn(executable, fixed, {
             cwd: start.directory,
             env: turnEnvironment(configuration, start),
             stdio: ["pipe", "pipe", "pipe"],
+            detached: start.shell !== undefined,
         });
-        return { child, configuration };
+        return { child, configuration, standardInput };
     }
     catch (error) {
         rmSync(configuration, { recursive: true, force: true });
         throw error;
     }
 }
-function receivedLines(stream, lines) {
+function streamMetadata(stream, event) {
+    if (typeof event !== "object" || event === null)
+        return false;
+    const field = (name) => Reflect.get(event, name);
+    const type = field("type");
+    const sessionId = textOf(field("session_id"));
+    const discovered = stream.sessionId === null && sessionId !== null;
+    if (discovered)
+        stream.sessionId = sessionId;
+    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;
+    return discovered;
+}
+function receivedLines(stream, input) {
+    const { lines, worker } = input;
     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);
+        const discovered = streamMetadata(stream, parsed(line));
+        const result = streamResult(line, worker);
         if (result !== undefined) {
             const errorType = result.errorType ?? stream.errorType;
             stream.result = {
                 ...result,
+                sessionId: result.sessionId ?? stream.sessionId,
                 ...(errorType === null ? {} : { errorType }),
             };
         }
+        if (discovered || result !== undefined) {
+            saveProgress(stream, input);
+        }
     }
 }
-function activityOutput(start) {
-    if (start.mode === "analysis")
+function saveProgress(stream, input) {
+    const progress = { sessionId: stream.sessionId, result: stream.result };
+    stream.saved = stream.saved
+        .then(() => {
+        if (stream.failure === undefined)
+            return input.progress?.(progress);
         return undefined;
+    })
+        .catch((error) => {
+        stream.failure = { error };
+        input.failed();
+    });
+}
+function activityOutput(start) {
     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 = {
+function streamAdapter(worker, stderr) {
+    if (worker === "opencode") {
+        const translated = opencodeStream();
+        stderr.setEncoding("utf8");
+        stderr.on("data", translated.stderr);
+        return translated;
+    }
+    if (worker === "codex")
+        return codexStream();
+    if (worker === "cursor-agent")
+        return cursorStream();
+    if (worker === "gemini")
+        return geminiStream();
+    return undefined;
+}
+function streamState() {
+    return {
+        failure: undefined,
+        sessionId: null,
+        saved: Promise.resolve(),
         pending: "",
         result: undefined,
         model: null,
         errorType: null,
     };
+}
+function turnOutput(start, child) {
+    const output = activityOutput(start);
+    if (start.output === "text")
+        return textOutput(child, { output, limit: start.resultBytes ?? 48_000 });
+    const { stdout, stderr } = child;
+    const adapter = streamAdapter(start.worker, stderr);
+    const stream = streamState();
     const received = (lines) => {
-        receivedLines(stream, lines);
+        receivedLines(stream, {
+            lines,
+            progress: start.progress,
+            failed: () => {
+                signalTurn({ child, start }, "SIGKILL");
+            },
+            ...(start.worker === undefined ? {} : { worker: start.worker }),
+        });
     };
     const written = (lines) => {
         for (const line of lines)
-            output?.write(`${line}\n`);
+            output.write(`${line}\n`);
         received(lines);
     };
     stdout.setEncoding("utf8");
     stdout.on("data", (chunk) => {
-        if (codex === undefined)
-            output?.write(chunk);
+        if (adapter === undefined)
+            output.write(chunk);
         const lines = `${stream.pending}${chunk}`.split("\n");
         stream.pending = lines.pop() ?? "";
-        if (codex !== undefined) {
-            written(lines.flatMap(codex.line));
+        if (adapter !== undefined) {
+            written(lines.flatMap(adapter.line));
             return;
         }
         received(lines);
     });
     return async (exitCode) => {
-        if (codex !== undefined) {
-            written(codex.line(stream.pending));
-            written([codex.result(exitCode)]);
+        if (adapter !== undefined) {
+            written(adapter.line(stream.pending));
+            written([adapter.result(exitCode)]);
         }
-        if (output !== undefined)
-            await ended(output);
-        if (codex === undefined)
+        await ended(output);
+        if (adapter === undefined)
             received([stream.pending]);
+        await stream.saved;
+        if (stream.failure !== undefined)
+            throw stream.failure.error;
         const result = stream.result;
         return result === undefined
             ? undefined
             : {
                 ...result,
-                model: result.model ??
-                    stream.model ??
-                    commandModel(start.mode === "analysis" ? analysisCommand() : start.command),
+                model: result.model ?? stream.model ?? commandModel(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),
-    };
+function signalTurn(turn, signal) {
+    const { child, start } = turn;
+    if (start.shell === undefined || child.pid === undefined) {
+        child.kill(signal);
+        return;
+    }
+    try {
+        process.kill(-child.pid, signal);
+    }
+    catch (error) {
+        const code = Reflect.get(Object(error), "code");
+        if (code !== "ESRCH" && code !== "EPERM")
+            throw error;
+        child.kill(signal);
+    }
 }
 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")));
+    const { child, configuration, standardInput } = spawnTurn(start);
+    const output = turnOutput(start, child);
+    const warnings = grokUsageWarnings();
+    if (start.worker === "grok") {
+        child.stderr.setEncoding("utf8");
+        child.stderr.on("data", warnings.write);
+    }
+    child.stderr.pipe(createWriteStream(join(start.folder, "turn.stderr.log")));
     child.stdin.on("error", () => undefined);
-    child.stdin.end(start.prompt);
+    child.stdin.end(standardInput);
     const closed = new Promise((settle) => {
         child.once("error", () => undefined);
         child.once("close", settle);
@@ -200,17 +241,22 @@ export function startTurn(start) {
         ended: closed
             .then(async (exitCode) => {
             timers.forEach(clearTimeout);
+            const result = await output(exitCode);
             return {
                 exitCode,
-                result: withoutAnalysisToken(start, await output(exitCode)),
+                result: result !== undefined && warnings.incomplete()
+                    ? { ...result, usage: usageOf(null), costUsd: null }
+                    : result,
             };
         })
             .finally(() => {
             rmSync(configuration, { recursive: true, force: true });
         }),
         stop: (graceMilliseconds) => {
-            child.kill("SIGTERM");
-            timers.push(setTimeout(() => child.kill("SIGKILL"), graceMilliseconds).unref());
+            signalTurn({ child, start }, "SIGTERM");
+            timers.push(setTimeout(() => {
+                signalTurn({ child, start }, "SIGKILL");
+            }, graceMilliseconds).unref());
         },
     };
 }

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

@@ -1,10 +1,9 @@
+import { type HarnessSettings } from "../harness-defaults.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 { Delivery, DeliveryIntent } from "../broker/actor/delivery-intents.ts";
 import { type RetrySettings } from "./retrying-turn.ts";
 import { type WorkerReport } from "./operation-journal.ts";
-export interface ClaudeWorkerSettings extends RetrySettings {
-    readonly worker?: Worker;
+export interface ClaudeWorkerSettings extends RetrySettings, HarnessSettings {
     readonly profiles?: TurnProfiles;
     readonly workflowId?: (runId: string) => Promise<string | undefined>;
     readonly repository: string;
@@ -16,6 +15,8 @@ export interface ClaudeWorkerSettings extends RetrySettings {
     readonly stopMilliseconds?: number;
 }
 export interface ClaudeWorker extends Delivery {
+    readonly recover: (intent: DeliveryIntent) => Promise<void>;
+    readonly harness: (operationId: string) => Promise<string | undefined>;
     readonly stop: NonNullable<Delivery["stop"]>;
     readonly close: () => Promise<void>;
 }