@xiaohhhh1/canvas-agent 0.4.15 → 0.4.17

package/dist/integrations/fastmoss.d.ts

@@ -0,0 +1,59 @@
+export type FastMossPhase = "idle" | "saved" | "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;
+    categories?: 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 authenticatedMarker;
+    private readonly dataDir;
+    private savedAuthenticated;
+    constructor();
+    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;
+    private openProductRanking;
+}
+export declare function fastMossSalesRankUrl(market?: string): string;
+export {};

package/dist/integrations/fastmoss.js

@@ -0,0 +1,425 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rm, 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 FASTMOSS_SALES_RANK = "https://www.fastmoss.com/e-commerce/saleslist";
+const MEMBERSHIP_RECHECK_MS = 5 * 60_000;
+const PRODUCT_TABLE_TIMEOUT_MS = 45_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");
+    authenticatedMarker = path.join(this.profileDir, "authenticated.json");
+    dataDir = path.join(CONFIG_DIR, "fastmoss-selection");
+    savedAuthenticated = existsSync(this.authenticatedMarker);
+    constructor() {
+        if (!this.savedAuthenticated)
+            return;
+        this.phase = "saved";
+        this.authenticated = true;
+        this.message = "FastMoss 登录已保存在本机；窗口可以关闭，抓取时会自动恢复";
+    }
+    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: { width: 480, height: 900 },
+                screen: { width: 515, height: 995 },
+                deviceScaleFactor: 1,
+                args: ["--window-size=515,995", "--window-position=20,20"],
+            });
+        }
+        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 = this.savedAuthenticated ? "saved" : "idle";
+            this.authenticated = this.savedAuthenticated;
+            this.verificationRequired = false;
+            this.membershipExpired = false;
+            this.lastMembershipCheckAt = 0;
+            this.message = this.savedAuthenticated
+                ? "FastMoss 窗口已关闭，登录仍保存在本机；抓取时会自动恢复"
+                : "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 = this.savedAuthenticated ? "saved" : "idle";
+            this.authenticated = this.savedAuthenticated;
+            this.verificationRequired = false;
+            this.membershipExpired = false;
+            this.lastMembershipCheckAt = 0;
+            this.message = this.savedAuthenticated
+                ? "FastMoss 登录已保存在本机；窗口可以关闭，抓取时会自动恢复"
+                : "请先启动 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: [...document.querySelectorAll("table tbody tr")].some((row) => {
+                const text = (row.textContent || "").replace(/\s+/g, " ").trim();
+                return row.querySelectorAll("td").length >= 3 && !/^(?:no data|loading\.?\.?.?|暂无数据|暂无商品|无数据)$/i.test(text);
+            }),
+        })).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|slide to complete the puzzle|verification failed|人机验证|安全验证|滑块验证|请完成验证/.test(haystack);
+        const loginRequired = /\/login|\/signin|sign in|log in|登录账号|密码登录|扫码登录|登录\s*\/\s*注册/.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);
+        if (this.authenticated) {
+            this.savedAuthenticated = true;
+            await mkdir(this.profileDir, { recursive: true });
+            await writeFile(this.authenticatedMarker, JSON.stringify({ authenticated: true, updatedAt: new Date().toISOString() }), "utf8");
+        }
+        else if (loginRequired) {
+            this.savedAuthenticated = false;
+            await rm(this.authenticatedMarker, { force: true });
+        }
+        if (this.verificationRequired) {
+            this.phase = "verification_required";
+            this.message = "检测到 FastMoss 滑块验证，请在移动版登录窗口中手动完成；通过后刷新状态即可继续";
+        }
+        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 = {}) {
+        if (!this.context || !this.page || this.page.isClosed())
+            await this.start();
+        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 尚未登录；请在恢复的窗口中完成登录后重试");
+        await this.openProductRanking(input);
+        const collected = new Map();
+        const pages = [];
+        let previousSignature = "";
+        for (let pageNumber = 1; pageNumber <= 30; pageNumber += 1) {
+            const snapshot = await readVisibleTableSnapshot(this.page);
+            if (!snapshot.tables[0]?.rows.length || snapshot.signature === previousSignature)
+                break;
+            previousSignature = snapshot.signature;
+            pages.push(snapshot.url);
+            const pageRecords = extractRows(snapshot.tables, { ...input, date: localDate() }, snapshot.url);
+            pageRecords.forEach((row) => collected.set(String(row.product_id || row.title), row));
+            this.captured = collected.size;
+            this.message = `正在读取可见榜单第 ${pageNumber} 页，已收集 ${this.captured} 条商品数据`;
+            if (!await clickVisibleNextPage(this.page))
+                break;
+            await this.page.waitForTimeout(800);
+            await this.inspect();
+            if (this.verificationRequired || this.membershipExpired)
+                break;
+        }
+        const records = [...collected.values()];
+        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, pages, records }, null, 2), "utf8");
+        this.message = this.verificationRequired ? `已保存验证前的 ${records.length} 条数据；请手动完成滑块后再次抓取，程序会接着合并` : `已读取 ${pages.length} 个可见分页，共 ${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 = this.savedAuthenticated ? "saved" : "idle";
+        this.authenticated = this.savedAuthenticated;
+        this.verificationRequired = false;
+        this.membershipExpired = false;
+        this.lastMembershipCheckAt = 0;
+        this.message = this.savedAuthenticated
+            ? "FastMoss 窗口已关闭，登录仍保存在本机；抓取时会自动恢复"
+            : "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.savedAuthenticated = false;
+        await rm(this.authenticatedMarker, { force: true });
+        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];
+    }
+    async openProductRanking(input) {
+        if (!this.page || this.page.isClosed())
+            throw new Error("FastMoss 专用浏览器未打开");
+        const market = normalizeMarket(input.market);
+        this.message = `正在自动进入 ${market} 商品榜单`;
+        await this.page.goto(fastMossSalesRankUrl(market), { waitUntil: "domcontentloaded", timeout: 60_000 });
+        const deadline = Date.now() + PRODUCT_TABLE_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+            const snapshot = await readVisibleTableSnapshot(this.page);
+            if (hasReadableProductRows(snapshot)) {
+                this.phase = "ready";
+                this.message = `${market} 商品榜单已打开，正在开始采集`;
+                return;
+            }
+            await this.inspect();
+            if (this.verificationRequired)
+                throw new Error("检测到 FastMoss 滑块验证，请在专用窗口中手动完成后再次抓取");
+            if (this.membershipExpired)
+                throw new Error("FastMoss 会员已过期或当前账号没有商品榜单权限，请先更换账号");
+            if (!this.authenticated)
+                throw new Error("FastMoss 登录已失效，请在专用窗口中重新登录后再次抓取");
+            await this.page.waitForTimeout(750);
+        }
+        throw new Error("FastMoss 商品榜单自动加载超时；请检查网络或在窗口中完成人工验证后重试");
+    }
+}
+export function fastMossSalesRankUrl(market) {
+    const url = new URL(FASTMOSS_SALES_RANK);
+    url.searchParams.set("region", normalizeMarket(market));
+    return url.toString();
+}
+function normalizeMarket(value) {
+    const market = String(value || "MX").trim().toUpperCase();
+    return /^[A-Z]{2}$/.test(market) ? market : "MX";
+}
+function hasReadableProductRows(snapshot) {
+    return snapshot.tables.some((table) => table.rows.some((row) => row.cells.filter(Boolean).length >= 3));
+}
+async function readVisibleTableSnapshot(page) {
+    return 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) => {
+                    const text = row.cells.join(" ").replace(/\s+/g, " ").trim();
+                    return row.cells.filter(Boolean).length >= 3 && !/^(?:no data|loading\.?\.?.?|暂无数据|暂无商品|无数据)$/i.test(text);
+                }),
+            };
+        }).sort((left, right) => right.rows.length - left.rows.length).slice(0, 1);
+        const primary = tables[0];
+        const signature = JSON.stringify([location.href, primary?.headers, primary?.rows[0]?.cells, primary?.rows[primary.rows.length - 1]?.cells]);
+        return { title: document.title, url: location.href, tables, signature };
+    });
+}
+async function clickVisibleNextPage(page) {
+    return page.evaluate(() => {
+        const shown = (element) => Boolean(element.getClientRects().length);
+        const selectors = [
+            ".ant-pagination-next button", ".ant-pagination-next", ".el-pagination .btn-next",
+            "button[aria-label*='next' i]", "[class*='pagination'] [class*='next']", "[class*='pagination'] [aria-label*='下一页']",
+        ];
+        const candidates = [...new Set(selectors.flatMap((selector) => [...document.querySelectorAll(selector)]))];
+        const next = candidates.find((element) => {
+            if (!shown(element))
+                return false;
+            const parent = element.closest("li,button,[class*='next']");
+            const disabled = element.matches(":disabled") || element.getAttribute("aria-disabled") === "true" || parent?.getAttribute("aria-disabled") === "true" || /disabled/.test(`${element.className} ${parent?.className || ""}`);
+            return !disabled;
+        });
+        if (!next)
+            return false;
+        next.click();
+        return true;
+    });
+}
+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 productCell = String(pick(/^商品$|商品名|商品标题|product|title/i) || row.cells.find((cell) => cell.length > 5) || "");
+            const title = productCell.replace(/\s*(?:售价|价格|price)\s*[：:].*$/is, "").trim();
+            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(/(?:detail|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);
+            const priceText = String(pick(/^价格$|^售价$|price/i) || productCell.match(/(?:售价|价格|price)\s*[：:]\s*([^\s]+)/i)?.[1] || "");
+            const storeName = String(pick(/所属店铺|店铺|shop|store/i)).replace(/\s*店铺销量\s*[：:].*$/is, "").trim();
+            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: storeName,
+                category: String(pick(/类目|分类|category/i) || context.category || context.categories?.[0] || ""),
+                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(priceText),
+                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/manager.js

@@ -418,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.15",
+  "version": "0.4.17",
   "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"