@ycodium-ai/agent-codex 0.2.3102 → 0.2.3112

package/dist/index.js

@@ -678,7 +678,7 @@ async function spawnCodexAppServer(input) {
 }
 
 // src/failureCategory.ts
-var codexProcessExitCategory = (session) => session !== void 0 && !session.closed && typeof session.nativeThreadId === "string" && session.nativeThreadId.length > 0 ? "transport" : void 0;
+var codexProcessExitCategory = (session) => session !== void 0 && !session.stopRequested && typeof session.nativeThreadId === "string" && session.nativeThreadId.length > 0 ? "transport" : void 0;
 
 // src/protocol.ts
 var CODEX_INITIALIZE_PARAMS = {
@@ -996,7 +996,7 @@ async function createCodexRpcClient(handle, handlers) {
   let stderrTail = "";
   let exitReason = null;
   let exitFailureCategory;
-  let closed = false;
+  let closeTask;
   const attach = (error) => exitFailureCategory === void 0 ? error : Object.assign(error, { failureCategory: exitFailureCategory });
   const failAll = (reason, failureCategory) => {
     if (exitReason === null) exitFailureCategory = failureCategory;
@@ -1132,19 +1132,39 @@ async function createCodexRpcClient(handle, handlers) {
   const respondError = async (id, code, message) => {
     await writeLine({ id, error: { code, message } }, id);
   };
-  const close = async () => {
-    if (closed) return;
-    closed = true;
-    try {
-      await handle.closeStdin();
-    } catch {
-    }
-    try {
-      await handle.kill("SIGTERM");
-    } catch {
-    }
-    failAll("the client was closed");
-    await Promise.all([pumpStdout, pumpStderr]);
+  const close = (options) => {
+    if (closeTask) return closeTask;
+    closeTask = Promise.resolve().then(async () => {
+      try {
+        await handle.closeStdin();
+      } catch {
+      }
+      try {
+        await handle.kill("SIGTERM");
+      } finally {
+        failAll("the client was closed");
+      }
+      const drained = Promise.all([pumpStdout, pumpStderr]);
+      if (options === void 0) {
+        await drained;
+        return;
+      }
+      let timer;
+      try {
+        await Promise.race([
+          drained,
+          new Promise((resolve2) => {
+            timer = setTimeout(() => {
+              options.onDrainTimeout();
+              resolve2();
+            }, options.drainTimeoutMs);
+          })
+        ]);
+      } finally {
+        if (timer !== void 0) clearTimeout(timer);
+      }
+    });
+    return closeTask;
   };
   return {
     request,
@@ -3064,6 +3084,60 @@ function openCommandsOf(booked) {
   };
 }
 
+// src/sessionLifecycle.ts
+import { isExecutorLifecycleEvent } from "@ycodium-ai/plugin-api/executor";
+var CodexSessionLifecycle = class {
+  closing = false;
+  closed = false;
+  #stopped = false;
+  #task;
+  #exit;
+  threadId;
+  publish;
+  requestClose;
+  constructor(threadId, publish, requestClose) {
+    this.threadId = threadId;
+    this.publish = publish;
+    this.requestClose = requestClose;
+  }
+  /** 宿主发起的停止（stopSession / dispose）已认领；进程自己退出或协议关闭不算。 */
+  get stopRequested() {
+    return this.#stopped;
+  }
+  get acceptsLifecycle() {
+    return !this.closed && !this.#stopped;
+  }
+  stop() {
+    this.#stopped = true;
+  }
+  emit(event) {
+    if (isExecutorLifecycleEvent(event) && !this.acceptsLifecycle) return;
+    if (event.type === "session.exited") {
+      this.#exit ??= event;
+      this.requestClose();
+      return;
+    }
+    this.publish(event);
+  }
+  /** 停止边界必须同步认领；RPC 的 dispatch 同步发布，认领前的终态已经交给事件流。 */
+  close(reason, cleanup) {
+    if (reason === "stop") this.stop();
+    if (this.#task) return this.#task;
+    this.closing = true;
+    this.#task = (async () => {
+      try {
+        await cleanup();
+      } finally {
+        this.closed = true;
+      }
+      this.publish(
+        this.#exit ?? baseEvent({ type: "session.exited", threadId: this.threadId, payload: {} })
+      );
+    })();
+    return this.#task;
+  }
+};
+
 // src/sessionCollab.ts
 var COLLAB_META_LOOKUP_TIMEOUT_MS = 5e3;
 function metaValue(value) {
@@ -3530,8 +3604,18 @@ var CodexSessionRuntime = class {
   /** 宿主解好的这一轮的档（座位画的就是它）。缺席 = 宿主没给，按 `runtimeMode` 查表。 */
   nativeModeId;
   interactionMode;
-  closed = false;
-  closeCompleted = false;
+  get closed() {
+    return this.#lifecycle.closed;
+  }
+  get closing() {
+    return this.#lifecycle.closing;
+  }
+  get stopRequested() {
+    return this.#lifecycle.stopRequested;
+  }
+  markStopped() {
+    this.#lifecycle.stop();
+  }
   turns = [];
   pendingApprovals = /* @__PURE__ */ new Map();
   pendingUserInputs = /* @__PURE__ */ new Map();
@@ -3553,6 +3637,8 @@ var CodexSessionRuntime = class {
   attachments;
   rpc;
   emit;
+  #lifecycle;
+  closeOptions;
   #collab = new CodexSessionCollab(this);
   #requests = new CodexSessionRequests(this);
   /**
@@ -3574,11 +3660,20 @@ var CodexSessionRuntime = class {
       codexNativeModeFor(this.runtimeMode, this.nativeModeId)
     );
   }
-  constructor(host, rpc, emit, input, cwd, appServerArgs, grants, declineRelay, attachments) {
+  constructor(host, rpc, emit, input, cwd, appServerArgs, grants, declineRelay, attachments, closeOptions = {}) {
     this.attachments = attachments;
+    this.closeOptions = closeOptions;
     this.host = host;
     this.rpc = rpc;
-    this.emit = emit;
+    this.#lifecycle = new CodexSessionLifecycle(input.threadId, emit, () => {
+      void (closeOptions.requestClose?.() ?? this.close("process")).catch((error) => {
+        host.log.warn("closing codex session failed", {
+          threadId: input.threadId,
+          error: String(error)
+        });
+      });
+    });
+    this.emit = (event) => this.#lifecycle.emit(event);
     this.threadId = input.threadId;
     this.cwd = cwd;
     this.runtimeMode = input.runtimeMode;
@@ -3602,6 +3697,7 @@ var CodexSessionRuntime = class {
     };
   }
   registerWriteAck(jsonRpcId) {
+    if (this.closing) return Promise.resolve("closed");
     return new Promise((resolve2) => {
       this.writeAcks.set(jsonRpcId, { resolve: resolve2 });
     });
@@ -3711,17 +3807,18 @@ var CodexSessionRuntime = class {
     })) {
       this.emit(event);
     }
-    if (method === "turn/started") {
+    if (method === "turn/started" && this.#lifecycle.acceptsLifecycle) {
       const turnId = turnIdOf(params);
       if (turnId) this.activeTurnId = turnId;
     }
-    if (method === "turn/completed") {
+    if (method === "turn/completed" && this.#lifecycle.acceptsLifecycle) {
       this.activeTurnId = void 0;
       const { activeTurnId: _completedTurn, ...idleSession } = this.session;
       this.session = { ...idleSession, status: "idle", updatedAt: nowIso() };
     }
   }
   async handleServerRequest(id, method, params) {
+    if (this.closing) return;
     return this.#requests.handleServerRequest(id, method, params);
   }
   async respondToRequest(requestId, decision, reason, persist) {
@@ -3733,6 +3830,7 @@ var CodexSessionRuntime = class {
   async withActiveWriterRecovery(run, allowUnsubscribe) {
     let lastError;
     for (let attempt = 0; attempt < ACTIVE_WRITER_ATTEMPTS; attempt += 1) {
+      if (this.closing) throw new Error("codex session is closing");
       try {
         return await run();
       } catch (error) {
@@ -3840,6 +3938,7 @@ var CodexSessionRuntime = class {
     return items;
   }
   async sendTurn(input) {
+    if (this.closing) throw new Error("codex session is closing");
     if (!this.nativeThreadId) throw new Error("codex session has no native thread");
     if (this.hasConfiguredMcpServer) {
       await this.rpc.request("config/mcpServer/reload", void 0, 0).catch((error) => {
@@ -3872,6 +3971,7 @@ var CodexSessionRuntime = class {
       })
     };
     const isSteer = input.expectedTurnId !== void 0;
+    if (this.closing) throw new Error("codex session is closing");
     const result = await markProviderRejection(
       () => isSteer ? this.rpc.request(
         "turn/steer",
@@ -3961,31 +4061,59 @@ var CodexSessionRuntime = class {
   settlePendingUserInputs(result) {
     return this.#requests.settlePendingUserInputs(result);
   }
-  async close() {
-    if (this.closeCompleted) return;
-    this.closed = true;
-    this.requestKinds.clear();
-    this.failPendingNativeWrites("session closed before write confirmation");
-    this.settlePendingApprovals();
-    this.settlePendingUserInputs({});
-    this.declineRelay.clear(this.threadId);
-    this.grants.clear();
-    try {
-      await this.rpc.close();
-    } catch {
-    }
-    this.closeCompleted = true;
-    this.emit({
-      eventId: nextEventId(),
-      provider: CODEX_DRIVER_KIND,
-      threadId: this.threadId,
-      createdAt: nowIso(),
-      type: "session.exited",
-      payload: {}
+  close(reason = "stop") {
+    return this.#lifecycle.close(reason, async () => {
+      this.requestKinds.clear();
+      this.failPendingNativeWrites("session closed before write confirmation");
+      this.settlePendingApprovals();
+      this.settlePendingUserInputs({});
+      this.declineRelay.clear(this.threadId);
+      this.grants.clear();
+      await this.rpc.close({
+        drainTimeoutMs: this.closeOptions.drainTimeoutMs ?? 2e3,
+        onDrainTimeout: () => {
+          this.#lifecycle.closed = true;
+          this.host.log.warn("codex output drain timed out", { threadId: this.threadId });
+        }
+      });
     });
   }
 };
 
+// src/eventBus.ts
+var EventBus = class {
+  #queued = [];
+  #waiters = [];
+  #closed = false;
+  push(event) {
+    const waiter = this.#waiters.shift();
+    if (waiter) {
+      waiter({ done: false, value: event });
+      return;
+    }
+    this.#queued.push(event);
+  }
+  close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    while (this.#waiters.length > 0) {
+      this.#waiters.shift()?.({ done: true, value: void 0 });
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        const queued = this.#queued.shift();
+        if (queued !== void 0) return Promise.resolve({ done: false, value: queued });
+        if (this.#closed) return Promise.resolve({ done: true, value: void 0 });
+        return new Promise((resolve2) => {
+          this.#waiters.push(resolve2);
+        });
+      }
+    };
+  }
+};
+
 // src/sessions.ts
 import * as NodeFS3 from "node:fs";
 import * as NodePath4 from "node:path";
@@ -5714,38 +5842,6 @@ function missingBinaryDetail(binaryPath) {
 var yieldTick = () => new Promise((resolve2) => {
   setImmediate(resolve2);
 });
-var EventBus = class {
-  #queued = [];
-  #waiters = [];
-  #closed = false;
-  push(event) {
-    const waiter = this.#waiters.shift();
-    if (waiter) {
-      waiter({ done: false, value: event });
-      return;
-    }
-    this.#queued.push(event);
-  }
-  close() {
-    if (this.#closed) return;
-    this.#closed = true;
-    while (this.#waiters.length > 0) {
-      this.#waiters.shift()?.({ done: true, value: void 0 });
-    }
-  }
-  [Symbol.asyncIterator]() {
-    return {
-      next: () => {
-        const queued = this.#queued.shift();
-        if (queued !== void 0) return Promise.resolve({ done: false, value: queued });
-        if (this.#closed) return Promise.resolve({ done: true, value: void 0 });
-        return new Promise((resolve2) => {
-          this.#waiters.push(resolve2);
-        });
-      }
-    };
-  }
-};
 function accountToAuth2(account) {
   switch (account.state) {
     case "signed-in":
@@ -5775,9 +5871,11 @@ var createCodexInstance = (config, host, attachments, cache) => {
   const signInOperations = /* @__PURE__ */ new Map();
   const live = /* @__PURE__ */ new Map();
   let disposed = false;
+  let disposeTask;
   const requireThread = (threadId) => {
     const booked = threads.get(threadId);
     if (!booked) throw new Error(`unknown thread ${threadId}`);
+    if (booked.closing) throw new Error(`thread ${threadId} is closing`);
     return booked;
   };
   const probeAuth = () => accountToAuth2(readCodexAccount(accountHomeFromLayout(layoutFor(recipe))));
@@ -5831,7 +5929,7 @@ var createCodexInstance = (config, host, attachments, cache) => {
       ({ handle } = await spawnCodexAppServer({ host, recipe, layout }));
     } catch (error) {
       if (error instanceof ExecutorSpawnRefusedError) {
-        const borrowed = [...threads.values()][0];
+        const borrowed = [...threads.values()].find((entry) => !entry.closing);
         if (borrowed !== void 0) return await run(borrowed.rpc);
       }
       throw error;
@@ -5868,8 +5966,12 @@ var createCodexInstance = (config, host, attachments, cache) => {
     live.set(handle.pid, { command, ...threadId === void 0 ? {} : { threadId } });
     void handle.exited.finally(() => live.delete(handle.pid));
   };
-  const stopBooked = async (booked) => {
-    await booked.runtime.close().catch(() => void 0);
+  const stopBooked = (threadId, booked, reason = "stop") => {
+    if (reason === "stop") booked.runtime.markStopped();
+    booked.closing ??= booked.runtime.close(reason).then(() => {
+      if (threads.get(threadId) === booked) threads.delete(threadId);
+    });
+    return booked.closing;
   };
   const instance = {
     probe: async () => {
@@ -5930,8 +6032,8 @@ var createCodexInstance = (config, host, attachments, cache) => {
       if (cwd.trim() === "") throw new Error("workspace path missing");
       const existing = threads.get(input.threadId);
       if (existing !== void 0) {
-        await stopBooked(existing);
-        threads.delete(input.threadId);
+        if (existing.closing) throw new Error(`thread ${input.threadId} is closing`);
+        await stopBooked(input.threadId, existing);
       }
       const layout = layoutFor(recipe);
       const { handle, args } = await spawnCodexAppServer({
@@ -5942,6 +6044,7 @@ var createCodexInstance = (config, host, attachments, cache) => {
       });
       trackHandle(handle, [recipe.binaryPath, ...args].join(" "), input.threadId);
       let runtime;
+      let booked;
       const rpc = await createCodexRpcClient(handle, {
         onNotification: (notification) => {
           runtime?.handleNotification(notification.method, notification.params);
@@ -5962,7 +6065,13 @@ var createCodexInstance = (config, host, attachments, cache) => {
           runtime?.settleNativeWrite(id, status);
         },
         onExit: () => {
-          if (runtime && !runtime.closed) void runtime.close().catch(() => void 0);
+          if (booked)
+            void stopBooked(input.threadId, booked, "process").catch((error) => {
+              host.log.warn("closing codex session failed", {
+                threadId: input.threadId,
+                error: String(error)
+              });
+            });
         },
         failureCategoryForProcessExit: () => codexProcessExitCategory(runtime)
       });
@@ -5975,22 +6084,25 @@ var createCodexInstance = (config, host, attachments, cache) => {
         args,
         void 0,
         void 0,
-        attachments
+        attachments,
+        { requestClose: () => stopBooked(input.threadId, booked, "process") }
       );
+      booked = { runtime, rpc, handle };
+      threads.set(input.threadId, booked);
       try {
         await rpc.request("initialize", CODEX_INITIALIZE_PARAMS);
         await rpc.notify("initialized");
         await setCodexSessionSkillRoots(rpc, input.skills, host.log, input.threadId);
         const session = await runtime.openThread(input);
         await yieldTick();
-        threads.set(input.threadId, { runtime, rpc, handle });
+        if (booked.closing) throw new Error("codex session closed during startup");
         host.log.info("session started", {
           threadId: input.threadId,
           nativeThreadId: runtime.nativeThreadId
         });
         return session;
       } catch (error) {
-        await runtime.close().catch(() => void 0);
+        await stopBooked(input.threadId, booked).catch(() => void 0);
         throw error;
       }
     },
@@ -6009,8 +6121,8 @@ var createCodexInstance = (config, host, attachments, cache) => {
       }
     },
     interruptTurn: async (threadId, turnId) => {
-      const booked = threads.get(threadId);
-      if (booked === void 0) return;
+      if (!threads.has(threadId)) return;
+      const booked = requireThread(threadId);
       host.log.info("interrupt turn", { threadId, turnId });
       await booked.runtime.interruptTurn(turnId);
     },
@@ -6038,26 +6150,31 @@ var createCodexInstance = (config, host, attachments, cache) => {
     stopSession: async (threadId) => {
       const booked = threads.get(threadId);
       if (booked === void 0) return;
-      threads.delete(threadId);
-      await stopBooked(booked);
+      await stopBooked(threadId, booked);
     },
     readThread: async (threadId) => {
       const booked = requireThread(threadId);
       return await booked.runtime.readThread();
     },
     events,
-    dispose: async () => {
-      if (disposed) return;
+    dispose: () => {
+      if (disposeTask) return disposeTask;
       disposed = true;
-      const operations = [...signInOperations.values()];
-      signInOperations.clear();
-      for (const operation of operations) {
-        await operation.close().catch(() => void 0);
-      }
-      const booked = [...threads.values()];
-      threads.clear();
-      await Promise.all(booked.map((entry) => stopBooked(entry)));
-      events.close();
+      const closing = Promise.allSettled(
+        [...threads.entries()].map(([threadId, booked]) => stopBooked(threadId, booked))
+      );
+      disposeTask = (async () => {
+        const operations = [...signInOperations.values()];
+        signInOperations.clear();
+        for (const operation of operations) {
+          await operation.close().catch(() => void 0);
+        }
+        for (const result of await closing) {
+          if (result.status === "rejected") throw result.reason;
+        }
+        events.close();
+      })();
+      return disposeTask;
     },
     // 项目里的 repo 级技能：探测的 app-server 没有工作区，只报得出用户与系统级；这里按目录问
     // 一次性 app-server（与读额度同一条进程通道），宿主缓存结果。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ycodium-ai/agent-codex",
-  "version": "0.2.3102",
+  "version": "0.2.3112",
   "description": "Codex executor: Codex CLI over the app-server JSON-RPC protocol.",
   "keywords": [
     "ycodium",
@@ -29,7 +29,7 @@
     "tailwindcss": "^4.0.0",
     "typescript": "~6.0.3",
     "vite-plus": "0.2.2",
-    "@ycodium-ai/plugin-api": "0.2.3102",
+    "@ycodium-ai/plugin-api": "0.2.3112",
     "ycodium-executor-testing": "0.0.0"
   },
   "ycodium": {