@harness-control/runner 0.1.0

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

@@ -0,0 +1,64 @@
+import { normalizeProviderModels } from "./shared.js";
+export class MockHarnessAdapter {
+    driverKind = "mock";
+    async probe(provider) {
+        return {
+            provider_instance_id: provider.id,
+            driver_kind: provider.driver_kind,
+            installed: true,
+            available: true,
+            status: "ready",
+            version: "0.0.0-mock",
+            models: normalizeProviderModels(provider.models),
+        };
+    }
+    async validateStart() {
+        return;
+    }
+    async startSession(input) {
+        return {
+            adapter_session_id: input.payload.session_id,
+        };
+    }
+    async sendTurn(input) {
+        return [
+            {
+                event_type: "turn.started",
+                turn_id: input.payload.turn_id,
+                data: {
+                    provider_instance_id: input.provider.id,
+                    input_length: input.payload.input.length,
+                    ...(input.payload.model_selection ? { model_selection: input.payload.model_selection } : {}),
+                },
+            },
+            {
+                event_type: "turn.completed",
+                turn_id: input.payload.turn_id,
+                data: {
+                    status: "accepted",
+                    final_output: {
+                        final_text: "",
+                    },
+                },
+            },
+        ];
+    }
+    async cancelTurn(input) {
+        return [
+            {
+                event_type: "turn.cancelled",
+                turn_id: input.turnId,
+                data: {
+                    status: "cancelled",
+                    final_output: {
+                        exit_reason: "cancel_requested",
+                    },
+                },
+            },
+        ];
+    }
+    async stopSession() {
+        return [];
+    }
+}
+//# sourceMappingURL=mock.js.map

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

