@xiaohhhh1/canvas-agent 0.4.39 → 0.4.41

package/dist/integrations/fastmoss.d.ts

@@ -138,6 +138,7 @@ export declare class FastMossIntegration {
     private loadRows;
     private useLatestPage;
     private openProductRanking;
+    private waitForManualVerification;
     private openVideoLearningPage;
     private readVideoLearningItems;
     /**
@@ -154,6 +155,11 @@ export declare class FastMossIntegration {
     private clickVideoLearningNextPage;
     private waitForVideoLearningNavigation;
 }
+export declare function waitForFastMossVerificationClear(inspect: () => Promise<Pick<FastMossStatus, "verificationRequired" | "membershipExpired" | "authenticated">>, options?: {
+    timeoutMs?: number;
+    pollMs?: number;
+    sleep?: (milliseconds: number) => Promise<unknown>;
+}): Promise<void>;
 export declare function videoEvidenceTimestamps(durationMs: number): number[];
 export declare function fastMossSalesRankUrl(market?: string): string;
 export declare function fastMossRankingUrl(source: FastMossRankingSource, market?: string): string;

package/dist/integrations/fastmoss.js

@@ -6,6 +6,7 @@ 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;
+const MANUAL_VERIFICATION_TIMEOUT_MS = 10 * 60_000;
 const PRODUCT_TABLE_TIMEOUT_MS = 45_000;
 const PRODUCT_RANK_PAGE_SIZE = 10;
 const PRODUCT_RANK_MAX_PAGES = 50;
@@ -175,7 +176,7 @@ export class FastMossIntegration {
             await this.start();
         await this.inspect();
         if (this.verificationRequired)
-            throw new Error("请先在 FastMoss 浏览器中手动完成验证");
+            await this.waitForManualVerification();
         if (this.membershipExpired)
             throw new Error("FastMoss 会员已过期或当前账号没有榜单权限，请先更换账号");
         if (Date.now() - this.lastMembershipCheckAt > MEMBERSHIP_RECHECK_MS) {
@@ -192,7 +193,16 @@ export class FastMossIntegration {
             let previousSignature = "";
             for (let pageNumber = 1; pageNumber <= PRODUCT_RANK_MAX_PAGES; pageNumber += 1) {
                 const snapshot = await readVisibleTableSnapshot(this.page);
-                if (!snapshot.tables[0]?.rows.length || snapshot.signature === previousSignature)
+                if (!snapshot.tables[0]?.rows.length) {
+                    await this.inspect();
+                    if (this.verificationRequired) {
+                        await this.waitForManualVerification();
+                        pageNumber -= 1;
+                        continue;
+                    }
+                    break;
+                }
+                if (snapshot.signature === previousSignature)
                     break;
                 previousSignature = snapshot.signature;
                 pages.push(snapshot.url);
@@ -204,10 +214,12 @@ export class FastMossIntegration {
                     break;
                 await this.page.waitForTimeout(800);
                 await this.inspect();
-                if (this.verificationRequired || this.membershipExpired)
+                if (this.verificationRequired)
+                    await this.waitForManualVerification();
+                if (this.membershipExpired)
                     break;
             }
-            if (this.verificationRequired || this.membershipExpired)
+            if (this.membershipExpired)
                 break;
         }
         const records = [...collected.values()];
@@ -227,7 +239,7 @@ export class FastMossIntegration {
                 : `采集在${stage === "ranking" ? "榜单" : "商品详情互证"}阶段发现会员权限异常；已保留上次 ${previousProducts} 个商品结果`;
             return { ...this.status(), records: marketRecords, allRows: previousRows, trendProducts: previousProducts, detailFailures, interrupted: true };
         };
-        if (this.verificationRequired || this.membershipExpired)
+        if (this.membershipExpired)
             return retainPreviousOnInterruption("ranking");
         const detailCandidates = selectDetailCandidates(marketRecords, DETAIL_CANDIDATE_LIMIT);
         const capturePage = this.page;
@@ -242,11 +254,13 @@ export class FastMossIntegration {
             if ((offset / DETAIL_FETCH_CONCURRENCY) % 10 === 0) {
                 this.useLatestPage();
                 await this.inspect();
-                if (this.verificationRequired || this.membershipExpired)
+                if (this.verificationRequired)
+                    await this.waitForManualVerification();
+                if (this.membershipExpired)
                     break;
             }
         }
-        if (this.verificationRequired || this.membershipExpired)
+        if (this.membershipExpired)
             return retainPreviousOnInterruption("detail", trendRows, detailFailures);
         if (!trendRows.length && !this.verificationRequired)
             throw new Error("榜单读取成功，但未能读取商品详情的最近 7 天销量；请检查会员权限后重试");
@@ -257,9 +271,7 @@ export class FastMossIntegration {
         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: marketRecords, detailCandidates: detailCandidates.map((record) => record.product_id), trendRows, detailFailures }, null, 2), "utf8");
         const trendProducts = new Set(trendRows.map((row) => String(row.product_id))).size;
-        this.message = this.verificationRequired
-            ? `已保存验证前的 ${trendProducts} 个商品趋势；请手动完成滑块后再次抓取`
-            : `四榜单去重后 ${marketRecords.length} 个商品，优先互证 ${detailCandidates.length} 个，其中 ${trendProducts} 个取得最近 ${DETAIL_TREND_DAYS} 天趋势`;
+        this.message = `四榜单去重后 ${marketRecords.length} 个商品，优先互证 ${detailCandidates.length} 个，其中 ${trendProducts} 个取得最近 ${DETAIL_TREND_DAYS} 天趋势`;
         return { ...this.status(), records: marketRecords, allRows, trendProducts, detailFailures };
     }
     /**
@@ -527,7 +539,7 @@ export class FastMossIntegration {
         const market = normalizeMarket(input.market);
         this.message = `正在自动进入 ${market} ${ranking.label}`;
         await this.page.goto(fastMossRankingUrl(ranking.source, market), { waitUntil: "domcontentloaded", timeout: 60_000 });
-        const deadline = Date.now() + PRODUCT_TABLE_TIMEOUT_MS;
+        let deadline = Date.now() + PRODUCT_TABLE_TIMEOUT_MS;
         while (Date.now() < deadline) {
             const snapshot = await readVisibleTableSnapshot(this.page);
             if (hasReadableProductRows(snapshot)) {
@@ -536,8 +548,11 @@ export class FastMossIntegration {
                 return;
             }
             await this.inspect();
-            if (this.verificationRequired)
-                throw new Error("检测到 FastMoss 滑块验证，请在专用窗口中手动完成后再次抓取");
+            if (this.verificationRequired) {
+                await this.waitForManualVerification();
+                deadline = Date.now() + PRODUCT_TABLE_TIMEOUT_MS;
+                continue;
+            }
             if (this.membershipExpired)
                 throw new Error("FastMoss 会员已过期或当前账号没有商品榜单权限，请先更换账号");
             if (!this.authenticated)
@@ -546,6 +561,28 @@ export class FastMossIntegration {
         }
         throw new Error("FastMoss 商品榜单自动加载超时；请检查网络或在窗口中完成人工验证后重试");
     }
+    async waitForManualVerification() {
+        if (!this.verificationRequired)
+            return;
+        this.phase = "verification_required";
+        this.message = "采集已暂停等待人工滑块；完成后会自动继续，无需刷新或重新点击";
+        await this.page?.bringToFront().catch(() => undefined);
+        await waitForFastMossVerificationClear(async () => {
+            const status = await this.inspect();
+            if (status.verificationRequired)
+                this.message = "采集已暂停等待人工滑块；完成后会自动继续，无需刷新或重新点击";
+            return status;
+        }, {
+            timeoutMs: MANUAL_VERIFICATION_TIMEOUT_MS,
+            sleep: (milliseconds) => this.page && !this.page.isClosed()
+                ? this.page.waitForTimeout(milliseconds)
+                : new Promise((resolve) => setTimeout(resolve, milliseconds)),
+        });
+        this.phase = "ready";
+        this.message = "人工验证已完成，正在自动继续采集";
+        await this.page?.waitForLoadState("domcontentloaded", { timeout: 10_000 }).catch(() => undefined);
+        await this.page?.waitForTimeout(1_000).catch(() => undefined);
+    }
     async openVideoLearningPage(url, label) {
         if (!this.page || this.page.isClosed())
             throw new Error("FastMoss 专用浏览器未打开");
@@ -722,6 +759,24 @@ export class FastMossIntegration {
         });
     }
 }
+export async function waitForFastMossVerificationClear(inspect, options = {}) {
+    const timeoutMs = Math.max(1, Number(options.timeoutMs || MANUAL_VERIFICATION_TIMEOUT_MS));
+    const pollMs = Math.max(1, Number(options.pollMs || 1_000));
+    const sleep = options.sleep || ((milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)));
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const status = await inspect();
+        if (status.membershipExpired)
+            throw new Error("FastMoss 会员已过期或当前账号没有商品榜单权限，请先更换账号");
+        if (!status.verificationRequired) {
+            if (!status.authenticated)
+                throw new Error("FastMoss 登录已失效，请在专用窗口中重新登录后再次抓取");
+            return;
+        }
+        await sleep(pollMs);
+    }
+    throw new Error("等待人工滑块超过 10 分钟，本次采集已停止；完成验证后可重新开始，已保存结果不会丢失");
+}
 export function videoEvidenceTimestamps(durationMs) {
     const maximumFrames = 24;
     const safeDuration = Math.max(1_000, Math.min(30 * 60_000, Math.round(Number(durationMs) || 0)));

package/dist/video-intelligence/local-analysis.d.ts

@@ -2,6 +2,8 @@ import type { AgentAttachment } from "../agent/types.js";
 import { type FastMossIntegration } from "../integrations/fastmoss.js";
 export type LocalVideoLearningSource = {
     id?: string;
+    source?: string;
+    platform?: string;
     sourceUrl?: string;
     source_url?: string;
     platformVideoId?: string;
@@ -29,6 +31,10 @@ type VideoArchiveUpload = {
     headers?: Record<string, string>;
     maxBytes?: number;
 };
+export declare function shouldUploadVideoArchive(input: {
+    kind: "uploaded-mp4" | "tiktok";
+    url: string;
+}, publicUrl: string): boolean;
 export declare class LocalVideoIntelligence {
     private readonly fastmoss;
     constructor(fastmoss: FastMossIntegration);
@@ -56,6 +62,10 @@ export declare class LocalVideoIntelligence {
         };
     }>;
 }
+export declare function verifiedVideoLearningSource(source: LocalVideoLearningSource): {
+    kind: "tiktok" | "uploaded-mp4";
+    url: string;
+};
 export declare function localVideoAnalysisPrompt(source: LocalVideoLearningSource, durationMs: number, transcript: string, attachments: AgentAttachment[]): string;
 export declare function assertJointVisualAndSpokenEvidence(analysis: Record<string, unknown>): void;
 export declare function timedTranscriptFromVtt(value: string): string;

package/dist/video-intelligence/local-analysis.js

@@ -9,28 +9,35 @@ const ANALYSIS_TIMEOUT_MS = 10 * 60_000;
 const TRANSCRIPT_LANGUAGES = "en.*,es.*,zh.*,pt.*,fr.*,de.*,vi.*,th.*,id.*,ms.*,ja.*,ko.*";
 const LOCAL_ASR_MODEL = "onnx-community/whisper-base";
 let localAsrPipeline;
+export function shouldUploadVideoArchive(input, publicUrl) {
+    return input.kind !== "uploaded-mp4" || input.url !== publicUrl;
+}
 export class LocalVideoIntelligence {
     fastmoss;
     constructor(fastmoss) {
         this.fastmoss = fastmoss;
     }
     async archive(source, upload) {
-        const sourceUrl = verifiedTikTokSourceUrl(source);
+        const input = verifiedVideoLearningSource(source);
         const uploadUrl = verifiedHttpsUrl(upload?.uploadUrl, "站内上传地址无效");
         const publicUrl = verifiedHttpsUrl(upload?.publicUrl, "站内视频地址无效");
         const maxBytes = Math.min(500 * 1024 * 1024, Math.max(1, Number(upload?.maxBytes || 100 * 1024 * 1024)));
         const workDir = await mkdtemp(path.join(os.tmpdir(), "canvas-video-archive-"));
         try {
-            const downloaded = await downloadVideoArchive(sourceUrl, workDir, maxBytes);
+            const downloaded = input.kind === "uploaded-mp4"
+                ? await downloadUploadedMp4(input.url, workDir, maxBytes)
+                : await downloadVideoArchive(input.url, workDir, maxBytes);
             const bytes = await readFile(downloaded.file);
-            const response = await fetch(uploadUrl, {
-                method: "PUT",
-                headers: { "Content-Type": "video/mp4" },
-                body: bytes,
-                signal: AbortSignal.timeout(5 * 60_000),
-            });
-            if (!response.ok)
-                throw new Error(`站内视频上传失败（HTTP ${response.status}）`);
+            if (shouldUploadVideoArchive(input, publicUrl)) {
+                const response = await fetch(uploadUrl, {
+                    method: "PUT",
+                    headers: { "Content-Type": "video/mp4" },
+                    body: bytes,
+                    signal: AbortSignal.timeout(5 * 60_000),
+                });
+                if (!response.ok)
+                    throw new Error(`站内视频上传失败（HTTP ${response.status}）`);
+            }
             return {
                 archive: {
                     publicUrl,
@@ -50,11 +57,10 @@ export class LocalVideoIntelligence {
         }
     }
     async analyze(source) {
-        const sourceUrl = verifiedTikTokSourceUrl(source);
         const archivedVideoUrl = String(source.archivedVideoUrl || source.archived_video_url || "").trim();
         const archivedTranscript = String(source.archivedTranscript || source.archived_transcript || "").trim();
         const hasArchivedMedia = Boolean(archivedVideoUrl);
-        const mediaUrl = archivedVideoUrl ? verifiedHttpsUrl(archivedVideoUrl, "站内视频副本地址无效") : sourceUrl;
+        const mediaUrl = archivedVideoUrl ? verifiedHttpsUrl(archivedVideoUrl, "站内视频副本地址无效") : verifiedTikTokSourceUrl(source);
         const platformVideoId = String(source.platformVideoId || source.platform_video_id || "").trim();
         const workDir = await mkdtemp(path.join(os.tmpdir(), "canvas-video-intelligence-"));
         try {
@@ -68,7 +74,7 @@ export class LocalVideoIntelligence {
                 transcriptSource = transcript ? `local-asr:${LOCAL_ASR_MODEL}` : "local-asr:no-speech-detected";
             }
             else if (!transcript) {
-                transcript = await extractTimedTranscript(sourceUrl, workDir).catch(() => "");
+                transcript = await extractTimedTranscript(mediaUrl, workDir).catch(() => "");
                 transcriptSource = transcript ? "TikTok native/automatic timed captions via local yt-dlp" : "caption-unavailable";
             }
             if (!visualEvidence.frames.length)
@@ -100,6 +106,16 @@ function verifiedTikTokSourceUrl(source) {
     }
     return sourceUrl;
 }
+export function verifiedVideoLearningSource(source) {
+    if (String(source.source || "").trim() === "manual-upload") {
+        const sourceUrl = verifiedHttpsUrl(String(source.sourceUrl || source.source_url || "").trim(), "上传视频地址无效");
+        const pathname = new URL(sourceUrl).pathname;
+        if (!/\.mp4$/i.test(pathname))
+            throw new Error("手动上传学习只接受 MP4 文件");
+        return { kind: "uploaded-mp4", url: sourceUrl };
+    }
+    return { kind: "tiktok", url: verifiedTikTokSourceUrl(source) };
+}
 function verifiedHttpsUrl(value, message) {
     try {
         const url = new URL(value);
@@ -119,8 +135,9 @@ export function localVideoAnalysisPrompt(source, durationMs, transcript, attachm
         `1. 每张图片是实际视频在指定毫秒的画面，文件名和时间映射如下。不能把封面、榜单或网页文字当视频内容。\n${frameTimeline}\n` +
         `2. 下面口播证据来自原生字幕、自动字幕或本机音轨语音识别。只概述，不输出连续逐字稿；若为空，表示没有识别到人声，不代表视频没有音轨，也不得凭画面猜口播。\n` +
         `3. segments 每段必须写 visual；若该段有人声，spokenText 必须概述口播；可见字幕写 onScreenText。画面、口播或字幕缺失就写 null。没有听觉音轨输入，audio 必须写 null，不得猜音乐、语气或音效。\n` +
-        `4. 0-3 秒至少按 500ms 证据判断；后续按镜头变化。所有机制和“为什么可能爆”的假设都必须引用真实 startMs/endMs。榜单指标只是相关性，不是因果。\n` +
-        `5. 目标是学习、融合、进化：只提炼可迁移机制，不复制原文案、人物、视觉资产或连续镜头顺序。\n\n` +
+        `4. 必须先判断整条视频的主带货形式 primary，只能选 factory-demo/comedy/mini-drama/ugc-testimonial/review-demo/tutorial/problem-solution/price-shock/unboxing/expert-explainer/lifestyle/live-cut/comparison/other。secondary 可选其他辅助形式。不能把 Hook 或实验假设冒充带货形式。\n` +
+        `5. 0-3 秒至少按 500ms 证据判断；后续按镜头变化。所有机制、带货形式和“为什么可能爆”的假设都必须引用真实 startMs/endMs。榜单指标只是相关性，不是因果。\n` +
+        `6. 目标是学习、融合、进化：只提炼可迁移机制，不复制原文案、人物、视觉资产或连续镜头顺序。\n\n` +
         `样本：${JSON.stringify({
             sourceUrl: source.sourceUrl || source.source_url,
             platformVideoId: source.platformVideoId || source.platform_video_id,
@@ -134,7 +151,8 @@ export function localVideoAnalysisPrompt(source, durationMs, transcript, attachm
             durationMs,
         })}\n\n` +
         `带时间码的口播字幕：\n${transcript}\n\n` +
-        `只返回一个 JSON 对象，不要 Markdown。字段必须是：schemaVersion="commerce-video-intelligence-v1"；durationMs；language；summary；` +
+        `只返回一个 JSON 对象，不要 Markdown。字段必须是：schemaVersion="commerce-video-intelligence-v2"；durationMs；language；summary；` +
+        `sellingFormat{primary,label,secondary,rationale,evidence[{startMs,endMs,observation}],confidence}；` +
         `hook{startMs,endMs,visual,spokenText,onScreenText,patternInterrupt,openLoop}；productFirstSeenMs；` +
         `segments[{startMs,endMs,role,visual,spokenText,onScreenText,audio,editing,confidence}]（至少2段）；` +
         `mechanisms[{type,label,mechanism,whyItMayWork,evidence[{startMs,endMs,observation}],confidence,replicationRisk}]（type 仅 hook/conflict/proof/pacing/trust/product-reveal/offer-framing/cta/audio）；` +
@@ -292,6 +310,25 @@ async function downloadVideoArchive(sourceUrl, workDir, maxBytes) {
     const transcript = await transcriptFromDirectory(workDir, lastError).catch(() => "");
     return { file: video.file, transcript, media };
 }
+async function downloadUploadedMp4(sourceUrl, workDir, maxBytes) {
+    const response = await fetch(sourceUrl, { signal: AbortSignal.timeout(5 * 60_000) });
+    if (!response.ok)
+        throw new Error(`读取上传视频失败（HTTP ${response.status}）`);
+    const declaredLength = Number(response.headers.get("content-length") || 0);
+    if (declaredLength > maxBytes)
+        throw new Error(`视频超过站内存储上限（${Math.ceil(maxBytes / 1024 / 1024)} MiB）`);
+    const bytes = Buffer.from(await response.arrayBuffer());
+    if (!bytes.length)
+        throw new Error("上传视频为空");
+    if (bytes.length > maxBytes)
+        throw new Error(`视频超过站内存储上限（${Math.ceil(maxBytes / 1024 / 1024)} MiB）`);
+    if (!bytes.subarray(0, 64).includes(Buffer.from("ftyp")))
+        throw new Error("上传文件不是可识别的 MP4");
+    const file = path.join(workDir, "manual-upload.mp4");
+    await writeFile(file, bytes);
+    const media = await inspectVideoFile(file, workDir);
+    return { file, transcript: "", media };
+}
 export async function inspectVideoFile(videoFile, workDir = path.dirname(videoFile)) {
     const probe = await runProcess(process.platform === "win32" ? "ffprobe.exe" : "ffprobe", [
         "-v", "error", "-show_entries", "stream=codec_type,codec_name,width,height,duration:format=duration,format_name", "-of", "json", videoFile,

package/package.json

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