@harness-control/runner 0.1.0

package/dist/harnesses/adapters/providers/codex-models.js

@@ -0,0 +1,62 @@
+import { z } from "zod";
+import { CodexRpc } from "./codex-rpc.js";
+const pageSchema = z.object({
+    data: z.array(z.object({
+        id: z.string(),
+        model: z.string(),
+        displayName: z.string(),
+        isDefault: z.boolean(),
+        supportedReasoningEfforts: z.array(z.object({ reasoningEffort: z.string() })),
+        defaultReasoningEffort: z.string(),
+    })),
+    nextCursor: z.string().nullable().optional(),
+});
+export async function codexModels(provider, timeoutMs) {
+    const rpc = new CodexRpc(provider.executable_path ?? "codex", process.cwd(), {
+        ...process.env,
+        ...provider.env,
+        ...(provider.home ? { CODEX_HOME: provider.home } : {}),
+    });
+    const timer = setTimeout(() => {
+        void rpc.process.stop();
+    }, timeoutMs);
+    try {
+        await rpc.request("initialize", {
+            clientInfo: { name: "hcp-runner", version: "0.0.0" },
+            capabilities: {},
+        });
+        rpc.notify("initialized");
+        const models = [];
+        let cursor;
+        do {
+            const page = pageSchema.parse(await rpc.request("model/list", { ...(cursor ? { cursor } : {}) }));
+            for (const model of page.data)
+                models.push({
+                    id: model.model,
+                    label: model.displayName,
+                    is_default: model.isDefault,
+                    capabilities: {
+                        option_descriptors: [
+                            {
+                                id: "reasoningEffort",
+                                label: "Reasoning effort",
+                                type: "select",
+                                default_value: model.defaultReasoningEffort,
+                                values: model.supportedReasoningEfforts.map(({ reasoningEffort }) => ({
+                                    value: reasoningEffort,
+                                    label: reasoningEffort,
+                                })),
+                            },
+                        ],
+                    },
+                });
+            cursor = page.nextCursor ?? undefined;
+        } while (cursor);
+        return models;
+    }
+    finally {
+        clearTimeout(timer);
+        await rpc.process.stop();
+    }
+}
+//# sourceMappingURL=codex-models.js.map

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

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import { NativeProcess } from "./native-process.js";
+declare const messageSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    method: z.ZodOptional<z.ZodString>;
+    params: z.ZodOptional<z.ZodUnknown>;
+    result: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export type RpcMessage = z.infer<typeof messageSchema>;
+export declare class CodexRpc {
+    #private;
+    readonly process: NativeProcess;
+    onNotification: (message: RpcMessage) => void;
+    onFailure: (error: Error) => void;
+    constructor(executable: string, cwd: string, env: NodeJS.ProcessEnv);
+    request(method: string, params: unknown): Promise<unknown>;
+    notify(method: string): void;
+}
+export {};
+//# sourceMappingURL=codex-rpc.d.ts.map

package/dist/harnesses/adapters/providers/codex-rpc.js

