@xiaohhhh1/canvas-agent 0.4.55 → 0.4.56

package/dist/agent/codex-client.js

@@ -9,6 +9,7 @@ const canvasAgentMcp = canvasAgentMcpCommand();
 const require = createRequire(import.meta.url);
 const STREAM_UPDATE_INTERVAL_MS = 40;
 const TURN_RECONCILE_INTERVAL_MS = 5_000;
+const APP_SERVER_INITIALIZE_TIMEOUT_MS = 30_000;
 /** 封装 Codex app-server 的 JSON-RPC 通信与事件转换。 */
 export class CodexAppClient {
     child;
@@ -52,9 +53,15 @@ export class CodexAppClient {
             onExit();
             emit("agent_log", { text: `Codex app-server exited: ${code ?? 0}` });
         });
-        await client.request("initialize", { clientInfo: { name: "canvas-agent", title: "Infinite Canvas Agent", version: VERSION }, capabilities: { experimentalApi: true, requestAttestation: false } });
-        client.notify("initialized");
-        return client;
+        try {
+            await withTimeout(client.request("initialize", { clientInfo: { name: "canvas-agent", title: "Infinite Canvas Agent", version: VERSION }, capabilities: { experimentalApi: true, requestAttestation: false } }), APP_SERVER_INITIALIZE_TIMEOUT_MS, "Codex app-server initialize timed out");
+            client.notify("initialized");
+            return client;
+        }
+        catch (error) {
+            await client.terminate("Codex app-server 初始化超时，已回收失去响应的进程");
+            throw error;
+        }
     }
     /** 创建新的 Codex 线程。 */
     async startThread(cwd, permissionMode = "request", modelSettings = {}) {
@@ -408,6 +415,21 @@ export class CodexAppClient {
         this.currentTurnId = "";
     }
 }
