@xiaohhhh1/canvas-agent 0.4.14 → 0.4.16

package/README.md

@@ -1,6 +1,6 @@
 # Infinite Canvas Agent
 
-本地 Canvas Agent 用来连接网站和用户自己电脑上的 Codex。它还负责持久化 Flow C 脚本队列、分段调用本机 Codex、自动回传草案，以及在网页关闭后继续把完成视频校验并保存到用户选择的磁盘目录。
+本地 Canvas Agent 用来连接网站和用户自己电脑上的 Codex。它还负责持久化 Flow C 脚本队列、分段调用本机 Codex、自动回传草案，以及在用户明确点击“一键下载本批全部”后把完成视频校验并保存到所选磁盘目录。
 
 ## 启动
 
@@ -87,7 +87,7 @@ npx -y @xiaohhhh1/canvas-agent mcp
 1. 客户在网站添加一个或多个产品，按顺序上传每个产品 1–5 张图片并填写数量。
 2. 点击“交给本机 Codex 写全部脚本”。本机助手每次只处理 10 条并持久化进度，断网或重启后可继续；脚本完成会自动回传网站，不创建付费任务。
 3. 客户审阅脚本并确认费用后，中心 `workflow-runner` 才执行故事板和视频生成。
-4. 客户只需首次选择一个本机目录。Agent 每 10 秒检查交付，先写 `.part`，校验大小与 SHA-256 后原子改名；清单已记录的批次序号不会重复下载，网页关闭后仍会继续。
+4. 客户先选择一个本机目录，再对需要的批次点击“一键下载本批全部”。登录另一台电脑、选择文件夹或查看历史批次都不会触发下载。Agent 以最多四路并行写 `.part`，校验大小与 SHA-256 后原子改名；清单已记录且校验有效的批次序号不会重复下载。
 
 本机持久状态默认保存在 `~/.infinite-canvas/workflow-state.json`，权限设为仅当前用户可读写。这里包含短期能力令牌和本机路径，不应上传、提交到 Git 或发到聊天中。
 

package/dist/integrations/fastmoss.d.ts

@@ -0,0 +1,53 @@
+export type FastMossPhase = "idle" | "launching" | "login_required" | "ready" | "verification_required" | "membership_expired" | "error";
+export type FastMossStatus = {
+    phase: FastMossPhase;
+    browserOpen: boolean;
+    authenticated: boolean;
+    verificationRequired: boolean;
+    membershipExpired: boolean;
+    message: string;
+    url: string | null;
+    captured: number;
+    lastCapture?: string;
+};
+type CaptureContext = {
+    market?: string;
+    category?: string;
+    shopType?: string;
+    periodDays?: number;
+};
+export declare class FastMossIntegration {
+    private context;
+    private page;
+    private phase;
+    private authenticated;
+    private verificationRequired;
+    private membershipExpired;
+    private message;
+    private captured;
+    private lastCapture?;
+    private lastMembershipCheckAt;
+    private readonly profileDir;
+    private readonly dataDir;
+    status(): FastMossStatus;
+    start(): Promise<FastMossStatus>;
+    inspect(): Promise<FastMossStatus>;
+    capture(input?: CaptureContext): Promise<{
+        records: Record<string, unknown>[];
+        allRows: Record<string, unknown>[];
+        phase: FastMossPhase;
+        browserOpen: boolean;
+        authenticated: boolean;
+        verificationRequired: boolean;
+        membershipExpired: boolean;
+        message: string;
+        url: string | null;
+        captured: number;
+        lastCapture?: string;
+    }>;
+    close(): Promise<FastMossStatus>;
+    switchAccount(): Promise<FastMossStatus>;
+    private loadRows;
+    private useLatestPage;
+}
+export {};

package/dist/integrations/fastmoss.js

