@neta-art/cohub-cli 10.8.2 → 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/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/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.2",
+  "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",