@harness-control/runner 0.1.0

package/dist/harnesses/adapters/providers/claude-runtime.js

@@ -0,0 +1,186 @@
+import { query, } from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod";
+import { HarnessAdapterError } from "../types.js";
+import { adapterMcpServers, assertCliMcpAttachmentProxied } from "./shared.js";
+import { selectedEffort } from "./native-turn.js";
+import { NativeProcess } from "./native-process.js";
+const resultSchema = z.object({
+    type: z.literal("result"),
+    subtype: z.literal("success"),
+    is_error: z.literal(false),
+    result: z.string(),
+    api_error_status: z.number().nullable().optional(),
+    terminal_reason: z.string().optional(),
+    stop_reason: z.string().nullable().optional(),
+    total_cost_usd: z.number().nonnegative().optional(),
+    modelUsage: z
+        .record(z.string(), z.object({
+        inputTokens: z.number().int().nonnegative(),
+        outputTokens: z.number().int().nonnegative(),
+        cacheReadInputTokens: z.number().int().nonnegative(),
+        cacheCreationInputTokens: z.number().int().nonnegative(),
+    }))
+        .optional(),
+});
+export function createClaudeTurn(queryFactory = query) {
+    return async (input, signal, emit) => {
+        const selection = input.payload.model_selection ?? input.startPayload.model_selection;
+        const effort = selectedEffort(selection, "claude");
+        const mcpServers = {};
+        for (const attachment of adapterMcpServers(input.mcpServers, input.startPayload)) {
+            assertCliMcpAttachmentProxied(attachment, "Claude Code", "claude");
+            mcpServers[attachment.name] = { type: "http", url: attachment.url };
+        }
+        let processHandle;
+        const abort = () => {
+            if (processHandle)
+                void processHandle.stop();
+        };
+        signal.addEventListener("abort", abort, { once: true });
+        let stream;
+        try {
+            signal.throwIfAborted();
+            stream = queryFactory({
+                prompt: input.payload.input,
+                options: {
+                    pathToClaudeCodeExecutable: input.provider.executable_path ?? "claude",
+                    cwd: input.startPayload.cwd,
+                    model: selection.model,
+                    ...(effort ? { effort } : {}),
+                    env: {
+                        ...globalThis.process.env,
+                        ...input.provider.env,
+                        ...(input.provider.home
+                            ? { CLAUDE_CONFIG_DIR: input.provider.home }
+                            : {}),
+                    },
+                    systemPrompt: { type: "preset", preset: "claude_code" },
+                    settingSources: [],
+                    persistSession: false,
+                    includePartialMessages: true,
+                    strictMcpConfig: true,
+                    mcpServers,
+                    permissionMode: "bypassPermissions",
+                    allowDangerouslySkipPermissions: true,
+                    disallowedTools: [
+                        "AskUserQuestion",
+                        "EnterPlanMode",
+                        "ExitPlanMode",
+                        "Agent",
+                        "Task",
+                    ],
+                    spawnClaudeCodeProcess: (options) => {
+                        processHandle = new NativeProcess(options.command, options.args, input.startPayload.cwd, options.env);
+                        processHandle.child.stderr.resume();
+                        if (signal.aborted)
+                            abort();
+                        return processHandle.child;
+                    },
+                },
+            });
+            let result;
+            let streamed = false;
+            for await (const message of stream) {
+                if (message.type === "stream_event" &&
+                    message.event.type === "content_block_delta") {
+                    const delta = message.event.delta;
+                    if (delta.type === "text_delta" || delta.type === "thinking_delta") {
+                        if (delta.type === "text_delta")
+                            streamed = true;
+                        emit({
+                            event_type: delta.type === "text_delta"
+                                ? "content.delta"
+                                : "reasoning.delta",
+                            turn_id: input.payload.turn_id,
+                            data: {
+                                delta: delta.type === "text_delta" ? delta.text : delta.thinking,
+                            },
+                        });
+                    }
+                }
+                else if (message.type === "assistant") {
+                    for (const block of message.message.content) {
+                        if (block.type === "tool_use")
+                            emit({
+                                event_type: "item.started",
+                                turn_id: input.payload.turn_id,
+                                data: {
+                                    item_id: block.id,
+                                    item_type: "tool_call",
+                                    summary: block.name,
+                                },
+                            });
+                    }
+                }
+                else if (message.type === "user" &&
+                    Array.isArray(message.message.content)) {
+                    for (const block of message.message.content) {
+                        if (block.type === "tool_result")
+                            emit({
+                                event_type: "item.completed",
+                                turn_id: input.payload.turn_id,
+                                data: {
+                                    item_id: block.tool_use_id,
+                                    item_type: "tool_call",
+                                    status: block.is_error ? "failed" : "completed",
+                                },
+                            });
+                    }
+                }
+                else if (message.type === "result") {
+                    const parsed = resultSchema.safeParse(message);
+                    if (!parsed.success || result !== undefined)
+                        throw new HarnessAdapterError("claude_result_error", "Claude returned an unsuccessful or malformed terminal result.");
+                    result = parsed.data;
+                    if ((result.api_error_status != null &&
+                        result.api_error_status >= 400) ||
+                        (result.terminal_reason !== undefined &&
+                            result.terminal_reason !== "completed") ||
+                        (result.stop_reason != null &&
+                            !["end_turn", "stop_sequence"].includes(result.stop_reason))) {
+                        throw new HarnessAdapterError("claude_result_error", "Claude ended with a provider error or execution limit.");
+                    }
+                }
+            }
+            if (!result)
+                throw new HarnessAdapterError("claude_missing_result", "Claude closed without a terminal result.");
+            if (!streamed && result.result)
+                emit({
+                    event_type: "content.delta",
+                    turn_id: input.payload.turn_id,
+                    data: { delta: result.result },
+                });
+            let inputTokens = 0;
+            let outputTokens = 0;
+            for (const usage of Object.values(result.modelUsage ?? {})) {
+                inputTokens +=
+                    usage.inputTokens +
+                        usage.cacheReadInputTokens +
+                        usage.cacheCreationInputTokens;
+                outputTokens += usage.outputTokens;
+            }
+            return {
+                final_text: result.result,
+                usage: {
+                    ...(result.modelUsage
+                        ? {
+                            input_tokens: inputTokens,
+                            output_tokens: outputTokens,
+                            total_tokens: inputTokens + outputTokens,
+                        }
+                        : {}),
+                    ...(result.total_cost_usd !== undefined
+                        ? { cost_usd: result.total_cost_usd }
+                        : {}),
+                },
+            };
+        }
+        finally {
+            signal.removeEventListener("abort", abort);
+            stream?.close();
+            if (processHandle)
+                await processHandle.stop();
+        }
+    };
+}
+//# sourceMappingURL=claude-runtime.js.map

