@neta-art/cohub-cli 8.1.1 → 8.3.0

package/dist/runtime/native/execution.js

@@ -0,0 +1,337 @@
+import { imageForPi } from "../harness.js";
+import { JsonRpcProcess, record } from "../json-rpc.js";
+import { ProcessCleanupUncertainError } from "../process-group.js";
+import { serializeDiagnosticError } from "../diagnostics.js";
+import { openPrivateServer } from "./codex-link.js";
+import { PI_DISCONNECTED } from "./pi-link.js";
+import { codexTranslator, piTranslator } from "./translate.js";
+const text = (value) => typeof value === "string" ? value : "";
+/** A stop request that the harness does not honour within this long ends its private process. */
+const ABORT_ESCALATION_MS = 5_000;
+/** Pause before asking a busy Pi again, so a Turn that is starting has reported itself. */
+const PI_BUSY_RETRY_MS = 100;
+/**
+ * Run one Cohub Turn in a local harness. Both harnesses are driven through the same interface a
+ * terminal user shares: Pi through the Cohub extension inside the Pi process, Codex through its
+ * app-server.
+ */
+export async function executeTurn(executor, input, emit, signal, requestId, context) {
+    signal.throwIfAborted();
+    const diverged = await executor.results.admit(input);
+    const turn = { input, emit, signal, diverged, started: (session) => executor.results.start(session, input, requestId) };
+    const run = await (input.harness === "pi" ? runPi : runCodex)(executor, turn, context);
+    let uncertainCleanup;
+    if (run.host)
+        uncertainCleanup = await closeHost(run.host, run.message.errorMessage);
+    const message = signal.aborted ? { ...run.message, stopReason: "aborted" } : run.message;
+    const archive = await executor.archives.stage({ sessionId: input.sessionId, harness: input.harness, nativeSessionId: run.session.nativeSessionId, path: run.session.path }, input.turnId).catch((error) => {
+        // A missing archive only costs cross-machine native resume; the file itself is intact.
+        executor.diagnostics?.log("warn", "archive.capture_failed", { error: serializeDiagnosticError(error) }, { ...context, component: "archive" });
+        return null;
+    });
+    executor.ingest.advance(run.session.path, input.turnId);
+    return { session: run.session, event: { type: "turn.end", message, resume: run.resume, archive }, ...(uncertainCleanup ? { uncertainCleanup } : {}) };
+}
+/** Variables a Turn's tools see, so a `cohub` call inside a tool knows where it runs. */
+const turnEnvironment = (input) => ({ COHUB_SPACE_ID: input.spaceId, COHUB_SESSION_ID: input.sessionId, COHUB_TURN_ID: input.turnId });
+async function runPi(executor, turn, context) {
+    const { input, signal } = turn;
+    if (input.accessMode === "read_only")
+        throw new Error("Pi cannot enforce read-only access; select Cohub or Codex");
+    // Cohub drives every Pi through its extension, which needs the control socket and a recent Pi.
+    if (executor.pi.unavailable)
+        throw new Error(executor.pi.unavailable);
+    const prepared = await executor.sessions.prepare({
+        sessionId: input.sessionId, turnId: input.turnId, harness: "pi", cwd: executor.cwd,
+        provider: input.provider, context: input.context, signal,
+        // A terminal Pi is continued only through its extension; without one it is read-only.
+        resumable: (transcript) => transcript.path !== turn.diverged && (transcript.origin === "cohub" || executor.pi.find(transcript.nativeSessionId) !== null),
+    });
+    let session = prepared.session;
+    let link = executor.pi.find(session.nativeSessionId);
+    let host = null;
+    let message = { ordinal: 0, content: [] };
+    let begun = false;
+    try {
+        if (!link) {
+            host = new JsonRpcProcess(executor.executables.pi || "pi", ["--mode", "rpc", "--session", session.path, "-e", executor.piExtension], executor.cwd, "pi", turnEnvironment(input));
+            watchHost(host, executor.diagnostics, context);
+            const rpc = host;
+            // Nobody is at this Pi's terminal to answer an extension's question.
+            rpc.onEvent((event) => {
+                if (event.type === "extension_ui_request" && ["confirm", "select", "input", "editor"].includes(text(event.method)))
+                    rpc.write({ type: "extension_ui_response", id: event.id, cancelled: true });
+            });
+            await configurePiHost(host, input);
+            link = await Promise.race([
+                executor.pi.waitFor({ sessionId: session.nativeSessionId, sessionFile: session.path }, signal),
+                new Promise((_, reject) => host?.onFailure(reject)),
+            ]);
+        }
+        const piSession = link;
+        session = { ...session, nativeSessionId: piSession.sessionId };
+        // Never interleave with a Turn a terminal user is running; follow it instead.
+        await executor.pi.idle(piSession.sessionId, signal);
+        const content = await piPrompt(input);
+        signal.throwIfAborted();
+        await turn.started(session);
+        begun = true;
+        const translator = piTranslator(turn.emit);
+        const model = !host && input.model && input.provider ? { provider: input.provider, id: input.model } : null;
+        await new Promise((resolve, reject) => {
+            let escalation;
+            /** Events held until Pi takes the prompt; until then they belong to a terminal Turn. */
+            let held = [];
+            let done = false;
+            const finish = (error) => {
+                if (done)
+                    return;
+                done = true;
+                off();
+                signal.removeEventListener("abort", abort);
+                clearTimeout(escalation);
+                if (error)
+                    reject(error);
+                else
+                    resolve();
+            };
+            const feed = (event) => {
+                try {
+                    if (translator.push(event))
+                        finish();
+                }
+                catch (error) {
+                    finish(error);
+                }
+            };
+            const off = executor.pi.subscribe(piSession.sessionId, (event) => {
+                if (event.type === PI_DISCONNECTED) {
+                    finish(new Error("Pi exited during the Turn"));
+                    return;
+                }
+                if (held)
+                    held.push(event);
+                else
+                    feed(event);
+            });
+            const abort = () => {
+                // Not taken yet: the Pi is running someone else's Turn, which is not Cohub's to stop.
+                if (held) {
+                    finish(signal.reason ?? new Error("Aborted"));
+                    return;
+                }
+                void executor.pi.abort(piSession.sessionId).catch(() => undefined);
+                if (host)
+                    escalation = setTimeout(() => void host?.close().catch(() => undefined), ABORT_ESCALATION_MS);
+            };
+            signal.addEventListener("abort", abort, { once: true });
+            void (async () => {
+                for (;;) {
+                    // Only what follows this request can be this Turn's.
+                    held = [];
+                    const { accepted } = await executor.pi.prompt(piSession.sessionId, { turnId: input.turnId, content, model, thinkingLevel: host ? null : input.thinkingLevel ?? null, env: turnEnvironment(input) });
+                    if (accepted)
+                        break;
+                    // The terminal started a Turn first: wait for it to settle, then ask again.
+                    await new Promise((resolve) => setTimeout(resolve, PI_BUSY_RETRY_MS));
+                    await executor.pi.idle(piSession.sessionId, signal);
+                    if (done)
+                        return;
+                }
+                const events = held ?? [];
+                held = null;
+                if (done) {
+                    void executor.pi.abort(piSession.sessionId).catch(() => undefined);
+                    return;
+                }
+                for (const event of events)
+                    feed(event);
+                if (signal.aborted)
+                    abort();
+            })().catch(finish);
+            if (signal.aborted)
+                abort();
+        });
+        message = translator.last();
+        // The Pi keeps running for its terminal user; its tools no longer work for this Turn.
+        if (!host)
+            void executor.pi.context(piSession.sessionId, { COHUB_TURN_ID: null }).catch(() => undefined);
+    }
+    catch (error) {
+        // Before the prompt, nothing ran and the error is the outcome.
+        if (!begun) {
+            if (host)
+                await closeHost(host, null).catch(() => undefined);
+            throw error;
+        }
+        message = { ...message, stopReason: signal.aborted ? "aborted" : "error", errorMessage: signal.aborted ? null : error instanceof Error ? error.message : String(error) };
+    }
+    return { session, resume: prepared.resume, message, host };
+}
+/** A Pi that Cohub starts is configured through its RPC before the extension takes the prompt. */
+async function configurePiHost(host, input) {
+    if (input.model) {
+        let provider = input.provider;
+        if (!provider) {
+            const catalog = await host.request("get_available_models");
+            const matches = (Array.isArray(catalog.models) ? 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 host.request("set_model", { provider, modelId: input.model });
+    }
+    if (input.thinkingLevel)
+        await host.request("set_thinking_level", { level: input.thinkingLevel });
+}
+async function piPrompt(input) {
+    const blocks = input.messages.flatMap((message) => message.content);
+    return await Promise.all(blocks.map(async (block) => {
+        if (block.type === "image")
+            return await imageForPi(block);
+        return { type: "text", text: block.type === "text" ? block.text : JSON.stringify(block) };
+    }));
+}
+async function runCodex(executor, turn, context) {
+    const { input, signal } = turn;
+    const shared = await executor.codex.get();
+    const prepared = await executor.sessions.prepare({
+        sessionId: input.sessionId, turnId: input.turnId, harness: "codex", cwd: executor.cwd,
+        provider: input.provider, context: input.context, signal,
+        // Only the shared server coordinates with terminal clients; a private one never opens their files.
+        resumable: (transcript) => transcript.path !== turn.diverged && (transcript.origin === "cohub" || shared !== null),
+    });
+    let session = prepared.session;
+    let host = null;
+    let channel = shared;
+    let message = { ordinal: 0, content: [] };
+    let begun = false;
+    try {
+        if (!channel) {
+            host = new JsonRpcProcess(executor.executables.codex || "codex", ["app-server", "--listen", "stdio://"], executor.cwd, "codex", turnEnvironment(input));
+            watchHost(host, executor.diagnostics, context);
+            channel = await openPrivateServer(host);
+        }
+        const codex = channel;
+        const threadOptions = {
+            cwd: executor.cwd,
+            ...(input.model ? { model: input.model } : {}),
+            ...(input.provider && input.provider !== "codex" ? { modelProvider: input.provider } : {}),
+            ...(input.accessMode === "read_only" ? { sandbox: "read-only" } : {}),
+            // Tools of a shared server otherwise see the environment of whoever started that server.
+            config: { "shell_environment_policy.set.COHUB_SPACE_ID": input.spaceId, "shell_environment_policy.set.COHUB_SESSION_ID": input.sessionId },
+        };
+        const existing = { ...threadOptions, threadId: session.nativeSessionId, path: session.path, excludeTurns: true };
+        const opened = prepared.resume === "new" ? await codex.request("thread/start", threadOptions)
+            : prepared.resume === "restored" ? await codex.request("thread/fork", existing)
+                : await codex.request("thread/resume", existing);
+        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");
+        const threadId = thread.id;
+        if (thread.path !== session.path || threadId !== session.nativeSessionId) {
+            session = { ...session, nativeSessionId: threadId, path: thread.path };
+            executor.ingest.adopt(session, input.sessionId);
+        }
+        const translator = codexTranslator(turn.emit, { provider: text(opened.modelProvider) || "codex", model: text(opened.model) || input.model || null });
+        const content = await codexPrompt(input);
+        signal.throwIfAborted();
+        await turn.started(session);
+        begun = true;
+        let nativeTurnId = null;
+        executor.codex.driving.add(threadId);
+        await new Promise((resolve, reject) => {
+            let escalation;
+            let done = false;
+            const finish = (error) => {
+                if (done)
+                    return;
+                done = true;
+                off();
+                offClose();
+                signal.removeEventListener("abort", abort);
+                clearTimeout(escalation);
+                if (error)
+                    reject(error);
+                else
+                    resolve();
+            };
+            const interrupt = () => { if (nativeTurnId)
+                void codex.request("turn/interrupt", { threadId, turnId: nativeTurnId }).catch(() => undefined); };
+            const off = codex.onEvent((event) => {
+                const params = event.params;
+                if (event.id != null) {
+                    // An unattended Cohub Turn never grants an escalation.
+                    if (!codex.shared || params.threadId === threadId && (!nativeTurnId || params.turnId === nativeTurnId))
+                        codex.refuse(event.id, "Approval requires an interactive local client");
+                    return;
+                }
+                if (params.threadId !== threadId)
+                    return;
+                // A resumed thread replays its last usage; only this Turn's counts belong to it.
+                if (event.method === "thread/tokenUsage/updated" && params.turnId !== nativeTurnId)
+                    return;
+                if (event.method === "turn/started" && !nativeTurnId) {
+                    nativeTurnId = text(record(params.turn).id) || null;
+                    if (signal.aborted)
+                        interrupt();
+                }
+                if (event.method === "turn/completed" && nativeTurnId && text(record(params.turn).id) !== nativeTurnId)
+                    return;
+                try {
+                    if (translator.push(event))
+                        finish();
+                }
+                catch (error) {
+                    finish(error);
+                }
+            });
+            const offClose = codex.onClose((error) => finish(error));
+            const abort = () => {
+                interrupt();
+                if (host)
+                    escalation = setTimeout(() => void host?.close().catch(() => undefined), ABORT_ESCALATION_MS);
+            };
+            signal.addEventListener("abort", abort, { once: true });
+            codex.request("turn/start", { threadId, clientUserMessageId: input.turnId, input: content, ...(input.thinkingLevel ? { effort: input.thinkingLevel } : {}) })
+                .then((result) => { nativeTurnId ??= text(record(result.turn).id) || null; if (signal.aborted)
+                interrupt(); })
+                .catch(finish);
+        }).finally(() => executor.codex.driving.delete(threadId));
+        message = translator.last();
+    }
+    catch (error) {
+        if (!begun) {
+            if (host)
+                await closeHost(host, null).catch(() => undefined);
+            throw error;
+        }
+        message = { ...message, stopReason: signal.aborted ? "aborted" : "error", errorMessage: signal.aborted ? null : error instanceof Error ? error.message : String(error) };
+    }
+    return { session, resume: prepared.resume, message, host };
+}
+async function codexPrompt(input) {
+    return 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: [] };
+    }));
+}
+function watchHost(host, diagnostics, context) {
+    if (!diagnostics)
+        return;
+    host.onFailure((error) => diagnostics.log("error", "harness.rpc_process_failed", { error: serializeDiagnosticError(error) }, { ...context, component: "harness" }));
+    host.onTimeout((method, timeoutMs) => diagnostics.log("error", "harness.rpc_timeout", { method, timeoutMs }, { ...context, component: "harness" }));
+}
+/** Close a harness process Cohub started. An unconfirmable cleanup marks the result uncertain; it never masks it. */
+async function closeHost(host, executionError) {
+    return await host.close().then(() => undefined, (cleanupError) => {
+        const processGroupId = host.processGroupId;
+        if (!(cleanupError instanceof ProcessCleanupUncertainError) || processGroupId == null)
+            throw cleanupError;
+        const detail = executionError ? `; execution error: ${executionError}` : "";
+        return { processGroupId, error: `${cleanupError.message}${detail}` };
+    });
+}