@@ -0,0 +1,9 @@
+import { type ChildProcessWithoutNullStreams } from "node:child_process";
+export declare class NativeProcess {
+    #private;
+    readonly child: ChildProcessWithoutNullStreams;
+    readonly closed: Promise<void>;
+    constructor(executable: string, args: string[], cwd: string, env: NodeJS.ProcessEnv);
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=native-process.d.ts.map

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

@@ -0,0 +1,41 @@
+import { spawn } from "node:child_process";
+import { killChildProcess } from "./cli-process.js";
+export class NativeProcess {
+    child;
+    closed;
+    #closed = false;
+    #stopping;
+    constructor(executable, args, cwd, env) {
+        this.child = spawn(executable, args, {
+            cwd,
+            env,
+            stdio: "pipe",
+            detached: process.platform !== "win32",
+        });
+        this.child.on("error", () => { }); // The close event also fires after spawn errors.
+        this.child.stdin.on("error", () => { }); // Runtime detects closure; avoid an unhandled EPIPE.
+        this.closed = new Promise((resolve) => {
+            this.child.once("close", () => {
+                this.#closed = true;
+                resolve();
+            });
+        });
+    }
+    stop() {
+        this.#stopping ??= this.#stop();
+        return this.#stopping;
+    }
+    async #stop() {
+        if (this.#closed)
+            return;
+        killChildProcess(this.child, "SIGTERM");
+        const forceKill = setTimeout(() => killChildProcess(this.child, "SIGKILL"), 1_000);
+        try {
+            await this.closed;
+        }
+        finally {
+            clearTimeout(forceKill);
+        }
+    }
+}
+//# sourceMappingURL=native-process.js.map

package/dist/harnesses/adapters/providers/native-turn.d.ts

@@ -0,0 +1,17 @@
+import type { HarnessExecutionCapabilities, HarnessModelSelection, HarnessTurnFinalOutput } from "@harness-control/protocol";
+import { type HarnessAdapterEvent, type HarnessAdapterStartInput, type HarnessAdapterTurnInput } from "../types.js";
+export declare function nativeExecutionCapabilities(driver: "codex" | "claude"): HarnessExecutionCapabilities;
+export declare function validateNativeStart(input: HarnessAdapterStartInput, driver: "codex" | "claude"): void;
+export type NativeTurn = (input: HarnessAdapterTurnInput, signal: AbortSignal, emit: (event: HarnessAdapterEvent) => void) => Promise<HarnessTurnFinalOutput>;
+/** Owns terminal decisions after the provider runtime has finished cleanup. */
+export declare class NativeTurns {
+    #private;
+    readonly driver: string;
+    readonly timeoutMs: number;
+    constructor(driver: string, timeoutMs: number);
+    run(input: HarnessAdapterTurnInput, execute: NativeTurn): Promise<HarnessAdapterEvent[]>;
+    cancel(sessionId: string, turnId?: string): Promise<HarnessAdapterEvent[]>;
+    stop(sessionId: string): Promise<HarnessAdapterEvent[]>;
+}
+export declare function selectedEffort(selection: HarnessModelSelection, driver: "codex" | "claude"): string | undefined;
+//# sourceMappingURL=native-turn.d.ts.map

package/dist/harnesses/adapters/providers/native-turn.js

@@ -0,0 +1,139 @@
+import { HarnessAdapterError, } from "../types.js";
+import { turnFailedEvent } from "./shared.js";
+export function nativeExecutionCapabilities(driver) {
+    return {
+        streaming: true,
+        multi_turn: false,
+        session_continuation: false,
+        approval_policies: ["full_access"],
+        sandbox_modes: driver === "codex"
+            ? ["read_only", "workspace_write", "danger_full_access"]
+            : ["danger_full_access"],
+    };
+}
+export function validateNativeStart(input, driver) {
+    const capabilities = nativeExecutionCapabilities(driver);
+    if (input.payload.continue_session && !capabilities.session_continuation)
+        throw new HarnessAdapterError("continuation_unsupported", "Native continuation is not supported by this runner profile.");
+    if (!capabilities.approval_policies.includes(input.payload.approval_policy))
+        throw new HarnessAdapterError("approval_policy_unsupported", "Interactive approval policies are not supported by this runner profile.");
+    if (!capabilities.sandbox_modes.includes(input.payload.sandbox_mode))
+        throw new HarnessAdapterError("sandbox_unsupported", "The requested filesystem containment is not supported by this adapter.");
+    if (input.provider.launch_args.length)
+        throw new HarnessAdapterError("launch_args_unsupported", "Native drivers require structured configuration instead of launch arguments.");
+    selectedEffort(input.payload.model_selection, driver);
+}
+/** Owns terminal decisions after the provider runtime has finished cleanup. */
+export class NativeTurns {
+    driver;
+    timeoutMs;
+    #active = new Map();
+    #usedSessions = new Set();
+    constructor(driver, timeoutMs) {
+        this.driver = driver;
+        this.timeoutMs = timeoutMs;
+    }
+    async run(input, execute) {
+        const { session_id: sessionId, turn_id: turnId } = input.payload;
+        if (this.#active.has(sessionId)) {
+            throw new HarnessAdapterError(`${this.driver}_turn_in_progress`, "The session already has an active turn.");
+        }
+        if (this.#usedSessions.has(sessionId)) {
+            throw new HarnessAdapterError("session_turn_limit", "This provider profile supports one turn per session; native multi-turn sessions are not implemented.");
+        }
+        this.#usedSessions.add(sessionId);
+        const controller = new AbortController();
+        let finish;
+        const done = new Promise((resolve) => {
+            finish = resolve;
+        });
+        this.#active.set(sessionId, { id: turnId, controller, done });
+        const timeout = setTimeout(() => controller.abort("timeout"), this.timeoutMs);
+        const events = [];
+        const emit = (event) => {
+            if (controller.signal.aborted)
+                return;
+            if (input.emitEvent)
+                input.emitEvent(event);
+            else
+                events.push(event);
+        };
+        try {
+            const output = await execute(input, controller.signal, emit);
+            if (!controller.signal.aborted) {
+                events.push({
+                    event_type: "turn.completed",
+                    turn_id: turnId,
+                    data: { status: "completed", final_output: output },
+                });
+            }
+        }
+        catch (error) {
+            if (!controller.signal.aborted) {
+                events.push(turnFailedEvent(turnId, "provider_error", error instanceof HarnessAdapterError
+                    ? error.code
+                    : `${this.driver}_runtime_failed`, error instanceof HarnessAdapterError
+                    ? error.message
+                    : "Provider runtime failed; inspect local diagnostics.", false));
+            }
+        }
+        finally {
+            clearTimeout(timeout);
+            if (controller.signal.aborted) {
+                events.push(controller.signal.reason === "timeout"
+                    ? turnFailedEvent(turnId, "timeout", `${this.driver}_turn_timeout`, "Provider turn timed out.", false)
+                    : {
+                        event_type: "turn.cancelled",
+                        turn_id: turnId,
+                        data: {
+                            status: "cancelled",
+                            final_output: { exit_reason: "cancel_requested" },
+                        },
+                    });
+            }
+            try {
+                if (input.emitEvent) {
+                    for (const event of events)
+                        input.emitEvent(event);
+                    events.length = 0;
+                }
+            }
+            finally {
+                this.#active.delete(sessionId);
+                finish();
+            }
+        }
+        return events;
+    }
+    async cancel(sessionId, turnId) {
+        const active = this.#active.get(sessionId);
+        if (active && (turnId === undefined || active.id === turnId)) {
+            active.controller.abort("cancel_requested");
+            await active.done;
+        }
+        // The running turn owns the single terminal event, including cancellation.
+        return [];
+    }
+    async stop(sessionId) {
+        await this.cancel(sessionId);
+        this.#usedSessions.delete(sessionId);
+        return [];
+    }
+}
+export function selectedEffort(selection, driver) {
+    let effort;
+    for (const option of selection.options ?? []) {
+        const expected = driver === "codex" ? "reasoningEffort" : "effort";
+        const values = ["low", "medium", "high", "xhigh", "max"];
+        if (option.id !== expected ||
+            typeof option.value !== "string" ||
+            option.value.length === 0 ||
+            (driver === "claude" && !values.includes(option.value)) ||
+            effort !== undefined) {
+            throw new HarnessAdapterError("unsupported_model_option", "Unsupported or duplicate model option.");
+        }
+        effort = option.value;
+    }
+    return effort;
+}
+//# sourceMappingURL=native-turn.js.map

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

@@ -0,0 +1,44 @@
+import type { ProviderInstanceConfig } from "../../../config/index.js";
+import type { ProviderDriverStatus } from "../../../host/provider-registry.js";
+import type { HarnessAdapter, HarnessAdapterCancelInput, HarnessAdapterEvent, HarnessAdapterSession, HarnessAdapterStartInput, HarnessAdapterStopInput, HarnessAdapterTurnInput } from "../types.js";
+type OpenCodeRuntimeStartInput = {
+    executable: string;
+    launchArgs: string[];
+    cwd: string;
+    env: Record<string, string>;
+    mcpServers: Record<string, {
+        type: "remote";
+        url: string;
+        enabled: true;
+    }>;
+};
+export type OpenCodeRuntimeTurnInput = {
+    turnId: string;
+    input: string;
+    model: string;
+    emitEvent: (event: HarnessAdapterEvent) => void;
+};
+export type OpenCodeRuntime = {
+    readonly sessionId: string;
+    sendTurn(input: OpenCodeRuntimeTurnInput): Promise<string>;
+    cancelTurn(): Promise<void>;
+    close(): Promise<void>;
+};
+export type OpenCodeRuntimeFactory = (input: OpenCodeRuntimeStartInput) => Promise<OpenCodeRuntime>;
+export type OpenCodeHarnessAdapterOptions = {
+    runtimeFactory?: OpenCodeRuntimeFactory;
+    probeTimeoutMs?: number;
+};
+export declare class OpenCodeHarnessAdapter implements HarnessAdapter {
+    #private;
+    readonly driverKind = "opencode";
+    constructor(options?: OpenCodeHarnessAdapterOptions);
+    probe(provider: ProviderInstanceConfig): Promise<ProviderDriverStatus>;
+    validateStart(): Promise<void>;
+    startSession(input: HarnessAdapterStartInput): Promise<HarnessAdapterSession>;
+    sendTurn(input: HarnessAdapterTurnInput): Promise<HarnessAdapterEvent[]>;
+    cancelTurn(input: HarnessAdapterCancelInput): Promise<HarnessAdapterEvent[]>;
+    stopSession(input: HarnessAdapterStopInput): Promise<HarnessAdapterEvent[]>;
+}
+export {};
+//# sourceMappingURL=opencode.d.ts.map