package/dist/harnesses/adapters/providers/claude.d.ts

@@ -0,0 +1,24 @@
+import type { ProviderInstanceConfig } from "../../../config/index.js";
+import type { ProviderDriverStatus } from "../../../host/provider-registry.js";
+import { type HarnessAdapter, type HarnessAdapterStartInput, type HarnessAdapterSession, type HarnessAdapterTurnInput, type HarnessAdapterEvent, type HarnessAdapterCancelInput, type HarnessAdapterStopInput } from "../types.js";
+import { type CliProcessSpawner } from "./cli-process.js";
+import { type ClaudeQueryFactory } from "./claude-runtime.js";
+export type ClaudeHarnessAdapterOptions = {
+    processSpawner?: CliProcessSpawner;
+    probeTimeoutMs?: number;
+    turnTimeoutMs?: number;
+    processKillGraceMs?: number;
+    queryFactory?: ClaudeQueryFactory;
+};
+export declare class ClaudeHarnessAdapter implements HarnessAdapter {
+    #private;
+    readonly driverKind = "claude";
+    constructor(options?: ClaudeHarnessAdapterOptions);
+    probe(provider: ProviderInstanceConfig): Promise<ProviderDriverStatus>;
+    validateStart(input: HarnessAdapterStartInput): Promise<void>;
+    startSession(input: HarnessAdapterStartInput): Promise<HarnessAdapterSession>;
+    sendTurn(input: HarnessAdapterTurnInput): Promise<HarnessAdapterEvent[]>;
+    cancelTurn(input: HarnessAdapterCancelInput): Promise<HarnessAdapterEvent[]>;
+    stopSession(input: HarnessAdapterStopInput): Promise<HarnessAdapterEvent[]>;
+}
+//# sourceMappingURL=claude.d.ts.map