@@ -0,0 +1,114 @@
+import { StringDecoder } from "node:string_decoder";
+import { z } from "zod";
+import { HarnessAdapterError } from "../types.js";
+import { NativeProcess } from "./native-process.js";
+import { processFailureMessage } from "./cli-process.js";
+const messageSchema = z.object({
+    id: z.union([z.string(), z.number()]).optional(),
+    method: z.string().optional(),
+    params: z.unknown().optional(),
+    result: z.unknown().optional(),
+    error: z.unknown().optional(),
+});
+export class CodexRpc {
+    process;
+    #pending = new Map();
+    #nextId = 1;
+    #failure;
+    #buffer = "";
+    #decoder = new StringDecoder("utf8");
+    onNotification = () => { };
+    onFailure = () => { };
+    constructor(executable, cwd, env) {
+        this.process = new NativeProcess(executable, ["app-server", "--listen", "stdio://"], cwd, env);
+        this.process.child.stderr.resume();
+        this.process.child.stdout.on("data", (chunk) => {
+            try {
+                this.#buffer += this.#decoder.write(chunk);
+                let newline;
+                while ((newline = this.#buffer.indexOf("\n")) >= 0) {
+                    if (newline > 8 * 1024 * 1024)
+                        throw new Error("Oversized frame");
+                    const line = this.#buffer.slice(0, newline);
+                    this.#buffer = this.#buffer.slice(newline + 1);
+                    this.#receive(messageSchema.parse(JSON.parse(line)));
+                }
+                if (Buffer.byteLength(this.#buffer) > 8 * 1024 * 1024)
+                    throw new Error("Oversized frame");
+            }
+            catch {
+                this.#fail(new HarnessAdapterError("codex_protocol_error", "Codex returned an invalid protocol message."));
+                void this.process.stop();
+            }
+        });
+        void this.process.closed.then(() => this.#fail(new HarnessAdapterError("codex_process_closed", "Codex process closed before the operation finished.")));
+    }
+    request(method, params) {
+        if (this.#failure)
+            return Promise.reject(this.#failure);
+        const id = this.#nextId++;
+        return new Promise((resolve, reject) => {
+            this.#pending.set(id, { resolve, reject });
+            this.#write({ id, method, params });
+        });
+    }
+    notify(method) {
+        this.#write({ method });
+    }
+    #write(message) {
+        this.process.child.stdin.write(`${JSON.stringify(message)}\n`, (error) => {
+            if (error)
+                this.#fail(new HarnessAdapterError("codex_transport_closed", "Codex input transport closed."));
+        });
+    }
+    #receive(message) {
+        if (this.#failure)
+            return;
+        if (message.method && message.id !== undefined) {
+            this.#write({
+                id: message.id,
+                error: {
+                    code: -32601,
+                    message: "Interactive provider requests are not supported by this runner profile.",
+                },
+            });
+            this.#fail(new HarnessAdapterError("unsupported_provider_request", "Codex requested unsupported interactive input."));
+            void this.process.stop();
+        }
+        else if (message.method) {
+            this.onNotification(message);
+        }
+        else if (typeof message.id === "number") {
+            const pending = this.#pending.get(message.id);
+            if (!pending)
+                return;
+            this.#pending.delete(message.id);
+            if (message.error !== undefined) {
+                const error = z
+                    .object({ message: z.string() })
+                    .safeParse(message.error);
+                const detail = processFailureMessage({
+                    exitCode: null,
+                    signal: null,
+                    stdout: "",
+                    stderr: "",
+                    error: error.success ? error.data.message : undefined,
+                    timedOut: false,
+                }, "Codex rejected a native request.", []);
+                pending.reject(new HarnessAdapterError("codex_request_failed", detail));
+            }
+            else
+                pending.resolve(message.result);
+        }
+    }
+    #fail(error) {
+        if (this.#failure)
+            return;
+        this.#failure = error;
+        for (const pending of this.#pending.values())
+            pending.reject(error);
+        this.#pending.clear();
+        this.onFailure(error);
+    }
+}
+//# sourceMappingURL=codex-rpc.js.map

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

@@ -0,0 +1,3 @@
+import { type NativeTurn } from "./native-turn.js";
+export declare const runCodexTurn: NativeTurn;
+//# sourceMappingURL=codex-runtime.d.ts.map

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

@@ -0,0 +1,267 @@
+import { z } from "zod";
+import { realpath } from "node:fs/promises";
+import { HarnessAdapterError } from "../types.js";
+import { adapterMcpServers, assertCliMcpAttachmentProxied } from "./shared.js";
+import { selectedEffort } from "./native-turn.js";
+import { CodexRpc } from "./codex-rpc.js";
+const object = z.record(z.string(), z.unknown());
+const idObject = z.object({ id: z.string() });
+const startedSchema = z.object({
+    thread: idObject,
+    sandbox: z.object({
+        type: z.string(),
+        writableRoots: z.array(z.string()).optional(),
+        excludeTmpdirEnvVar: z.boolean().optional(),
+        excludeSlashTmp: z.boolean().optional(),
+    }),
+    approvalPolicy: z.string(),
+});
+const deltaSchema = z.object({
+    threadId: z.string(),
+    turnId: z.string(),
+    delta: z.string(),
+});
+const itemSchema = z.object({
+    threadId: z.string(),
+    turnId: z.string(),
+    item: z.object({
+        id: z.string(),
+        type: z.string(),
+        text: z.string().optional(),
+        phase: z.string().nullable().optional(),
+    }),
+});
+const terminalSchema = z.object({
+    threadId: z.string(),
+    turn: z.object({
+        id: z.string(),
+        status: z.string(),
+        error: z.unknown().nullable().optional(),
+    }),
+});
+export const runCodexTurn = async (input, signal, emit) => {
+    signal.throwIfAborted();
+    const selection = input.payload.model_selection ?? input.startPayload.model_selection;
+    const effort = selectedEffort(selection, "codex");
+    const rpc = new CodexRpc(input.provider.executable_path ?? "codex", input.startPayload.cwd, {
+        ...process.env,
+        ...input.provider.env,
+        ...(input.provider.home ? { CODEX_HOME: input.provider.home } : {}),
+    });
+    const abort = () => {
+        void rpc.process.stop();
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    if (signal.aborted)
+        abort();
+    try {
+        await rpc.request("initialize", {
+            clientInfo: { name: "hcp-runner", version: "0.0.0" },
+            capabilities: {},
+        });
+        rpc.notify("initialized");
+        const configResult = z.object({ config: object }).parse(await rpc.request("config/read", {
+            cwd: input.startPayload.cwd,
+            includeLayers: false,
+        }));
+        const inherited = object.parse(configResult.config.mcp_servers ?? {});
+        const servers = {};
+        for (const name of Object.keys(inherited))
+            servers[name] = { enabled: false };
+        for (const attachment of adapterMcpServers(input.mcpServers, input.startPayload)) {
+            assertCliMcpAttachmentProxied(attachment, "Codex", "codex");
+            if (Object.hasOwn(inherited, attachment.name)) {
+                throw new HarnessAdapterError("mcp_name_conflict", "An attachment conflicts with an inherited MCP server name.");
+            }
+            servers[attachment.name] = {
+                url: attachment.url,
+                enabled: true,
+                default_tools_approval_mode: "approve",
+            };
+        }
+        const sandbox = input.startPayload.sandbox_mode.replaceAll("_", "-");
+        const started = startedSchema.parse(await rpc.request("thread/start", {
+            cwd: input.startPayload.cwd,
+            model: selection.model,
+            sandbox,
+            approvalPolicy: "never",
+            ephemeral: true,
+            config: {
+                mcp_servers: servers,
+                "features.apps": false,
+                "features.multi_agent": false,
+                "sandbox_workspace_write.writable_roots": [],
+                "sandbox_workspace_write.exclude_tmpdir_env_var": true,
+                "sandbox_workspace_write.exclude_slash_tmp": true,
+            },
+        }));
+        const expectedSandbox = {
+            read_only: "readOnly",
+            workspace_write: "workspaceWrite",
+            danger_full_access: "dangerFullAccess",
+        }[input.startPayload.sandbox_mode];
+        if (started.sandbox.type !== expectedSandbox ||
+            started.approvalPolicy !== "never") {
+            throw new HarnessAdapterError("policy_mismatch", "Codex did not accept the requested execution policy.");
+        }
+        if (started.sandbox.type === "workspaceWrite") {
+            const cwd = await realpath(input.startPayload.cwd);
+            const roots = await Promise.all((started.sandbox.writableRoots ?? []).map((root) => realpath(root)));
+            if (started.sandbox.writableRoots === undefined ||
+                roots.some((root) => root !== cwd) ||
+                started.sandbox.excludeTmpdirEnvVar !== true ||
+                started.sandbox.excludeSlashTmp !== true) {
+                throw new HarnessAdapterError("policy_mismatch", "Codex granted writes beyond the requested workspace.");
+            }
+        }
+        const threadId = started.thread.id;
+        const allowedServers = new Set(adapterMcpServers(input.mcpServers, input.startPayload).map((attachment) => attachment.name));
+        let cursor;
+        do {
+            const inventory = z
+                .object({
+                data: z.array(z.object({
+                    name: z.string(),
+                    runtimeStatus: z.string().nullable().optional(),
+                    tools: object.optional(),
+                })),
+                nextCursor: z.string().nullable().optional(),
+            })
+                .parse(await rpc.request("mcpServerStatus/list", {
+                threadId,
+                ...(cursor ? { cursor } : {}),
+            }));
+            if (inventory.data.some((server) => !allowedServers.has(server.name) &&
+                !(Object.hasOwn(inherited, server.name) &&
+                    server.runtimeStatus === "disabled" &&
+                    Object.keys(server.tools ?? {}).length === 0))) {
+                throw new HarnessAdapterError("mcp_scope_mismatch", "Codex exposed an MCP server outside the selected attachment scope.");
+            }
+            cursor = inventory.nextCursor ?? undefined;
+        } while (cursor);
+        let nativeTurnId;
+        let finalText;
+        let usage;
+        let settled = false;
+        let resolve;
+        let reject;
+        const terminal = new Promise((yes, no) => {
+            resolve = yes;
+            reject = no;
+        });
+        // Attach immediately: the server can emit a terminal event before turn/start replies.
+        void terminal.catch(() => { });
+        rpc.onFailure = (error) => {
+            if (!settled) {
+                settled = true;
+                reject(error);
+            }
+        };
+        rpc.onNotification = (message) => {
+            if (settled)
+                return;
+            if (message.method === "turn/started") {
+                const event = z
+                    .object({ threadId: z.string(), turn: idObject })
+                    .parse(message.params);
+                if (event.threadId === threadId)
+                    nativeTurnId = event.turn.id;
+            }
+            else if (message.method === "item/agentMessage/delta" ||
+                message.method === "item/reasoning/summaryTextDelta") {
+                const event = deltaSchema.parse(message.params);
+                if (event.threadId !== threadId ||
+                    (nativeTurnId && event.turnId !== nativeTurnId))
+                    return;
+                emit({
+                    event_type: message.method === "item/agentMessage/delta"
+                        ? "content.delta"
+                        : "reasoning.delta",
+                    turn_id: input.payload.turn_id,
+                    data: { delta: event.delta },
+                });
+            }
+            else if (message.method === "item/started" ||
+                message.method === "item/completed") {
+                const event = itemSchema.parse(message.params);
+                if (event.threadId !== threadId ||
+                    (nativeTurnId && event.turnId !== nativeTurnId))
+                    return;
+                emit({
+                    event_type: message.method === "item/started"
+                        ? "item.started"
+                        : "item.completed",
+                    turn_id: input.payload.turn_id,
+                    data: {
+                        item_id: event.item.id,
+                        item_type: event.item.type,
+                        ...(event.item.text !== undefined
+                            ? { content: event.item.text }
+                            : {}),
+                    },
+                });
+                if (message.method === "item/completed" &&
+                    event.item.type === "agentMessage" &&
+                    event.item.phase !== "commentary")
+                    finalText = event.item.text;
+            }
+            else if (message.method === "thread/tokenUsage/updated") {
+                const event = z
+                    .object({
+                    threadId: z.string(),
+                    turnId: z.string(),
+                    tokenUsage: z.object({
+                        total: z.object({
+                            inputTokens: z.number().int().nonnegative(),
+                            outputTokens: z.number().int().nonnegative(),
+                            totalTokens: z.number().int().nonnegative(),
+                        }),
+                    }),
+                })
+                    .parse(message.params);
+                if (event.threadId !== threadId ||
+                    (nativeTurnId && event.turnId !== nativeTurnId))
+                    return;
+                usage = {
+                    input_tokens: event.tokenUsage.total.inputTokens,
+                    output_tokens: event.tokenUsage.total.outputTokens,
+                    total_tokens: event.tokenUsage.total.totalTokens,
+                };
+                emit({
+                    event_type: "usage.updated",
+                    turn_id: input.payload.turn_id,
+                    data: { ...usage },
+                });
+            }
+            else if (message.method === "turn/completed") {
+                const event = terminalSchema.parse(message.params);
+                if (event.threadId !== threadId ||
+                    (nativeTurnId && event.turn.id !== nativeTurnId))
+                    return;
+                settled = true;
+                if (event.turn.status !== "completed" ||
+                    event.turn.error != null ||
+                    finalText === undefined) {
+                    reject(new HarnessAdapterError("codex_turn_failed", "Codex ended without a successful final answer."));
+                }
+                else
+                    resolve({ final_text: finalText, ...(usage ? { usage } : {}) });
+            }
+        };
+        const turn = z.object({ turn: idObject }).parse(await rpc.request("turn/start", {
+            threadId,
+            model: selection.model,
+            ...(effort ? { effort } : {}),
+            input: [{ type: "text", text: input.payload.input, text_elements: [] }],
+        }));
+        if (nativeTurnId !== undefined && nativeTurnId !== turn.turn.id)
+            throw new HarnessAdapterError("codex_turn_mismatch", "Codex returned conflicting turn identities.");
+        nativeTurnId = turn.turn.id;
+        return await terminal;
+    }
+    finally {
+        signal.removeEventListener("abort", abort);
+        await rpc.process.stop();
+    }
+};
+//# sourceMappingURL=codex-runtime.js.map

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

@@ -0,0 +1,22 @@
+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";
+export type CodexHarnessAdapterOptions = {
+    processSpawner?: CliProcessSpawner;
+    probeTimeoutMs?: number;
+    turnTimeoutMs?: number;
+    processKillGraceMs?: number;
+};
+export declare class CodexHarnessAdapter implements HarnessAdapter {
+    #private;
+    readonly driverKind = "codex";
+    constructor(options?: CodexHarnessAdapterOptions);
+    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=codex.d.ts.map

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

@@ -0,0 +1,161 @@
+import { codexModels } from "./codex-models.js";
+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 { runCodexTurn } from "./codex-runtime.js";
+export class CodexHarnessAdapter {
+    driverKind = "codex";
+    #processSpawner;
+    #probeTimeoutMs;
+    #processKillGraceMs;
+    #turns;
+    constructor(options = {}) {
+        this.#processSpawner = options.processSpawner ?? spawnProviderCliProcess;
+        this.#probeTimeoutMs = options.probeTimeoutMs ?? 5_000;
+        this.#processKillGraceMs = options.processKillGraceMs ?? 1_000;
+        this.#turns = new NativeTurns("codex", options.turnTimeoutMs ?? 10 * 60 * 1000);
+    }
+    async probe(provider) {
+        const executable = provider.executable_path ?? "codex";
+        const diagnosticPaths = codexDiagnosticPaths(provider, executable, process.cwd());
+        const launchArgs = codexLaunchArgs(provider);
+        const versionResult = await this.#runProcess(executable, [...launchArgs, "--version"], {
+            cwd: process.cwd(),
+            env: providerEnvironment(provider),
+        }, this.#probeTimeoutMs);
+        if (versionResult.timedOut ||
+            versionResult.error ||
+            versionResult.exitCode !== 0) {
+            return {
+                provider_instance_id: provider.id,
+                driver_kind: "codex",
+                execution_capabilities: nativeExecutionCapabilities("codex"),
+                installed: false,
+                available: false,
+                status: "unavailable",
+                message: versionResult.timedOut
+                    ? "Codex version probe timed out."
+                    : processFailureMessage(versionResult, "Codex executable is not available.", diagnosticPaths),
+                models: normalizeProviderModels(provider.models),
+            };
+        }
+        const authResult = await this.#runProcess(executable, [...launchArgs, "login", "status"], {
+            cwd: process.cwd(),
+            env: providerEnvironment(provider),
+        }, this.#probeTimeoutMs);
+        if (authResult.timedOut || authResult.error) {
+            const version = firstLine(versionResult.stdout);
+            return {
+                provider_instance_id: provider.id,
+                driver_kind: "codex",
+                execution_capabilities: nativeExecutionCapabilities("codex"),
+                installed: true,
+                available: false,
+                status: "unavailable",
+                ...(version ? { version } : {}),
+                message: authResult.timedOut
+                    ? "Codex authentication probe timed out."
+                    : processFailureMessage(authResult, "Codex authentication probe failed.", diagnosticPaths),
+                models: normalizeProviderModels(provider.models),
+            };
+        }
+        if (authResult.exitCode !== 0) {
+            const version = firstLine(versionResult.stdout);
+            return {
+                provider_instance_id: provider.id,
+                driver_kind: "codex",
+                execution_capabilities: nativeExecutionCapabilities("codex"),
+                installed: true,
+                available: false,
+                status: "unauthenticated",
+                ...(version ? { version } : {}),
+                message: processFailureMessage(authResult, "Codex is not authenticated.", diagnosticPaths),
+                models: normalizeProviderModels(provider.models),
+            };
+        }
+        let models;
+        try {
+            models =
+                provider.models.length > 0
+                    ? normalizeProviderModels(provider.models)
+                    : await codexModels(provider, this.#probeTimeoutMs);
+        }
+        catch {
+            return {
+                provider_instance_id: provider.id,
+                driver_kind: "codex",
+                installed: true,
+                available: false,
+                status: "unavailable",
+                message: "Codex native model discovery failed.",
+                models: [],
+                execution_capabilities: nativeExecutionCapabilities("codex"),
+            };
+        }
+        const version = firstLine(versionResult.stdout);
+        return {
+            provider_instance_id: provider.id,
+            driver_kind: "codex",
+            execution_capabilities: nativeExecutionCapabilities("codex"),
+            installed: true,
+            available: true,
+            status: "ready",
+            ...(version ? { version } : {}),
+            authStatus: "authenticated",
+            models,
+        };
+    }
+    async validateStart(input) {
+        validateNativeStart(input, "codex");
+    }
+    async startSession(input) {
+        await this.validateStart(input);
+        for (const attachment of adapterMcpServers(input.mcpServers, input.payload))
+            assertCliMcpAttachmentProxied(attachment, "Codex", "codex");
+        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 runCodexTurn(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: "Codex execution timed out.",
+            terminatedErrorMessage: "Codex process was terminated.",
+            startFailureMessage: "Codex process failed before start.",
+        });
+    }
+}
+function codexDiagnosticPaths(provider, executable, ...paths) {
+    return [provider.executable_path, provider.home, executable, ...paths].filter((value) => value !== undefined && value.length > 0);
+}
+function providerEnvironment(provider) {
+    return {
+        ...provider.env,
+        ...(provider.home ? { CODEX_HOME: provider.home } : {}),
+    };
+}
+function codexLaunchArgs(provider) {
+    return provider.launch_args;
+}
+//# sourceMappingURL=codex.js.map

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

@@ -0,0 +1,13 @@
+import type { ProviderInstanceConfig } from "../../../config/index.js";
+import type { ProviderDriverStatus } from "../../../host/provider-registry.js";
+import type { HarnessAdapter, HarnessAdapterCancelInput, HarnessAdapterEvent, HarnessAdapterSession, HarnessAdapterStartInput, HarnessAdapterTurnInput } from "../types.js";
+export declare class MockHarnessAdapter implements HarnessAdapter {
+    readonly driverKind = "mock";
+    probe(provider: ProviderInstanceConfig): Promise<ProviderDriverStatus>;
+    validateStart(): Promise<void>;
+    startSession(input: HarnessAdapterStartInput): Promise<HarnessAdapterSession>;
+    sendTurn(input: HarnessAdapterTurnInput): Promise<HarnessAdapterEvent[]>;
+    cancelTurn(input: HarnessAdapterCancelInput): Promise<HarnessAdapterEvent[]>;
+    stopSession(): Promise<HarnessAdapterEvent[]>;
+}
+//# sourceMappingURL=mock.d.ts.map