@neta-art/cohub-cli 6.11.2 → 7.0.0

package/dist/runtime/harness.js

@@ -0,0 +1,403 @@
+import { JsonRpcProcess, record } from "./json-rpc.js";
+import { codexModelCatalog } from "./model-catalog.js";
+import { codexTokenTotals, codexUsage, subtractCodexTokens } from "./codex-usage.js";
+import { downloadPublicImage } from "../safe-remote-image.js";
+const runtimeEnvironment = (input) => ({ COHUB_SPACE_ID: input.spaceId, COHUB_SESSION_ID: input.sessionId, COHUB_TURN_ID: input.turnId });
+const array = (value) => Array.isArray(value) ? value : [];
+const text = (value) => typeof value === "string" ? value : "";
+export function piContent(value) {
+    return array(value).flatMap((entry) => {
+        const block = record(entry);
+        if (block.type === "text")
+            return [{ type: "text", text: text(block.text) }];
+        if (block.type === "thinking")
+            return [{ type: "thinking", thinking: text(block.thinking), ...(typeof (block.thinkingSignature ?? block.signature) === "string" ? { signature: String(block.thinkingSignature ?? block.signature) } : {}) }];
+        if (block.type === "toolCall")
+            return [{ type: "tool_use", id: text(block.id), name: text(block.name), input: record(block.arguments) }];
+        if (block.type === "image")
+            return [{ type: "image", source: { type: "base64", data: text(block.data), media_type: text(block.mimeType) } }];
+        return [{ type: "text", text: JSON.stringify(block) }];
+    });
+}
+async function imageForPi(block) {
+    if (block.source.type === "base64")
+        return { type: "image", data: block.source.data, mimeType: block.source.media_type };
+    const image = await downloadPublicImage(block.source.url);
+    return { type: "image", data: Buffer.from(image.bytes).toString("base64"), mimeType: image.mimeType };
+}
+export function promptText(content) {
+    return content.filter((block) => block.type !== "image").map((block) => block.type === "text" ? block.text : JSON.stringify(block)).join("\n");
+}
+async function initializeCodex(rpc) {
+    await rpc.request("initialize", { clientInfo: { name: "cohub", title: "Cohub", version: "1" }, capabilities: { experimentalApi: true } });
+    rpc.write({ method: "initialized", params: {} });
+}
+/** Ask the native process to stop, then hard-close it if the request does not settle quickly. */
+function createAbortEscalation(rpc, signal, interrupt) {
+    let timer = null;
+    const abort = () => {
+        interrupt();
+        timer ??= setTimeout(() => { void rpc.close().catch(() => undefined); }, 5000);
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    return {
+        abort,
+        clear: () => { signal.removeEventListener("abort", abort); if (timer)
+            clearTimeout(timer); },
+    };
+}
+/** Native files stay authoritative; archival failure only degrades cross-host resume. */
+async function finishHarnessTurn(store, state, message, resume, turnId) {
+    const archive = await store.archive(state, turnId).catch((error) => { console.error("Native archive unavailable; local files retained:", error); return null; });
+    return { state, event: { type: "turn.end", message, resume, archive } };
+}
+export async function discoverHarnesses(harnesses, options, cwd) {
+    const models = [];
+    await Promise.all(harnesses.map(async (harness) => {
+        const rpc = new JsonRpcProcess(options[harness] || harness, harness === "pi" ? ["--mode", "rpc", "--no-session"] : ["app-server", "--listen", "stdio://"], cwd, harness);
+        try {
+            if (harness === "pi") {
+                const result = await rpc.request("get_available_models");
+                for (const value of array(result.models)) {
+                    const model = record(value);
+                    if (model.id && model.provider)
+                        models.push({ harness, id: text(model.id), provider: text(model.provider), name: text(model.name) || text(model.id) });
+                }
+            }
+            else {
+                await initializeCodex(rpc);
+                const config = await rpc.request("config/read", { includeLayers: false, cwd });
+                const entries = [];
+                const cursors = new Set();
+                let cursor = null;
+                do {
+                    const result = await rpc.request("model/list", { cursor, limit: 100 });
+                    entries.push(...array(result.data));
+                    cursor = typeof result.nextCursor === "string" ? result.nextCursor : null;
+                    if (entries.length > 2000 || cursor && cursors.has(cursor))
+                        throw new Error("Invalid model catalog pagination");
+                    if (cursor)
+                        cursors.add(cursor);
+                } while (cursor);
+                models.push(...codexModelCatalog(config, entries));
+            }
+        }
+        finally {
+            await rpc.close();
+        }
+    }));
+    return { harnesses, models };
+}
+export async function executePi(input, options, cwd, store, emit, signal) {
+    if (input.accessMode === "read_only")
+        throw new Error("Pi cannot enforce read-only access; select Cohub or Codex");
+    signal.throwIfAborted();
+    const { state, resume } = await store.prepare(input, cwd, signal);
+    signal.throwIfAborted();
+    const rpc = new JsonRpcProcess(options.pi || "pi", ["--mode", "rpc", "--session", state.path], cwd, "pi", runtimeEnvironment(input));
+    let ordinal = -1;
+    let currentContent = [];
+    let last = { ordinal: 0, content: [] };
+    const abortEscalation = createAbortEscalation(rpc, signal, () => { void rpc.request("abort").catch(() => undefined); });
+    try {
+        if (input.model) {
+            let provider = input.provider;
+            if (!provider) {
+                const catalog = await rpc.request("get_available_models");
+                const matches = array(catalog.models).map(record).filter((model) => model.id === input.model);
+                if (matches.length !== 1)
+                    throw new Error("Select a provider for this local model");
+                provider = text(matches[0]?.provider);
+            }
+            await rpc.request("set_model", { provider, modelId: input.model });
+        }
+        if (input.thinkingLevel)
+            await rpc.request("set_thinking_level", { level: input.thinkingLevel });
+        const stateResult = await rpc.request("get_state");
+        state.nativeSessionId = text(stateResult.sessionId) || state.nativeSessionId;
+        const model = record(stateResult.model);
+        const content = input.messages.flatMap((message) => message.content);
+        const images = await Promise.all(content.flatMap((block) => block.type === "image" ? [imageForPi(block)] : []));
+        signal.throwIfAborted();
+        await store.started(state, input.turnId);
+        await new Promise((resolve, reject) => {
+            const offFailure = rpc.onFailure(reject);
+            const off = rpc.onEvent((event) => {
+                try {
+                    if (event.type === "extension_ui_request") {
+                        if (["confirm", "select", "input", "editor"].includes(text(event.method)))
+                            rpc.write({ type: "extension_ui_response", id: event.id, cancelled: true });
+                        return;
+                    }
+                    if (event.type === "message_start" && record(event.message).role === "assistant") {
+                        ordinal++;
+                        currentContent = [];
+                        emit({ type: "message.start", ordinal });
+                    }
+                    if (event.type === "message_end" && record(event.message).role === "assistant") {
+                        currentContent = piContent(record(event.message).content);
+                        emit({ type: "content.replace", ordinal, content: currentContent });
+                    }
+                    if (event.type === "tool_execution_start") {
+                        const id = text(event.toolCallId);
+                        if (!currentContent.some((block) => block.type === "tool_use" && block.id === id))
+                            currentContent.push({ type: "tool_use", id, name: text(event.toolName), input: record(event.args), _meta: { toolStatus: "running" } });
+                        emit({ type: "content.replace", ordinal, content: [...currentContent] });
+                    }
+                    if (event.type === "tool_execution_update" || event.type === "tool_execution_end") {
+                        const id = text(event.toolCallId);
+                        const rawResult = event.type === "tool_execution_end" ? event.result : event.partialResult;
+                        const result = record(rawResult);
+                        const resultContent = typeof rawResult === "string" ? rawResult : piContent(result.content);
+                        currentContent = currentContent.filter((block) => block.type !== "tool_result" || block.tool_use_id !== id);
+                        currentContent.push({ type: "tool_result", tool_use_id: id, content: resultContent, is_error: Boolean(event.isError), _meta: { toolStatus: event.type === "tool_execution_end" ? "done" : "running" } });
+                        emit({ type: "content.replace", ordinal, content: [...currentContent] });
+                    }
+                    if (event.type === "message_update") {
+                        const delta = record(event.assistantMessageEvent);
+                        if (delta.type === "text_delta" || delta.type === "thinking_delta")
+                            emit({ type: "text.delta", ordinal, index: Number(delta.contentIndex ?? 0), kind: delta.type === "text_delta" ? "text" : "thinking", delta: text(delta.delta) });
+                    }
+                    if (event.type === "turn_end") {
+                        const message = record(event.message);
+                        const content = piContent(message.content);
+                        for (const resultValue of array(event.toolResults)) {
+                            const result = record(resultValue);
+                            content.push({ type: "tool_result", tool_use_id: text(result.toolCallId), content: typeof result.content === "string" ? result.content : piContent(result.content), is_error: Boolean(result.isError) });
+                        }
+                        last = { ordinal: Math.max(0, ordinal), content, provider: text(message.provider) || text(model.provider), model: text(message.model) || text(model.id), usage: message.usage, stopReason: text(message.stopReason) === "toolUse" ? "tool_use" : text(message.stopReason) || "stop", errorMessage: text(message.errorMessage) || null };
+                        emit({ type: "content.replace", ordinal: last.ordinal, content });
+                        if (last.stopReason === "tool_use")
+                            emit({ type: "message.commit", message: last });
+                    }
+                    if (event.type === "agent_settled" || event.type === "agent_end" && event.willRetry === undefined) {
+                        off();
+                        offFailure();
+                        resolve();
+                    }
+                }
+                catch (error) {
+                    off();
+                    offFailure();
+                    reject(error);
+                }
+            });
+            void rpc.request("prompt", { message: promptText(content), images }).catch((error) => { off(); offFailure(); reject(error); });
+        });
+        await rpc.request("get_state");
+    }
+    catch (error) {
+        if (!state.pendingTurnId)
+            throw error;
+        last = { ...last, stopReason: signal.aborted ? "aborted" : "error", errorMessage: signal.aborted ? null : error instanceof Error ? error.message : String(error) };
+    }
+    finally {
+        abortEscalation.clear();
+        await rpc.close();
+    }
+    if (signal.aborted)
+        last = { ...last, stopReason: "aborted" };
+    return finishHarnessTurn(store, state, last, resume, input.turnId);
+}
+export function codexItemContent(item) {
+    if (item.type === "agentMessage" || item.type === "plan")
+        return [{ type: "text", text: text(item.text) }];
+    if (item.type === "reasoning")
+        return [{ type: "thinking", thinking: [...array(item.summary), ...array(item.content)].map(text).join("\n") }];
+    if (item.type === "userMessage")
+        return [];
+    if (item.type === "contextCompaction")
+        return [{ type: "system_note", note_type: "compacted", text: "Context compacted" }];
+    const id = text(item.id);
+    const name = item.type === "commandExecution" ? "bash" : item.type === "fileChange" ? "apply_patch" : text(item.tool) || text(item.type);
+    const input = item.type === "commandExecution" ? { command: item.command, cwd: item.cwd } : item.type === "fileChange" ? { changes: item.changes } : record(item.arguments);
+    return [
+        { type: "tool_use", id, name, input },
+        { type: "tool_result", tool_use_id: id, content: typeof item.aggregatedOutput === "string" ? item.aggregatedOutput : JSON.stringify(item.result ?? item.error ?? item.changes ?? item), is_error: item.status === "failed" || typeof item.exitCode === "number" && item.exitCode !== 0 },
+    ];
+}
+export async function executeCodex(input, options, cwd, store, emit, signal) {
+    signal.throwIfAborted();
+    const { state, resume } = await store.prepare(input, cwd, signal);
+    signal.throwIfAborted();
+    const rpc = new JsonRpcProcess(options.codex || "codex", ["app-server", "--listen", "stdio://"], cwd, "codex", runtimeEnvironment(input));
+    let nativeTurnId = null;
+    let ordinal = -1;
+    const ordinals = new Map();
+    const items = new Map();
+    const outputs = new Map();
+    const completedItems = new Set();
+    let pending = null;
+    let final = { ordinal: 0, content: [] };
+    let usage;
+    let usageBaseline = state.codexTokenTotals;
+    const latestMessage = () => {
+        if (pending && pending.ordinal >= ordinal)
+            return pending;
+        const item = [...items.entries()].find(([id]) => ordinals.get(id) === ordinal)?.[1];
+        return { ordinal: Math.max(0, ordinal), content: item ? codexItemContent(item) : [] };
+    };
+    const abortEscalation = createAbortEscalation(rpc, signal, () => {
+        if (nativeTurnId)
+            void rpc.request("turn/interrupt", { threadId: state.nativeSessionId, turnId: nativeTurnId }).catch(() => undefined);
+    });
+    try {
+        await initializeCodex(rpc);
+        const threadOptions = {
+            cwd,
+            ...(input.model ? { model: input.model } : {}),
+            ...(input.provider && input.provider !== "codex" ? { modelProvider: input.provider } : {}),
+            ...(input.accessMode === "read_only" ? { sandbox: "read-only" } : {}),
+        };
+        const opened = resume === "native"
+            ? await rpc.request("thread/resume", { ...threadOptions, threadId: state.nativeSessionId, excludeTurns: true })
+            : resume === "restored"
+                ? await rpc.request("thread/fork", { ...threadOptions, threadId: state.nativeSessionId, path: state.path, excludeTurns: true })
+                : await rpc.request("thread/start", threadOptions);
+        const thread = record(opened.thread);
+        if (typeof thread.id !== "string" || typeof thread.path !== "string")
+            throw new Error("Codex did not provide a durable native thread");
+        state.nativeSessionId = thread.id;
+        state.path = thread.path;
+        const provider = text(opened.modelProvider) || "codex";
+        const model = text(opened.model) || input.model;
+        const content = await Promise.all(input.messages.flatMap((message) => message.content).map(async (block) => {
+            if (block.type === "image") {
+                const image = await imageForPi(block);
+                return { type: "image", url: `data:${image.mimeType};base64,${image.data}` };
+            }
+            return { type: "text", text: block.type === "text" ? block.text : JSON.stringify(block), text_elements: [] };
+        }));
+        signal.throwIfAborted();
+        await store.started(state, input.turnId);
+        await new Promise((resolve, reject) => {
+            const offFailure = rpc.onFailure(reject);
+            const off = rpc.onEvent((event) => {
+                try {
+                    const method = text(event.method);
+                    const params = record(event.params);
+                    if (event.id != null) {
+                        // Keep native approval policy. An unattended client never grants an escalation.
+                        rpc.write({ id: event.id, error: { code: -32000, message: "Approval requires an interactive local client" } });
+                        return;
+                    }
+                    if (params.threadId !== state.nativeSessionId)
+                        return;
+                    if (method === "turn/started") {
+                        nativeTurnId = text(record(params.turn).id);
+                        if (signal.aborted)
+                            abortEscalation.abort();
+                    }
+                    if (method === "thread/tokenUsage/updated" && nativeTurnId && params.turnId === nativeTurnId) {
+                        const nativeUsage = record(params.tokenUsage);
+                        const total = codexTokenTotals(nativeUsage.total);
+                        usageBaseline ??= subtractCodexTokens(total, codexTokenTotals(nativeUsage.last));
+                        state.codexTokenTotals = total;
+                        usage = codexUsage(subtractCodexTokens(total, usageBaseline));
+                    }
+                    if (method === "item/started") {
+                        const item = record(params.item);
+                        if (item.type === "userMessage" || completedItems.has(text(item.id)))
+                            return;
+                        const existingOrdinal = ordinals.get(text(item.id));
+                        if (pending && (existingOrdinal == null || existingOrdinal > pending.ordinal)) {
+                            emit({ type: "message.commit", message: pending });
+                            pending = null;
+                        }
+                        if (existingOrdinal != null) {
+                            items.set(text(item.id), item);
+                            if (item.type === "agentMessage" && text(item.text))
+                                emit({ type: "content.replace", ordinal: existingOrdinal, content: codexItemContent(item) });
+                            return;
+                        }
+                        ordinal++;
+                        ordinals.set(text(item.id), ordinal);
+                        items.set(text(item.id), item);
+                        emit({ type: "message.start", ordinal });
+                        if (!["agentMessage", "reasoning", "plan"].includes(text(item.type)))
+                            emit({ type: "content.replace", ordinal, content: codexItemContent(item).filter((block) => block.type !== "tool_result") });
+                    }
+                    if (method === "item/agentMessage/delta" || method === "item/reasoning/textDelta" || method === "item/reasoning/summaryTextDelta") {
+                        const id = text(params.itemId);
+                        if (completedItems.has(id))
+                            return;
+                        const itemOrdinal = ordinals.get(id);
+                        const item = items.get(id);
+                        if (item) {
+                            if (method === "item/agentMessage/delta")
+                                item.text = text(item.text) + text(params.delta);
+                            else {
+                                const key = method.includes("summary") ? "summary" : "content";
+                                item[key] = [array(item[key]).map(text).join("\n") + text(params.delta)];
+                            }
+                        }
+                        if (itemOrdinal != null)
+                            emit({ type: "text.delta", ordinal: itemOrdinal, index: 0, kind: method === "item/agentMessage/delta" ? "text" : "thinking", delta: text(params.delta) });
+                    }
+                    if (method === "item/commandExecution/outputDelta") {
+                        const id = text(params.itemId);
+                        const item = items.get(id);
+                        const itemOrdinal = ordinals.get(id);
+                        if (item && itemOrdinal != null) {
+                            const output = (outputs.get(id) ?? "") + text(params.delta);
+                            outputs.set(id, output);
+                            item.aggregatedOutput = output;
+                            emit({ type: "content.replace", ordinal: itemOrdinal, content: codexItemContent(item) });
+                        }
+                    }
+                    if (method === "item/completed") {
+                        const item = record(params.item);
+                        if (item.type === "userMessage" || completedItems.has(text(item.id)))
+                            return;
+                        completedItems.add(text(item.id));
+                        const itemOrdinal = ordinals.get(text(item.id)) ?? ++ordinal;
+                        if (!ordinals.has(text(item.id))) {
+                            ordinals.set(text(item.id), itemOrdinal);
+                            emit({ type: "message.start", ordinal: itemOrdinal });
+                        }
+                        items.set(text(item.id), item);
+                        const message = { ordinal: itemOrdinal, content: codexItemContent(item), provider, model, stopReason: "stop" };
+                        emit({ type: "content.replace", ordinal: itemOrdinal, content: message.content });
+                        if (pending && pending.ordinal > itemOrdinal)
+                            emit({ type: "message.commit", message });
+                        else {
+                            if (pending && pending.ordinal !== itemOrdinal)
+                                emit({ type: "message.commit", message: pending });
+                            pending = message;
+                        }
+                    }
+                    if (method === "turn/completed") {
+                        const turn = record(params.turn);
+                        final = { ...latestMessage(), provider, model, stopReason: turn.status === "interrupted" ? "aborted" : turn.status === "failed" ? "error" : "stop", errorMessage: text(record(turn.error).message) || null };
+                        off();
+                        offFailure();
+                        resolve();
+                    }
+                }
+                catch (error) {
+                    off();
+                    offFailure();
+                    reject(error);
+                }
+            });
+            void rpc.request("turn/start", { threadId: state.nativeSessionId, clientUserMessageId: input.userMessageId, input: content, ...(input.thinkingLevel ? { effort: input.thinkingLevel } : {}) })
+                .then((result) => { nativeTurnId = text(record(result.turn).id); if (signal.aborted)
+                abortEscalation.abort(); })
+                .catch((error) => { off(); offFailure(); reject(error); });
+        });
+    }
+    catch (error) {
+        if (!state.pendingTurnId)
+            throw error;
+        final = { ...latestMessage(), stopReason: signal.aborted ? "aborted" : "error", errorMessage: signal.aborted ? null : error instanceof Error ? error.message : String(error) };
+    }
+    finally {
+        abortEscalation.clear();
+        await rpc.close();
+    }
+    if (signal.aborted)
+        final = { ...final, stopReason: "aborted" };
+    if (usage)
+        final = { ...final, usage };
+    return finishHarnessTurn(store, state, final, resume, input.turnId);
+}

package/dist/runtime/json-rpc.d.ts

@@ -0,0 +1,37 @@
+export type JsonRecord = Record<string, unknown>;
+export declare const record: (value: unknown) => JsonRecord;
+/** LF framing without rescanning the accumulated record on every pipe chunk. */
+export declare class JsonLineDecoder {
+    private onValue;
+    private maxBytes;
+    private decoder;
+    private fragments;
+    private bytes;
+    constructor(onValue: (value: JsonRecord) => void, maxBytes?: number);
+    private append;
+    private emit;
+    push(chunk: Buffer): void;
+    end(): void;
+}
+export declare function harnessEnvironment(): NodeJS.ProcessEnv;
+export declare class JsonRpcProcess {
+    private mode;
+    private child;
+    private pending;
+    private listeners;
+    private failureListeners;
+    private failure;
+    private nextId;
+    private stderr;
+    private closed;
+    private closing;
+    constructor(binary: string, args: string[], cwd: string, mode: "pi" | "codex", context?: Record<string, string>);
+    private fail;
+    private receive;
+    write(value: unknown): void;
+    request(method: string, params?: JsonRecord, timeoutMs?: number): Promise<JsonRecord>;
+    onEvent(listener: (event: JsonRecord) => void): () => boolean;
+    onFailure(listener: (error: Error) => void): () => boolean;
+    close(): Promise<void>;
+    private closeProcessGroup;
+}

package/dist/runtime/json-rpc.js

@@ -0,0 +1,165 @@
+import { spawn } from "node:child_process";
+import { StringDecoder } from "node:string_decoder";
+import { RUNTIME_MAX_FRAME_BYTES } from "@neta-art/cohub";
+import { stopProcessGroup } from "./process-group.js";
+export const record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+/** LF framing without rescanning the accumulated record on every pipe chunk. */
+export class JsonLineDecoder {
+    onValue;
+    maxBytes;
+    decoder = new StringDecoder("utf8");
+    fragments = [];
+    bytes = 0;
+    constructor(onValue, maxBytes = RUNTIME_MAX_FRAME_BYTES) {
+        this.onValue = onValue;
+        this.maxBytes = maxBytes;
+    }
+    append(fragment) {
+        this.bytes += Buffer.byteLength(fragment);
+        if (this.bytes > this.maxBytes)
+            throw new Error("RPC frame is too large");
+        this.fragments.push(fragment);
+    }
+    emit() {
+        const line = this.fragments.join("");
+        this.fragments = [];
+        this.bytes = 0;
+        if (!line.trim())
+            return;
+        const value = JSON.parse(line);
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            throw new Error("RPC frame must be an object");
+        this.onValue(value);
+    }
+    push(chunk) {
+        const text = this.decoder.write(chunk);
+        let start = 0;
+        for (let end = text.indexOf("\n"); end >= 0; end = text.indexOf("\n", start)) {
+            this.append(text.slice(start, end));
+            this.emit();
+            start = end + 1;
+        }
+        if (start < text.length)
+            this.append(text.slice(start));
+    }
+    end() { this.append(this.decoder.end()); this.emit(); }
+}
+export function harnessEnvironment() {
+    return Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.startsWith("COHUB_") && !["WORKER_SECRET", "DATABASE_URL", "REDIS_URL"].includes(key)));
+}
+export class JsonRpcProcess {
+    mode;
+    child;
+    pending = new Map();
+    listeners = new Set();
+    failureListeners = new Set();
+    failure = null;
+    nextId = 0;
+    stderr = "";
+    closed;
+    closing = null;
+    constructor(binary, args, cwd, mode, context = {}) {
+        this.mode = mode;
+        this.child = spawn(binary, args, { cwd, env: { ...harnessEnvironment(), ...context }, stdio: "pipe", detached: process.platform !== "win32" });
+        this.closed = new Promise((resolve) => this.child.once("close", () => resolve()));
+        const decoder = new JsonLineDecoder((value) => this.receive(value));
+        this.child.stdout.on("data", (chunk) => { try {
+            decoder.push(chunk);
+        }
+        catch (error) {
+            this.fail(error);
+        } });
+        this.child.stdout.on("end", () => { try {
+            decoder.end();
+        }
+        catch (error) {
+            this.fail(error);
+        } });
+        this.child.stderr.on("data", (chunk) => { this.stderr = (this.stderr + chunk.toString()).slice(-8192); });
+        this.child.on("error", (error) => this.fail(error));
+        this.child.stdin.on("error", (error) => this.fail(error));
+        this.child.once("close", (code) => this.fail(new Error(`${binary} exited (${code}): ${this.stderr}`)));
+    }
+    fail(value) {
+        if (this.failure)
+            return;
+        this.failure = value instanceof Error ? value : new Error(String(value));
+        for (const pending of this.pending.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(this.failure);
+        }
+        this.pending.clear();
+        for (const listener of this.failureListeners)
+            listener(this.failure);
+    }
+    receive(value) {
+        const key = value.id == null ? null : String(value.id);
+        const response = this.mode === "pi" ? value.type === "response" : "result" in value || "error" in value;
+        if (key && response) {
+            const pending = this.pending.get(key);
+            if (!pending)
+                return;
+            this.pending.delete(key);
+            clearTimeout(pending.timer);
+            if (value.error || value.success === false)
+                pending.reject(new Error(typeof value.error === "string" ? value.error : String(record(value.error).message ?? "RPC request failed")));
+            else
+                pending.resolve(record(this.mode === "pi" ? value.data : value.result));
+            return;
+        }
+        for (const listener of this.listeners)
+            listener(value);
+    }
+    write(value) {
+        if (this.failure)
+            throw this.failure;
+        const data = `${JSON.stringify(value)}\n`;
+        if (this.child.stdin.writableLength + Buffer.byteLength(data) > RUNTIME_MAX_FRAME_BYTES)
+            throw new Error("RPC input backpressure limit exceeded");
+        this.child.stdin.write(data);
+    }
+    request(method, params = {}, timeoutMs = 30_000) {
+        if (this.failure)
+            return Promise.reject(this.failure);
+        const id = String(++this.nextId);
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => { this.pending.delete(id); reject(new Error(`${method} timed out`)); }, timeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+            try {
+                this.write(this.mode === "pi" ? { ...params, id, type: method } : { id, method, params });
+            }
+            catch (error) {
+                clearTimeout(timer);
+                this.pending.delete(id);
+                reject(error);
+            }
+        });
+    }
+    onEvent(listener) { this.listeners.add(listener); return () => this.listeners.delete(listener); }
+    onFailure(listener) {
+        this.failureListeners.add(listener);
+        if (this.failure)
+            queueMicrotask(() => { if (this.failure && this.failureListeners.has(listener))
+                listener(this.failure); });
+        return () => this.failureListeners.delete(listener);
+    }
+    close() {
+        this.closing ??= this.closeProcessGroup();
+        return this.closing;
+    }
+    async closeProcessGroup() {
+        try {
+            if (this.child.pid)
+                await stopProcessGroup(this.child.pid);
+        }
+        finally {
+            this.child.stdin.destroy();
+            this.child.stdout.destroy();
+            this.child.stderr.destroy();
+            this.fail(new Error("RPC process closed"));
+            this.listeners.clear();
+            this.failureListeners.clear();
+        }
+        await this.closed;
+    }
+}

