@neta-art/cohub-cli 8.2.0 → 8.3.1

package/dist/runtime/native/codex-link.js

@@ -0,0 +1,249 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import WebSocket from "ws";
+import { harnessEnvironment, record } from "../json-rpc.js";
+import { atLeast, harnessVersion } from "./version.js";
+/** First Codex release whose terminal client attaches to a shared app-server by default. */
+export const CODEX_SHARED_MIN_VERSION = [0, 156, 0];
+const REQUEST_TIMEOUT_MS = 60_000;
+const JOIN_ATTEMPTS = 20;
+const JOIN_RETRY_MS = 100;
+/** `codex app-server daemon start` returns once the server listens; anything slower has failed. */
+const DAEMON_START_TIMEOUT_MS = 30_000;
+const codexHome = () => process.env.CODEX_HOME?.trim() || join(homedir(), ".codex");
+/** The socket every Codex client on this machine discovers; a terminal `codex` attaches to it. */
+const codexControlSocket = () => join(codexHome(), "app-server-control", "app-server-control.sock");
+export const supportsSharedServer = (version) => atLeast(version, CODEX_SHARED_MIN_VERSION);
+/** Start the shared app-server when none is running. */
+async function ensureSharedServer(binary, cwd) {
+    if (existsSync(codexControlSocket()) && await probe())
+        return true;
+    const child = spawn(binary, ["app-server", "daemon", "start"], { cwd, env: harnessEnvironment(), stdio: ["ignore", "pipe", "ignore"], detached: true });
+    let output = "";
+    child.stdout.on("data", (bytes) => { output += bytes.toString("utf8"); });
+    // `exit`, not `close`: the server it forks may inherit stdout and keep the pipe open for good.
+    const timer = setTimeout(() => child.kill(), DAEMON_START_TIMEOUT_MS);
+    const ended = new Promise((resolve) => child.stdout.once("end", resolve));
+    const code = await new Promise((resolve) => { child.once("exit", resolve); child.once("error", () => resolve(null)); })
+        .finally(() => clearTimeout(timer));
+    // Its last output may still be buffered when it exits; a pipe that stays open is let go.
+    await Promise.race([ended, new Promise((resolve) => setTimeout(resolve, 1_000).unref())]);
+    child.stdout.destroy();
+    if (code !== 0)
+        return false;
+    try {
+        return ["started", "alreadyRunning", "already_running"].includes(String(JSON.parse(output.trim().split("\n").at(-1) ?? "{}").status)) && await probe();
+    }
+    catch {
+        return false;
+    }
+}
+async function probe() {
+    try {
+        const channel = await openShared();
+        await channel.close();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function openShared() {
+    const socket = new WebSocket(`ws+unix://${codexControlSocket()}:/`);
+    await new Promise((resolve, reject) => {
+        socket.once("open", () => resolve());
+        socket.once("error", reject);
+    });
+    const channel = new SocketChannel(socket);
+    await initialize(channel);
+    return channel;
+}
+/** A private app-server over stdio, used when no shared one is available; it lives for one Turn. */
+export async function openPrivateServer(rpc) {
+    const channel = new StdioChannel(rpc);
+    await initialize(channel);
+    return channel;
+}
+/** The Runtime's connection to the shared app-server. */
+export class CodexShared {
+    binary;
+    cwd;
+    enabled;
+    channel = null;
+    opening = null;
+    ensured = false;
+    connectListeners = new Set();
+    driving = new Set();
+    constructor(binary, cwd, enabled) {
+        this.binary = binary;
+        this.cwd = cwd;
+        this.enabled = enabled;
+    }
+    async get() {
+        if (!this.enabled)
+            return null;
+        if (this.channel && !this.channel.closed)
+            return this.channel;
+        this.opening ??= (async () => {
+            if (!this.ensured) {
+                this.ensured = true;
+                if (!supportsSharedServer(await harnessVersion(this.binary)) || !await ensureSharedServer(this.binary, this.cwd))
+                    return null;
+            }
+            const channel = await openShared();
+            this.channel = channel;
+            for (const listener of this.connectListeners)
+                listener(channel);
+            return channel;
+        })().catch(() => null).finally(() => { this.opening = null; });
+        return await this.opening;
+    }
+    onConnect(listener) {
+        this.connectListeners.add(listener);
+        return () => { this.connectListeners.delete(listener); };
+    }
+    async join(threadId) {
+        const channel = await this.get();
+        return channel ? await joinThread(channel, threadId) : null;
+    }
+    async interrupt(threadId, turnId) {
+        const channel = await this.get();
+        if (!channel)
+            return false;
+        await joinThread(channel, threadId);
+        await channel.request("turn/interrupt", { threadId, turnId });
+        return true;
+    }
+    async close() {
+        await this.channel?.close();
+        this.channel = null;
+    }
+}
+async function initialize(channel) {
+    await channel.request("initialize", { clientInfo: { name: "cohub-runtime", title: "Cohub", version: "1" }, capabilities: { experimentalApi: true } });
+    // The notification completes the handshake; responses are not expected.
+    channel.notify("initialized");
+}
+class SocketChannel {
+    socket;
+    shared = true;
+    pending = new Map();
+    listeners = new Set();
+    closeListeners = new Set();
+    counter = 0;
+    closedError = null;
+    constructor(socket) {
+        this.socket = socket;
+        socket.on("message", (data) => {
+            let message;
+            try {
+                message = record(JSON.parse(String(data)));
+            }
+            catch {
+                return;
+            }
+            const id = message.id;
+            if (id != null && ("result" in message || "error" in message)) {
+                const pending = this.pending.get(String(id));
+                if (!pending)
+                    return;
+                this.pending.delete(String(id));
+                clearTimeout(pending.timer);
+                if (message.error)
+                    pending.reject(new Error(String(record(message.error).message ?? "Codex request failed")));
+                else
+                    pending.resolve(record(message.result));
+                return;
+            }
+            if (typeof message.method !== "string")
+                return;
+            const event = { method: message.method, params: record(message.params), ...(id != null ? { id: id } : {}) };
+            for (const listener of this.listeners)
+                listener(event);
+        });
+        socket.on("close", () => this.fail(new Error("Codex app-server disconnected")));
+        socket.on("error", (error) => this.fail(error instanceof Error ? error : new Error(String(error))));
+    }
+    get closed() { return this.closedError !== null; }
+    fail(error) {
+        if (this.closedError)
+            return;
+        this.closedError = error;
+        for (const pending of this.pending.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+        this.pending.clear();
+        for (const listener of this.closeListeners)
+            listener(error);
+        this.closeListeners.clear();
+    }
+    request(method, params = {}, timeoutMs = REQUEST_TIMEOUT_MS) {
+        if (this.closedError)
+            return Promise.reject(this.closedError);
+        const id = `cohub-${++this.counter}`;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => { this.pending.delete(id); reject(new Error(`Codex ${method} timed out`)); }, timeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+            this.socket.send(JSON.stringify({ id, method, params }));
+        });
+    }
+    notify(method, params = {}) { this.socket.send(JSON.stringify({ method, params })); }
+    refuse(id, message) { if (!this.closedError)
+        this.socket.send(JSON.stringify({ id, error: { code: -32000, message } })); }
+    onEvent(listener) { this.listeners.add(listener); return () => { this.listeners.delete(listener); }; }
+    onClose(listener) {
+        if (this.closedError) {
+            const error = this.closedError;
+            queueMicrotask(() => listener(error));
+            return () => undefined;
+        }
+        this.closeListeners.add(listener);
+        return () => { this.closeListeners.delete(listener); };
+    }
+    async close() { this.fail(new Error("Codex app-server connection closed")); this.socket.close(); }
+}
+class StdioChannel {
+    rpc;
+    shared = false;
+    failed = false;
+    constructor(rpc) {
+        this.rpc = rpc;
+        rpc.onFailure(() => { this.failed = true; });
+    }
+    get closed() { return this.failed; }
+    request(method, params = {}, timeoutMs) { return this.rpc.request(method, params, timeoutMs); }
+    notify(method, params = {}) { this.rpc.write({ method, params }); }
+    refuse(id, message) { try {
+        this.rpc.write({ id, error: { code: -32000, message } });
+    }
+    catch { /* The process is gone. */ } }
+    onClose(listener) { return this.rpc.onFailure(listener); }
+    onEvent(listener) {
+        return this.rpc.onEvent((event) => {
+            if (typeof event.method !== "string")
+                return;
+            listener({ method: event.method, params: record(event.params), ...(event.id != null ? { id: event.id } : {}) });
+        });
+    }
+    async close() { await this.rpc.close(); }
+}
+/**
+ * Join a thread that another client runs. A thread's rollout is written when its first Turn starts,
+ * so a join that arrives a moment early is retried briefly instead of failing the observation.
+ */
+async function joinThread(channel, threadId) {
+    let lastError;
+    for (let attempt = 0; attempt < JOIN_ATTEMPTS; attempt += 1) {
+        try {
+            return await channel.request("thread/resume", { threadId });
+        }
+        catch (error) {
+            lastError = error;
+            await new Promise((resolve) => setTimeout(resolve, JOIN_RETRY_MS));
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error("Cannot join the Codex thread");
+}

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

@@ -0,0 +1,16 @@
+import type { Harness } from "./adapters.js";
+/** Private state of one Space's Runtime on this machine. */
+export declare const runtimeStateRoot: (spaceId: string, base?: string) => string;
+/** What the user agreed to for native sessions in the bound directory. */
+export type NativeConfig = {
+    version: 2;
+    identity: string;
+    spaceId: string;
+    root: string;
+    harnesses: Harness[];
+    enabledAt: string;
+    codexShared: boolean;
+};
+export declare const nativeConfigPath: (stateRoot: string) => string;
+export declare function readNativeConfig(stateRoot: string, identity: string): Promise<NativeConfig | null>;
+export declare function writeNativeConfig(stateRoot: string, config: NativeConfig): Promise<void>;

package/dist/runtime/native/config.js

@@ -0,0 +1,24 @@
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { atomicRuntimeJson } from "../archive-store.js";
+/** Private state of one Space's Runtime on this machine. */
+export const runtimeStateRoot = (spaceId, base = join(homedir(), ".local", "state", "cohub", "runtime")) => join(base, spaceId);
+export const nativeConfigPath = (stateRoot) => join(stateRoot, "native", "config.json");
+export async function readNativeConfig(stateRoot, identity) {
+    try {
+        const config = JSON.parse(await readFile(nativeConfigPath(stateRoot), "utf8"));
+        if (config.version !== 2 || !Array.isArray(config.harnesses) || typeof config.enabledAt !== "string")
+            throw new Error("Invalid native sync configuration");
+        // Another account's consent never applies.
+        return config.identity === identity ? config : null;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+export async function writeNativeConfig(stateRoot, config) {
+    await atomicRuntimeJson(nativeConfigPath(stateRoot), config);
+}

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

@@ -0,0 +1,88 @@
+import type { NativeRuntimeEvent } from "@neta-art/cohub";
+import type { RuntimeArchiveStore } from "../archive-store.js";
+import { type RuntimeDiagnostics } from "../diagnostics.js";
+import type { HarnessOptions } from "../harness.js";
+import type { SessionTurnProjectionClient } from "../turn-projection.js";
+import { type Harness } from "./adapters.js";
+import { type NativeConfig } from "./config.js";
+import type { Executor } from "./execution.js";
+import { NativeIngest, type ImportJob } from "./ingest.js";
+import { type PiExtensionState } from "./install.js";
+export type NativeStatus = {
+    synced: Harness[];
+    transcripts: number;
+    running: number;
+    pi: {
+        extension: PiExtensionState;
+        connected: number;
+        unavailable: string | null;
+    } | null;
+    codex: {
+        control: "shared" | "private";
+        watching: number;
+    } | null;
+    import: ImportJob & {
+        queued: number;
+        running: number;
+    };
+};
+/**
+ * Everything the Runtime does with native sessions: the ingest engine (data plane), the Pi and
+ * Codex links (control plane), and the executor that runs Cohub Turns through them.
+ */
+export declare class NativeRuntime {
+    private readonly options;
+    readonly ingest: NativeIngest;
+    readonly executor: Executor;
+    private readonly pi;
+    private readonly codex;
+    private readonly streams;
+    private readonly filePreviews;
+    private readonly watched;
+    private readonly active;
+    private send;
+    private extension;
+    constructor(options: {
+        spaceId: string;
+        root: string;
+        stateRoot: string;
+        harnesses: Harness[];
+        executables: HarnessOptions;
+        identity: string;
+        config: NativeConfig | null;
+        archives: RuntimeArchiveStore;
+        projectionSource: SessionTurnProjectionClient;
+        diagnostics: RuntimeDiagnostics;
+    });
+    private get synced();
+    start(signal: AbortSignal): Promise<void>;
+    connect(send: ((event: NativeRuntimeEvent) => Promise<unknown>) | null): void;
+    stop(sessionId: string, turnId: string): boolean;
+    status(): NativeStatus;
+    control(action: string, message: Record<string, unknown>): Promise<unknown>;
+    private reload;
+    private refreshScope;
+    close(signal: AbortSignal): Promise<void>;
+    private sink;
+    /**
+     * A connected Pi. A user prompt starting and the agent settling are the two moments its file has
+     * something to persist; everything between streams as a preview of a Turn someone runs there.
+     */
+    private onPiEvent;
+    private stream;
+    private endStream;
+    private endFilePreview;
+    private observeCodex;
+    private watchCodexThread;
+    private onCodexEvent;
+    /**
+     * A terminal Pi runs many Turns in one process; once the ledger knows which one is running, its
+     * tools are told, so a `cohub` call from a tool names the right Space, Session and Turn.
+     */
+    private onRunning;
+    /**
+     * A running Turn's file grew. A connected client streams it already; otherwise the preview is
+     * read from the file, at a pace set by a timer, not by every write.
+     */
+    private onGrowth;
+}