@xiaohhhh1/canvas-agent 0.4.54 → 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/dist/workflow/manager.d.ts

@@ -270,7 +270,6 @@ export declare class WorkflowManager {
     private pumpScriptQueue;
     private finishDownloadDirectorySelection;
     private runScript;
-    private ensureCreativeCandidateSelections;
     private runCandidateChunk;
     /** 一个 chunk 使用独立线程；解析与中心持久化失败不会影响并行 lane。 */
     private runScriptChunk;
@@ -296,5 +295,17 @@ export declare function terminalScriptChunkError(results: Array<{
 }>): string;
 export declare function scriptChunkPrompt(id: string, task: ScriptTask, ordinals: number[]): string;
 export declare function creativeCandidatePrompt(id: string, task: ScriptTask, ordinals: number[]): string;
+/**
+ * 已选创意永远优先进入脚本扩写；只有当前没有可写脚本时才生成下一小波候选。
+ * 每次最多占用受控 worker 数量的子批，避免把整批候选提前塞满 worker 队列。
+ */
+export declare function nextScriptPipelineWave(task: Pick<ScriptTask, "requested_count" | "selected_candidates">, receivedOrdinals: number[], durationSeconds: 10 | 20 | 30, scriptChunkSize: number, candidateChunkSize?: number, concurrency?: number): {
+    stage: "script";
+    chunks: number[][];
+} | {
+    stage: "candidate";
+    chunks: number[][];
+};
+export declare function immediateScriptOrdinals(task: Pick<ScriptTask, "selected_candidates">, receivedOrdinals: number[], candidateOrdinals: number[]): number[];
 export declare function missingOrdinals(total: number, received: number[]): number[];
 export {};

package/dist/workflow/manager.js

@@ -244,7 +244,6 @@ export class WorkflowManager {
             if (Date.parse(task.expires_at) <= Date.now())
                 throw new ExpiredCapabilityError("脚本交接已过期，请在网页重新点击交给本机 Codex");
             const workspace = ensureSiteWorkspace(this.config);
-            task = await this.ensureCreativeCandidateSelections(id, task, workspace.workspacePath);
             const durationSeconds = Number(task.duration_seconds || 10);
             const chunkSizes = flowCScriptChunkSizes(durationSeconds);
             // Fail locally before starting any worker if a future schema edit
@@ -253,17 +252,55 @@ export class WorkflowManager {
                 flowCScriptOutputSchema(durationSeconds, chunkSize);
             record.activeChunks = 0;
             let chunkSizeIndex = 0;
+            let candidateChunkSize = 2;
             while (record.receivedOrdinals.length < task.requested_count) {
+                task = await this.scriptTask(id);
+                const selectedBefore = selectedCandidateOrdinals(task);
+                const wave = nextScriptPipelineWave(task, record.receivedOrdinals, durationSeconds, chunkSizes[chunkSizeIndex], candidateChunkSize);
+                if (wave.stage === "candidate") {
+                    const receivedBefore = record.receivedOrdinals.length;
+                    record.message = `本机 Codex 正在选择下一小批创意（${selectedBefore.length}/${task.requested_count}）；选好后立即写对应脚本`;
+                    record.activeChunks = 0;
+                    record.updatedAt = now();
+                    this.save();
+                    const pipelineResults = await Promise.all(wave.chunks.map(async (ordinals) => {
+                        const candidateResult = await this.runCandidateChunk(id, task, ordinals, workspace.workspacePath);
+                        if (candidateResult.error)
+                            return [candidateResult];
+                        const selectedTask = await this.scriptTask(id);
+                        const scriptOrdinals = immediateScriptOrdinals(selectedTask, this.scriptRecord(id).receivedOrdinals, ordinals);
+                        if (!scriptOrdinals.length)
+                            return [candidateResult];
+                        this.scriptRecord(id).attempts += 1;
+                        const scriptResult = await this.runScriptChunk(id, selectedTask, scriptOrdinals, workspace.workspacePath);
+                        return [candidateResult, scriptResult];
+                    }));
+                    const results = pipelineResults.flat();
+                    task = await this.scriptTask(id);
+                    const terminalError = terminalScriptChunkError(results);
+                    if (terminalError)
+                        throw new Error(`创意或脚本结构化契约被 Codex 拒绝，已停止自动重试（${terminalError}）`);
+                    if (record.receivedOrdinals.length > receivedBefore)
+                        chunkSizeIndex = 0;
+                    if (selectedCandidateOrdinals(task).length > selectedBefore.length) {
+                        candidateChunkSize = 2;
+                        continue;
+                    }
+                    if (candidateChunkSize > 1) {
+                        candidateChunkSize = 1;
+                        continue;
+                    }
+                    const lastError = results.map((result) => result.error).filter(Boolean).at(-1) || "候选生成或中心选题未返回结果";
+                    throw new Error(`创意候选阶段已隔离到单条仍失败（${lastError}），请点击重试`);
+                }
                 const before = record.receivedOrdinals.length;
-                const missing = missingOrdinals(task.requested_count, record.receivedOrdinals);
                 const chunkSize = chunkSizes[chunkSizeIndex];
-                const chunks = flowCScriptChunks(durationSeconds, missing, chunkSize);
                 record.chunkSize = chunkSize;
-                record.attempts += chunks.length;
-                record.message = `本机 Codex 正在用 ${FLOW_C_CODEX_WORKER_CONCURRENCY} 个受控 worker 写 ${chunks.length} 个独立子批（${before}/${task.requested_count}）`;
+                record.attempts += wave.chunks.length;
+                record.message = `创意已选 ${selectedBefore.length}/${task.requested_count}；正在立即写 ${wave.chunks.length} 个对应脚本子批（已回传 ${before}/${task.requested_count}）`;
                 record.updatedAt = now();
                 this.save();
-                const results = await Promise.all(chunks.map((ordinals) => this.runScriptChunk(id, task, ordinals, workspace.workspacePath)));
+                const results = await Promise.all(wave.chunks.map((ordinals) => this.runScriptChunk(id, task, ordinals, workspace.workspacePath)));
                 task = await this.scriptTask(id);
                 const terminalError = terminalScriptChunkError(results);
                 if (terminalError) {
@@ -304,36 +341,6 @@ export class WorkflowManager {
             this.runningScripts.delete(id);
         }
     }
-    async ensureCreativeCandidateSelections(id, initialTask, cwd) {
-        let task = initialTask;
-        let chunkSize = 2;
-        while (selectedCandidateOrdinals(task).length < task.requested_count) {
-            const before = selectedCandidateOrdinals(task).length;
-            const missing = missingOrdinals(task.requested_count, selectedCandidateOrdinals(task));
-            const chunks = chunkNumbers(missing, chunkSize);
-            const record = this.scriptRecord(id);
-            record.message = `本机 Codex 正在生成可审核创意候选，中心将自动选题（${before}/${task.requested_count}）`;
-            record.activeChunks = 0;
-            record.updatedAt = now();
-            this.save();
-            const results = await Promise.all(chunks.map((ordinals) => this.runCandidateChunk(id, task, ordinals, cwd)));
-            task = await this.scriptTask(id);
-            const terminalError = terminalScriptChunkError(results);
-            if (terminalError)
-                throw new Error(`创意候选结构化契约被 Codex 拒绝，已停止自动重试（${terminalError}）`);
-            if (selectedCandidateOrdinals(task).length > before) {
-                chunkSize = 2;
-                continue;
-            }
-            if (chunkSize > 1) {
-                chunkSize = 1;
-                continue;
-            }
-            const lastError = results.map((result) => result.error).filter(Boolean).at(-1) || "候选生成或中心选题未返回结果";
-            throw new Error(`创意候选阶段已隔离到单条仍失败（${lastError}），请点击重试`);
-        }
-        return task;
-    }
     async runCandidateChunk(id, task, ordinals, cwd) {
         const result = await runCodexWorkflowTurn(creativeCandidatePrompt(id, task, ordinals), this.emit, {
             cwd,
@@ -676,6 +683,25 @@ function chunkNumbers(values, size) {
         chunks.push(values.slice(index, index + size));
     return chunks;
 }
+/**
+ * 已选创意永远优先进入脚本扩写；只有当前没有可写脚本时才生成下一小波候选。
+ * 每次最多占用受控 worker 数量的子批，避免把整批候选提前塞满 worker 队列。
+ */
+export function nextScriptPipelineWave(task, receivedOrdinals, durationSeconds, scriptChunkSize, candidateChunkSize = 2, concurrency = FLOW_C_CODEX_WORKER_CONCURRENCY) {
+    const selected = selectedCandidateOrdinals(task);
+    const selectedSet = new Set(selected);
+    const scriptReady = missingOrdinals(task.requested_count, receivedOrdinals).filter((ordinal) => selectedSet.has(ordinal));
+    if (scriptReady.length) {
+        return { stage: "script", chunks: flowCScriptChunks(durationSeconds, scriptReady, scriptChunkSize).slice(0, concurrency) };
+    }
+    const candidateMissing = missingOrdinals(task.requested_count, selected);
+    return { stage: "candidate", chunks: chunkNumbers(candidateMissing, candidateChunkSize).slice(0, concurrency) };
+}
+export function immediateScriptOrdinals(task, receivedOrdinals, candidateOrdinals) {
+    const selected = new Set(selectedCandidateOrdinals(task));
+    const received = new Set(receivedOrdinals);
+    return candidateOrdinals.filter((ordinal) => selected.has(ordinal) && !received.has(ordinal));
+}
 function compactJson(value, limit) {
     return JSON.stringify(value).slice(0, limit);
 }

package/package.json

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