package/dist/harnesses/adapters/providers/claude.js

@@ -0,0 +1,189 @@
+import { firstLine, processFailureMessage, spawnProviderCliProcess, startManagedCliProcess, } from "./cli-process.js";
+import { normalizeProviderModels, adapterMcpServers, assertCliMcpAttachmentProxied, } from "./shared.js";
+import { NativeTurns, nativeExecutionCapabilities, validateNativeStart, } from "./native-turn.js";
+import { createClaudeTurn } from "./claude-runtime.js";
+export class ClaudeHarnessAdapter {
+    driverKind = "claude";
+    #processSpawner;
+    #probeTimeoutMs;
+    #processKillGraceMs;
+    #turns;
+    #execute;
+    constructor(options = {}) {
+        this.#processSpawner = options.processSpawner ?? spawnProviderCliProcess;
+        this.#probeTimeoutMs = options.probeTimeoutMs ?? 5_000;
+        this.#processKillGraceMs = options.processKillGraceMs ?? 1_000;
+        this.#turns = new NativeTurns("claude", options.turnTimeoutMs ?? 10 * 60 * 1000);
+        this.#execute = createClaudeTurn(options.queryFactory);
+    }
+    async probe(provider) {
+        const executable = provider.executable_path ?? "claude";
+        const diagnosticPaths = claudeDiagnosticPaths(provider, executable, process.cwd());
+        const launchArgs = claudeLaunchArgs(provider);
+        const versionResult = await this.#runProcess(executable, [...launchArgs, "--version"], {
+            cwd: process.cwd(),
+            env: claudeEnvironment(provider),
+        }, this.#probeTimeoutMs);
+        if (versionResult.timedOut ||
+            versionResult.error ||
+            versionResult.exitCode !== 0) {
+            return {
+                provider_instance_id: provider.id,
+                driver_kind: "claude",
+                execution_capabilities: nativeExecutionCapabilities("claude"),
+                installed: false,
+                available: false,
+                status: "unavailable",
+                message: versionResult.timedOut
+                    ? "Claude Code version probe timed out."
+                    : processFailureMessage(versionResult, "Claude Code executable is not available.", diagnosticPaths),
+                models: normalizeProviderModels(provider.models),
+            };
+        }
+        const authResult = await this.#runProcess(executable, [...launchArgs, "auth", "status", "--json"], {
+            cwd: process.cwd(),
+            env: claudeEnvironment(provider),
+        }, this.#probeTimeoutMs);
+        const version = firstLine(versionResult.stdout);
+        if (authResult.timedOut || authResult.error) {
+            return {
+                provider_instance_id: provider.id,
+                driver_kind: "claude",
+                execution_capabilities: nativeExecutionCapabilities("claude"),
+                installed: true,
+                available: false,
+                status: "unavailable",
+                ...(version ? { version } : {}),
+                message: authResult.timedOut
+                    ? "Claude Code authentication probe timed out."
+                    : processFailureMessage(authResult, "Claude Code authentication probe failed.", diagnosticPaths),
+                models: normalizeProviderModels(provider.models),
+            };
+        }
+        if (authResult.exitCode !== 0 ||
+            claudeAuthStatus(authResult.stdout) === false) {
+            return {
+                provider_instance_id: provider.id,
+                driver_kind: "claude",
+                execution_capabilities: nativeExecutionCapabilities("claude"),
+                installed: true,
+                available: false,
+                status: "unauthenticated",
+                ...(version ? { version } : {}),
+                message: processFailureMessage(authResult, "Claude Code is not authenticated.", diagnosticPaths),
+                models: normalizeProviderModels(provider.models),
+            };
+        }
+        return {
+            provider_instance_id: provider.id,
+            driver_kind: "claude",
+            execution_capabilities: nativeExecutionCapabilities("claude"),
+            installed: true,
+            available: true,
+            status: "ready",
+            ...(version ? { version } : {}),
+            authStatus: "authenticated",
+            models: provider.models.length > 0
+                ? normalizeProviderModels(provider.models)
+                : [
+                    {
+                        id: "sonnet",
+                        label: "Claude Sonnet",
+                        is_default: true,
+                        capabilities: {
+                            option_descriptors: [
+                                {
+                                    id: "effort",
+                                    label: "Effort",
+                                    type: "select",
+                                    values: ["low", "medium", "high", "xhigh", "max"].map((value) => ({ value, label: value })),
+                                },
+                            ],
+                        },
+                    },
+                    {
+                        id: "opus",
+                        label: "Claude Opus",
+                        capabilities: { option_descriptors: [] },
+                    },
+                    {
+                        id: "haiku",
+                        label: "Claude Haiku",
+                        capabilities: { option_descriptors: [] },
+                    },
+                ],
+        };
+    }
+    async validateStart(input) {
+        validateNativeStart(input, "claude");
+    }
+    async startSession(input) {
+        await this.validateStart(input);
+        for (const attachment of adapterMcpServers(input.mcpServers, input.payload))
+            assertCliMcpAttachmentProxied(attachment, "Claude", "claude");
+        return { adapter_session_id: input.payload.session_id };
+    }
+    async sendTurn(input) {
+        return this.#turns.run(input, async (request, signal, emit) => {
+            await this.validateStart({
+                payload: request.startPayload,
+                provider: request.provider,
+            });
+            return this.#execute(request, signal, emit);
+        });
+    }
+    async cancelTurn(input) {
+        return this.#turns.cancel(input.sessionId, input.turnId);
+    }
+    async stopSession(input) {
+        return this.#turns.stop(input.sessionId);
+    }
+    #runProcess(executable, argv, options, timeoutMs) {
+        return this.#startProcess(executable, argv, options, timeoutMs).completion;
+    }
+    #startProcess(executable, argv, options, timeoutMs) {
+        return startManagedCliProcess({
+            processSpawner: this.#processSpawner,
+            executable,
+            argv,
+            runOptions: options,
+            timeoutMs,
+            processKillGraceMs: this.#processKillGraceMs,
+            timeoutErrorMessage: "Claude Code execution timed out.",
+            terminatedErrorMessage: "Claude Code process was terminated.",
+            startFailureMessage: "Claude Code process failed before start.",
+        });
+    }
+}
+function claudeDiagnosticPaths(provider, executable, ...paths) {
+    return [provider.executable_path, provider.home, executable, ...paths].filter((value) => value !== undefined && value.length > 0);
+}
+function claudeEnvironment(provider) {
+    return {
+        ...provider.env,
+        ...(provider.home ? { CLAUDE_CONFIG_DIR: provider.home } : {}),
+    };
+}
+function claudeLaunchArgs(provider) {
+    return provider.launch_args;
+}
+function claudeAuthStatus(stdout) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            return undefined;
+        }
+        throw error;
+    }
+    if (!isJsonObject(parsed) || typeof parsed["loggedIn"] !== "boolean") {
+        return undefined;
+    }
+    return parsed["loggedIn"];
+}
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=claude.js.map

