@xiaohhhh1/canvas-agent 0.4.43 → 0.4.45

package/dist/agent/codex-client.d.ts

@@ -1,5 +1,5 @@
 import { type JsonRecord } from "../utils/value.js";
-import type { CodexPlanUpdate, CodexRequestParams } from "./codex-protocol.js";
+import type { CodexPlanUpdate, CodexRequestParams, CodexTurn } from "./codex-protocol.js";
 import type { AgentEmit, AgentPermissionMode } from "./types.js";
 /** 封装 Codex app-server 的 JSON-RPC 通信与事件转换。 */
 export declare class CodexAppClient {
@@ -46,6 +46,8 @@ export declare class CodexAppClient {
     startTurn(threadId: string, prompt: string, images: string[], permissionMode: AgentPermissionMode, onTurn?: (turnId: string) => void, outputSchema?: JsonRecord): Promise<string>;
     /** 中断当前正在运行的 Codex turn。 */
     interruptCurrentTurn(): Promise<boolean>;
+    /** 终止失去响应的 app-server，让后续队列可以在新进程继续。 */
+    terminate(message?: string): Promise<void>;
     /** 回复网页端已经确认的 Codex 权限请求。 */
     resolveApproval(requestId: string, decision: string): boolean;
     /** 发送 JSON-RPC 请求并保存待处理 Promise。 */
@@ -64,6 +66,13 @@ export declare class CodexAppClient {
     private emitDelta;
     /** 合并短时间内的文本增量，减少 SSE 传输和前端渲染次数。 */
     private flushDelta;
+    /**
+     * app-server 的流式通知偶尔会在本地重连时丢失。定期读取线程的最终
+     * 状态，保证被中断的 turn 不会只因少了一条通知而永久占着 Flow C 队列。
+     */
+    private scheduleTurnReconciliation;
+    /** 清除 turn 等待器与其轮询计时器。 */
+    private clearActiveTurn;
     /** 自动回复 app-server 发起的授权或交互请求。 */
     private answerServerRequest;
     /** 完成指定 JSON-RPC 请求。 */
@@ -73,3 +82,9 @@ export declare class CodexAppClient {
     /** 拒绝进程退出时仍未完成的请求与 turn。 */
     private failAll;
 }
+/** 只有正常 completed 才能被调用方视为可用脚本。 */
+export declare function isTerminalTurnStatus(status: unknown): boolean;
+/** interrupted 也必须作为失败传回，不能被误当成空的成功响应。 */
+export declare function turnFailure(turn: Pick<CodexTurn, "status" | "error">): Error | null;
+/** 补偿轮询发现终态时，尽量取回已完成的结构化文本。 */
+export declare function turnText(turn: CodexTurn): string;

package/dist/agent/codex-client.js

@@ -8,6 +8,7 @@ import { field } from "../utils/value.js";
 const canvasAgentMcp = canvasAgentMcpCommand();
 const require = createRequire(import.meta.url);
 const STREAM_UPDATE_INTERVAL_MS = 40;
+const TURN_RECONCILE_INTERVAL_MS = 5_000;
 /** 封装 Codex app-server 的 JSON-RPC 通信与事件转换。 */
 export class CodexAppClient {
     child;
@@ -110,7 +111,10 @@ export class CodexAppClient {
                 throw completed.error;
             return completed?.text || "";
         }
-        return await new Promise((resolve, reject) => this.activeTurns.set(turnId, { resolve, reject }));
+        return await new Promise((resolve, reject) => {
+            this.activeTurns.set(turnId, { resolve, reject });
+            this.scheduleTurnReconciliation(threadId, turnId);
+        });
     }
     /** 中断当前正在运行的 Codex turn。 */
     async interruptCurrentTurn() {
@@ -128,6 +132,17 @@ export class CodexAppClient {
             return false;
         }
     }
+    /** 终止失去响应的 app-server，让后续队列可以在新进程继续。 */
+    terminate(message = "Codex app-server was restarted") {
+        this.failAll(message);
+        if (this.child.exitCode !== null)
+            return Promise.resolve();
+        return new Promise((resolve) => {
+            const timer = setTimeout(resolve, 2000);
+            this.child.once("exit", () => { clearTimeout(timer); resolve(); });
+            this.child.kill();
+        });
+    }
     /** 回复网页端已经确认的 Codex 权限请求。 */
     resolveApproval(requestId, decision) {
         const request = this.approvalRequests.get(requestId);
@@ -256,11 +271,11 @@ export class CodexAppClient {
             const turn = params.turn;
             const turnId = turn.id;
             const pending = this.activeTurns.get(turnId);
-            const error = turn.error;
+            const error = turnFailure(turn);
             const text = this.finalTextByTurn.get(turnId) || "";
             this.finalTextByTurn.delete(turnId);
             if (pending) {
-                this.activeTurns.delete(turnId);
+                this.clearActiveTurn(turnId);
                 error ? pending.reject(new Error(error.message || "Codex turn failed")) : pending.resolve(text);
             }
             else if (turnId) {
@@ -300,6 +315,53 @@ export class CodexAppClient {
         if (pending.delta)
             this.emit("agent_event", { agent: "codex", type: "item.updated", item: { id, type: pending.itemType, delta: pending.delta }, ...codexEventScope(pending.params) });
     }
+    /**
+     * app-server 的流式通知偶尔会在本地重连时丢失。定期读取线程的最终
+     * 状态，保证被中断的 turn 不会只因少了一条通知而永久占着 Flow C 队列。
+     */
+    scheduleTurnReconciliation(threadId, turnId) {
+        const check = async () => {
+            const pending = this.activeTurns.get(turnId);
+            if (!pending)
+                return;
+            try {
+                const result = await this.readThread(threadId, true);
+                const thread = field(result, "thread");
+                const turns = Array.isArray(field(thread, "turns")) ? field(thread, "turns") : [];
+                const turn = turns.find((item) => item?.id === turnId);
+                if (turn && isTerminalTurnStatus(turn.status)) {
+                    const error = turnFailure(turn);
+                    const text = turnText(turn);
+                    this.finalTextByTurn.delete(turnId);
+                    this.clearActiveTurn(turnId);
+                    error ? pending.reject(new Error(error.message)) : pending.resolve(text);
+                    if (turnId === this.currentTurnId) {
+                        this.currentThreadId = "";
+                        this.currentTurnId = "";
+                    }
+                    return;
+                }
+            }
+            catch (error) {
+                // The normal deadline in the workflow manager remains the hard
+                // fallback. A transient read error must not cancel live work.
+                logger.debug("Codex turn reconciliation read failed", { threadId, turnId, error });
+            }
+            const current = this.activeTurns.get(turnId);
+            if (current)
+                current.reconcileTimer = setTimeout(() => void check(), TURN_RECONCILE_INTERVAL_MS);
+        };
+        const pending = this.activeTurns.get(turnId);
+        if (pending)
+            pending.reconcileTimer = setTimeout(() => void check(), TURN_RECONCILE_INTERVAL_MS);
+    }
+    /** 清除 turn 等待器与其轮询计时器。 */
+    clearActiveTurn(turnId) {
+        const pending = this.activeTurns.get(turnId);
+        if (pending?.reconcileTimer)
+            clearTimeout(pending.reconcileTimer);
+        this.activeTurns.delete(turnId);
+    }
     /** 自动回复 app-server 发起的授权或交互请求。 */
     answerServerRequest(message) {
         const method = String(message.method);
@@ -328,7 +390,13 @@ export class CodexAppClient {
     }
     /** 拒绝进程退出时仍未完成的请求与 turn。 */
     failAll(message) {
-        [...this.pending.values(), ...this.activeTurns.values()].forEach((item) => item.reject(new Error(message)));
+        [...this.pending.values()].forEach((item) => item.reject(new Error(message)));
+        [...this.activeTurns.entries()].forEach(([turnId, item]) => {
+            if (item.reconcileTimer)
+                clearTimeout(item.reconcileTimer);
+            this.activeTurns.delete(turnId);
+            item.reject(new Error(message));
+        });
         this.pendingDeltas.forEach((item) => clearTimeout(item.timer));
         this.pending.clear();
         this.activeTurns.clear();
@@ -340,6 +408,35 @@ export class CodexAppClient {
         this.currentTurnId = "";
     }
 }
+/** 只有正常 completed 才能被调用方视为可用脚本。 */
+export function isTerminalTurnStatus(status) {
+    return ["completed", "failed", "interrupted", "cancelled", "canceled"].includes(String(status || "").toLowerCase());
+}
+/** interrupted 也必须作为失败传回，不能被误当成空的成功响应。 */
+export function turnFailure(turn) {
+    if (turn.error)
+        return new Error(turn.error.message || "Codex turn failed");
+    const status = String(turn.status || "completed").toLowerCase();
+    return status === "completed" ? null : new Error(`Codex turn ${status}`);
+}
+/** 补偿轮询发现终态时，尽量取回已完成的结构化文本。 */
+export function turnText(turn) {
+    const items = Array.isArray(field(turn, "items")) ? field(turn, "items") : [];
+    for (const item of [...items].reverse()) {
+        if (!["agent_message", "agentMessage"].includes(String(field(item, "type") || "")))
+            continue;
+        const text = field(item, "text");
+        if (typeof text === "string" && text)
+            return text;
+        const content = field(item, "content");
+        if (Array.isArray(content)) {
+            const joined = content.map((part) => String(field(part, "text") || "")).join("");
+            if (joined)
+                return joined;
+        }
+    }
+    return "";
+}
 /** 生成 Codex 调用 Canvas Agent MCP 的启动命令。 */
 function canvasAgentMcpCommand() {
     const current = process.argv.find((arg) => /index\.(t|j)s$/.test(arg)) || "";

package/dist/agent/codex-protocol.d.ts

@@ -6,6 +6,7 @@ export type CodexThread = JsonRecord & {
 };
 export type CodexTurn = JsonRecord & {
     id: string;
+    status?: string;
     error?: CodexTurnError | null;
     durationMs?: number | null;
 };

package/dist/agent/codex.d.ts

@@ -22,6 +22,8 @@ export { summarizeCodexThread } from "./codex-history.js";
 export declare function runCodexTurn(prompt: string, emit: AgentEmit, attachments?: AgentAttachment[], options?: CodexRunOptions): Promise<CodexRunResult>;
 /** 中断当前线程正在执行的 Codex turn。 */
 export declare function interruptCodexTurn(threadId?: string): Promise<boolean>;
+/** 强制回收失去响应的 app-server；只用于有界超时恢复。 */
+export declare function restartCodexApp(message?: string): Promise<void>;
 /** 回复当前 app-server 的待处理权限请求。 */
 export declare function resolveCodexApproval(requestId: string, decision: string): Promise<boolean>;
 /** 创建新的 Codex 线程并记录当前线程 ID。 */

package/dist/agent/codex.js

@@ -24,6 +24,14 @@ export async function interruptCodexTurn(threadId) {
         return false;
     return await codexApp.interruptCurrentTurn();
 }
+/** 强制回收失去响应的 app-server；只用于有界超时恢复。 */
+export async function restartCodexApp(message = "Codex 执行超时，正在重启本机脚本引擎") {
+    const app = codexApp;
+    codexApp = null;
+    codexAppStart = null;
+    codexThreadId = "";
+    await app?.terminate(message);
+}
 /** 回复当前 app-server 的待处理权限请求。 */
 export async function resolveCodexApproval(requestId, decision) {
     return Boolean(codexApp?.resolveApproval(requestId, decision));

package/dist/canvas/schemas.d.ts

@@ -975,16 +975,16 @@ export declare const toolInputSchemas: {
     }, "strip", z.ZodTypeAny, {
         title: string;
         kind: "text" | "image";
-        source?: string | undefined;
         content?: string | undefined;
+        source?: string | undefined;
         tags?: string[] | undefined;
         imageUrl?: string | undefined;
         note?: string | undefined;
     }, {
         title: string;
         kind: "text" | "image";
-        source?: string | undefined;
         content?: string | undefined;
+        source?: string | undefined;
         tags?: string[] | undefined;
         imageUrl?: string | undefined;
         note?: string | undefined;

package/dist/canvas/tools.d.ts

@@ -173,8 +173,8 @@ export declare function parseToolInput(name: ToolName, input: unknown): {
 } | {
     title: string;
     kind: "text" | "image";
-    source?: string | undefined;
     content?: string | undefined;
+    source?: string | undefined;
     tags?: string[] | undefined;
     imageUrl?: string | undefined;
     note?: string | undefined;

package/dist/index.js

@@ -7,6 +7,10 @@ if (process.argv[2] === "mcp") {
     await ensureHttpServer();
     await startMcpServer();
 }
+else if (process.argv[2] === "upgrade") {
+    await ensureHttpServer();
+    console.log("Canvas Agent upgraded and running in the background.");
+}
 else if (process.argv[2] === "watch")
     startHttpSupervisor();
 else

package/dist/server/http.js

@@ -59,7 +59,7 @@ export function startHttpServer() {
             return void res.json({});
         next();
     });
-    app.get("/health", (_req, res) => res.json({ ...session.health(), version: VERSION, relayReady: relayStatus.ready, relayLastReadyAt: relayStatus.lastReadyAt, relayLastDisconnectAt: relayStatus.lastDisconnectAt }));
+    app.get("/health", (_req, res) => res.json({ ...session.health(), version: VERSION, workflow: workflows.health(), relayReady: relayStatus.ready, relayLastReadyAt: relayStatus.lastReadyAt, relayLastDisconnectAt: relayStatus.lastDisconnectAt }));
     app.get("/config", (_req, res) => res.json({ ok: true, url: config.url, hasToken: true }));
     app.use((req, res, next) => {
         if (validToken(req, requestUrl(req, config), config.token))

package/dist/workflow/manager.d.ts

@@ -1,7 +1,22 @@
 import type { AgentEmit } from "../agent/types.js";
 import { type CanvasAgentConfig } from "../config.js";
+export declare const FLOW_C_CODEX_TURN_TIMEOUT_MS: number;
 type ScriptStatus = "queued" | "running" | "complete" | "error" | "expired";
 type DownloadStatus = "waiting" | "running" | "complete" | "error" | "expired";
+type ScriptRecord = {
+    id: string;
+    apiBase: string;
+    accessToken: string;
+    status: ScriptStatus;
+    requestedCount: number;
+    receivedOrdinals: number[];
+    threadId?: string;
+    message?: string;
+    expiresAt?: string;
+    attempts: number;
+    priorityAt?: string;
+    updatedAt: string;
+};
 type ScriptTask = {
     id: string;
     workflow: "flow-c";
@@ -86,6 +101,11 @@ export declare class WorkflowManager {
             updatedAt: string;
         }[];
     };
+    health(): {
+        activeScriptHandoffIds: string[];
+        queuedScripts: number;
+        blockedScripts: number;
+    };
     startDownloadDirectorySelection(): {
         id: string;
         status: "selecting" | "selected" | "cancelled" | "error";
@@ -174,4 +194,5 @@ export declare class WorkflowManager {
     private downloadRecord;
     private save;
 }
+export declare function compareScriptQueueRecords(left: Pick<ScriptRecord, "priorityAt" | "updatedAt">, right: Pick<ScriptRecord, "priorityAt" | "updatedAt">): number;
 export {};

package/dist/workflow/manager.js

@@ -5,13 +5,14 @@ import { mkdir, open, rename, stat, unlink } from "node:fs/promises";
 import path from "node:path";
 import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
-import { runCodexTurn, startCodexThread } from "../agent/codex.js";
+import { restartCodexApp, runCodexTurn, startCodexThread } from "../agent/codex.js";
 import { CONFIG_DIR, ensureSiteWorkspace } from "../config.js";
 import { logger } from "../utils/logger.js";
 import { windowsPowerShellExecutable } from "../utils/windows.js";
 import { FLOW_C_SCRIPT_CHUNK_MAX, FLOW_C_SCRIPT_CHUNK_SIZES } from "./constants.js";
 import { flowCScriptOutputSchema, parseFlowCScriptOutput } from "./script-output.js";
 const STATE_FILE = path.join(CONFIG_DIR, "workflow-state.json");
+export const FLOW_C_CODEX_TURN_TIMEOUT_MS = 8 * 60 * 1000;
 /** 本机持久化的 Flow C 控制器：脚本交给本机 Codex，视频直接落盘。 */
 export class WorkflowManager {
     config;
@@ -46,6 +47,7 @@ export class WorkflowManager {
             threadId: previous?.threadId,
             expiresAt: String(input.expiresAt || previous?.expiresAt || "") || undefined,
             attempts: previous?.attempts || 0,
+            priorityAt: now(),
             message: previous?.status === "complete" ? previous.message : "已进入本机 Codex 队列",
             updatedAt: now(),
         };
@@ -57,6 +59,7 @@ export class WorkflowManager {
         const id = workflowId(idValue, "脚本交接 ID");
         const record = this.scriptRecord(id);
         record.status = "queued";
+        record.priorityAt = now();
         record.message = "正在重新连接本机 Codex";
         record.updatedAt = now();
         this.save();
@@ -109,6 +112,14 @@ export class WorkflowManager {
             subscriptions: Object.values(this.state.downloads).map(publicDownload),
         };
     }
+    health() {
+        const records = Object.values(this.state.scripts);
+        return {
+            activeScriptHandoffIds: [...this.runningScripts],
+            queuedScripts: records.filter((record) => record.status === "queued" || record.status === "running").length,
+            blockedScripts: records.filter((record) => record.status === "error").length,
+        };
+    }
     startDownloadDirectorySelection() {
         if (this.directorySelection?.status === "selecting")
             return this.directorySelection;
@@ -177,7 +188,7 @@ export class WorkflowManager {
             while (true) {
                 const next = Object.values(this.state.scripts)
                     .filter((record) => (record.status === "queued" || record.status === "running") && !this.runningScripts.has(record.id))
-                    .sort((left, right) => left.updatedAt.localeCompare(right.updatedAt))[0];
+                    .sort(compareScriptQueueRecords)[0];
                 if (!next)
                     break;
                 await this.runScript(next.id);
@@ -207,6 +218,7 @@ export class WorkflowManager {
         this.runningScripts.add(id);
         const record = this.scriptRecord(id);
         try {
+            delete record.priorityAt;
             record.status = "running";
             record.message = "正在读取完整产品清单";
             record.updatedAt = now();
@@ -236,7 +248,7 @@ export class WorkflowManager {
                     record.message = `本机 Codex 正在写第 ${missing[0]}–${missing.at(-1)} 条（总计 ${task.requested_count} 条）`;
                     record.updatedAt = now();
                     this.save();
-                    const result = await runCodexTurn(scriptChunkPrompt(id, task, missing), this.emit, [], { threadId: record.threadId, cwd: workspace.workspacePath, permissionMode: "full", outputSchema: flowCScriptOutputSchema(Number(task.duration_seconds || 10), missing.length), onThread: (threadId) => { record.threadId = threadId; this.save(); } });
+                    const result = await runCodexScriptWithTimeout(scriptChunkPrompt(id, task, missing), this.emit, { threadId: record.threadId, cwd: workspace.workspacePath, permissionMode: "full", outputSchema: flowCScriptOutputSchema(Number(task.duration_seconds || 10), missing.length), onThread: (threadId) => { record.threadId = threadId; this.save(); } });
                     await this.scriptTask(id);
                     progressed = record.receivedOrdinals.length > before;
                     if (!progressed && result.ok && result.text) {
@@ -417,6 +429,28 @@ export class WorkflowManager {
     }
     save() { saveState(this.state); }
 }
+export function compareScriptQueueRecords(left, right) {
+    if (left.priorityAt || right.priorityAt)
+        return String(right.priorityAt || "").localeCompare(String(left.priorityAt || ""));
+    return left.updatedAt.localeCompare(right.updatedAt);
+}
+async function runCodexScriptWithTimeout(prompt, emit, options) {
+    let timer;
+    const turn = runCodexTurn(prompt, emit, [], options);
+    const timeout = new Promise((resolve) => { timer = setTimeout(() => resolve("timeout"), FLOW_C_CODEX_TURN_TIMEOUT_MS); });
+    try {
+        const result = await Promise.race([turn, timeout]);
+        if (result !== "timeout")
+            return result;
+        await restartCodexApp("Flow C 脚本回合超过 8 分钟，已自动终止并换新会话");
+        await turn;
+        return { ok: false, error: "Flow C 脚本回合超过 8 分钟，已自动终止并换新会话" };
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
 class ExpiredCapabilityError extends Error {
 }
 function scriptChunkPrompt(id, task, ordinals) {

package/package.json

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