@neta-art/cohub-cli 10.8.1 → 10.8.3

package/dist/board-kernel.js

@@ -32153,6 +32153,10 @@ async function loadCanvasModule() {
 		throw new Error("Board image export needs the optional '@napi-rs/canvas' package. Install it with: npm i @napi-rs/canvas", { cause });
 	}
 }
+function installDOMMatrix(canvasModule) {
+	const globals = globalThis;
+	globals.DOMMatrix ??= canvasModule.DOMMatrix;
+}
 function installAnimationFrameShim() {
 	const globals = globalThis;
 	if (globals.requestAnimationFrame) return () => {};
@@ -32207,6 +32211,7 @@ async function createNodeBoardRenderer(options = {}) {
 			throw new Error("XML parsing is not available in Node board export.");
 		}
 	});
+	installDOMMatrix(canvasModule);
 	installBoardTextMeasurement();
 	const restoreAnimationFrame = installAnimationFrameShim();
 	const renderer = new CanvasRenderer();

package/dist/runtime/harnesses/codex.js

@@ -4,7 +4,7 @@ import { projectNativeSession } from "@neta-art/cohub";
 import { JsonRpcProcess, record } from "../json-rpc.js";
 import { codexModelCatalog } from "../model-catalog.js";
 import { describeError } from "../../network-error.js";
-import { openPrivateServer } from "../native/codex-link.js";
+import { CODEX_UNLOAD_DELAY_SECS, openPrivateServer, resumeThread } from "../native/codex-link.js";
 import { ArchiveNotRestorableError, copyNativeArchive } from "../native/archive.js";
 import { codexArchivedSessionsDirectory, codexRolloutBytes, codexRolloutIdOf, codexSessionsDirectory, ensurePlainCodexRollout, readFirstRecord, readNativeTranscript, } from "../native/transcript.js";
 import { codexTranslator } from "../native/translate.js";