package/dist/harnesses/adapters/providers/cli-process.d.ts

@@ -0,0 +1,44 @@
+import { type ChildProcessWithoutNullStreams } from "node:child_process";
+export type CliProcessRunOptions = {
+    cwd: string;
+    env: Record<string, string>;
+};
+export type CliProcessResult = {
+    exitCode: number | null;
+    signal: NodeJS.Signals | null;
+    stdout: string;
+    stderr: string;
+    error: string | undefined;
+    timedOut: boolean;
+};
+export type CliProcessHandle = {
+    readonly result: Promise<CliProcessResult>;
+    kill(signal?: NodeJS.Signals): void;
+};
+export type CliProcessSpawner = (executable: string, argv: string[], options: CliProcessRunOptions) => CliProcessHandle;
+export type CodexProcessRunOptions = CliProcessRunOptions;
+export type CodexProcessResult = CliProcessResult;
+export type CodexProcessHandle = CliProcessHandle;
+export type CodexProcessSpawner = CliProcessSpawner;
+export type CliManagedProcess = {
+    readonly completion: Promise<CliProcessResult>;
+    terminate(): void;
+};
+export type CliManagedProcessOptions = {
+    processSpawner: CliProcessSpawner;
+    executable: string;
+    argv: string[];
+    runOptions: CliProcessRunOptions;
+    timeoutMs: number;
+    processKillGraceMs: number;
+    timeoutErrorMessage: string;
+    terminatedErrorMessage: string;
+    startFailureMessage: string;
+};
+export declare function startManagedCliProcess(options: CliManagedProcessOptions): CliManagedProcess;
+export declare function spawnProviderCliProcess(executable: string, argv: string[], options: CliProcessRunOptions): CliProcessHandle;
+export declare function processFailureDetails(result: CliProcessResult): Record<string, unknown>;
+export declare function processFailureMessage(result: CliProcessResult, fallback: string, diagnosticPaths: string[]): string;
+export declare function firstLine(value: string): string | undefined;
+export declare function killChildProcess(child: ChildProcessWithoutNullStreams, signal: NodeJS.Signals): void;
+//# sourceMappingURL=cli-process.d.ts.map