package/dist/runtime/model-catalog.d.ts

@@ -0,0 +1,6 @@
+import type { RuntimeCapabilities } from "@neta-art/cohub";
+import { type JsonRecord } from "./json-rpc.js";
+type Model = RuntimeCapabilities["models"][number];
+/** Codex's built-in catalog is not authoritative for an arbitrary custom provider. */
+export declare function codexModelCatalog(configResponse: JsonRecord, entries: unknown[]): Model[];
+export {};

package/dist/runtime/model-catalog.js

@@ -0,0 +1,19 @@
+import { record } from "./json-rpc.js";
+/** Codex's built-in catalog is not authoritative for an arbitrary custom provider. */
+export function codexModelCatalog(configResponse, entries) {
+    const config = record(configResponse.config);
+    const provider = typeof config.model_provider === "string" ? config.model_provider : "openai";
+    const configuredModel = typeof config.model === "string" ? config.model : null;
+    const customCatalog = typeof config.model_catalog_json === "string";
+    const catalog = provider !== "openai" && !customCatalog ? [] : entries;
+    const models = catalog.flatMap((value) => {
+        const model = record(value);
+        const id = typeof model.model === "string" ? model.model : typeof model.id === "string" ? model.id : null;
+        if (!id || model.hidden)
+            return [];
+        return [{ harness: "codex", provider, id, name: typeof model.displayName === "string" ? model.displayName : id }];
+    });
+    if (configuredModel && !models.some((model) => model.id === configuredModel))
+        models.unshift({ harness: "codex", provider, id: configuredModel, name: configuredModel });
+    return models;
+}

package/dist/runtime/native-archive.d.ts

@@ -0,0 +1,16 @@
+import { type CodexTokenTotals } from "./codex-usage.js";
+export declare function readCodexArchiveTotals(path: string): Promise<CodexTokenTotals | undefined>;
+/** Change only the header of a working copy. Raw archive bytes remain untouched. */
+export declare function importNativeArchive(input: {
+    source: string;
+    target: string;
+    harness: "pi" | "codex";
+    nativeSessionId: string;
+    id: string;
+    cwd: string;
+    signal?: AbortSignal;
+}): Promise<{
+    checksum: string;
+    nativeSessionId: string;
+    codexTokenTotals: CodexTokenTotals | undefined;
+}>;