+async function withTimeout(promise, timeoutMs, message) {
+    let timer;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_resolve, reject) => {
+                timer = setTimeout(() => reject(new Error(message)), Math.max(1, timeoutMs));
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
 /** 只有正常 completed 才能被调用方视为可用脚本。 */
 export function isTerminalTurnStatus(status) {
     return ["completed", "failed", "interrupted", "cancelled", "canceled"].includes(String(status || "").toLowerCase());

package/dist/agent/codex.d.ts

@@ -56,6 +56,16 @@ export declare function runCodexWorkflowTurn(prompt: string, emit: AgentEmit, op
     onWorkerStart?: () => void;
     onWorkerFinish?: () => void;
 }): Promise<CodexWorkflowRunResult>;
+/**
+ * 给 Flow C 的完整 app-server 链路设置硬截止时间。超时后不再等待原 Promise
+ * 自行结束；否则初始化或 thread/start 永不返回时会永久占住 worker lane。
+ */
+export declare function runBoundedWorkflowOperation<T>(operation: Promise<T>, timeoutMs: number, onTimeout: () => Promise<void> | void): Promise<{
+    timedOut: false;
+    value: T;
+} | {
+    timedOut: true;
+}>;
 /** Contract/preflight 4xx errors are deterministic and must never burn every fallback chunk size. */
 export declare function isDeterministicWorkflowContractError(error: unknown): boolean;
 /** 强制回收失去响应的 app-server；只用于有界超时恢复。 */

package/dist/agent/codex.js

@@ -44,26 +44,26 @@ export async function runCodexWorkflowTurn(prompt, emit, options) {
         const threadStartedAt = Date.now();
         let threadStartMs = 0;
         let modelStartedAt = 0;
-        let timer;
         let app = workflowCodexApps.get(workerIndex);
         try {
-            if (!app)
-                app = await startWorkflowCodexApp(workerIndex, options.appEmit || emit);
-            const thread = await app.startThread(options.cwd, options.permissionMode || "request", modelSettings);
-            const threadId = String(field(thread, "id") || "");
-            options.onThread?.(threadId);
-            threadStartMs = Date.now() - threadStartedAt;
-            modelStartedAt = Date.now();
-            const turn = app.startTurn(threadId, prompt, [], options.permissionMode || "request", options.onTurn, options.outputSchema, modelSettings);
-            const timeout = new Promise((resolve) => { timer = setTimeout(() => resolve("timeout"), options.timeoutMs); });
-            const result = await Promise.race([turn, timeout]);
-            if (result === "timeout") {
+            const operation = (async () => {
+                if (!app)
+                    app = await startWorkflowCodexApp(workerIndex, options.appEmit || emit);
+                const thread = await app.startThread(options.cwd, options.permissionMode || "request", modelSettings);
+                const threadId = String(field(thread, "id") || "");
+                options.onThread?.(threadId);
+                threadStartMs = Date.now() - threadStartedAt;
+                modelStartedAt = Date.now();
+                return await app.startTurn(threadId, prompt, [], options.permissionMode || "request", options.onTurn, options.outputSchema, modelSettings);
+            })();
+            const result = await runBoundedWorkflowOperation(operation, options.timeoutMs, async () => {
                 workflowCodexApps.delete(workerIndex);
-                await app.terminate("Flow C 脚本回合超时，已仅回收当前 worker");
-                await turn.catch(() => undefined);
-                return { ok: false, error: "Flow C 脚本回合超过 8 分钟，已自动终止当前 worker", retryable: true, timings: { queueWaitMs, threadStartMs, modelMs: Date.now() - modelStartedAt } };
+                await app?.terminate("Flow C 脚本执行链路超时，已仅回收当前 worker");
+            });
+            if (result.timedOut) {
+                return { ok: false, error: "Flow C 脚本执行链路超过 8 分钟，已自动终止当前 worker", retryable: true, timings: { queueWaitMs, threadStartMs: threadStartMs || Date.now() - threadStartedAt, modelMs: modelStartedAt ? Date.now() - modelStartedAt : 0 } };
             }
-            return { ok: true, text: result, timings: { queueWaitMs, threadStartMs, modelMs: Date.now() - modelStartedAt } };
+            return { ok: true, text: result.value, timings: { queueWaitMs, threadStartMs, modelMs: Date.now() - modelStartedAt } };
         }
         catch (error) {
             logger.error("Flow C Codex worker failed", { workerIndex, error });
@@ -72,12 +72,36 @@ export async function runCodexWorkflowTurn(prompt, emit, options) {
             return { ok: false, error: message, retryable: !isDeterministicWorkflowContractError(message), timings: { queueWaitMs, threadStartMs: threadStartMs || Date.now() - threadStartedAt, modelMs: modelStartedAt ? Date.now() - modelStartedAt : 0 } };
         }
         finally {
-            if (timer)
-                clearTimeout(timer);
             options.onWorkerFinish?.();
         }
     });
 }
+/**
+ * 给 Flow C 的完整 app-server 链路设置硬截止时间。超时后不再等待原 Promise
+ * 自行结束；否则初始化或 thread/start 永不返回时会永久占住 worker lane。
+ */
+export async function runBoundedWorkflowOperation(operation, timeoutMs, onTimeout) {
+    let timer;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => resolve({ timedOut: true }), Math.max(1, timeoutMs));
+    });
+    try {
+        const result = await Promise.race([
+            operation.then((value) => ({ timedOut: false, value })),
+            timeout,
+        ]);
+        if (!result.timedOut)
+            return result;
+        // Avoid an unhandled rejection if process termination settles the abandoned operation later.
+        void operation.catch(() => undefined);
+        await onTimeout();
+        return result;
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
 /** Contract/preflight 4xx errors are deterministic and must never burn every fallback chunk size. */
 export function isDeterministicWorkflowContractError(error) {
     const message = errorMessage(error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xiaohhhh1/canvas-agent",
-  "version": "0.4.55",
+  "version": "0.4.56",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",