package/dist/harnesses/adapters/providers/cli-process.js

@@ -0,0 +1,195 @@
+import { spawn } from "node:child_process";
+import { redactValue } from "../../../mcp/redaction.js";
+const MAX_CAPTURED_CLI_OUTPUT_BYTES = 64 * 1024;
+export function startManagedCliProcess(options) {
+    const handle = spawnCliProcess(options);
+    let settled = false;
+    let timedOut = false;
+    let timeout;
+    let forceKill;
+    let settleProcess = () => { };
+    const completion = new Promise((resolve) => {
+        settleProcess = (result) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+            if (forceKill) {
+                clearTimeout(forceKill);
+            }
+            resolve({
+                ...result,
+                timedOut: result.timedOut || timedOut,
+            });
+        };
+    });
+    const terminate = (asTimeout) => {
+        if (settled)
+            return;
+        if (asTimeout) {
+            timedOut = true;
+        }
+        handle.kill("SIGTERM");
+        if (!forceKill) {
+            forceKill = setTimeout(() => {
+                handle.kill("SIGKILL");
+            }, options.processKillGraceMs);
+        }
+    };
+    timeout = setTimeout(() => terminate(true), options.timeoutMs);
+    handle.result.then((result) => settleProcess(result), (error) => settleProcess(processExceptionResult(error, options.startFailureMessage)));
+    return {
+        completion,
+        terminate: () => terminate(false),
+    };
+}
+export function spawnProviderCliProcess(executable, argv, options) {
+    const child = spawn(executable, argv, {
+        cwd: options.cwd,
+        env: {
+            ...process.env,
+            ...options.env,
+        },
+        stdio: "pipe",
+        detached: process.platform !== "win32",
+    });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    child.stdin.end();
+    const result = new Promise((resolve) => {
+        const settle = (processResult) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            resolve(processResult);
+        };
+        child.stdout.on("data", (chunk) => {
+            stdout = appendLimitedProcessOutput(stdout, chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr = appendLimitedProcessOutput(stderr, chunk);
+        });
+        child.once("error", (error) => {
+            settle({
+                exitCode: null,
+                signal: null,
+                stdout,
+                stderr,
+                error: error.message,
+                timedOut: false,
+            });
+        });
+        child.once("close", (exitCode, signal) => {
+            settle({
+                exitCode,
+                signal,
+                stdout,
+                stderr,
+                error: undefined,
+                timedOut: false,
+            });
+        });
+    });
+    return {
+        result,
+        kill(signal = "SIGTERM") {
+            killChildProcess(child, signal);
+        },
+    };
+}
+export function processFailureDetails(result) {
+    return {
+        ...(result.exitCode !== null ? { exit_code: result.exitCode } : {}),
+        ...(result.signal !== null ? { signal: result.signal } : {}),
+        ...(result.timedOut ? { timed_out: true } : {}),
+    };
+}
+export function processFailureMessage(result, fallback, diagnosticPaths) {
+    const rawMessage = firstNonEmpty(result.error ?? "", result.stderr, result.stdout, fallback);
+    const redactedValue = redactValue(redactLocalPaths(rawMessage, diagnosticPaths));
+    return typeof redactedValue === "string" ? redactedValue : fallback;
+}
+export function firstLine(value) {
+    const line = value.split(/\r?\n/).find((candidate) => candidate.trim().length > 0);
+    return line?.trim();
+}
+function spawnCliProcess(options) {
+    try {
+        return options.processSpawner(options.executable, options.argv, options.runOptions);
+    }
+    catch (error) {
+        return resolvedProcessHandle(processExceptionResult(error, options.startFailureMessage));
+    }
+}
+function appendLimitedProcessOutput(existing, chunk) {
+    const combined = Buffer.concat([Buffer.from(existing), chunk]);
+    if (combined.byteLength <= MAX_CAPTURED_CLI_OUTPUT_BYTES) {
+        return combined.toString("utf8");
+    }
+    return combined.subarray(0, MAX_CAPTURED_CLI_OUTPUT_BYTES).toString("utf8");
+}
+export function killChildProcess(child, signal) {
+    try {
+        if (process.platform === "win32" && child.pid !== undefined) {
+            const argv = ["/pid", String(child.pid), "/T"];
+            if (signal === "SIGKILL") {
+                argv.push("/F");
+            }
+            const killer = spawn("taskkill", argv, { stdio: "ignore" });
+            killer.once("error", () => {
+                child.kill(signal);
+            });
+            return;
+        }
+        if (process.platform !== "win32" && child.pid !== undefined) {
+            process.kill(-child.pid, signal);
+            return;
+        }
+        child.kill(signal);
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ESRCH") {
+            return;
+        }
+        throw error;
+    }
+}
+function resolvedProcessHandle(result) {
+    return {
+        result: Promise.resolve(result),
+        kill() {
+            return;
+        },
+    };
+}
+function processExceptionResult(error, fallback = "Provider process failed before start.") {
+    return {
+        exitCode: null,
+        signal: null,
+        stdout: "",
+        stderr: "",
+        error: error instanceof Error ? error.message : fallback,
+        timedOut: false,
+    };
+}
+function firstNonEmpty(...values) {
+    const found = values.find((value) => value.trim().length > 0);
+    return found?.trim() ?? "Provider command failed.";
+}
+function redactLocalPaths(value, paths) {
+    let redacted = value;
+    const sortedPaths = [...new Set(paths)].sort((left, right) => right.length - left.length);
+    for (const path of sortedPaths) {
+        redacted = redacted.split(path).join("<local-path>");
+    }
+    return redacted
+        .replace(/\/(?:Users|home|private|tmp|var|opt|Applications|Volumes)\/[^\s'"]+/g, "<local-path>")
+        .replace(/[A-Za-z]:\\[^\s'"]+/g, "<local-path>")
+        .trim();
+}
+//# sourceMappingURL=cli-process.js.map

package/dist/harnesses/adapters/providers/codex-models.d.ts

@@ -0,0 +1,4 @@
+import type { HarnessModel } from "@harness-control/protocol";
+import type { ProviderInstanceConfig } from "../../../config/index.js";
+export declare function codexModels(provider: ProviderInstanceConfig, timeoutMs: number): Promise<HarnessModel[]>;
+//# sourceMappingURL=codex-models.d.ts.map