@@ -41,6 +41,7 @@ async function runCodex(executor, turn) {
     let channel = shared;
     let message = { ordinal: 0, content: [] };
     let begun = false;
+    let joined = null;
     try {
         if (!channel) {
             host = new JsonRpcProcess(...harnessCommand(executor.executables.codex || "codex", ["app-server", "--listen", "stdio://"], executor.cwd), executor.cwd, "jsonrpc", turnEnvironment(input));
@@ -54,13 +55,17 @@ async function runCodex(executor, turn) {
             ...(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 },
+            config: {
+                "shell_environment_policy.set.COHUB_SPACE_ID": input.spaceId, "shell_environment_policy.set.COHUB_SESSION_ID": input.sessionId,
+                ...(codex.shared ? { thread_unload_delay_secs: CODEX_UNLOAD_DELAY_SECS } : {}),
+            },
         };
         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);
+                : await resumeThread(codex, existing);
         const thread = record(opened.thread);
+        joined = text(thread.id) || null;
         if (typeof thread.id !== "string" || typeof thread.path !== "string")
             throw new Error("Codex did not provide a durable native thread");
         const threadId = thread.id;
@@ -143,6 +148,10 @@ async function runCodex(executor, turn) {
         }
         message = { ...message, stopReason: signal.aborted ? "aborted" : "error", errorMessage: signal.aborted ? null : describeError(error) };
     }
+    finally {
+        if (joined && channel?.shared)
+            await executor.codex.release(joined);
+    }
     return { session, resume: prepared.resume, message, host };
 }
 async function codexPrompt(input) {

package/dist/runtime/native/attach.js

@@ -29,22 +29,21 @@ export async function ensureNativeSync(input, log = (line) => process.stderr.wri
         return { enabled: false, harnesses: [], codexShared: false, importHistory: false, note: "unsupported" };
     const stateRoot = runtimeStateRoot(input.spaceId);
     const previous = await readNativeConfig(stateRoot, input.identity).catch(() => null);
-    if (previous && nativeSyncSatisfied(previous, input)) {
-        await maintain(previous, log, input.executables?.pi);
-        return { enabled: true, harnesses: previous.harnesses, codexShared: previous.codexShared, importHistory: false };
-    }
+    const alreadySynced = previous && nativeSyncSatisfied(previous, input);
     const interactive = process.stdin.isTTY === true;
     const confirm = async (question) => input.yes ? true : interactive ? await ask(question) : false;
-    if (!input.yes && !interactive) {
-        log("Native sync off · rerun interactively or with --yes to enable\n");
-        return { enabled: false, harnesses: input.harnesses, codexShared: false, importHistory: false, note: "non-interactive" };
-    }
-    const names = input.harnesses.map((harness) => LOCAL_HARNESS_SPECS[harness].label).join(" and ");
-    if (!await confirm(`Sync ${names} chats in this folder to this Space so they continue on the web? Their history may contain secrets. [Y/n] `)) {
-        return { enabled: false, harnesses: input.harnesses, codexShared: false, importHistory: false, note: "declined" };
+    if (!alreadySynced) {
+        if (!input.yes && !interactive) {
+            log("Native sync off · rerun interactively or with --yes to enable\n");
+            return { enabled: false, harnesses: input.harnesses, codexShared: false, importHistory: false, note: "non-interactive" };
+        }
+        const names = input.harnesses.map((harness) => LOCAL_HARNESS_SPECS[harness].label).join(" and ");
+        if (!await confirm(`Sync ${names} chats in this folder to this Space so they continue on the web? Their history may contain secrets. [Y/n] `)) {
+            return { enabled: false, harnesses: input.harnesses, codexShared: false, importHistory: false, note: "declined" };
+        }
     }
     let codexShared = previous?.codexShared ?? false;
-    if (input.harnesses.includes("codex") && !codexShared) {
+    if (input.harnesses.includes("codex") && !codexShared && (input.yes || interactive)) {
         const version = await harnessVersion(input.executables?.codex || "codex");
         if (!sharedServerAvailable) {
             log("Shared Codex sessions are unavailable on Windows; terminal Codex chats sync read-only\n");
@@ -56,6 +55,16 @@ export async function ensureNativeSync(input, log = (line) => process.stderr.wri
             codexShared = await confirm("Let terminal Codex and the web drive the same live sessions? Cohub starts Codex's shared app-server, which keeps running in the background. [Y/n] ");
         }
     }
+    if (previous && alreadySynced) {
+        if (codexShared !== previous.codexShared) {
+            await writeNativeConfig(stateRoot, { ...previous, codexShared }).catch((error) => {
+                log(`Shared Codex sessions unavailable; Runtime continues without them — ${serializeDiagnosticError(error).message}\n`);
+                codexShared = previous.codexShared;
+            });
+        }
+        await maintain(previous, log, input.executables?.pi);
+        return { enabled: true, harnesses: previous.harnesses, codexShared, importHistory: false };
+    }
     const harnesses = [...new Set([...(previous?.root === input.root ? previous.harnesses : []), ...input.harnesses])];
     const config = {
         version: 2, identity: input.identity, spaceId: input.spaceId, root: input.root, harnesses,

package/dist/runtime/native/codex-link.d.ts

@@ -2,6 +2,11 @@ import { type JsonRpcProcess, type JsonRecord } from "../json-rpc.js";
 import { type Version } from "./version.js";
 /** First Codex release whose terminal client attaches to a shared app-server by default. */
 export declare const CODEX_SHARED_MIN_VERSION: Version;
+/**
+ * A loaded thread holds Codex's per-thread writer lock, which Codex Desktop and other app-servers
+ * need to continue it. Long enough for an immediate follow-up Turn; honoured from Codex 0.164.
+ */
+export declare const CODEX_UNLOAD_DELAY_SECS = 10;
 export type CodexEvent = {
     method: string;
     params: JsonRecord;
@@ -32,11 +37,17 @@ export declare class CodexShared {
     private opening;
     private ensured;
     private readonly connectListeners;
+    private readonly releaseListeners;
     readonly driving: Set<string>;
     constructor(binary: string, cwd: string, enabled: boolean);
     get(): Promise<CodexChannel | null>;
     onConnect(listener: (channel: CodexChannel) => void): () => void;
+    onRelease(listener: (threadId: string) => void): () => void;
+    /** Drop this connection's subscription so an idle thread can unload and free its writer lock. */
+    release(threadId: string): Promise<void>;
     join(threadId: string): Promise<JsonRecord | null>;
     interrupt(threadId: string, turnId: string): Promise<boolean>;
     close(): Promise<void>;
 }
+/** Resume a thread for a Cohub Turn, waiting out an unload in progress. */
+export declare function resumeThread(channel: CodexChannel, params: JsonRecord): Promise<JsonRecord>;

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

@@ -10,6 +10,12 @@ export const CODEX_SHARED_MIN_VERSION = [0, 156, 0];
 const REQUEST_TIMEOUT_MS = 60_000;
 const JOIN_ATTEMPTS = 20;
 const JOIN_RETRY_MS = 100;
+const CLOSING_ATTEMPTS = 100;
+/**
+ * A loaded thread holds Codex's per-thread writer lock, which Codex Desktop and other app-servers
+ * need to continue it. Long enough for an immediate follow-up Turn; honoured from Codex 0.164.
+ */
+export const CODEX_UNLOAD_DELAY_SECS = 10;
 /** `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");
@@ -77,6 +83,7 @@ export class CodexShared {
     opening = null;
     ensured = false;
     connectListeners = new Set();
+    releaseListeners = new Set();
     driving = new Set();
     constructor(binary, cwd, enabled) {
         this.binary = binary;
@@ -106,6 +113,19 @@ export class CodexShared {
         this.connectListeners.add(listener);
         return () => { this.connectListeners.delete(listener); };
     }
+    onRelease(listener) {
+        this.releaseListeners.add(listener);
+        return () => { this.releaseListeners.delete(listener); };
+    }
+    /** Drop this connection's subscription so an idle thread can unload and free its writer lock. */
+    async release(threadId) {
+        for (const listener of this.releaseListeners)
+            listener(threadId);
+        const channel = this.channel;
+        if (!channel || channel.closed)
+            return;
+        await channel.request("thread/unsubscribe", { threadId }).catch(() => undefined);
+    }
     async join(threadId) {
         const channel = await this.get();
         return channel ? await joinThread(channel, threadId) : null;
@@ -232,6 +252,22 @@ class StdioChannel {
     }
     async close() { await this.rpc.close(); }
 }
+/** Resume a thread for a Cohub Turn, waiting out an unload in progress. */
+export async function resumeThread(channel, params) {
+    for (let attempt = 1;; attempt += 1) {
+        try {
+            return await channel.request("thread/resume", params);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (message.includes("already has an active writer"))
+                throw new Error("This Codex conversation is open in another app, such as Codex Desktop. Close it there, then retry.");
+            if (!message.includes("is closing") || attempt >= CLOSING_ATTEMPTS)
+                throw error;
+            await new Promise((resolve) => setTimeout(resolve, JOIN_RETRY_MS));
+        }
+    }
+}
 /**
  * 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.

package/dist/runtime/native/daemon.js

@@ -51,6 +51,11 @@ export class NativeRuntime {
         });
         this.codex = new CodexShared(options.executables.codex || "codex", options.root, Boolean(options.config?.codexShared) && options.harnesses.includes("codex"));
         this.codex.onConnect((channel) => this.observeCodex(channel));
+        // Its next Turn is found again through the server's status broadcast.
+        this.codex.onRelease((threadId) => {
+            this.watched.delete(threadId);
+            this.endStream(`codex:${threadId}`);
+        });
         this.ingest = new NativeIngest({
             spaceId: options.spaceId,
             cwd: options.root,
@@ -311,6 +316,7 @@ export class NativeRuntime {
             this.endStream(key);
             if (watched.path)
                 this.ingest.touch(watched.path);
+            void this.codex.release(threadId);
             return;
         }
         this.stream(key, "codex", threadId).translator.push(event);

package/dist/runtime/native/transcript.js

@@ -158,11 +158,22 @@ async function scanCodexRollouts(signal) {
     codexRolloutIndexCache = { at: Date.now(), home, index };
     return index;
 }
+async function* compressedCodexRolloutBytes(path, signal) {
+    const decoder = createZstdDecompress();
+    // pipeline keeps error listeners attached, so stopping at a header or prefix cannot crash with an unhandled decoder error.
+    const pumping = pipeline(createReadStream(path), decoder, { signal }).catch(() => { });
+    try {
+        yield* decoder;
+    }
+    finally {
+        decoder.destroy();
+        await pumping;
+    }
+}
 /** Raw JSONL bytes of a rollout, transparently decompressing `.zst` and honoring a lineage cutoff. */
 export async function* codexRolloutBytes(path, endBytes, signal) {
-    // compose (not pipe) so a source error propagates and early exit destroys both streams.
     const stream = path.endsWith(".zst")
-        ? createReadStream(path, { signal }).compose(createZstdDecompress())
+        ? compressedCodexRolloutBytes(path, signal)
         : createReadStream(path, endBytes != null ? { end: endBytes - 1, signal } : { signal });
     let total = 0, last = -1;
     for await (const chunk of stream) {
@@ -522,9 +533,10 @@ function parseCodexLines(lines, segment) {
                 calls.get(id)?.content.push({ type: "tool_result", tool_use_id: id, content: typeof payload.output === "string" ? payload.output : JSON.stringify(payload.output ?? null) });
             }
         }
+        // Cohub tags a Turn it starts with its own cloud Turn id (`client_id`), so the file itself records
+        // which Turns already belong to a cloud Turn and must not be ingested twice. Older Codex writes it
+        // on `item_completed`'s UserMessage, newer Codex on `user_message`.
         if (entry.type === "event_msg" && payload.type === "item_completed") {
-            // Cohub tags a Turn it starts with its own cloud Turn id, so the file itself records which
-            // Turns already belong to a cloud Turn (and must not be ingested twice).
             const item = record(payload.item);
             if (item.type === "UserMessage") {
                 const clientId = text(item.client_id);
@@ -540,6 +552,9 @@ function parseCodexLines(lines, segment) {
             }
         }
         if (entry.type === "event_msg" && payload.type === "user_message") {
+            const clientId = text(payload.client_id);
+            if (clientId)
+                current.cloudTurnId = clientId;
             if (!userFromResponse)
                 current.userContent = [{ type: "text", text: text(payload.message) }];
             userFromResponse = true;

package/dist/runtime/supervisor.js

@@ -152,11 +152,23 @@ export async function runRuntime(config, onState, externalSignal, onDiagnostic)
                     });
                     bridge.stdin?.on("error", () => undefined);
                     const closed = new Promise((resolve) => {
+                        let drainTimer;
                         bridge.once("error", (error) => diagnostics.log("error", "sandboxd.process_error", { error: serializeDiagnosticError(error) }));
-                        bridge.once("close", (code, exitSignal) => {
+                        bridge.once("exit", (code, exitSignal) => {
                             childStopped = true;
                             if (!signal.aborted)
                                 diagnostics.log("warn", "sandboxd.process_exit", { code, signal: exitSignal });
+                            // Descendants may still hold inherited pipes. After draining buffered
+                            // output, close only our ends so supervision can continue.
+                            drainTimer = setTimeout(() => {
+                                diagnostics.log("warn", "sandboxd.stdio_drain_timeout");
+                                for (const stream of bridge.stdio)
+                                    stream?.destroy();
+                            }, 1000);
+                        });
+                        bridge.once("close", () => {
+                            childStopped = true;
+                            clearTimeout(drainTimer);
                             resolve();
                         });
                     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "10.8.1",
+  "version": "10.8.3",
   "description": "CLI for Cohub — spaces, sessions, and agent collaboration.",
   "type": "module",
   "engines": {
@@ -18,7 +18,7 @@
     "NOTICE"
   ],
   "dependencies": {
-    "@neta-art/cohub": "12.1.0",
+    "@neta-art/cohub": "12.1.1",
     "@neta-art/generation": "^0.1.40",
     "commander": "^15.0.0",
     "sharp": "^0.35.4",