@xiaohhhh1/canvas-agent 0.4.3 → 0.4.5

package/dist/agent/codex.d.ts

@@ -9,9 +9,15 @@ type CodexRunOptions = {
     onTurn?: (turnId: string) => void;
     onFinish?: () => void;
 };
+export type CodexRunResult = {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
 export { summarizeCodexThread } from "./codex-history.js";
 /** 将 Codex turn 加入串行队列并等待执行完成。 */
-export declare function runCodexTurn(prompt: string, emit: AgentEmit, attachments?: AgentAttachment[], options?: CodexRunOptions): Promise<void>;
+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 的待处理权限请求。 */

package/dist/agent/codex.js

@@ -14,9 +14,9 @@ export { summarizeCodexThread } from "./codex-history.js";
 /** 将 Codex turn 加入串行队列并等待执行完成。 */
 export async function runCodexTurn(prompt, emit, attachments = [], options = {}) {
     if (!prompt.trim())
-        return;
+        return { ok: false, error: "Codex prompt is empty" };
     codexQueue = codexQueue.catch(() => undefined).then(() => runCodexTurnNow(prompt, emit, attachments, options));
-    await codexQueue;
+    return await codexQueue;
 }
 /** 中断当前线程正在执行的 Codex turn。 */
 export async function interruptCodexTurn(threadId) {
@@ -115,10 +115,13 @@ async function runCodexTurnNow(prompt, emit, attachments, options) {
             unmaterializedThreadIds.delete(threadId);
             await app.startTurn(threadId, prompt, files, options.permissionMode || "request", options.onTurn);
         }
+        return { ok: true };
     }
     catch (error) {
         logger.error("Codex turn failed", error);
-        emit("agent_error", { message: errorMessage(error) });
+        const message = errorMessage(error);
+        emit("agent_error", { message });
+        return { ok: false, error: message };
     }
     finally {
         options.onFinish?.();

package/dist/server/ensure-http.d.ts

@@ -1,2 +1,3 @@
-/** 插件 MCP 启动时确保本机 HTTP/后台队列服务常驻，无需客户另开终端。 */
+/** Ensure the local HTTP worker is running the same version as the MCP process. */
 export declare function ensureHttpServer(): Promise<void>;
+export declare function healthVersion(value: unknown): string;

package/dist/server/ensure-http.js

@@ -1,10 +1,21 @@
 import { spawn } from "node:child_process";
-import { loadConfig } from "../config.js";
-/** 插件 MCP 启动时确保本机 HTTP/后台队列服务常驻，无需客户另开终端。 */
+import { loadConfig, VERSION } from "../config.js";
+/** Ensure the local HTTP worker is running the same version as the MCP process. */
 export async function ensureHttpServer() {
     const config = loadConfig(true);
-    if (await healthy(config.url))
+    const current = await probeHealth(config.url);
+    if (current.ok && current.version === VERSION)
         return;
+    if (current.ok) {
+        const stopped = await requestShutdown(config.url, config.token);
+        if (!stopped)
+            throw new Error(`本机 Canvas Agent ${current.version || "旧版本"} 仍在运行，请关闭后重试以升级到 ${VERSION}`);
+        for (let attempt = 0; attempt < 40 && (await probeHealth(config.url)).ok; attempt += 1) {
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+        if ((await probeHealth(config.url)).ok)
+            throw new Error("旧版 Canvas Agent 未能正常退出，请关闭后重试");
+    }
     const entry = process.argv[1];
     if (!entry)
         throw new Error("无法定位 Canvas Agent 启动文件");
@@ -12,14 +23,35 @@ export async function ensureHttpServer() {
     child.unref();
     for (let attempt = 0; attempt < 40; attempt += 1) {
         await new Promise((resolve) => setTimeout(resolve, 250));
-        if (await healthy(config.url))
+        const next = await probeHealth(config.url);
+        if (next.ok && next.version === VERSION)
             return;
     }
     throw new Error("本机 Canvas Agent 后台服务启动失败");
 }
-async function healthy(url) {
+export function healthVersion(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return "";
+    return typeof value.version === "string" ? String(value.version) : "";
+}
+async function probeHealth(url) {
     try {
         const response = await fetch(new URL("/health", url), { signal: AbortSignal.timeout(800) });
+        if (!response.ok)
+            return { ok: false, version: "" };
+        return { ok: true, version: healthVersion(await response.json()) };
+    }
+    catch {
+        return { ok: false, version: "" };
+    }
+}
+async function requestShutdown(url, token) {
+    try {
+        const response = await fetch(new URL("/agent/shutdown", url), {
+            method: "POST",
+            headers: { "x-canvas-agent-token": token },
+            signal: AbortSignal.timeout(1500),
+        });
         return response.ok;
     }
     catch {

package/dist/server/http.js

@@ -5,7 +5,7 @@ import express from "express";
 import { runClaudeTurn } from "../agent/claude.js";
 import { archiveCodexThread, interruptCodexTurn, isRecoverableThreadError, listCodexThreads, readCodexThread, resolveCodexApproval, resumeCodexThread, runCodexTurn, startCodexThread, summarizeCodexThread, verifyCodexThreadWorkspace } from "../agent/codex.js";
 import { CanvasSession } from "../canvas/session.js";
-import { DEFAULT_PORT, ensureSiteWorkspace, loadConfig, saveConfig, updateSiteWorkspace } from "../config.js";
+import { DEFAULT_PORT, ensureSiteWorkspace, loadConfig, saveConfig, updateSiteWorkspace, VERSION } from "../config.js";
 import { startRelayBridge } from "../relay-bridge.js";
 import { logger } from "../utils/logger.js";
 import { windowsRootExecutable, windowsSystemExecutable } from "../utils/windows.js";
@@ -53,13 +53,21 @@ export function startHttpServer() {
             return void res.json({});
         next();
     });
-    app.get("/health", (_req, res) => res.json(session.health()));
+    app.get("/health", (_req, res) => res.json({ ...session.health(), version: VERSION }));
     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))
             return next();
         res.status(401).json({ ok: false, error: "invalid token" });
     });
+    let httpServer;
+    app.post("/agent/shutdown", (_req, res) => {
+        res.json({ ok: true, version: VERSION });
+        setTimeout(() => {
+            httpServer?.close(() => process.exit(0));
+            setTimeout(() => process.exit(0), 2000).unref();
+        }, 50).unref();
+    });
     app.get("/events", (req, res) => session.openEvents(requestUrl(req, config), res));
     app.post("/canvas/state", (req, res) => {
         session.updateState(req.body, String(req.query.clientId || "") || undefined);
@@ -259,7 +267,7 @@ export function startHttpServer() {
         logger.error("HTTP request failed", { method: req.method, path: req.path, error });
         res.status(500).json({ ok: false, error: error.message });
     });
-    app.listen(port, "127.0.0.1", () => {
+    httpServer = app.listen(port, "127.0.0.1", () => {
         console.log("Infinite Canvas Agent");
         console.log(`Local URL: ${config.url}`);
         console.log(`Connect token: ${config.token}`);

package/dist/server/mcp.js

@@ -3,6 +3,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { z } from "zod";
 import { toolDescriptions, toolInputSchemas, toolNames } from "../canvas/schemas.js";
 import { AGENT_PROMPT, loadConfig, VERSION } from "../config.js";
+import { FLOW_C_SCRIPT_CHUNK_MAX } from "../workflow/constants.js";
 /** 启动通过标准输入输出通信的 MCP 服务。 */
 export async function startMcpServer() {
     const config = loadConfig(true);
@@ -22,7 +23,7 @@ function registerWorkflowTools(server, config) {
         inputSchema: { handoffId: z.string().uuid().describe("网站创建的脚本交接 ID") },
     }, async ({ handoffId }) => workflowTool(config, `/agent/workflow/script-handoffs/${encodeURIComponent(handoffId)}/task`, { method: "GET" }));
     server.registerTool("flow_c_submit_script_chunk", {
-        description: "把本段独立完成的 Flow C 高质量脚本持久化回传给网站。每次 1–30 条；成功后再创作下一段。",
+        description: `把本段独立完成的 Flow C 高质量脚本持久化回传给网站。每次 1–${FLOW_C_SCRIPT_CHUNK_MAX} 条；成功后再创作下一段。`,
         inputSchema: {
             handoffId: z.string().uuid().describe("脚本交接 ID"),
             jobs: z.array(z.object({
@@ -30,7 +31,7 @@ function registerWorkflowTools(server, config) {
                 productIndex: z.number().int().nonnegative(),
                 sellingFormId: z.string().min(1).max(100),
                 script: z.string().min(40).max(20_000),
-            })).min(1).max(25),
+            })).min(1).max(FLOW_C_SCRIPT_CHUNK_MAX),
         },
     }, async ({ handoffId, jobs }) => workflowTool(config, `/agent/workflow/script-handoffs/${encodeURIComponent(handoffId)}/draft-chunks`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ jobs }) }));
 }

package/dist/workflow/constants.d.ts

@@ -0,0 +1,3 @@
+/** Flow C 脚本分段的唯一上限和自动降级顺序，MCP 与调度器必须共用。 */
+export declare const FLOW_C_SCRIPT_CHUNK_SIZES: readonly [30, 15, 10];
+export declare const FLOW_C_SCRIPT_CHUNK_MAX: 30;

package/dist/workflow/constants.js

@@ -0,0 +1,3 @@
+/** Flow C 脚本分段的唯一上限和自动降级顺序，MCP 与调度器必须共用。 */
+export const FLOW_C_SCRIPT_CHUNK_SIZES = [30, 15, 10];
+export const FLOW_C_SCRIPT_CHUNK_MAX = FLOW_C_SCRIPT_CHUNK_SIZES[0];

package/dist/workflow/manager.js

@@ -9,8 +9,8 @@ import { 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";
 const STATE_FILE = path.join(CONFIG_DIR, "workflow-state.json");
-const SCRIPT_CHUNK_SIZE = 30;
 const DOWNLOAD_POLL_MS = 10_000;
 /** 本机持久化的 Flow C 控制器：脚本交给本机 Codex，视频直接落盘。 */
 export class WorkflowManager {
@@ -85,8 +85,8 @@ export class WorkflowManager {
     /** MCP 分段回传脚本，中心接口再次执行数量、产品索引和脚本完整性校验。 */
     async submitScriptChunk(idValue, jobsValue) {
         const record = this.scriptRecord(workflowId(idValue, "脚本交接 ID"));
-        if (!Array.isArray(jobsValue) || !jobsValue.length || jobsValue.length > SCRIPT_CHUNK_SIZE)
-            throw new Error(`每段必须包含 1–${SCRIPT_CHUNK_SIZE} 条脚本`);
+        if (!Array.isArray(jobsValue) || !jobsValue.length || jobsValue.length > FLOW_C_SCRIPT_CHUNK_MAX)
+            throw new Error(`每段必须包含 1–${FLOW_C_SCRIPT_CHUNK_MAX} 条脚本`);
         const jobs = jobsValue;
         const data = await commerceJson(`${record.apiBase}/workflow-script-handoffs/${encodeURIComponent(record.id)}/draft-chunks`, record.accessToken, "x-workflow-handoff-token", { method: "POST", body: JSON.stringify({ jobs }) });
         if (Array.isArray(data.receivedOrdinals))
@@ -217,23 +217,39 @@ export class WorkflowManager {
                 this.save();
             }
             while (record.receivedOrdinals.length < task.requested_count) {
-                const missing = missingOrdinals(task.requested_count, record.receivedOrdinals).slice(0, SCRIPT_CHUNK_SIZE);
-                if (!missing.length)
-                    break;
                 let progressed = false;
-                for (let attempt = 1; attempt <= 3 && !progressed; attempt += 1) {
+                let lastRange = "";
+                let lastError = "";
+                for (const [attemptIndex, chunkSize] of FLOW_C_SCRIPT_CHUNK_SIZES.entries()) {
+                    const missing = missingOrdinals(task.requested_count, record.receivedOrdinals).slice(0, chunkSize);
+                    if (!missing.length) {
+                        progressed = true;
+                        break;
+                    }
+                    lastRange = `${missing[0]}–${missing.at(-1)}`;
                     const before = record.receivedOrdinals.length;
                     record.attempts += 1;
                     record.message = `本机 Codex 正在写第 ${missing[0]}–${missing.at(-1)} 条（总计 ${task.requested_count} 条）`;
                     record.updatedAt = now();
                     this.save();
-                    await runCodexTurn(scriptChunkPrompt(id, task, missing), this.emit, [], { threadId: record.threadId, cwd: workspace.workspacePath, permissionMode: "full", onThread: (threadId) => { record.threadId = threadId; this.save(); } });
+                    const result = await runCodexTurn(scriptChunkPrompt(id, task, missing), this.emit, [], { threadId: record.threadId, cwd: workspace.workspacePath, permissionMode: "full", onThread: (threadId) => { record.threadId = threadId; this.save(); } });
+                    await this.scriptTask(id);
                     progressed = record.receivedOrdinals.length > before;
-                    if (!progressed && attempt < 3)
-                        record.message = `第 ${missing[0]}–${missing.at(-1)} 条未成功回传，正在自动重试 ${attempt + 1}/3`;
+                    if (progressed)
+                        break;
+                    // Keep provider/client details out of the browser-facing state. The
+                    // underlying Codex runner already records the technical error locally.
+                    lastError = result.ok ? "Codex 未调用回传工具" : "Codex 本轮执行失败";
+                    if (attemptIndex < FLOW_C_SCRIPT_CHUNK_SIZES.length - 1) {
+                        const nextSize = FLOW_C_SCRIPT_CHUNK_SIZES[attemptIndex + 1];
+                        record.message = `第 ${lastRange} 条未成功回传，正在换新会话并缩小为每段 ${nextSize} 条重试`;
+                        const thread = await startCodexThread(this.emit, workspace.workspacePath, "full");
+                        record.threadId = String(thread.id || "");
+                        this.save();
+                    }
                 }
                 if (!progressed)
-                    throw new Error(`本机 Codex 连续 3 次未回传第 ${missing[0]}–${missing.at(-1)} 条，请点击重试`);
+                    throw new Error(`本机 Codex 已自动换会话并降级到每段 10 条，仍未回传第 ${lastRange} 条${lastError ? `（${lastError}）` : ""}，请点击重试`);
             }
             const finalTask = await this.scriptTask(id);
             if (finalTask.status === "ready" && record.receivedOrdinals.length === task.requested_count) {
@@ -374,6 +390,7 @@ function scriptChunkPrompt(id, task, ordinals) {
 必须使用 MCP 工具 flow_c_get_script_task 读取完整任务，再只创作 ordinal ${ordinals[0]} 到 ${ordinals.at(-1)}（精确列表：${ordinals.join(", ")}）。
 本段 productIndex 必须严格按此映射填写：${scriptProductAssignments(task.product_quantities, ordinals)}。不得凭产品名称猜测或把相邻产品编号混用。
 脚本质量绝不能因批量而降低：每条都必须独立构思、完整、真实合规，严格遵守任务 instructions、产品图片顺序和 productIndex；使用目标市场 ${task.market} 的自然本地语言与偏快但清晰的 10 秒节奏。
+用户没有指定带货方向时，不得随意只用一种泛化形式；必须按任务 instructions 中“已批准的创意方向”逐条做产品适配轮换。轮换必须按每个产品自己的序号连续计算，不能因 30/15/10 条分段、换会话或跨产品边界而从第一个方向重新开始；让同一产品在重复某一方向前优先覆盖其他适配方向。
 写完后必须调用 flow_c_submit_script_chunk 一次回传这 ${ordinals.length} 条，handoffId=${id}。不要创建付费批次，不要调用供应商模型，不要在聊天输出大段 JSON。工具返回成功后仅简短结束。`;
 }
 function scriptProductAssignments(productQuantities, ordinals) {

package/package.json

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