@xiaohhhh1/canvas-agent 0.4.21 → 0.4.23

package/dist/integrations/fastmoss.d.ts

@@ -1,3 +1,4 @@
+export type FastMossRankingSource = "new" | "hot" | "video" | "sales";
 export type FastMossPhase = "idle" | "saved" | "launching" | "login_required" | "ready" | "verification_required" | "membership_expired" | "error";
 export type FastMossStatus = {
     phase: FastMossPhase;
@@ -17,6 +18,19 @@ type CaptureContext = {
     shopType?: string;
     periodDays?: number;
 };
+type VideoLearningCaptureContext = {
+    market?: string;
+    target?: number;
+};
+type VideoLearningDimension = "commerce-video" | "high-sales" | "high-roas" | "high-exposure" | "high-engagement";
+type VisibleVideoItem = {
+    text: string;
+    links: string[];
+    media: string[];
+    images: string[];
+    headers: string[];
+    cells: string[];
+};
 export declare class FastMossIntegration {
     private context;
     private page;
@@ -37,6 +51,21 @@ export declare class FastMossIntegration {
     start(): Promise<FastMossStatus>;
     inspect(): Promise<FastMossStatus>;
     capture(input?: CaptureContext): Promise<{
+        records: Record<string, unknown>[];
+        allRows: Record<string, unknown>[];
+        trendProducts: number;
+        detailFailures: number;
+        interrupted: boolean;
+        phase: FastMossPhase;
+        browserOpen: boolean;
+        authenticated: boolean;
+        verificationRequired: boolean;
+        membershipExpired: boolean;
+        message: string;
+        url: string | null;
+        captured: number;
+        lastCapture?: string;
+    } | {
         records: Record<string, unknown>[];
         allRows: Record<string, unknown>[];
         trendProducts: number;
@@ -51,6 +80,29 @@ export declare class FastMossIntegration {
         captured: number;
         lastCapture?: string;
     }>;
+    /**
+     * Reuse the exact same local, persistent FastMoss browser used by product selection.
+     * This reads only visible ranking pages and visible media elements. It never creates
+     * private FastMoss API requests and pauses for the operator when a CAPTCHA appears.
+     */
+    captureLearningVideos(input?: VideoLearningCaptureContext): Promise<{
+        sources: Record<string, unknown>[];
+        rejected: {
+            dimension: VideoLearningDimension;
+            reason: string;
+        }[];
+        requestedTarget: number;
+        complete: boolean;
+        phase: FastMossPhase;
+        browserOpen: boolean;
+        authenticated: boolean;
+        verificationRequired: boolean;
+        membershipExpired: boolean;
+        message: string;
+        url: string | null;
+        captured: number;
+        lastCapture?: string;
+    }>;
     close(): Promise<FastMossStatus>;
     observations(): Promise<{
         rows: Record<string, unknown>[];
@@ -59,9 +111,45 @@ export declare class FastMossIntegration {
     private loadRows;
     private useLatestPage;
     private openProductRanking;
+    private openVideoLearningPage;
 }
 export declare function fastMossSalesRankUrl(market?: string): string;
+export declare function fastMossRankingUrl(source: FastMossRankingSource, market?: string): string;
+export declare function mergeRankingRecord(target: Map<string, Record<string, unknown>>, row: Record<string, unknown>, source: FastMossRankingSource, position: number): void;
+export declare function selectDetailCandidates(records: Array<Record<string, unknown>>, limit?: number): Record<string, unknown>[];
+export declare function isAnalyzableVideoUrl(value: string): boolean;
+export declare function videoLearningSourcesFromItems(items: VisibleVideoItem[], context: {
+    market: string;
+    dimension: VideoLearningDimension;
+    observedAt: string;
+}): Record<string, unknown>[];
 export declare function productIdFromUrl(value: string): string;
+/** Extract only the evidence required by the AI short-video selection model. */
+export declare function detailOverviewEvidence(overviewPayload: unknown, basePayload?: unknown): {
+    recentVideoSales: number;
+    recentLiveSales: number;
+    recentCreatorCount: number;
+    recentVideoCount: number;
+    recentLiveCount: number;
+    videoTransactionShare: number | null;
+    liveTransactionShare: number | null;
+    adSalesShare: number | null;
+    organicTrafficShare: number | null;
+    creatorAdds: number;
+    videoAdds: number;
+    stock: number;
+    rating: number;
+    reviewCount: number;
+    totalCreatorCount: number;
+    totalVideoCount: number;
+    totalLiveCount: number;
+    viralIndex: number;
+    popularityIndex: number;
+    countryRank: number;
+    categoryRank: number;
+    launchTime: number;
+    commission: number | null;
+};
 export declare function detailTrendRows(record: Record<string, unknown>, payload: unknown, days?: number): {
     date: string;
     source: string;
@@ -71,5 +159,28 @@ export declare function detailTrendRows(record: Record<string, unknown>, payload
     price: number;
     currency: string;
     period_days: number;
+    recentVideoSales: number;
+    recentLiveSales: number;
+    recentCreatorCount: number;
+    recentVideoCount: number;
+    recentLiveCount: number;
+    videoTransactionShare: number | null;
+    liveTransactionShare: number | null;
+    adSalesShare: number | null;
+    organicTrafficShare: number | null;
+    creatorAdds: number;
+    videoAdds: number;
+    stock: number;
+    rating: number;
+    reviewCount: number;
+    totalCreatorCount: number;
+    totalVideoCount: number;
+    totalLiveCount: number;
+    viralIndex: number;
+    popularityIndex: number;
+    countryRank: number;
+    categoryRank: number;
+    launchTime: number;
+    commission: number | null;
 }[];
 export {};

package/dist/integrations/fastmoss.js

@@ -5,13 +5,23 @@ 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;
 const PRODUCT_RANK_PAGE_SIZE = 10;
 const PRODUCT_RANK_MAX_PAGES = 50;
+const DETAIL_CANDIDATE_LIMIT = 200;
 const DETAIL_TREND_DAYS = 7;
 const DETAIL_FETCH_CONCURRENCY = 3;
+const VIDEO_LEARNING_TARGET = 36;
+const VIDEO_COMMERCE_TARGET = 12;
+const VIDEO_AI_TARGET_PER_DIMENSION = 6;
+const VIDEO_AI_RANKING_PATH = "/zh/creativecenter/top-ai-videos";
+const RANKING_DEFINITIONS = [
+    { source: "new", label: "新品榜", pathname: "/e-commerce/newProducts" },
+    { source: "hot", label: "热推榜", pathname: "/e-commerce/hotlist" },
+    { source: "video", label: "视频商品榜", pathname: "/e-commerce/hotvideo" },
+    { source: "sales", label: "销量榜", pathname: "/e-commerce/saleslist" },
+];
 export class FastMossIntegration {
     context = null;
     page = null;
@@ -171,24 +181,28 @@ export class FastMossIntegration {
         }
         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 <= PRODUCT_RANK_MAX_PAGES; 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();
+        for (const ranking of RANKING_DEFINITIONS) {
+            await this.openProductRanking(input, ranking);
+            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)
+                    break;
+                previousSignature = snapshot.signature;
+                pages.push(snapshot.url);
+                const pageRecords = extractRows(snapshot.tables, { ...input, date: localDate() }, snapshot.url);
+                pageRecords.forEach((row, index) => mergeRankingRecord(collected, row, ranking.source, (pageNumber - 1) * PRODUCT_RANK_PAGE_SIZE + index + 1));
+                this.captured = collected.size;
+                this.message = `正在读取${ranking.label}第 ${pageNumber} 页，跨榜单去重后 ${this.captured} 个商品`;
+                if (!await clickVisibleNextPage(this.page))
+                    break;
+                await this.page.waitForTimeout(800);
+                await this.inspect();
+                if (this.verificationRequired || this.membershipExpired)
+                    break;
+            }
             if (this.verificationRequired || this.membershipExpired)
                 break;
         }
@@ -197,20 +211,39 @@ export class FastMossIntegration {
             throw new Error("已自动进入 FastMoss 商品榜单，但没有读取到商品数据；请检查会员权限或页面是否仍在加载");
         const requestedMarket = normalizeMarket(input.market);
         const marketRecords = records.filter((record) => !record.market || normalizeExtractedMarket(record.market) === requestedMarket);
+        const retainPreviousOnInterruption = async (stage, partialTrendRows = [], detailFailures = 0) => {
+            await mkdir(this.dataDir, { recursive: true });
+            const attemptedAt = new Date().toISOString();
+            const previousRows = await this.loadRows();
+            await writeFile(path.join(this.dataDir, `capture-${localDate()}-interrupted-${Date.now()}.json`), JSON.stringify({ attemptedAt, interrupted: true, stage, pages, records: marketRecords, trendRows: partialTrendRows, detailFailures }, null, 2), "utf8");
+            this.captured = marketRecords.length;
+            const previousProducts = new Set(previousRows.map((row) => String(row.product_id))).size;
+            this.message = this.verificationRequired
+                ? `采集在${stage === "ranking" ? "榜单" : "商品详情互证"}阶段遇到人工验证；已保留上次 ${previousProducts} 个商品结果，请完成滑块后重新抓取`
+                : `采集在${stage === "ranking" ? "榜单" : "商品详情互证"}阶段发现会员权限异常；已保留上次 ${previousProducts} 个商品结果`;
+            return { ...this.status(), records: marketRecords, allRows: previousRows, trendProducts: previousProducts, detailFailures, interrupted: true };
+        };
+        if (this.verificationRequired || this.membershipExpired)
+            return retainPreviousOnInterruption("ranking");
+        const detailCandidates = selectDetailCandidates(marketRecords, DETAIL_CANDIDATE_LIMIT);
+        const capturePage = this.page;
         const trendRows = [];
         let detailFailures = 0;
-        for (let offset = 0; offset < marketRecords.length; offset += DETAIL_FETCH_CONCURRENCY) {
-            const chunk = marketRecords.slice(offset, offset + DETAIL_FETCH_CONCURRENCY);
-            const results = await Promise.all(chunk.map((record) => fetchDetailTrend(this.page, record, DETAIL_TREND_DAYS)));
+        for (let offset = 0; offset < detailCandidates.length; offset += DETAIL_FETCH_CONCURRENCY) {
+            const chunk = detailCandidates.slice(offset, offset + DETAIL_FETCH_CONCURRENCY);
+            const results = await Promise.all(chunk.map((record) => fetchDetailTrend(capturePage, record, DETAIL_TREND_DAYS)));
             results.forEach((rows) => rows.length ? trendRows.push(...rows) : detailFailures += 1);
-            this.message = `正在读取商品最近 ${DETAIL_TREND_DAYS} 天趋势：${Math.min(offset + chunk.length, marketRecords.length)}/${marketRecords.length}`;
-            await this.page.waitForTimeout(150);
+            this.message = `正在互证商品最近 ${DETAIL_TREND_DAYS} 天趋势：${Math.min(offset + chunk.length, detailCandidates.length)}/${detailCandidates.length}`;
+            await capturePage.waitForTimeout(150);
             if ((offset / DETAIL_FETCH_CONCURRENCY) % 10 === 0) {
+                this.useLatestPage();
                 await this.inspect();
                 if (this.verificationRequired || this.membershipExpired)
                     break;
             }
         }
+        if (this.verificationRequired || this.membershipExpired)
+            return retainPreviousOnInterruption("detail", trendRows, detailFailures);
         if (!trendRows.length && !this.verificationRequired)
             throw new Error("榜单读取成功，但未能读取商品详情的最近 7 天销量；请检查会员权限后重试");
         await mkdir(this.dataDir, { recursive: true });
@@ -218,13 +251,112 @@ export class FastMossIntegration {
         this.lastCapture = new Date().toISOString();
         this.captured = marketRecords.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: marketRecords, trendRows, detailFailures }, 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} 个商品，其中 ${trendProducts} 个取得最近 ${DETAIL_TREND_DAYS} 天趋势`;
+            : `四榜单去重后 ${marketRecords.length} 个商品，优先互证 ${detailCandidates.length} 个，其中 ${trendProducts} 个取得最近 ${DETAIL_TREND_DAYS} 天趋势`;
         return { ...this.status(), records: marketRecords, allRows, trendProducts, detailFailures };
     }
+    /**
+     * Reuse the exact same local, persistent FastMoss browser used by product selection.
+     * This reads only visible ranking pages and visible media elements. It never creates
+     * private FastMoss API requests and pauses for the operator when a CAPTCHA appears.
+     */
+    async captureLearningVideos(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 (!this.authenticated || !this.page || this.page.isClosed())
+            throw new Error("FastMoss 尚未登录；请在恢复的窗口中完成登录后重试");
+        const market = normalizeMarket(input.market || "US");
+        const requestedTarget = Math.max(1, Math.min(VIDEO_LEARNING_TARGET, Number(input.target || VIDEO_LEARNING_TARGET)));
+        const sources = [];
+        const rejected = [];
+        const seen = new Set();
+        const collect = async (dimension, limit) => {
+            if (!this.page)
+                return;
+            let previousSignature = "";
+            for (let pageNumber = 1; pageNumber <= 5 && sources.filter((item) => item.rankingDimension === dimension).length < limit; pageNumber += 1) {
+                const snapshot = await readVisibleVideoLearningItems(this.page);
+                const signature = JSON.stringify(snapshot.map((item) => [item.text, item.media, item.links]).slice(0, 20));
+                if (!snapshot.length || (pageNumber > 1 && signature === previousSignature))
+                    break;
+                previousSignature = signature;
+                const normalized = videoLearningSourcesFromItems(snapshot, { market, dimension, observedAt: new Date().toISOString() });
+                for (const item of normalized) {
+                    const key = String(item.platformVideoId || item.sourceUrl || "");
+                    if (!key || seen.has(key))
+                        continue;
+                    // A learning sample must point to an actual visible media/public-video URL.
+                    // Ranking metadata without readable media is retained only as a rejection,
+                    // never counted toward the 36 analyzable videos.
+                    if (!item.sourceUrl || !isAnalyzableVideoUrl(String(item.sourceUrl))) {
+                        rejected.push({ dimension, reason: "榜单条目没有暴露可读取的视频地址" });
+                        continue;
+                    }
+                    seen.add(key);
+                    sources.push(item);
+                    if (sources.filter((source) => source.rankingDimension === dimension).length >= limit)
+                        break;
+                }
+                this.captured = sources.length;
+                this.message = `正在读取视频学习样本：${dimension} ${sources.filter((item) => item.rankingDimension === dimension).length}/${limit}，合计 ${sources.length}/${requestedTarget}`;
+                if (sources.filter((item) => item.rankingDimension === dimension).length >= limit)
+                    break;
+                if (!await clickVisibleNextPage(this.page))
+                    break;
+                await this.page.waitForTimeout(900);
+                await this.inspect();
+                if (this.verificationRequired)
+                    throw new Error("采集视频榜单时出现滑块验证；请手动完成后重新采集，未完成样本不会计数");
+                if (this.membershipExpired)
+                    throw new Error("当前 FastMoss 账号没有继续查看视频榜单的权限");
+            }
+        };
+        await this.openVideoLearningPage(fastMossRankingUrl("video", market), `${market} 视频商品榜`);
+        await collect("commerce-video", Math.min(VIDEO_COMMERCE_TARGET, requestedTarget));
+        const aiDimensions = [
+            { dimension: "high-sales", labels: ["高销量榜单", "High Sales"] },
+            { dimension: "high-roas", labels: ["高ROAS榜单", "High ROAS"] },
+            { dimension: "high-exposure", labels: ["高曝光榜单", "High Exposure"] },
+            { dimension: "high-engagement", labels: ["高互动榜单", "High Engagement"] },
+        ];
+        if (sources.length < requestedTarget) {
+            const aiUrl = new URL(VIDEO_AI_RANKING_PATH, FASTMOSS_HOME);
+            aiUrl.searchParams.set("region", market);
+            await this.openVideoLearningPage(aiUrl.toString(), `${market} AI 带货视频榜`);
+            for (const entry of aiDimensions) {
+                if (sources.length >= requestedTarget)
+                    break;
+                const clicked = await clickVisibleText(this.page, entry.labels);
+                if (!clicked) {
+                    rejected.push({ dimension: entry.dimension, reason: `没有找到${entry.labels[0]}标签` });
+                    continue;
+                }
+                await this.page.waitForTimeout(900);
+                await this.inspect();
+                if (this.verificationRequired)
+                    throw new Error("采集 AI 视频榜时出现滑块验证；请手动完成后重新采集");
+                const remaining = Math.min(VIDEO_AI_TARGET_PER_DIMENSION, requestedTarget - sources.length);
+                await collect(entry.dimension, remaining);
+            }
+        }
+        await mkdir(this.dataDir, { recursive: true });
+        const capturedAt = new Date().toISOString();
+        await writeFile(path.join(this.dataDir, "video-learning-observations.json"), JSON.stringify({ capturedAt, market, sources, rejected }, null, 2), "utf8");
+        this.lastCapture = capturedAt;
+        this.captured = sources.length;
+        this.message = sources.length >= requestedTarget
+            ? `已从同一 FastMoss 专用窗口取得 ${sources.length} 条可分析视频样本`
+            : `只取得 ${sources.length}/${requestedTarget} 条可分析视频；其余条目未暴露视频地址，不会冒充有效样本`;
+        return { ...this.status(), sources, rejected, requestedTarget, complete: sources.length >= requestedTarget };
+    }
     async close() {
         const context = this.context;
         this.context = null;
@@ -276,18 +408,18 @@ export class FastMossIntegration {
         if (pages.length)
             this.page = pages[pages.length - 1];
     }
-    async openProductRanking(input) {
+    async openProductRanking(input, ranking = RANKING_DEFINITIONS[0]) {
         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 });
+        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;
         while (Date.now() < deadline) {
             const snapshot = await readVisibleTableSnapshot(this.page);
             if (hasReadableProductRows(snapshot)) {
                 this.phase = "ready";
-                this.message = `${market} 商品榜单已打开，正在开始采集`;
+                this.message = `${market} ${ranking.label}已打开，正在开始采集`;
                 return;
             }
             await this.inspect();
@@ -301,14 +433,62 @@ export class FastMossIntegration {
         }
         throw new Error("FastMoss 商品榜单自动加载超时；请检查网络或在窗口中完成人工验证后重试");
     }
+    async openVideoLearningPage(url, label) {
+        if (!this.page || this.page.isClosed())
+            throw new Error("FastMoss 专用浏览器未打开");
+        this.message = `正在自动进入 ${label}`;
+        await this.page.goto(url, { waitUntil: "domcontentloaded", timeout: 60_000 });
+        const deadline = Date.now() + PRODUCT_TABLE_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+            const items = await readVisibleVideoLearningItems(this.page);
+            if (items.length)
+                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(`${label}加载超时；请检查网络或在专用窗口中确认页面可见`);
+    }
 }
 export function fastMossSalesRankUrl(market) {
-    const url = new URL(FASTMOSS_SALES_RANK);
+    return fastMossRankingUrl("sales", market);
+}
+export function fastMossRankingUrl(source, market) {
+    const definition = RANKING_DEFINITIONS.find((item) => item.source === source) || RANKING_DEFINITIONS[0];
+    const url = new URL(definition.pathname, FASTMOSS_HOME);
     url.searchParams.set("region", normalizeMarket(market));
     url.searchParams.set("page", "1");
     url.searchParams.set("pagesize", String(PRODUCT_RANK_PAGE_SIZE));
     return url.toString();
 }
+export function mergeRankingRecord(target, row, source, position) {
+    const key = String(row.product_id || row.title);
+    const existing = target.get(key) || {};
+    const sources = [...new Set([...(Array.isArray(existing.ranking_sources) ? existing.ranking_sources.map(String) : []), source])];
+    const positions = existing.ranking_positions && typeof existing.ranking_positions === "object" ? existing.ranking_positions : {};
+    target.set(key, {
+        ...existing,
+        ...row,
+        ranking_sources: sources,
+        ranking_positions: { ...positions, [source]: position },
+        cross_list_count: sources.filter((item) => item !== "sales").length,
+    });
+}
+export function selectDetailCandidates(records, limit = DETAIL_CANDIDATE_LIMIT) {
+    const bestPosition = (record) => {
+        const positions = record.ranking_positions && typeof record.ranking_positions === "object" ? Object.values(record.ranking_positions) : [];
+        return Math.min(...positions.map(Number).filter(Number.isFinite), Number.MAX_SAFE_INTEGER);
+    };
+    return [...records].sort((left, right) => {
+        const crossDifference = Number(right.cross_list_count || 0) - Number(left.cross_list_count || 0);
+        return crossDifference || bestPosition(left) - bestPosition(right);
+    }).slice(0, Math.max(1, limit));
+}
 function normalizeMarket(value) {
     const market = String(value || "MX").trim().toUpperCase();
     return /^[A-Z]{2}$/.test(market) ? market : "MX";
@@ -374,6 +554,203 @@ async function clickVisibleNextPage(page) {
         return true;
     });
 }
+async function clickVisibleText(page, labels) {
+    return page.evaluate((expected) => {
+        const shown = (element) => Boolean(element.getClientRects().length);
+        const normalized = (value) => value.replace(/\s+/g, "").toLowerCase();
+        const wanted = expected.map(normalized);
+        const candidates = [...document.querySelectorAll("button,a,[role='tab'],[role='button'],label")]
+            .filter(shown)
+            .filter((element) => {
+            const text = normalized(element.innerText || element.textContent || "");
+            return wanted.some((label) => text === label || text.includes(label));
+        });
+        const target = candidates[0];
+        if (!target)
+            return false;
+        target.click();
+        return true;
+    }, labels);
+}
+async function readVisibleVideoLearningItems(page) {
+    return page.evaluate(() => {
+        const shown = (element) => {
+            const node = element;
+            const rect = node.getBoundingClientRect();
+            const style = getComputedStyle(node);
+            return Boolean(node.getClientRects().length) && rect.width >= 80 && rect.height >= 30 && style.visibility !== "hidden" && style.display !== "none";
+        };
+        const absoluteUrl = (value) => {
+            try {
+                return new URL(value, location.href).toString();
+            }
+            catch {
+                return "";
+            }
+        };
+        const mediaUrls = (root) => {
+            const direct = [...root.querySelectorAll("video")].flatMap((video) => [
+                video.currentSrc,
+                video.src,
+                video.poster,
+                ...[...video.querySelectorAll("source[src]")].map((source) => source.src),
+            ]);
+            const data = [...root.querySelectorAll("[data-video],[data-video-url],[data-play-url],[data-src]")].flatMap((element) => [
+                element.dataset.video || "",
+                element.dataset.videoUrl || "",
+                element.dataset.playUrl || "",
+                element.dataset.src || "",
+            ]);
+            return [...new Set([...direct, ...data].filter(Boolean).map(absoluteUrl).filter(Boolean))];
+        };
+        const serialize = (root, headers = [], cells = []) => ({
+            text: root.innerText.replace(/\s+/g, " ").trim().slice(0, 8000),
+            links: [...new Set([...root.querySelectorAll("a[href]")].map((link) => link.href).filter(Boolean))],
+            media: mediaUrls(root),
+            images: [...new Set([...root.querySelectorAll("img")].map((image) => image.currentSrc || image.src || image.dataset.src || "").filter(Boolean).map(absoluteUrl).filter(Boolean))],
+            headers,
+            cells,
+        });
+        const tableItems = [...document.querySelectorAll("table tbody tr")]
+            .filter(shown)
+            .map((row) => {
+            const table = row.closest("table");
+            const headers = [...(table?.querySelectorAll("thead th") || [])].map((cell) => cell.innerText.replace(/\s+/g, " ").trim());
+            const cells = [...row.querySelectorAll("td")].map((cell) => cell.innerText.replace(/\s+/g, " ").trim());
+            return serialize(row, headers, cells);
+        })
+            .filter((item) => item.text && (item.links.length || item.media.length || item.images.length));
+        const cardCandidates = [...document.querySelectorAll("article,li,[class*='card'],[class*='item']")]
+            .filter(shown)
+            .filter((element) => {
+            const rect = element.getBoundingClientRect();
+            const text = element.innerText.replace(/\s+/g, " ").trim();
+            return rect.width >= 180 && rect.height >= 160 && text.length >= 8 && Boolean(element.querySelector("video,img"));
+        })
+            .sort((left, right) => {
+            const a = left.getBoundingClientRect();
+            const b = right.getBoundingClientRect();
+            return a.width * a.height - b.width * b.height;
+        });
+        const cards = [];
+        const accepted = new Set();
+        for (const element of cardCandidates) {
+            if ([...accepted].some((other) => element.contains(other)))
+                continue;
+            accepted.add(element);
+            cards.push(serialize(element));
+            if (cards.length >= 80)
+                break;
+        }
+        const combined = [...tableItems, ...cards];
+        const seen = new Set();
+        return combined.filter((item) => {
+            const key = JSON.stringify([item.text.slice(0, 300), item.media[0], item.links[0], item.images[0]]);
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        });
+    });
+}
+function firstHttp(values, expected) {
+    return values.find((value) => /^https?:\/\//i.test(value) && (!expected || expected.test(value))) || "";
+}
+function videoIdFromValues(values) {
+    for (const value of values) {
+        const direct = value.match(/(?:video|aweme|item|material)[/=_-](\d{8,})/i)?.[1];
+        if (direct)
+            return direct;
+        try {
+            const url = new URL(value);
+            const query = url.searchParams.get("aweme_id") || url.searchParams.get("video_id") || url.searchParams.get("item_id");
+            if (query && /^\d{8,}$/.test(query))
+                return query;
+        }
+        catch { }
+    }
+    return "";
+}
+function labeledMetrics(item) {
+    const metrics = {};
+    item.headers.forEach((header, index) => {
+        const value = item.cells[index];
+        if (!header || !value)
+            return;
+        const numeric = numberValue(value);
+        const key = /销量|sales|sold/i.test(header) ? "sales"
+            : /销售额|成交额|gmv/i.test(header) ? "gmv"
+                : /播放|曝光|views?|impressions?/i.test(header) ? "views"
+                    : /点赞|likes?/i.test(header) ? "likes"
+                        : /评论|comments?/i.test(header) ? "comments"
+                            : /roas/i.test(header) ? "roas"
+                                : "";
+        if (key && Number.isFinite(numeric))
+            metrics[key] = numeric;
+    });
+    const patterns = [
+        ["sales", /(?:总销量|销量|sales)\s*[:：]?\s*([\d,.]+(?:万|亿|k|w)?)/i],
+        ["gmv", /(?:总销售额|销售额|GMV)\s*[:：$]?\s*([\d,.]+(?:万|亿|k|w)?)/i],
+        ["views", /(?:总播放量|视频播放量|播放量|曝光)\s*[:：]?\s*([\d,.]+(?:万|亿|k|w)?)/i],
+        ["likes", /(?:总点赞数|点赞数|点赞)\s*[:：]?\s*([\d,.]+(?:万|亿|k|w)?)/i],
+        ["comments", /(?:总评论数|评论数|评论)\s*[:：]?\s*([\d,.]+(?:万|亿|k|w)?)/i],
+        ["roas", /ROAS\s*[:：]?\s*([\d,.]+)/i],
+    ];
+    for (const [key, pattern] of patterns) {
+        const match = item.text.match(pattern)?.[1];
+        if (match && metrics[key] == null)
+            metrics[key] = numberValue(match);
+    }
+    return metrics;
+}
+export function isAnalyzableVideoUrl(value) {
+    try {
+        const url = new URL(value);
+        if (!/^https?:$/.test(url.protocol))
+            return false;
+        const pathAndQuery = url.pathname + url.search;
+        if (/\.(?:jpe?g|png|webp|gif|avif)(?:$|\?)/i.test(pathAndQuery))
+            return false;
+        return /\.(?:mp4|mov|m4v|webm)(?:$|\?)/i.test(pathAndQuery)
+            || /tiktok\.com$/i.test(url.hostname) && /\/video\/\d+/i.test(url.pathname)
+            || /(?:tiktokcdn|byteoversea|ibytedtos|muscdn)/i.test(url.hostname) && /(?:video|tos)/i.test(url.pathname);
+    }
+    catch {
+        return false;
+    }
+}
+export function videoLearningSourcesFromItems(items, context) {
+    const output = [];
+    const seen = new Set();
+    for (const [index, item] of items.entries()) {
+        const mediaUrl = item.media.find((value) => isAnalyzableVideoUrl(value)) || "";
+        const publicVideoUrl = firstHttp(item.links, /tiktok\.com\/.*(?:video|v)\//i);
+        const traceUrl = firstHttp(item.links, /video|aweme|creative|material/i);
+        const sourceUrl = mediaUrl || publicVideoUrl || traceUrl;
+        const platformVideoId = videoIdFromValues([sourceUrl, ...item.links, ...item.media]) || stableId(`${context.dimension}|${item.text}|${item.images[0] || ""}`);
+        if (seen.has(platformVideoId))
+            continue;
+        const title = item.cells.find((cell) => cell.length >= 5 && cell.length <= 300) || item.text.split(/(?=销量|销售额|播放|曝光|ROAS)/i)[0]?.trim().slice(0, 500) || "";
+        if (!title || (!sourceUrl && !item.images.length))
+            continue;
+        seen.add(platformVideoId);
+        output.push({
+            source: "fastmoss-agent",
+            platform: "tiktok",
+            platformVideoId,
+            sourceUrl: sourceUrl || null,
+            market: context.market,
+            rankingDimension: context.dimension,
+            rank: index + 1,
+            title,
+            productTitle: item.cells[0] || title,
+            thumbnailUrl: firstHttp(item.images),
+            metrics: labeledMetrics(item),
+            observedAt: context.observedAt,
+        });
+    }
+    return output;
+}
 function findChromiumExecutable() {
     const home = os.homedir();
     const candidates = process.platform === "win32" ? [
@@ -406,6 +783,7 @@ function extractRows(tables, context, pageUrl) {
             const storeName = String(pick(/所属店铺|店铺|shop|store/i)).replace(/\s*店铺销量\s*[：:].*$/is, "").trim();
             output.push({
                 date: context.date,
+                capture_date: context.date,
                 source: "fastmoss-agent",
                 product_id: productId,
                 platform_product_id: String(pick(/平台商品|tiktok.*id/i) || productId),
@@ -444,15 +822,68 @@ export function productIdFromUrl(value) {
         return String(value).match(/(?:detail|product|goods|item)[/=_-](\d+)/i)?.[1] || "";
     }
 }
+function percentValue(value) {
+    const number = Number(String(value ?? "").replace("%", ""));
+    return Number.isFinite(number) ? number : null;
+}
+function distributionShare(value, expected) {
+    const container = value && typeof value === "object" ? value : {};
+    const list = Array.isArray(container.list) ? container.list : [];
+    const item = list.find((entry) => expected.test(String(entry.category ?? entry.source ?? "")));
+    return item ? percentValue(item.propotion ?? item.proportion ?? item.percent) : null;
+}
+/** Extract only the evidence required by the AI short-video selection model. */
+export function detailOverviewEvidence(overviewPayload, basePayload) {
+    const overviewEnvelope = overviewPayload && typeof overviewPayload === "object" ? overviewPayload : {};
+    const overviewData = overviewEnvelope.data && typeof overviewEnvelope.data === "object" ? overviewEnvelope.data : {};
+    const overview = overviewData.overview && typeof overviewData.overview === "object" ? overviewData.overview : {};
+    const content = overviewData.content_distribution && typeof overviewData.content_distribution === "object" ? overviewData.content_distribution : {};
+    const ads = overviewData.ads_distribution && typeof overviewData.ads_distribution === "object" ? overviewData.ads_distribution : {};
+    const chart = Array.isArray(overviewData.chart_list) ? overviewData.chart_list : [];
+    const baseEnvelope = basePayload && typeof basePayload === "object" ? basePayload : {};
+    const baseData = baseEnvelope.data && typeof baseEnvelope.data === "object" ? baseEnvelope.data : {};
+    const product = baseData.product && typeof baseData.product === "object" ? baseData.product : {};
+    const videoShare = distributionShare(content.units_sold, /^video$/i);
+    const liveShare = distributionShare(content.units_sold, /^live$/i);
+    const adShare = distributionShare(ads.units_sold, /adtraffic|advert|广告/i);
+    const organicShare = distributionShare(ads.units_sold, /othertraffic|organic|自然|其他/i);
+    return {
+        recentVideoSales: Number(overview.video_sold_count || 0),
+        recentLiveSales: Number(overview.live_sold_count || 0),
+        recentCreatorCount: Number(overview.author_count || 0),
+        recentVideoCount: Number(overview.aweme_count || 0),
+        recentLiveCount: Number(overview.live_count || 0),
+        videoTransactionShare: videoShare,
+        liveTransactionShare: liveShare,
+        adSalesShare: adShare,
+        organicTrafficShare: organicShare,
+        creatorAdds: chart.reduce((sum, point) => sum + Number(point.inc_author_count || 0), 0),
+        videoAdds: chart.reduce((sum, point) => sum + Number(point.inc_aweme_count || 0), 0),
+        stock: Number(product.stock_count || 0),
+        rating: Number(product.product_rating || 0),
+        reviewCount: Number(product.review_count || 0),
+        totalCreatorCount: Number(product.author_count || 0),
+        totalVideoCount: Number(product.aweme_count || 0),
+        totalLiveCount: Number(product.live_count || 0),
+        viralIndex: Number(product.viral_index || 0),
+        popularityIndex: Number(product.popularity_index || 0),
+        countryRank: Number(product.country_rank || 0),
+        categoryRank: Number(product.category_rank || 0),
+        launchTime: Number(product.launch_time || 0),
+        commission: percentValue(product.commission_rate),
+    };
+}
 export function detailTrendRows(record, payload, days = DETAIL_TREND_DAYS) {
     const envelope = payload && typeof payload === "object" ? payload : {};
     const data = envelope.data && typeof envelope.data === "object" ? envelope.data : {};
     const points = Array.isArray(data.chart_list) ? data.chart_list : [];
+    const evidence = detailOverviewEvidence(payload);
     return points.slice(-days).flatMap((point) => {
         const date = String(point.dt || "").slice(0, 10);
         if (!/^\d{4}-\d{2}-\d{2}$/.test(date))
             return [];
         return [{
+                ...evidence,
                 ...record,
                 date,
                 source: "fastmoss-agent-detail-trend",
@@ -469,18 +900,32 @@ async function fetchDetailTrend(page, record, days) {
     const productId = String(record.product_id || productIdFromUrl(String(record.product_url || "")));
     if (!/^\d+$/.test(productId))
         return [];
-    const payload = await page.evaluate(async ({ productId, days }) => {
-        const url = new URL("/api/goods/v3/overview", location.origin);
-        url.searchParams.set("product_id", productId);
-        url.searchParams.set("d_type", String(days));
-        url.searchParams.set("_time", String(Math.floor(Date.now() / 1000)));
-        url.searchParams.set("cnonce", String(Math.floor(10_000_000 + Math.random() * 90_000_000)));
-        const response = await fetch(url, { credentials: "include" });
-        if (!response.ok)
-            return null;
-        return response.json().catch(() => null);
-    }, { productId, days }).catch(() => null);
-    return detailTrendRows({ ...record, product_id: productId, platform_product_id: productId }, payload, days);
+    const rawUrl = String(record.product_url || "");
+    const detailUrl = /fastmoss\.com\/.*e-commerce\/detail\//i.test(rawUrl)
+        ? rawUrl
+        : new URL(`/zh/e-commerce/detail/${productId}`, FASTMOSS_HOME).toString();
+    const detailPage = await page.context().newPage();
+    try {
+        // Capture only responses emitted by the visible product-detail page.
+        // The Agent does not manufacture requests to private endpoints.
+        const overviewResponse = detailPage.waitForResponse((response) => {
+            const url = response.url();
+            return response.ok() && url.includes("/api/goods/v3/overview") && url.includes(productId);
+        }, { timeout: PRODUCT_TABLE_TIMEOUT_MS }).then((response) => response.json()).catch(() => null);
+        const baseResponse = detailPage.waitForResponse((response) => {
+            const url = response.url();
+            return response.ok() && url.includes("/api/goods/v3/base") && url.includes(productId);
+        }, { timeout: PRODUCT_TABLE_TIMEOUT_MS }).then((response) => response.json()).catch(() => null);
+        await detailPage.goto(detailUrl, { waitUntil: "domcontentloaded", timeout: 60_000 });
+        const [overview, base] = await Promise.all([overviewResponse, baseResponse]);
+        if (!overview)
+            return [];
+        const evidence = detailOverviewEvidence(overview, base);
+        return detailTrendRows({ ...record, ...evidence, product_id: productId, platform_product_id: productId }, overview, days);
+    }
+    finally {
+        await detailPage.close().catch(() => undefined);
+    }
 }
 function normalizeExtractedMarket(value) {
     const key = String(value || "").trim().toLowerCase();

package/dist/server/http.js

@@ -137,6 +137,7 @@ export function startHttpServer() {
     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/video-learning/capture", route(async (req, res) => res.json({ ok: true, ...await fastmoss.captureLearningVideos(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);

package/package.json

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