@@ -0,0 +1,301 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { chromium } from "playwright-core";
+import { CONFIG_DIR } from "../config.js";
+const FASTMOSS_HOME = "https://www.fastmoss.com/";
+const MEMBERSHIP_RECHECK_MS = 5 * 60_000;
+export class FastMossIntegration {
+    context = null;
+    page = null;
+    phase = "idle";
+    authenticated = false;
+    verificationRequired = false;
+    membershipExpired = false;
+    message = "尚未启动 FastMoss 专用浏览器";
+    captured = 0;
+    lastCapture;
+    lastMembershipCheckAt = 0;
+    profileDir = path.join(CONFIG_DIR, "fastmoss-session");
+    dataDir = path.join(CONFIG_DIR, "fastmoss-selection");
+    status() {
+        return {
+            phase: this.phase,
+            browserOpen: Boolean(this.context),
+            authenticated: this.authenticated,
+            verificationRequired: this.verificationRequired,
+            membershipExpired: this.membershipExpired,
+            message: this.message,
+            url: this.page?.url() || null,
+            captured: this.captured,
+            lastCapture: this.lastCapture,
+        };
+    }
+    async start() {
+        if (this.context) {
+            this.useLatestPage();
+            if (this.page && !this.page.isClosed())
+                return this.inspect();
+            await this.context.close().catch(() => undefined);
+            this.context = null;
+            this.page = null;
+        }
+        this.phase = "launching";
+        this.membershipExpired = false;
+        this.lastMembershipCheckAt = 0;
+        this.message = "正在启动 FastMoss 专用浏览器";
+        try {
+            await mkdir(this.profileDir, { recursive: true });
+            const executablePath = findChromiumExecutable();
+            if (!executablePath)
+                throw new Error("未找到 Google Chrome 或 Microsoft Edge，请先安装浏览器");
+            this.context = await chromium.launchPersistentContext(this.profileDir, {
+                executablePath,
+                headless: false,
+                viewport: null,
+                args: ["--start-maximized"],
+            });
+        }
+        catch (error) {
+            this.phase = "error";
+            this.message = error instanceof Error ? error.message : "FastMoss 专用浏览器启动失败";
+            throw error;
+        }
+        this.page = this.context.pages()[0] || await this.context.newPage();
+        this.context.on("page", (page) => {
+            this.page = page;
+        });
+        this.context.on("close", () => {
+            this.context = null;
+            this.page = null;
+            this.phase = "idle";
+            this.authenticated = false;
+            this.verificationRequired = false;
+            this.membershipExpired = false;
+            this.lastMembershipCheckAt = 0;
+            this.message = "FastMoss 浏览器已关闭；本机登录资料仍保留";
+        });
+        if (!this.page.url() || this.page.url() === "about:blank")
+            await this.page.goto(FASTMOSS_HOME, { waitUntil: "domcontentloaded", timeout: 60_000 });
+        return this.inspect();
+    }
+    async inspect() {
+        this.useLatestPage();
+        if (!this.page || this.page.isClosed()) {
+            this.phase = "idle";
+            this.authenticated = false;
+            this.verificationRequired = false;
+            this.membershipExpired = false;
+            this.lastMembershipCheckAt = 0;
+            this.message = "请先启动 FastMoss 专用浏览器";
+            return this.status();
+        }
+        const snapshot = await this.page.evaluate(() => ({
+            title: document.title,
+            url: location.href,
+            text: (document.body?.innerText || "").slice(0, 12_000),
+            hasTable: Boolean(document.querySelector("table tbody tr")),
+        })).catch(() => ({ title: "", url: this.page?.url() || "", text: "", hasTable: false }));
+        const haystack = `${snapshot.title}\n${snapshot.url}\n${snapshot.text}`.toLowerCase();
+        this.verificationRequired = /captcha|verify|verification|security check|人机验证|安全验证|滑块验证|请完成验证/.test(haystack);
+        const loginRequired = /\/login|\/signin|sign in|log in|登录账号|密码登录|扫码登录/.test(haystack) && !snapshot.hasTable;
+        const explicitExpiry = /(?:会员|套餐|订阅|专业版|高级版|账号).{0,16}(?:已过期|已到期|到期失效|无法使用)|(?:membership|subscription|plan|account).{0,28}(?:has\s+)?expired|(?:membership|subscription|plan).{0,20}(?:is no longer active|needs renewal)/i.test(haystack);
+        const entitlementUnavailable = /(?:当前账号|当前套餐).{0,20}(?:无权|没有权限|不支持|无法)(?:查看|访问|使用)|(?:开通|升级)(?:会员|专业版|套餐).{0,16}(?:后)?(?:才可|方可)(?:查看|访问|使用)|仅限(?:会员|专业版)(?:查看|使用)/i.test(haystack);
+        this.membershipExpired = explicitExpiry || (!snapshot.hasTable && entitlementUnavailable);
+        this.lastMembershipCheckAt = Date.now();
+        this.authenticated = !this.verificationRequired && !loginRequired && /fastmoss\.com/i.test(snapshot.url) && snapshot.url !== FASTMOSS_HOME;
+        if (this.verificationRequired) {
+            this.phase = "verification_required";
+            this.message = "检测到平台验证，请在专用浏览器中手动完成后再刷新状态";
+        }
+        else if (this.membershipExpired) {
+            this.phase = "membership_expired";
+            this.message = "FastMoss 会员已过期或当前账号没有榜单权限，请更换有权限的账号后重新连接";
+        }
+        else if (!this.authenticated) {
+            this.phase = "login_required";
+            this.message = "请在专用浏览器中登录 FastMoss，并打开商品榜单页";
+        }
+        else {
+            this.phase = "ready";
+            this.message = snapshot.hasTable ? "FastMoss 已连接，当前榜单可以抓取" : "FastMoss 已登录，请打开需要抓取的商品榜单";
+        }
+        return this.status();
+    }
+    async capture(input = {}) {
+        await this.inspect();
+        if (this.verificationRequired)
+            throw new Error("请先在 FastMoss 浏览器中手动完成验证");
+        if (this.membershipExpired)
+            throw new Error("FastMoss 会员已过期或当前账号没有榜单权限，请先更换账号");
+        if (Date.now() - this.lastMembershipCheckAt > MEMBERSHIP_RECHECK_MS) {
+            await this.inspect();
+            if (this.membershipExpired)
+                throw new Error("FastMoss 会员已过期或当前账号没有榜单权限，请先更换账号");
+        }
+        if (!this.authenticated || !this.page || this.page.isClosed())
+            throw new Error("FastMoss 尚未登录或专用浏览器未打开");
+        const snapshot = await this.page.evaluate(() => {
+            const shown = (element) => Boolean(element.getClientRects().length);
+            const tables = [...document.querySelectorAll("table")].filter(shown).map((table) => {
+                const rows = [...table.querySelectorAll("tr")].filter(shown);
+                const headers = [...(rows[0]?.querySelectorAll("th,td") || [])].map((cell) => cell.innerText.replace(/\s+/g, " ").trim());
+                return {
+                    headers,
+                    rows: rows.slice(1).map((row) => ({
+                        cells: [...row.querySelectorAll("td")].map((cell) => cell.innerText.replace(/\s+/g, " ").trim()),
+                        links: [...row.querySelectorAll("a[href]")].map((link) => link.href),
+                        images: [...row.querySelectorAll("img")].map((image) => {
+                            const src = image.currentSrc || image.src || image.dataset.src || image.dataset.original || "";
+                            const href = image.closest("a[href]")?.href || "";
+                            const hint = `${image.alt} ${image.title} ${image.className} ${image.closest("td")?.textContent || ""} ${src}`;
+                            return { src, href, content: image.dataset.content || image.dataset.url || "", isQr: /qr|qrcode|二维码/i.test(hint) };
+                        }).filter((image) => image.src).concat([...row.querySelectorAll("canvas")].map((canvas) => {
+                            let src = "";
+                            try {
+                                src = canvas.toDataURL("image/png");
+                            }
+                            catch { }
+                            const href = canvas.closest("a[href]")?.href || "";
+                            const hint = `${canvas.className} ${canvas.id} ${canvas.closest("td")?.textContent || ""}`;
+                            return { src, href, content: canvas.dataset.content || canvas.dataset.url || "", isQr: /qr|qrcode|二维码/i.test(hint) };
+                        }).filter((canvas) => canvas.src)),
+                    })).filter((row) => row.cells.some(Boolean)),
+                };
+            }).sort((left, right) => right.rows.length - left.rows.length);
+            return { title: document.title, url: location.href, tables: tables.slice(0, 1) };
+        });
+        const records = extractRows(snapshot.tables, { ...input, date: localDate() }, snapshot.url);
+        if (!records.length)
+            throw new Error("当前页面没有可读取的商品表格，请先打开 FastMoss 商品榜单");
+        await mkdir(this.dataDir, { recursive: true });
+        const stored = await this.loadRows();
+        const indexed = new Map(stored.map((row) => [`${row.date}:${row.product_id || row.title}`, row]));
+        records.forEach((row) => indexed.set(`${row.date}:${row.product_id || row.title}`, row));
+        const allRows = [...indexed.values()];
+        this.lastCapture = new Date().toISOString();
+        this.captured = records.length;
+        await writeFile(path.join(this.dataDir, "observations.json"), JSON.stringify(allRows, null, 2), "utf8");
+        await writeFile(path.join(this.dataDir, `capture-${localDate()}.json`), JSON.stringify({ capturedAt: this.lastCapture, page: snapshot.url, records }, null, 2), "utf8");
+        this.message = `已读取当前页面 ${records.length} 条商品数据`;
+        return { ...this.status(), records, allRows };
+    }
+    async close() {
+        const context = this.context;
+        this.context = null;
+        this.page = null;
+        if (context)
+            await context.close();
+        this.phase = "idle";
+        this.authenticated = false;
+        this.verificationRequired = false;
+        this.membershipExpired = false;
+        this.lastMembershipCheckAt = 0;
+        this.message = "FastMoss 浏览器已关闭；本机登录资料仍保留";
+        return this.status();
+    }
+    async switchAccount() {
+        if (!this.context || !this.page || this.page.isClosed())
+            await this.start();
+        this.useLatestPage();
+        if (!this.page || this.page.isClosed())
+            throw new Error("FastMoss 专用浏览器未打开");
+        await this.page.goto(FASTMOSS_HOME, { waitUntil: "domcontentloaded", timeout: 60_000 });
+        await this.page.bringToFront();
+        this.phase = "login_required";
+        this.authenticated = false;
+        this.verificationRequired = false;
+        this.membershipExpired = false;
+        this.lastMembershipCheckAt = 0;
+        this.message = "请在 FastMoss 专用浏览器中退出当前账号并登录新的会员账号，完成后返回网页刷新状态";
+        return this.status();
+    }
+    async loadRows() {
+        try {
+            return JSON.parse(await readFile(path.join(this.dataDir, "observations.json"), "utf8"));
+        }
+        catch {
+            return [];
+        }
+    }
+    useLatestPage() {
+        const pages = this.context?.pages().filter((page) => !page.isClosed()) || [];
+        if (pages.length)
+            this.page = pages[pages.length - 1];
+    }
+}
+function findChromiumExecutable() {
+    const home = os.homedir();
+    const candidates = process.platform === "win32" ? [
+        path.join(process.env.PROGRAMFILES || "C:\\Program Files", "Google/Chrome/Application/chrome.exe"),
+        path.join(process.env["PROGRAMFILES(X86)"] || "C:\\Program Files (x86)", "Google/Chrome/Application/chrome.exe"),
+        path.join(process.env.LOCALAPPDATA || path.join(home, "AppData/Local"), "Google/Chrome/Application/chrome.exe"),
+        path.join(process.env.PROGRAMFILES || "C:\\Program Files", "Microsoft/Edge/Application/msedge.exe"),
+        path.join(process.env["PROGRAMFILES(X86)"] || "C:\\Program Files (x86)", "Microsoft/Edge/Application/msedge.exe"),
+        path.join(process.env.LOCALAPPDATA || path.join(home, "AppData/Local"), "Microsoft/Edge/Application/msedge.exe"),
+    ] : process.platform === "darwin" ? [
+        "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+        "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+        path.join(home, "Applications/Google Chrome.app/Contents/MacOS/Google Chrome"),
+    ] : ["/usr/bin/google-chrome", "/usr/bin/google-chrome-stable", "/usr/bin/microsoft-edge", "/usr/bin/chromium"];
+    return candidates.find(existsSync) || null;
+}
+function extractRows(tables, context, pageUrl) {
+    const output = [];
+    for (const table of tables) {
+        for (const row of table.rows) {
+            const raw = Object.fromEntries(row.cells.map((value, index) => [table.headers[index] || `column_${index + 1}`, value]));
+            const pick = (...patterns) => Object.entries(raw).find(([key]) => patterns.some((pattern) => pattern.test(key)))?.[1] || "";
+            const title = String(pick(/商品名|商品标题|product|title/i) || row.cells.find((cell) => cell.length > 5) || "");
+            const productUrl = row.links.find((link) => /product|goods|item|detail/i.test(link)) || row.links[0] || pageUrl;
+            const productId = String(pick(/商品\s*id|product\s*id/i) || productUrl.match(/(?:product|goods|item)[/=_-]([\w-]+)/i)?.[1] || stableId(`${title}:${productUrl}`));
+            const images = row.images.filter((image) => !image.isQr).map((image) => image.src);
+            const qr = row.images.find((image) => image.isQr);
+            output.push({
+                date: context.date,
+                source: "fastmoss-agent",
+                product_id: productId,
+                platform_product_id: String(pick(/平台商品|tiktok.*id/i) || productId),
+                title,
+                product_url: productUrl,
+                store_name: String(pick(/店铺|shop|store/i)),
+                category: String(pick(/类目|category/i) || context.category || ""),
+                market: String(pick(/国家|市场|market|country/i) || context.market || ""),
+                shop_type: String(pick(/店铺类型|shop.*type|seller.*type/i) || context.shopType || ""),
+                period_days: context.periodDays || 7,
+                price: numberValue(pick(/价格|售价|price/i)),
+                units_sold: numberValue(pick(/销量|sold|sales|orders/i)),
+                gmv: numberValue(pick(/gmv|销售额|成交额/i)),
+                commission: numberValue(pick(/佣金|commission/i)),
+                creators: numberValue(pick(/达人|creator/i)),
+                trend_score: numberValue(pick(/趋势|增长|growth|trend/i)),
+                image_urls: images,
+                image: images[0] || "",
+                qr_image_url: qr?.src || "",
+                qr_content: qr?.content || qr?.href || "",
+                raw,
+            });
+        }
+    }
+    return output.filter((row) => row.title);
+}
+function numberValue(value) {
+    const raw = String(value || "").replace(/,/g, "");
+    const match = raw.match(/-?\d+(?:\.\d+)?/);
+    if (!match)
+        return 0;
+    const factor = /亿/i.test(raw) ? 100_000_000 : /万|w\b/i.test(raw) ? 10_000 : /k\b/i.test(raw) ? 1_000 : 1;
+    return Number(match[0]) * factor;
+}
+function stableId(input) {
+    let hash = 2166136261;
+    for (const char of input)
+        hash = Math.imul(hash ^ char.charCodeAt(0), 16777619);
+    return `fastmoss-${(hash >>> 0).toString(16)}`;
+}
+function localDate() {
+    const date = new Date();
+    date.setMinutes(date.getMinutes() - date.getTimezoneOffset());
+    return date.toISOString().slice(0, 10);
+}