package/dist/runtime/native/identity.d.ts

@@ -0,0 +1,9 @@
+/** Deterministic UUID-shaped id. A native Turn always names the same cloud Turn. */
+export declare function nativeStableId(value: string): string;
+/**
+ * Cloud Turn id of a native Turn. A transcript can reach more than one Space (a directory rebound
+ * to another Space, or another account), so the Space is part of the identity; within it, Codex
+ * Turn ids are globally unique (a fork shares its history's Turns) and Pi entry ids are per
+ * session.
+ */
+export declare function nativeTurnId(spaceId: string, harness: "pi" | "codex", nativeSessionId: string, turnKey: string): string;

package/dist/runtime/native/identity.js

@@ -0,0 +1,15 @@
+import { createHash } from "node:crypto";
+/** Deterministic UUID-shaped id. A native Turn always names the same cloud Turn. */
+export function nativeStableId(value) {
+    const hex = createHash("sha256").update(value).digest("hex");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-5${hex.slice(13, 16)}-a${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
+}
+/**
+ * Cloud Turn id of a native Turn. A transcript can reach more than one Space (a directory rebound
+ * to another Space, or another account), so the Space is part of the identity; within it, Codex
+ * Turn ids are globally unique (a fork shares its history's Turns) and Pi entry ids are per
+ * session.
+ */
+export function nativeTurnId(spaceId, harness, nativeSessionId, turnKey) {
+    return nativeStableId(JSON.stringify(harness === "pi" ? ["native", spaceId, "pi", nativeSessionId, turnKey] : ["native", spaceId, "codex", turnKey]));
+}

package/dist/runtime/native/ingest.d.ts

@@ -0,0 +1,241 @@
+import { type NativeIngestResult, type NativeRuntimeEvent } from "@neta-art/cohub";
+import { type Harness } from "./adapters.js";
+import type { RuntimeArchiveStore } from "../archive-store.js";
+export declare const DEFAULT_IMPORT_CONCURRENCY = 4;
+export declare const MAX_IMPORT_CONCURRENCY = 8;
+export type TranscriptState = {
+    harness: Harness;
+    path: string;
+    nativeSessionId: string;
+    cwd: string;
+    threadKind: "user" | "internal" | "spawned";
+    size: number;
+    mtimeMs: number;
+    ino: number;
+    scannedBytes: number;
+    throughTurnKey: string | null;
+    throughTurnId: string | null;
+    sessionId: string | null;
+    runningTurnId: string | null;
+    runningTurnKey: string | null;
+    headTurnId: string | null;
+    origin: "cohub" | "native";
+    controllable?: boolean;
+};
+export type ImportFilter = {
+    harnesses?: Harness[];
+    nativeSessionId?: string;
+};
+/** A backfill of conversations that predate sync. Persisted so a restart resumes it. */
+export type ImportJob = {
+    state: "idle" | "running" | "paused" | "done";
+    filter: ImportFilter;
+    concurrency: number;
+    files: number;
+    done: number;
+    turns: number;
+    bytes: number;
+    totalBytes: number;
+    startedAt: string | null;
+    failed: Array<{
+        path: string;
+        message: string;
+    }>;
+};
+export type IngestTransport = {
+    ingest(event: Extract<NativeRuntimeEvent, {
+        type: "ingest";
+    }>, options?: {
+        signal?: AbortSignal;
+    }): Promise<NativeIngestResult>;
+    known(turnIds: string[], options?: {
+        signal?: AbortSignal;
+    }): Promise<Array<{
+        turnId: string;
+        sessionId: string;
+        settled: boolean;
+    }>>;
+    progress(event: Extract<NativeRuntimeEvent, {
+        type: "progress";
+    }>, options?: {
+        signal?: AbortSignal;
+    }): Promise<{
+        accepted?: boolean;
+        resync?: boolean;
+    } | unknown>;
+    status(sessionId: string, turnId: string, controllable?: boolean, options?: {
+        signal?: AbortSignal;
+    }): Promise<{
+        abortRequested: boolean;
+        status?: string;
+    }>;
+};
+export type IngestHooks = {
+    /**
+     * Control-plane certainty about a Pi session's file as last written at `mtimeMs`: `true` when the
+     * agent settled after that write, `false` while it runs, `null` when the control plane cannot
+     * tell.
+     */
+    piSettled?: (nativeSessionId: string, mtimeMs: number) => boolean | null;
+    controllable?: (state: TranscriptState) => boolean;
+    abortTurn?: (state: TranscriptState) => void;
+    onGrowth?: (state: TranscriptState) => void;
+    onRunning?: (state: TranscriptState, turnId: string | null) => void;
+    onError?: (error: unknown, context: {
+        path: string;
+        harness: Harness;
+    }) => void;
+};
+/** A transcript on disk that may belong to the bound directory. */
+export type NativeCandidate = {
+    harness: Harness;
+    path: string;
+    size: number;
+    mtimeMs: number;
+    ino: number;
+};
+/** Whether a session in `cwd` belongs to the directory bound at `root`. */
+export declare const owns: (root: string, cwd: string, nested?: readonly string[]) => boolean;
+/** Every transcript of the bound directory and its subdirectories, newest first. */
+export declare function discoverTranscripts(cwd: string, harnesses: Harness[], options?: {
+    headers?: boolean;
+    nested?: readonly string[];
+    signal?: AbortSignal;
+}): Promise<Array<NativeCandidate & {
+    nativeSessionId?: string;
+}>>;
+/**
+ * The daemon's data plane. A harness's transcript is both the durable record of a conversation and
+ * the local outbox.
+ */
+export declare class NativeIngest {
+    private readonly options;
+    private readonly states;
+    private readonly live;
+    private readonly busy;
+    private readonly reads;
+    private readonly timers;
+    private readonly failures;
+    private readonly aliveAt;
+    private readonly runningPaths;
+    private writing;
+    private readonly foreign;
+    private importQueue;
+    private runningLive;
+    private runningImport;
+    private job;
+    private stopped;
+    private readonly dirty;
+    private jobDirty;
+    private journalLines;
+    private writeTimer;
+    private readonly watchers;
+    private transport;
+    private harnesses;
+    private enabledAt;
+    private watching;
+    private nested;
+    constructor(options: {
+        spaceId: string;
+        cwd: string;
+        harnesses: Harness[];
+        enabledAt: string;
+        root: string;
+        archives: RuntimeArchiveStore;
+        hooks?: IngestHooks;
+    });
+    owns(cwd: string): boolean;
+    exclude(nested: string[]): void;
+    configure(harnesses: Harness[], enabledAt: string): void;
+    private get ledgerPath();
+    load(): Promise<void>;
+    connect(transport: IngestTransport | null): void;
+    /**
+     * Record that Cohub created or chose this transcript for a Session, before any Turn of it runs.
+     */
+    adopt(session: {
+        harness: Harness;
+        path: string;
+        nativeSessionId: string;
+        cwd: string;
+    }, sessionId: string, through?: {
+        turnKey: string | null;
+        turnId: string | null;
+    }): void;
+    advance(path: string, turnId: string): void;
+    touch(path: string): void;
+    running(harness: Harness, nativeSessionId: string): TranscriptState | null;
+    stop(sessionId: string, turnId: string): boolean;
+    alive(harness: Harness, nativeSessionId: string): void;
+    /**
+     * A native client came or went, so whether Cohub can stop this session's running Turn may have
+     * changed.
+     */
+    controlChanged(harness: Harness, nativeSessionId: string): void;
+    status(): {
+        transcripts: number;
+        live: number;
+        running: number;
+        import: {
+            state: "idle" | "running" | "paused" | "done";
+            filter: ImportFilter;
+            concurrency: number;
+            files: number;
+            done: number;
+            turns: number;
+            bytes: number;
+            totalBytes: number;
+            startedAt: string | null;
+            failed: Array<{
+                path: string;
+                message: string;
+            }>;
+            queued: number;
+            running: number;
+        };
+    };
+    transcriptFor(sessionId: string, harness: Harness, headTurnId: string | null): TranscriptState | null;
+    scan(): Promise<void>;
+    plan(filter?: ImportFilter, signal?: AbortSignal): Promise<Array<NativeCandidate & {
+        nativeSessionId?: string;
+    }>>;
+    /**
+     * Start or resume a backfill. What was imported is tracked, so resuming simply plans again; the
+     * server recognizes any Turn it already has, so an interrupted batch is never duplicated.
+     */
+    startImport(filter?: ImportFilter, concurrency?: number): Promise<ImportJob>;
+    pauseImport(): ImportJob;
+    watch(signal: AbortSignal): Promise<void>;
+    private watchHarness;
+    private resync;
+    private reportControl;
+    close(signal: AbortSignal): Promise<void>;
+    private unchanged;
+    private drainLive;
+    private retryLater;
+    private drainImport;
+    private report;
+    private sync;
+    private read;
+    private crossesBoundary;
+    private blank;
+    private harnessFor;
+    private tailSettled;
+    private recheck;
+    private known;
+    private apply;
+    private markRunning;
+    private endRunning;
+    private cutOff;
+    private imported;
+    private archive;
+    private message;
+    private complete;
+    private markDirty;
+    private markJobDirty;
+    private scheduleWrite;
+    private write;
+    private append;
+    private overgrown;
+    private compact;
+}