@xiaohhhh1/canvas-agent 0.4.81 → 0.4.82

package/dist/relay-bridge.js

@@ -1,4 +1,5 @@
 import WebSocket from "ws";
+import { relayLocalRequest } from "./relay-request.js";
 const DEFAULT_RELAY_URL = "wss://canvas.xiaohhhh1.com/api/agent-relay";
 const RECONNECT_DELAY_MS = 3_000;
 const HEARTBEAT_INTERVAL_MS = 15_000;
@@ -78,18 +79,20 @@ export function startRelayBridge(config, options = {}) {
             const headers = new Headers(message.headers || {});
             headers.set("x-canvas-agent-token", config.token);
             const body = message.bodyBase64 ? Buffer.from(message.bodyBase64, "base64") : undefined;
-            const response = await fetch(target, { method: message.method || "GET", headers, body });
-            const bytes = Buffer.from(await response.arrayBuffer());
+            const response = await relayLocalRequest(target, message.method || "GET", headers, body);
             send({
                 type: "response",
                 id: message.id,
                 status: response.status,
-                contentType: response.headers.get("content-type") || "application/octet-stream",
-                bodyBase64: bytes.toString("base64"),
+                contentType: response.contentType,
+                bodyBase64: response.bytes.toString("base64"),
             });
         }
         catch (error) {
-            send({ type: "response", id: message.id, status: 502, contentType: "application/json", bodyBase64: Buffer.from(JSON.stringify({ ok: false, error: error instanceof Error ? error.message : "Agent relay request failed" })).toString("base64") });
+            const detail = error instanceof Error && error.message.startsWith("本机处理等待超时")
+                ? error.message
+                : "本机 Agent 请求连接中断；原视频仍保留，请恢复连接后重试。";
+            send({ type: "response", id: message.id, status: 502, contentType: "application/json", bodyBase64: Buffer.from(JSON.stringify({ ok: false, error: detail })).toString("base64") });
         }
     };
     const onMessage = (raw) => {

package/dist/relay-request.d.ts

@@ -0,0 +1,6 @@
+export declare function relayRequestTimeoutMs(pathname: string): number;
+export declare function relayLocalRequest(target: URL, method: string, headers: Headers, body?: Buffer, timeoutMs?: number): Promise<{
+    status: number;
+    contentType: string;
+    bytes: Buffer;
+}>;

package/dist/relay-request.js

@@ -0,0 +1,33 @@
+import http from "node:http";
+import https from "node:https";
+export function relayRequestTimeoutMs(pathname) {
+    if (["/agent/integrations/fastmoss/capture", "/agent/integrations/fastmoss/video-learning/capture"].includes(pathname))
+        return 25 * 60_000;
+    if (["/agent/video-intelligence/analyze", "/agent/video-intelligence/archive"].includes(pathname))
+        return 12 * 60_000;
+    return 20_000;
+}
+// Native fetch has a separate five-minute response-header deadline. A longer
+// AbortSignal does not extend it: use Node's HTTP client with one explicit deadline.
+export async function relayLocalRequest(target, method, headers, body, timeoutMs = relayRequestTimeoutMs(target.pathname)) {
+    return await new Promise((resolve, reject) => {
+        const request = (target.protocol === "https:" ? https : http).request(target, {
+            method, headers: Object.fromEntries(headers.entries()),
+        }, (response) => {
+            const chunks = [];
+            response.on("data", (chunk) => chunks.push(chunk));
+            response.on("error", reject);
+            response.on("end", () => resolve({
+                status: response.statusCode || 502,
+                contentType: String(response.headers["content-type"] || "application/octet-stream"),
+                bytes: Buffer.concat(chunks),
+            }));
+            response.on("close", () => clearTimeout(timer));
+        });
+        const timer = setTimeout(() => request.destroy(new Error("本机处理等待超时；任务可能仍在运行，请先查看状态，勿重复提交。")), timeoutMs);
+        timer.unref();
+        request.on("error", reject);
+        request.on("close", () => clearTimeout(timer));
+        request.end(body);
+    });
+}

package/dist/server/http.js

@@ -5,9 +5,10 @@ import express from "express";
 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 { CONFIG_DIR, DEFAULT_PORT, ensureSiteWorkspace, loadConfig, saveConfig, updateSiteWorkspace, VERSION } from "../config.js";
 import { FastMossIntegration } from "../integrations/fastmoss.js";
 import { LocalVideoIntelligence } from "../video-intelligence/local-analysis.js";
+import { VideoAnalysisJobs } from "../video-intelligence/jobs.js";
 import { startRelayBridge } from "../relay-bridge.js";
 import { logger } from "../utils/logger.js";
 import { windowsRootExecutable, windowsSystemExecutable } from "../utils/windows.js";
@@ -35,6 +36,7 @@ export function startHttpServer() {
     const workflows = new WorkflowManager(config, emit);
     const fastmoss = new FastMossIntegration();
     const videoIntelligence = new LocalVideoIntelligence(fastmoss);
+    const videoAnalysisJobs = new VideoAnalysisJobs(path.join(CONFIG_DIR, "video-analysis-jobs"), (source, onStage) => videoIntelligence.analyze(source, { onStage, timeoutMs: 30 * 60_000 }));
     let relayStatus = { ready: false };
     const app = express();
     app.disable("x-powered-by");
@@ -59,7 +61,7 @@ export function startHttpServer() {
             return void res.json({});
         next();
     });
-    app.get("/health", (_req, res) => res.json({ ...session.health(), version: VERSION, workflow: workflows.health(), relayReady: relayStatus.ready, relayLastReadyAt: relayStatus.lastReadyAt, relayLastDisconnectAt: relayStatus.lastDisconnectAt }));
+    app.get("/health", (_req, res) => res.json({ ...session.health(), version: VERSION, workflow: workflows.health(), videoAnalysisJobs: { version: 1, active: videoAnalysisJobs.activeCount }, relayReady: relayStatus.ready, relayLastReadyAt: relayStatus.lastReadyAt, relayLastDisconnectAt: relayStatus.lastDisconnectAt }));
     app.get("/config", (_req, res) => res.json({ ok: true, url: config.url, hasToken: true }));
     app.use((req, res, next) => {
         if (validToken(req, requestUrl(req, config), config.token))
@@ -145,6 +147,13 @@ export function startHttpServer() {
     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/video-intelligence/jobs", route(async (req, res) => res.json({ ok: true, job: await videoAnalysisJobs.start(req.body?.source || {}, String(req.body?.requestId || "")) })));
+    app.get("/agent/video-intelligence/jobs/:id", route(async (req, res) => {
+        const job = await videoAnalysisJobs.get(routeParam(req.params.id));
+        if (!job)
+            return res.status(404).json({ ok: false, error: "本机视频分析任务不存在" });
+        return res.json({ ok: true, job });
+    }));
     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/dist/video-intelligence/jobs.d.ts

@@ -0,0 +1,32 @@
+import { type LocalVideoLearningSource } from "./local-analysis.js";
+type Result = {
+    analysis: Record<string, unknown>;
+    evidence: Record<string, unknown>;
+};
+type Job = {
+    id: string;
+    attemptId: string;
+    requestId: string;
+    status: "running" | "completed" | "failed";
+    stage: string;
+    updatedAt: string;
+    result?: Result;
+    error?: string;
+};
+type Analyze = (source: LocalVideoLearningSource, stage: (value: string) => Promise<void>) => Promise<Result>;
+export declare class VideoAnalysisJobs {
+    private directory;
+    private analyze;
+    private active;
+    private locks;
+    constructor(directory: string, analyze: Analyze);
+    get activeCount(): number;
+    start(source: LocalVideoLearningSource & {
+        archived_sha256?: string;
+        archivedSha256?: string;
+    }, requestId: string): Promise<Job>;
+    get(id: string): Promise<Job | null>;
+    private run;
+    private save;
+}
+export {};

package/dist/video-intelligence/jobs.js

@@ -0,0 +1,89 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { localVideoAnalysisPrompt } from "./local-analysis.js";
+export class VideoAnalysisJobs {
+    directory;
+    analyze;
+    active = new Map();
+    locks = new Map();
+    constructor(directory, analyze) {
+        this.directory = directory;
+        this.analyze = analyze;
+    }
+    get activeCount() { return this.active.size; }
+    async start(source, requestId) {
+        if (!requestId || requestId.length > 100)
+            throw new Error("视频分析请求标识无效");
+        const identity = source.archived_sha256 || source.archivedSha256 || source.sourceUrl || source.source_url;
+        if (!source.id || !identity)
+            throw new Error("视频分析缺少稳定原片身份，请刷新后重试");
+        const id = createHash("sha256").update(JSON.stringify([source.id, identity, localVideoAnalysisPrompt(source, 0, "", [])])).digest("hex");
+        // Serialize admission for the same source, including network replay.
+        const previous = this.locks.get(id) || Promise.resolve();
+        const admission = previous.catch(() => undefined).then(async () => {
+            const existing = await this.get(id);
+            if (existing && (existing.status === "completed" || this.active.has(id) || existing.requestId === requestId))
+                return existing;
+            const job = { id, attemptId: randomUUID(), requestId, status: "running", stage: "读取原片与抽帧", updatedAt: new Date().toISOString() };
+            await this.save(job);
+            const task = this.run(job, source).catch(() => undefined).finally(() => this.active.delete(id));
+            this.active.set(id, task);
+            return { ...job };
+        });
+        this.locks.set(id, admission);
+        try {
+            return await admission;
+        }
+        finally {
+            if (this.locks.get(id) === admission)
+                this.locks.delete(id);
+        }
+    }
+    async get(id) {
+        if (!/^[a-f0-9]{64}$/.test(id))
+            throw new Error("视频分析任务标识无效");
+        let job;
+        try {
+            job = JSON.parse(await readFile(path.join(this.directory, id + ".json"), "utf8"));
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return null;
+            throw error;
+        }
+        if (job.status === "running" && !this.active.has(id)) {
+            job = { ...job, status: "failed", error: "本机程序曾中断，原视频保留；点击重试可重新分析。", stage: "等待手动重试" };
+            await this.save(job);
+        }
+        return job;
+    }
+    async run(job, source) {
+        try {
+            const result = await this.analyze(source, async (stage) => {
+                job.stage = stage;
+                await this.save(job);
+            });
+            // Persist before the browser can import the result. A lost response
+            // or refreshed page reads the same output without another model call.
+            job.result = result;
+            job.status = "completed";
+            job.stage = "分析已保存，等待网页回传";
+        }
+        catch (error) {
+            job.status = "failed";
+            const detail = error instanceof Error ? error.message : "本机视频分析失败";
+            job.error = detail === "fetch failed" ? `${job.stage}时网络连接失败；原片保留，请恢复网络后重试。` : detail;
+            job.stage = "分析失败，可手动重试";
+        }
+        await this.save(job);
+    }
+    async save(job) {
+        job.updatedAt = new Date().toISOString();
+        await mkdir(this.directory, { recursive: true });
+        const file = path.join(this.directory, job.id + ".json");
+        const temporary = file + "." + randomUUID() + ".tmp";
+        await writeFile(temporary, JSON.stringify(job), { mode: 0o600 });
+        await rename(temporary, file);
+    }
+}

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

@@ -53,7 +53,10 @@ export declare class LocalVideoIntelligence {
             durationMs: number;
         };
     }>;
-    analyze(source: LocalVideoLearningSource): Promise<{
+    analyze(source: LocalVideoLearningSource, options?: {
+        onStage?: (stage: string) => Promise<void>;
+        timeoutMs?: number;
+    }): Promise<{
         analysis: Record<string, unknown>;
         evidence: {
             durationMs: number;

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

@@ -60,7 +60,7 @@ export class LocalVideoIntelligence {
             await rm(workDir, { recursive: true, force: true }).catch(() => undefined);
         }
     }
-    async analyze(source) {
+    async analyze(source, options) {
         const archivedVideoUrl = String(source.archivedVideoUrl || source.archived_video_url || "").trim();
         const archivedTranscript = String(source.archivedTranscript || source.archived_transcript || "").trim();
         const hasArchivedMedia = Boolean(archivedVideoUrl);
@@ -74,6 +74,7 @@ export class LocalVideoIntelligence {
             let transcript = archivedTranscript;
             let transcriptSource = archivedTranscript ? "website-archive-caption" : "";
             if (!transcript && hasArchivedMedia) {
+                await options?.onStage?.("识别原片口播");
                 transcript = await transcribeLocalMedia("videoFile" in visualEvidence && typeof visualEvidence.videoFile === "string" ? visualEvidence.videoFile : undefined, workDir);
                 transcriptSource = transcript ? `local-asr:${LOCAL_ASR_MODEL}` : "local-asr:no-speech-detected";
             }
@@ -85,7 +86,8 @@ export class LocalVideoIntelligence {
                 throw new Error("没有取得任何真实视频画面，已停止分析");
             const attachments = await materializeFrames(visualEvidence.frames, workDir);
             const prompt = localVideoAnalysisPrompt(source, visualEvidence.durationMs, transcript, attachments);
-            const analysis = await runLocalCodexAnalysis(prompt, attachments, workDir);
+            await options?.onStage?.("Codex 正在对齐画面与口播，生成详细蓝图");
+            const analysis = await runLocalCodexAnalysis(prompt, attachments, workDir, options?.timeoutMs);
             assertJointVisualAndSpokenEvidence(analysis);
             return {
                 analysis,
@@ -485,7 +487,7 @@ function transcriptPreference(file) {
         return 3;
     return 1;
 }
-async function runLocalCodexAnalysis(prompt, attachments, workDir) {
+async function runLocalCodexAnalysis(prompt, attachments, workDir, timeoutMs = ANALYSIS_TIMEOUT_MS) {
     const outputFile = path.join(workDir, "analysis.json");
     // npm hoists dependencies next to the installed package in production, while
     // local development may keep them at a different ancestor. Resolve from this
@@ -495,7 +497,7 @@ async function runLocalCodexAnalysis(prompt, attachments, workDir) {
     for (const attachment of attachments)
         args.push("--image", path.join(workDir, String(attachment.name)));
     args.push("-");
-    const result = await runProcess(process.execPath, args, { cwd: workDir, timeoutMs: ANALYSIS_TIMEOUT_MS, stdin: prompt });
+    const result = await runProcess(process.execPath, args, { cwd: workDir, timeoutMs, stdin: prompt });
     if (!result.ok)
         throw new Error(localCodexAnalysisError(result));
     const raw = (await readFile(outputFile, "utf8")).trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/i, "");

package/package.json

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