package/dist/server/http.js

@@ -6,6 +6,7 @@ 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, VERSION } from "../config.js";
+import { FastMossIntegration } from "../integrations/fastmoss.js";
 import { startRelayBridge } from "../relay-bridge.js";
 import { logger } from "../utils/logger.js";
 import { windowsRootExecutable, windowsSystemExecutable } from "../utils/windows.js";
@@ -31,6 +32,7 @@ export function startHttpServer() {
         return workspace;
     };
     const workflows = new WorkflowManager(config, emit);
+    const fastmoss = new FastMossIntegration();
     const app = express();
     app.disable("x-powered-by");
     app.use(express.json({ limit: "30mb" }));
@@ -128,6 +130,12 @@ export function startHttpServer() {
         await openExternalUrl(url.toString());
         res.json({ ok: true });
     }));
+    app.get("/agent/integrations/fastmoss/status", route(async (_req, res) => res.json({ ok: true, ...await fastmoss.inspect() })));
+    app.post("/agent/integrations/fastmoss/start", route(async (_req, res) => res.json({ ok: true, ...await fastmoss.start() })));
+    app.post("/agent/integrations/fastmoss/refresh", route(async (_req, res) => res.json({ ok: true, ...await fastmoss.inspect() })));
+    app.post("/agent/integrations/fastmoss/switch-account", route(async (_req, res) => res.json({ ok: true, ...await fastmoss.switchAccount() })));
+    app.post("/agent/integrations/fastmoss/capture", route(async (req, res) => res.json({ ok: true, ...await fastmoss.capture(req.body || {}) })));
+    app.post("/agent/integrations/fastmoss/close", route(async (_req, res) => res.json({ ok: true, ...await fastmoss.close() })));
     app.get("/agent/codex/workspace", (_req, res) => {
         const workspace = ensureSiteWorkspace(config);
         res.json({ ok: true, workspace });

package/dist/workflow/constants.d.ts

@@ -1,4 +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;
-export declare const FLOW_C_DOWNLOAD_POLL_MS = 3000;

package/dist/workflow/constants.js

@@ -1,4 +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];
-export const FLOW_C_DOWNLOAD_POLL_MS = 3_000;

package/dist/workflow/manager.d.ts

@@ -22,8 +22,8 @@ export declare class WorkflowManager {
     private runningScripts;
     private scriptQueueRunning;
     private syncingDownloads;
+    private pendingDownloadBatchIds;
     private directorySelection?;
-    private downloadTimer?;
     constructor(config: CanvasAgentConfig, emit: AgentEmit);
     /** 接收网站创建的短期交接能力并立即启动本机 Codex。 */
     enqueueScript(input: {

package/dist/workflow/manager.js

@@ -9,7 +9,7 @@ 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_DOWNLOAD_POLL_MS, FLOW_C_SCRIPT_CHUNK_MAX, FLOW_C_SCRIPT_CHUNK_SIZES } from "./constants.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");
 /** 本机持久化的 Flow C 控制器：脚本交给本机 Codex，视频直接落盘。 */
 export class WorkflowManager {
@@ -19,8 +19,8 @@ export class WorkflowManager {
     runningScripts = new Set();
     scriptQueueRunning = false;
     syncingDownloads = false;
+    pendingDownloadBatchIds = new Set();
     directorySelection;
-    downloadTimer;
     constructor(config, emit) {
         this.config = config;
         this.emit = emit;
@@ -28,9 +28,6 @@ export class WorkflowManager {
             if (record.status === "queued" || record.status === "running")
                 this.scheduleScript(record.id);
         }
-        this.downloadTimer = setInterval(() => void this.syncDownloads(), FLOW_C_DOWNLOAD_POLL_MS);
-        this.downloadTimer.unref?.();
-        void this.syncDownloads();
     }
     /** 接收网站创建的短期交接能力并立即启动本机 Codex。 */
     enqueueScript(input) {
@@ -127,6 +124,7 @@ export class WorkflowManager {
     }
     clearDownloadDirectory() {
         delete this.state.downloadDirectory;
+        this.pendingDownloadBatchIds.clear();
         this.save();
         return this.downloadState();
     }
@@ -137,15 +135,15 @@ export class WorkflowManager {
             batchId,
             apiBase: commerceApiBase(input.apiBase),
             accessToken: secret(input.accessToken, "下载能力令牌"),
-            status: previous?.status === "complete" ? "complete" : "waiting",
+            status: "waiting",
             downloadedOrdinals: previous?.downloadedOrdinals || [],
             market: previous?.market,
             expiresAt: String(input.expiresAt || previous?.expiresAt || "") || undefined,
-            message: this.state.downloadDirectory ? "等待视频完成" : "请先选择本机保存文件夹",
+            message: this.state.downloadDirectory ? "已开始手动下载本批全部成片" : "请先选择本机保存文件夹",
             updatedAt: now(),
         };
         this.save();
-        void this.syncDownloads();
+        void this.syncDownloads(batchId);
         return publicDownload(this.state.downloads[batchId]);
     }
     async syncDownload(batchIdValue) {
@@ -164,7 +162,6 @@ export class WorkflowManager {
             throw new Error("选择的路径不是文件夹");
         this.state.downloadDirectory = resolved;
         this.save();
-        void this.syncDownloads();
         return this.downloadState();
     }
     scheduleScript(_id) {
@@ -277,13 +274,24 @@ export class WorkflowManager {
         }
     }
     async syncDownloads(onlyBatchId) {
-        if (this.syncingDownloads || !this.state.downloadDirectory)
+        if (!this.state.downloadDirectory)
+            return;
+        if (onlyBatchId)
+            this.pendingDownloadBatchIds.add(onlyBatchId);
+        else
+            for (const record of Object.values(this.state.downloads))
+                this.pendingDownloadBatchIds.add(record.batchId);
+        if (this.syncingDownloads)
             return;
         this.syncingDownloads = true;
         try {
-            const records = Object.values(this.state.downloads).filter((record) => !onlyBatchId || record.batchId === onlyBatchId);
-            for (const record of records)
-                await this.syncDownloadRecord(record);
+            while (this.pendingDownloadBatchIds.size) {
+                const batchId = this.pendingDownloadBatchIds.values().next().value;
+                this.pendingDownloadBatchIds.delete(batchId);
+                const record = this.state.downloads[batchId];
+                if (record)
+                    await this.syncDownloadRecord(record);
+            }
         }
         finally {
             this.syncingDownloads = false;
@@ -293,7 +301,7 @@ export class WorkflowManager {
     async syncDownloadRecord(record) {
         if (record.expiresAt && Date.parse(record.expiresAt) <= Date.now()) {
             record.status = "expired";
-            record.message = "下载授权已过期；打开网站后会自动续期";
+            record.message = "下载授权已过期；请在网站重新点击一键下载全部";
             return;
         }
         try {
@@ -301,21 +309,30 @@ export class WorkflowManager {
             const data = await commerceJson(`${record.apiBase}/workflow-downloads/${encodeURIComponent(record.batchId)}`, record.accessToken, "x-workflow-download-token");
             const batch = data.batch;
             record.market = batch.market;
-            for (const delivery of batch.deliveries || []) {
-                await this.saveDelivery(batch, delivery);
-                if (!record.downloadedOrdinals.includes(delivery.ordinal))
-                    record.downloadedOrdinals.push(delivery.ordinal);
-            }
+            const deliveries = batch.deliveries || [];
+            let cursor = 0;
+            const workers = Array.from({ length: Math.min(4, deliveries.length) }, async () => {
+                while (cursor < deliveries.length) {
+                    const delivery = deliveries[cursor++];
+                    await this.saveDelivery(batch, delivery);
+                    if (!record.downloadedOrdinals.includes(delivery.ordinal))
+                        record.downloadedOrdinals.push(delivery.ordinal);
+                    record.message = `正在保存本批全部成片：${record.downloadedOrdinals.length}/${deliveries.length}`;
+                    record.updatedAt = now();
+                    this.save();
+                }
+            });
+            await Promise.all(workers);
             record.downloadedOrdinals.sort((a, b) => a - b);
             const finished = ["completed", "cancelled", "failed"].includes(batch.status);
             record.status = finished && record.downloadedOrdinals.length >= (batch.deliveries?.length || 0) ? "complete" : "waiting";
             record.message = batch.deliveries?.length
-                ? `已自动保存 ${record.downloadedOrdinals.length} 条视频；${finished ? "本批次已结束" : "继续等待新视频"}`
-                : finished ? "批次已结束，暂无可下载视频" : "等待视频完成";
+                ? `已保存本批 ${record.downloadedOrdinals.length} 条成片；${finished ? "本批次已结束" : "如有新成片请再次点击下载"}`
+                : finished ? "批次已结束，暂无可下载视频" : "当前暂无成片可下载";
         }
         catch (error) {
             record.status = /expired|not found/i.test(error instanceof Error ? error.message : "") ? "expired" : "error";
-            record.message = error instanceof Error ? error.message : "自动下载失败，稍后重试";
+            record.message = error instanceof Error ? error.message : "下载失败，请再次点击下载";
             logger.warn("Local Flow C download sync failed", { batchId: record.batchId, error: record.message });
         }
         finally {
@@ -401,6 +418,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} 的自然本地语言与偏快但清晰的短视频节奏。${longVideoRules}
+每一个 ordinal 都必须从头到尾创作一份完整、独立的广告脚本，画面和口播必须在同一份脚本中一起独立构思。独立脚本天然包含独立口播：不得把任何一份口播当作整批公共模板，不得复用完整台词，也不得只换人物、场景或少数词后保留近似口播。音色身份可以为同一人物保持一致，但每条的 Hook、产品说明、证明表达和 CTA 都必须重新写。
 用户没有指定带货方向时，不得随意只用一种泛化形式；必须按任务 instructions 中“已批准的创意方向”逐条做产品适配轮换。轮换必须按每个产品自己的序号连续计算，不能因 30/15/10 条分段、换会话或跨产品边界而从第一个方向重新开始；让同一产品在重复某一方向前优先覆盖其他适配方向。
 工厂风格 A/B 是默认轮换中的演绎带货布景，不是商品来源声明；不得因用户未提供真实工厂资料而跳过，也绝不能写成我们的真实工厂、真实生产流程、真实产地、工厂直销、厂家出货或仓库现货。
 写完后必须调用 flow_c_submit_script_chunk 一次回传这 ${ordinals.length} 条，handoffId=${id}。不要创建付费批次，不要调用供应商模型，不要在聊天输出大段 JSON。工具返回成功后仅简短结束。`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xiaohhhh1/canvas-agent",
-  "version": "0.4.14",
+  "version": "0.4.16",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -24,6 +24,7 @@
     "@modelcontextprotocol/sdk": "^1.12.1",
     "@openai/codex": "0.145.0",
     "express": "^5.1.0",
+    "playwright-core": "^1.62.1",
     "ws": "^8.18.3",
     "winston": "^3.19.0",
     "zod": "^3.25.0"