@neta-art/cohub-cli 10.8.1 → 10.8.2

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "10.8.1",
+  "version": "10.8.2",
   "description": "CLI for Cohub — spaces, sessions, and agent collaboration.",
   "type": "module",
   "engines": {