@xiaohhhh1/canvas-agent 0.4.34 → 0.4.36

package/dist/integrations/fastmoss.d.ts

@@ -125,7 +125,7 @@ export declare class FastMossIntegration {
      * deliberately separate from ranking collection: the learning pipeline
      * must see the actual moving picture, never a FastMoss cover or HTML page.
      */
-    capturePublicVideoFrames(sourceUrl: string): Promise<{
+    capturePublicVideoFrames(sourceUrl: string, expectedVideoId?: string): Promise<{
         videoId: string;
         playerUrl: string;
         durationMs: number;

package/dist/integrations/fastmoss.js

@@ -393,10 +393,19 @@ export class FastMossIntegration {
      * deliberately separate from ranking collection: the learning pipeline
      * must see the actual moving picture, never a FastMoss cover or HTML page.
      */
-    async capturePublicVideoFrames(sourceUrl) {
-        const videoId = videoIdFromValues([sourceUrl]);
+    async capturePublicVideoFrames(sourceUrl, expectedVideoId) {
+        const videoId = String(expectedVideoId || videoIdFromValues([sourceUrl])).trim();
         if (!videoId)
             throw new Error("公开视频地址缺少可验证的 TikTok video ID");
+        let parsedUrl;
+        try {
+            parsedUrl = new URL(sourceUrl);
+        }
+        catch {
+            throw new Error("视频画面地址无效");
+        }
+        if (parsedUrl.protocol !== "https:")
+            throw new Error("视频画面地址必须使用 HTTPS");
         if (!this.context)
             await this.start();
         if (!this.context)

package/dist/server/http.js

@@ -140,6 +140,7 @@ export function startHttpServer() {
     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/video-intelligence/archive", route(async (req, res) => res.json({ ok: true, ...await videoIntelligence.archive(req.body?.source || {}, req.body?.upload || {}) })));
     app.post("/agent/video-intelligence/analyze", route(async (req, res) => res.json({ ok: true, ...await videoIntelligence.analyze(req.body?.source || 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) => {

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

@@ -16,10 +16,31 @@ export type LocalVideoLearningSource = {
     productTitle?: string;
     product_title?: string;
     metrics?: Record<string, unknown>;
+    archiveStatus?: string;
+    archive_status?: string;
+    archivedVideoUrl?: string;
+    archived_video_url?: string;
+    archivedTranscript?: string;
+    archived_transcript?: string;
+};
+type VideoArchiveUpload = {
+    uploadUrl: string;
+    publicUrl: string;
+    headers?: Record<string, string>;
+    maxBytes?: number;
 };
 export declare class LocalVideoIntelligence {
     private readonly fastmoss;
     constructor(fastmoss: FastMossIntegration);
+    archive(source: LocalVideoLearningSource, upload: VideoArchiveUpload): Promise<{
+        archive: {
+            publicUrl: string;
+            sha256: string;
+            bytes: number;
+            contentType: string;
+            transcript: string;
+        };
+    }>;
     analyze(source: LocalVideoLearningSource): Promise<{
         analysis: Record<string, unknown>;
         evidence: {
@@ -34,3 +55,5 @@ export declare class LocalVideoIntelligence {
 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;
+export declare function resolveLocalCodexEntrypoint(): string;
+export {};

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

@@ -1,8 +1,9 @@
 import { spawn } from "node:child_process";
-import { mkdtemp, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { mkdtemp, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
 import os from "node:os";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
 const ANALYSIS_TIMEOUT_MS = 10 * 60_000;
 const TRANSCRIPT_LANGUAGES = "en.*,es.*,zh.*,pt.*,fr.*,de.*,vi.*,th.*,id.*,ms.*,ja.*,ko.*";
 export class LocalVideoIntelligence {
@@ -10,16 +11,48 @@ export class LocalVideoIntelligence {
     constructor(fastmoss) {
         this.fastmoss = fastmoss;
     }
-    async analyze(source) {
-        const sourceUrl = String(source.sourceUrl || source.source_url || "").trim();
-        if (!/^https:\/\/(?:www\.)?tiktok\.com\/@[^/]+\/video\/\d+(?:[/?#]|$)/i.test(sourceUrl)) {
-            throw new Error("本机视频理解只接受已验证的 TikTok 公开作品地址");
+    async archive(source, upload) {
+        const sourceUrl = verifiedTikTokSourceUrl(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 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}）`);
+            return {
+                archive: {
+                    publicUrl,
+                    sha256: createHash("sha256").update(bytes).digest("hex"),
+                    bytes: bytes.length,
+                    contentType: "video/mp4",
+                    transcript: downloaded.transcript,
+                },
+            };
         }
+        finally {
+            await rm(workDir, { recursive: true, force: true }).catch(() => undefined);
+        }
+    }
+    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 mediaUrl = archivedVideoUrl ? verifiedHttpsUrl(archivedVideoUrl, "站内视频副本地址无效") : sourceUrl;
+        const platformVideoId = String(source.platformVideoId || source.platform_video_id || "").trim();
         const workDir = await mkdtemp(path.join(os.tmpdir(), "canvas-video-intelligence-"));
         try {
             const [visualEvidence, transcript] = await Promise.all([
-                this.fastmoss.capturePublicVideoFrames(sourceUrl),
-                extractTimedTranscript(sourceUrl, workDir),
+                this.fastmoss.capturePublicVideoFrames(mediaUrl, platformVideoId),
+                archivedTranscript ? Promise.resolve(archivedTranscript) : extractTimedTranscript(sourceUrl, workDir),
             ]);
             if (!visualEvidence.frames.length)
                 throw new Error("没有取得任何真实视频画面，已停止分析");
@@ -35,8 +68,8 @@ export class LocalVideoIntelligence {
                     durationMs: visualEvidence.durationMs,
                     frameCount: attachments.length,
                     transcriptCueCount: transcript.split("\n").filter(Boolean).length,
-                    visualSource: visualEvidence.playerUrl,
-                    transcriptSource: "TikTok native/automatic timed captions via local yt-dlp",
+                    visualSource: archivedVideoUrl ? "website-archive" : visualEvidence.playerUrl,
+                    transcriptSource: archivedTranscript ? "website-archive" : "TikTok native/automatic timed captions via local yt-dlp",
                 },
             };
         }
@@ -45,6 +78,24 @@ export class LocalVideoIntelligence {
         }
     }
 }
+function verifiedTikTokSourceUrl(source) {
+    const sourceUrl = String(source.sourceUrl || source.source_url || "").trim();
+    if (!/^https:\/\/(?:www\.)?tiktok\.com\/@[^/]+\/video\/\d+(?:[/?#]|$)/i.test(sourceUrl)) {
+        throw new Error("本机视频处理只接受已验证的 TikTok 公开作品地址");
+    }
+    return sourceUrl;
+}
+function verifiedHttpsUrl(value, message) {
+    try {
+        const url = new URL(value);
+        if (url.protocol !== "https:" || url.username || url.password)
+            throw new Error(message);
+        return url.toString();
+    }
+    catch {
+        throw new Error(message);
+    }
+}
 export function localVideoAnalysisPrompt(source, durationMs, transcript, attachments) {
     const frameTimeline = attachments.map((item) => `${item.name}: ${item.id}ms`).join("\n");
     return `你是 TikTok 电商短视频的多模态取证分析器。你必须同时理解画面、屏幕文字和人物口播，并把它们对齐到同一时间轴。\n\n` +
@@ -150,6 +201,48 @@ async function extractTimedTranscript(sourceUrl, workDir) {
             break;
         lastError = result.error;
     }
+    return transcriptFromDirectory(workDir, lastError);
+}
+async function downloadVideoArchive(sourceUrl, workDir, maxBytes) {
+    const output = path.join(workDir, "%(id)s.%(ext)s");
+    const args = [
+        "--no-playlist", "--no-warnings",
+        "--format", "bv*+ba/b", "--merge-output-format", "mp4", "--remux-video", "mp4",
+        "--write-subs", "--write-auto-subs", "--sub-langs", TRANSCRIPT_LANGUAGES, "--sub-format", "vtt",
+        "--max-filesize", String(maxBytes), "--output", output, sourceUrl,
+    ];
+    const attempts = process.platform === "win32"
+        ? [["yt-dlp.exe", args], ["py.exe", ["-m", "yt_dlp", ...args]]]
+        : [["yt-dlp", args], ["python3", ["-m", "yt_dlp", ...args]]];
+    let lastError = "";
+    let completed = false;
+    for (const [command, commandArgs] of attempts) {
+        const result = await runProcess(command, commandArgs, { cwd: workDir, timeoutMs: 5 * 60_000, allowMissing: true });
+        if (result.ok) {
+            completed = true;
+            break;
+        }
+        lastError = result.error;
+    }
+    if (!completed)
+        throw new Error(`视频下载失败${lastError ? `：${lastError}` : ""}`);
+    const names = await readdir(workDir);
+    const candidates = [];
+    for (const name of names.filter((value) => value.toLowerCase().endsWith(".mp4"))) {
+        const file = path.join(workDir, name);
+        const info = await stat(file);
+        if (info.isFile())
+            candidates.push({ file, size: info.size });
+    }
+    candidates.sort((left, right) => right.size - left.size);
+    const video = candidates[0];
+    if (!video?.size)
+        throw new Error("视频下载完成但没有生成 MP4 文件");
+    if (video.size > maxBytes)
+        throw new Error(`视频超过站内存储上限（${Math.ceil(maxBytes / 1024 / 1024)} MiB）`);
+    return { file: video.file, transcript: await transcriptFromDirectory(workDir, lastError) };
+}
+async function transcriptFromDirectory(workDir, lastError = "") {
     const subtitleFiles = (await readdir(workDir)).filter((name) => name.toLowerCase().endsWith(".vtt"));
     if (!subtitleFiles.length)
         throw new Error(`未取得视频口播字幕${lastError ? `：${lastError}` : ""}`);
@@ -173,7 +266,10 @@ function transcriptPreference(file) {
 }
 async function runLocalCodexAnalysis(prompt, attachments, workDir) {
     const outputFile = path.join(workDir, "analysis.json");
-    const codexEntrypoint = fileURLToPath(new URL("../../node_modules/@openai/codex/bin/codex.js", import.meta.url));
+    // npm hoists dependencies next to the installed package in production, while
+    // local development may keep them at a different ancestor. Resolve from this
+    // module instead of assuming a nested node_modules directory.
+    const codexEntrypoint = resolveLocalCodexEntrypoint();
     const args = [codexEntrypoint, "exec", "--ephemeral", "--skip-git-repo-check", "--sandbox", "read-only", "--color", "never", "--output-last-message", outputFile];
     for (const attachment of attachments)
         args.push("--image", path.join(workDir, String(attachment.name)));
@@ -189,6 +285,9 @@ async function runLocalCodexAnalysis(prompt, attachments, workDir) {
         throw new Error("本机 Codex 没有返回可校验的 JSON 视频分析结果");
     }
 }
+export function resolveLocalCodexEntrypoint() {
+    return createRequire(import.meta.url).resolve("@openai/codex/bin/codex.js");
+}
 async function runProcess(command, args, options) {
     return await new Promise((resolve) => {
         let stderr = "";

package/package.json

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