@clawos-dev/clawd 0.2.371 → 0.2.372

package/dist/cli.cjs

@@ -50493,7 +50493,7 @@ function stringValue2(value) {
 // src/tools/codex-app-server-query.ts
 var import_node_child_process5 = require("child_process");
 var DEFAULT_CODEX_QUERY_TIMEOUT_MS = 8e3;
-async function queryCodexAppServer(cwd, method, params, deps = {}) {
+async function withCodexAppServerClient(cwd, operation, run, deps = {}) {
   const cmd = process.env.CODEX_BIN ?? "codex";
   const args = ["app-server", "--listen", "stdio://"];
   const proc = deps.spawnOverride ? deps.spawnOverride(cmd, args, cwd) : (0, import_node_child_process5.spawn)(cmd, args, { cwd, env: process.env, stdio: ["pipe", "pipe", "pipe"] });
@@ -50502,7 +50502,7 @@ async function queryCodexAppServer(cwd, method, params, deps = {}) {
   let timer;
   const timeout = new Promise((_2, reject) => {
     timer = setTimeout(
-      () => reject(new Error(`codex app-server ${method} timed out after ${timeoutMs}ms`)),
+      () => reject(new Error(`codex app-server ${operation} timed out after ${timeoutMs}ms`)),
       timeoutMs
     );
     proc.on(
@@ -50522,12 +50522,20 @@ async function queryCodexAppServer(cwd, method, params, deps = {}) {
       timeout
     ]);
     deps.beforeRequest?.(client);
-    return await Promise.race([client.request(method, params), timeout]);
+    return await Promise.race([run(client), timeout]);
   } finally {
     if (timer) clearTimeout(timer);
     if (proc.exitCode === null && proc.signalCode === null) proc.kill("SIGTERM");
   }
 }
+async function queryCodexAppServer(cwd, method, params, deps = {}) {
+  return withCodexAppServerClient(
+    cwd,
+    method,
+    (client) => client.request(method, params),
+    deps
+  );
+}
 
 // src/tools/codex-model-list.ts
 var CODEX_CONTEXT_WINDOW = 258400;
@@ -54097,11 +54105,73 @@ function threadItems(thread) {
   }
   return items;
 }
-function threadMessages(thread) {
+function threadMessages(thread, subagentResults = /* @__PURE__ */ new Map()) {
   const messages = [];
-  for (const item of threadItems(thread)) messages.push(...threadItemToHistoryMessages(item));
+  for (const item of threadItems(thread)) {
+    messages.push(...threadItemToHistoryMessages(item));
+    const value = rec2(item);
+    const started = value && nativeSubagentStart(value);
+    const result = started && subagentResults.get(started.toolUseId);
+    if (result) messages.push(result);
+  }
   return messages;
 }
+function threadFromReadResponse(value, threadId) {
+  const res = rec2(value);
+  const thread = res && rec2(res.thread);
+  if (!thread) throw new Error(`Codex thread/read returned no thread for ${threadId}`);
+  return thread;
+}
+async function readThreadWithClient(client, threadId, timeoutMs) {
+  const request = client.request("thread/read", { threadId, includeTurns: true });
+  let timer;
+  const response = timeoutMs === void 0 ? await request : await Promise.race([
+    request,
+    new Promise((_2, reject) => {
+      timer = setTimeout(
+        () => reject(
+          new Error(
+            `Codex child thread/read ${threadId} timed out after ${timeoutMs}ms`
+          )
+        ),
+        timeoutMs
+      );
+    })
+  ]).finally(() => {
+    if (timer) clearTimeout(timer);
+  });
+  return threadFromReadResponse(response, threadId);
+}
+function terminalSubagentResult(started, child, parentThreadId) {
+  const actualId = str2(child.id);
+  const actualParentThreadId = str2(child.parentThreadId);
+  if (actualId !== started.agentId || actualParentThreadId !== parentThreadId) {
+    throw new Error(
+      `Codex subagent thread ${started.agentId} does not belong to parent thread ${parentThreadId} (returned id ${actualId ?? "missing"}, parent ${actualParentThreadId ?? "missing"})`
+    );
+  }
+  const turns = Array.isArray(child.turns) ? child.turns : [];
+  for (const value of turns) {
+    const turn = rec2(value);
+    const status = str2(turn?.status);
+    if (status === "completed") {
+      return {
+        kind: "tool_result",
+        toolUseId: started.toolUseId
+      };
+    }
+    if (status === "failed" || status === "interrupted") {
+      const rawError = turn?.error;
+      const error = str2(rawError) ?? str2(rec2(rawError)?.message);
+      return {
+        kind: "tool_result",
+        toolUseId: started.toolUseId,
+        error: error ?? `Codex subagent ${status}`
+      };
+    }
+  }
+  return void 0;
+}
 function userInputText(content) {
   if (!Array.isArray(content)) return "";
   return content.map((c) => {
@@ -54211,8 +54281,43 @@ var CodexHistoryReader = class {
     return out;
   }
   async read(args) {
-    const thread = await this.readThread(args.cwd, args.toolSessionId);
-    const messages = threadMessages(thread);
+    const queryTimeoutMs = this.deps.timeoutMs ?? DEFAULT_CODEX_QUERY_TIMEOUT_MS;
+    const queryStartedAt = Date.now();
+    const messages = await withCodexAppServerClient(
+      args.cwd,
+      "history/read",
+      async (client) => {
+        const parent = await readThreadWithClient(client, args.toolSessionId);
+        const starts = threadItems(parent).map((item) => {
+          const value = rec2(item);
+          return value && nativeSubagentStart(value);
+        }).filter((value) => value !== void 0);
+        const results = /* @__PURE__ */ new Map();
+        const childTimeoutMs = Math.floor(
+          (queryTimeoutMs - (Date.now() - queryStartedAt)) / 2
+        );
+        await Promise.all(
+          starts.map(async (started) => {
+            try {
+              if (childTimeoutMs <= 0) {
+                throw new Error(`Codex child thread/read ${started.agentId} timed out before request`);
+              }
+              const child = await readThreadWithClient(client, started.agentId, childTimeoutMs);
+              const result = terminalSubagentResult(started, child, args.toolSessionId);
+              if (result) results.set(started.toolUseId, result);
+            } catch (error) {
+              this.deps.logger?.warn("codex subagent history terminal unavailable", {
+                parentThreadId: args.toolSessionId,
+                childThreadId: started.agentId,
+                message: error.message
+              });
+            }
+          })
+        );
+        return threadMessages(parent, results);
+      },
+      this.deps
+    );
     const total = messages.length;
     const limit = args.limit ?? total;
     const offset = typeof args.offset === "number" ? Math.min(Math.max(0, args.offset), total) : Math.max(0, total - limit);
@@ -54254,17 +54359,15 @@ var CodexHistoryReader = class {
     return [];
   }
   async readThread(cwd, threadId) {
-    const res = rec2(
+    return threadFromReadResponse(
       await queryCodexAppServer(
         cwd,
         "thread/read",
         { threadId, includeTurns: true },
         this.deps
-      )
+      ),
+      threadId
     );
-    const thread = res && rec2(res.thread);
-    if (!thread) throw new Error(`Codex thread/read returned no thread for ${threadId}`);
-    return thread;
   }
 };
 
@@ -61035,7 +61138,7 @@ function computeMethodAccess(args) {
 }
 
 // src/version.ts
-var version = "0.2.371".length > 0 ? "0.2.371" : "dev";
+var version = "0.2.372".length > 0 ? "0.2.372" : "dev";
 
 // src/cli-probe/probe.ts
 var fs63 = __toESM(require("fs"), 1);
@@ -65037,7 +65140,7 @@ async function startDaemon(config) {
     "codex",
     new CodexAdapter({
       logger,
-      historyReader: new CodexHistoryReader(),
+      historyReader: new CodexHistoryReader({ logger }),
       // projectPaths 每次调用现取 —— 用户新建 project 后立即生效，不用重启 daemon
       codexHomeFor: (cwd) => resolveCodexHome({
         cwd,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawos-dev/clawd",
-  "version": "0.2.371",
+  "version": "0.2.372",
   "description": "Standalone clawd daemon — Claude Code (and future Codex) session server over WebSocket",
   "type": "module",
   "license": "MIT",