@ycodium-ai/agent-codex 0.2.3799 → 0.2.3831

package/dist/index.js

@@ -4650,6 +4650,112 @@ function mapServerRequestToEvents(input) {
   ];
 }
 
+// src/backgroundCommands.ts
+function commandDescription(item) {
+  const actions = Array.isArray(item["commandActions"]) ? item["commandActions"] : [];
+  const first = isRecord2(actions[0]) ? asString(actions[0]["command"]) : null;
+  return first ?? asString(item["command"]) ?? "";
+}
+var CodexBackgroundCommands = class {
+  #commands = /* @__PURE__ */ new Map();
+  #threadId;
+  #providerInstanceId;
+  constructor(threadId, providerInstanceId) {
+    this.#threadId = threadId;
+    this.#providerInstanceId = providerInstanceId;
+  }
+  #completed(taskId, turnId, status, method) {
+    return baseEvent({
+      type: "task.completed",
+      threadId: this.#threadId,
+      turnId,
+      payload: { taskId, status },
+      method,
+      providerInstanceId: this.#providerInstanceId
+    });
+  }
+  #settleTurn(method, params) {
+    const turnId = turnIdOf(params);
+    const events = [];
+    for (const [id, command] of this.#commands) {
+      if (command.background || turnId !== void 0 && command.turnId !== turnId) continue;
+      if (turnCompletedControlFlow(params).state !== "completed") {
+        this.#commands.delete(id);
+        continue;
+      }
+      this.#commands.set(id, { ...command, background: true });
+      events.push(
+        baseEvent({
+          type: "task.started",
+          threadId: this.#threadId,
+          turnId: command.turnId,
+          payload: { taskId: id, taskType: "local_bash", description: command.description },
+          method,
+          providerInstanceId: this.#providerInstanceId
+        })
+      );
+    }
+    return events;
+  }
+  /** 跟着通知走，返回要补发的 task 事件；放在该通知本身的事件之后发。 */
+  observe(method, params) {
+    if (method === "turn/completed") return this.#settleTurn(method, params);
+    if (method === "thread/closed") {
+      const closed = [...this.#commands].filter(([, command2]) => command2.background);
+      this.#commands.clear();
+      return closed.map(([id2, command2]) => this.#completed(id2, command2.turnId, "stopped", method));
+    }
+    if (!isRecord2(params) || !isRecord2(params["item"])) return [];
+    const item = params["item"];
+    const id = item["id"];
+    if (item["type"] !== "commandExecution" || typeof id !== "string") return [];
+    if (method === "item/started") {
+      if (item["source"] === "unifiedExecInteraction") return [];
+      this.#commands.set(id, {
+        turnId: turnIdOf(params),
+        description: commandDescription(item),
+        processId: asString(item["processId"]) ?? void 0,
+        background: false
+      });
+      return [];
+    }
+    if (method !== "item/completed") return [];
+    const command = this.#commands.get(id);
+    this.#commands.delete(id);
+    if (command?.background !== true) return [];
+    const status = itemStatusOf(params);
+    return [
+      this.#completed(
+        id,
+        command.turnId,
+        status === "failed" ? "failed" : status === "declined" ? "stopped" : "completed",
+        method
+      )
+    ];
+  }
+  /** 用户点停止时结束有进程号的后台任务；请求失败的留着，等它自己的 `item/completed`。 */
+  async stop(rpc, nativeThreadId) {
+    const running = [...this.#commands].filter(
+      (entry) => entry[1].background && entry[1].processId !== void 0
+    );
+    const stopped = await Promise.all(
+      running.map(async ([id, command]) => {
+        try {
+          await rpc.request("thread/backgroundTerminals/terminate", {
+            threadId: nativeThreadId,
+            processId: command.processId
+          });
+        } catch {
+          return [];
+        }
+        this.#commands.delete(id);
+        return [this.#completed(id, command.turnId, "stopped")];
+      })
+    );
+    return stopped.flat();
+  }
+};
+
 // src/openCommands.ts
 import {
   isPosixShellCommandFlag,
@@ -4804,6 +4910,21 @@ function readSubAgentActivity(method, params) {
     agentPath: asString(item["agentPath"]) ?? void 0
   };
 }
+async function interruptForeignTurns(rpc, turns) {
+  const started = Date.now();
+  await Promise.all(
+    [...turns.entries()].slice(0, 8).map(async ([thread, childTurn]) => {
+      if (Date.now() - started > 1e4) return;
+      try {
+        await Promise.race([
+          rpc.request("turn/interrupt", { threadId: thread, turnId: childTurn }, 0),
+          new Promise((resolve4) => setTimeout(resolve4, 3e3))
+        ]);
+      } catch {
+      }
+    })
+  );
+}
 var CodexSessionCollab = class {
   runtime;
   constructor(runtime) {
@@ -5299,6 +5420,7 @@ var CodexSessionRuntime = class {
   closeOptions;
   #collab = new CodexSessionCollab(this);
   #requests = new CodexSessionRequests(this);
+  #background;
   /**
    * 对外 requestId 的前缀，每个会话（即每个 app-server 进程）一份。JSON-RPC id 每个进程
    * 都从 0 数起，宿主按 requestId 记「已接受」，不加前缀的话重启后的新请求会撞上旧请求。
@@ -5333,6 +5455,7 @@ var CodexSessionRuntime = class {
       });
     });
     this.emit = (event) => this.#lifecycle.emit(event);
+    this.#background = new CodexBackgroundCommands(input.threadId, host.instanceId);
     this.threadId = input.threadId;
     this.cwd = cwd;
     this.runtimeMode = input.runtimeMode;
@@ -5483,6 +5606,7 @@ var CodexSessionRuntime = class {
     })) {
       this.emit(event);
     }
+    for (const event of this.#background.observe(method, params)) this.emit(event);
     if (method === "turn/started" && this.#lifecycle.acceptsLifecycle) {
       const turnId = turnIdOf(params);
       if (turnId) this.activeTurnId = turnId;
@@ -5678,21 +5802,13 @@ var CodexSessionRuntime = class {
     };
   }
   async interruptTurn(turnId) {
-    const childTurns = [...this.liveForeignTurns.entries()];
-    const started = Date.now();
-    await Promise.all(
-      childTurns.slice(0, 8).map(async ([thread, childTurn]) => {
-        if (Date.now() - started > 1e4) return;
-        try {
-          await Promise.race([
-            this.rpc.request("turn/interrupt", { threadId: thread, turnId: childTurn }, 0),
-            sleep(3e3)
-          ]);
-        } catch {
-        }
-      })
-    );
+    await interruptForeignTurns(this.rpc, this.liveForeignTurns);
     if (!this.nativeThreadId) return;
+    if (turnId === void 0) {
+      for (const event of await this.#background.stop(this.rpc, this.nativeThreadId)) {
+        this.emit(event);
+      }
+    }
     const target = turnId ?? this.activeTurnId;
     if (target) {
       await this.rpc.request("turn/interrupt", { threadId: this.nativeThreadId, turnId: target }, 0).catch(() => void 0);

package/package.json

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