infinite-canvas-local-proxy 0.2.2 → 0.2.3

package/README.md

@@ -56,7 +56,7 @@ http://127.0.0.1:23210/https://api.openai.com/v1/models
 - 默认数据目录为用户主目录下的 `.canvas-proxy`（Windows 为 `%USERPROFILE%\.canvas-proxy`），包括 `tasks.sqlite`、SQLite 日志文件和 `results/` 响应文件。备份时需停止代理后复制整个目录。
 - API Key、请求头和请求体仅在代理内存中用于上游请求；任务请求体、脚本上下文及 API Key 不写入数据库或任务日志。若上游响应或脚本错误中发现已识别的凭证原文，该结果不会保存或会在错误中脱敏。
 - 图片/视频脚本请求支持 JSON、文本、URL 编码和 multipart/form-data；multipart 文件在本地任务创建请求中临时 Base64 编码，代理端重建为 multipart 后发送。请求体总大小上限 80 MiB；独立二进制请求体不支持。
-- 任务数量、并发数和单个生成脚本的请求次数均不设上限；任务提交后会立即启动。生成任务仍受单任务 30 分钟等待时限、单次上游请求 10 分钟超时、80 MiB 请求体和 100 MiB 响应大小限制。成功/失败记录保留 24 小时。
+- 任务数量、并发数和单个生成脚本的请求次数均不设上限；任务提交后会立即启动。生成任务仍受单任务 60 分钟等待时限、单次上游请求 30 分钟超时、80 MiB 请求体和 100 MiB 响应大小限制。成功/失败记录保留 24 小时。
 - 可通过环境变量 `CANVAS_PROXY_DATA_DIR`、`CANVAS_PROXY_TASK_REQUEST_LIMIT_BYTES`、`CANVAS_PROXY_TASK_RESPONSE_LIMIT_BYTES`、`CANVAS_PROXY_TASK_TIMEOUT_MS` 和 `CANVAS_PROXY_TASK_RETENTION_MS` 调整目录与限制。
 - 代理进程重启时，原来排队或运行中的任务标记为“结果未知”，不会自动再次提交上游请求，以避免重复计费。已完成结果仍可从数据库记录和响应文件恢复，直至过期。
 - 代理只报告 queued/running/polling/完成/失败等本地状态，不提供或伪造供应商生成百分比。代理必须保持运行，才能在浏览器关闭后继续执行代理持有的请求或自定义脚本轮询。

package/index.js

@@ -24,7 +24,8 @@ const CORS_HEADERS = {
 const SKIP_REQUEST_HEADERS = new Set(["host", "connection", "content-length", "accept-encoding", "origin", "referer", "sec-fetch-dest", "sec-fetch-mode", "sec-fetch-site"]);
 /** fetch() already decoded and re-framed the body, so the upstream framing headers no longer apply. */
 const SKIP_RESPONSE_HEADERS = new Set(["content-encoding", "content-length", "transfer-encoding", "connection", "keep-alive"]);
-const TASK_TIMEOUT_MS = 30 * 60 * 1000;
+/** 异步生成任务的总生命周期：长视频、多轮素材处理都要能跑完，与 script-runner 的脚本超时对齐。 */
+const TASK_TIMEOUT_MS = 60 * 60 * 1000;
 const TASK_RETENTION_MS = 24 * 60 * 60 * 1000;
 const TASK_REQUEST_LIMIT = 80 * 1024 * 1024;
 const TASK_RESPONSE_LIMIT = 100 * 1024 * 1024;
@@ -318,7 +319,11 @@ export function createProxyServer(options = {}) {
         store.setStatus(taskId, "running", startedAt);
         const controller = new AbortController();
         const credentials = new Set(taskRequest.credentials);
-        const timeout = setTimeout(() => controller.abort(), taskTimeoutMs);
+        let timedOut = false;
+        const timeout = setTimeout(() => {
+            timedOut = true;
+            controller.abort();
+        }, taskTimeoutMs);
         try {
             const result = await runGenerationScriptTask(taskRequest.task, {
                 signal: controller.signal,
@@ -343,7 +348,17 @@ export function createProxyServer(options = {}) {
             store.setSucceeded(taskId, Date.now(), 200, "application/json; charset=utf-8", path.basename(responsePath));
             console.log(`${new Date().toLocaleTimeString()} task ${taskId.slice(0, 8)} -> completed ${((Date.now() - startedAt) / 1000).toFixed(1)}s`);
         } catch (error) {
-            const message = error && typeof error.message === "string" ? error.message : typeof error === "string" ? error : "Generation script failed.";
+            const rawMessage = String(
+                error && typeof error.message === "string" ? error.message : typeof error === "string" ? error : "Generation script failed.",
+            ).replace(/^Error:\s*/, "");
+            // 超时被 abort 时原始错误只是一句 Aborted，改成能看出是任务时长耗尽
+            const baseMessage = timedOut ? `Generation task exceeded the ${taskTimeoutMs >= 60000 ? `${Math.round(taskTimeoutMs / 60000)} minute` : `${Math.round(taskTimeoutMs / 1000)} second`} lifetime.` : rawMessage;
+            const upstream = error && typeof error === "object" ? error.upstream : null;
+            // 上游失败时把状态码与响应片段一并写进错误，否则只剩一句"脚本失败"，真因无从判断
+            const message =
+                upstream && !baseMessage.includes(`HTTP ${upstream.status}`)
+                    ? `${baseMessage.length > 300 ? `${baseMessage.slice(0, 300)}…` : baseMessage} | upstream ${upstream.status}${upstream.snippet ? `: ${upstream.snippet}` : ""}`
+                    : baseMessage;
             const safeMessage = [...credentials].filter(Boolean).reduce((text, credential) => text.replaceAll(credential, "[redacted]"), message).slice(0, 500);
             store.setStatus(taskId, controller.signal.aborted ? "failed" : "failed", Date.now(), safeMessage);
             console.log(`${new Date().toLocaleTimeString()} task ${taskId.slice(0, 8)} -> failed ${((Date.now() - startedAt) / 1000).toFixed(1)}s`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinite-canvas-local-proxy",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Minimal local forwarding proxy that lets the Infinite Canvas web app call AI provider APIs without CORS restrictions.",
   "license": "MIT",
   "type": "module",

package/script-runner.js

@@ -2,8 +2,10 @@ import { File } from "node:buffer";
 import { createHash } from "node:crypto";
 import vm from "node:vm";
 
-const SCRIPT_TIMEOUT_MS = 30 * 60 * 1000;
-const REQUEST_TIMEOUT_MS = 10 * 60 * 1000;
+/** 生成脚本的轮询生命周期上限：与 index.js 的任务总生命周期保持一致（60 分钟）。 */
+const SCRIPT_TIMEOUT_MS = 60 * 60 * 1000;
+/** 脚本内单次上游 HTTP 请求的超时：长任务里一次素材下载或视频渲染回调可能耗时较久。 */
+const REQUEST_TIMEOUT_MS = 30 * 60 * 1000;
 const mediaUploadCache = new Map();
 const MEDIA_UPLOAD_CACHE_LIMIT = 500;
 const abortPromises = new WeakMap();
@@ -242,7 +244,37 @@ async function responseData(response, responseType, limitBytes) {
     return text;
 }
 
-function createRequest({ signal, requestLimitBytes, responseLimitBytes, credentials, baseUrl }) {
+/**
+ * 记录最后一次上游失败响应的状态码与响应体片段，供任务失败时附加到错误信息里。
+ * 只读前 512 字节并立即取消，避免把整页错误 HTML 读进内存。
+ */
+function noteUpstreamFailure(trace, response, url) {
+    if (!trace || !response || response.ok) return;
+    const entry = { status: response.status, url: String(url || response.url || ""), snippet: "" };
+    trace.last = entry;
+    const reader = response.clone().body?.getReader();
+    if (!reader) return;
+    const decoder = new TextDecoder();
+    const chunks = [];
+    let bytes = 0;
+    (async () => {
+        try {
+            while (bytes < 512 && entry.snippet.length < 200) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                bytes += value.byteLength;
+                chunks.push(decoder.decode(value, { stream: true }));
+                entry.snippet = chunks.join("").replace(/\s+/g, " ").trim().slice(0, 200);
+            }
+        } catch {
+            // 片段抓取失败不影响任务本身
+        } finally {
+            reader.cancel().catch(() => {});
+        }
+    })();
+}
+
+function createRequest({ signal, requestLimitBytes, responseLimitBytes, credentials, baseUrl, upstreamTrace }) {
     const recordCredentials = (target, headers) => {
         for (const [name, value] of headers.entries()) {
             if (/authorization|api.?key/i.test(name)) credentials.add(value.replace(/^bearer\s+/i, ""));
@@ -295,6 +327,7 @@ function createRequest({ signal, requestLimitBytes, responseLimitBytes, credenti
             const data = await responseData(response, options.responseType, responseLimitBytes);
             if (!response.ok) {
                 const detail = typeof data === "string" ? data.slice(0, 300) : JSON.stringify(data).slice(0, 300);
+                if (upstreamTrace) upstreamTrace.last = { status: response.status, url: target.href, snippet: String(detail || "").slice(0, 200) };
                 throw new Error(`Upstream request failed (HTTP ${response.status})${detail ? `: ${detail}` : ""}`);
             }
             return {
@@ -326,6 +359,7 @@ function createRequest({ signal, requestLimitBytes, responseLimitBytes, credenti
             composed.dispose();
             throw error;
         }
+        noteUpstreamFailure(upstreamTrace, response, target);
         if (!response.body) {
             composed.dispose();
             return response;
@@ -486,13 +520,43 @@ async function cacheMediaUpload(file, namespace, upload) {
     }
 }
 
+function throwIfTaskFailed(result, kind) {
+    if (kind === "image" ? hasImageResult(result) : hasVideoResult(result)) return;
+    const status = isRecord(result) ? String(result.status || "").toLowerCase() : "";
+    if (["failed", "error", "cancelled", "canceled"].includes(status)) {
+        const detail = result.error;
+        const message =
+            typeof detail === "string"
+                ? detail
+                : detail && typeof detail === "object"
+                  ? String(detail.message || JSON.stringify(detail))
+                  : String(result.message || "Generation task failed.");
+        throw new Error(message.slice(0, 500));
+    }
+    if (status && !isPending(result) && !["completed", "succeeded", "success", "done"].includes(status)) {
+        throw new Error("Generation script returned an unsupported task status.");
+    }
+}
+
+function decorateUpstreamFailure(error, upstreamTrace) {
+    const last = upstreamTrace?.last;
+    if (!last) return error;
+    const target = error instanceof Error ? error : new Error(String(error));
+    if (target.upstream) return target;
+    Object.defineProperty(target, "upstream", { value: last, enumerable: true, writable: true });
+    return target;
+}
+
 export async function runGenerationScriptTask(task, options) {
     if (!isRecord(task) || typeof task.script !== "string" || task.script.length > 256 * 1024) throw new Error("Generation script is missing or too large.");
     if (task.kind !== "image" && task.kind !== "video") throw new Error("Generation task kind is unsupported.");
     if (!isRecord(task.context)) throw new Error("Generation script context is invalid.");
-    const timeoutMs = options.timeoutMs;
+    // 调用方未传或传入非法值时回落到默认生命周期；否则 deadline 会被压成 1ms，任务瞬间失败
+    const requestedTimeoutMs = Number(options.timeoutMs);
+    const timeoutMs = Number.isFinite(requestedTimeoutMs) && requestedTimeoutMs > 0 ? requestedTimeoutMs : SCRIPT_TIMEOUT_MS;
     const credentials = options.credentials instanceof Set ? options.credentials : new Set(options.credentials || []);
-    const { request, scriptFetch } = createRequest({ ...options, credentials, baseUrl: task.context.baseUrl });
+    const upstreamTrace = { last: null };
+    const { request, scriptFetch } = createRequest({ ...options, credentials, baseUrl: task.context.baseUrl, upstreamTrace });
     options.credentials = credentials;
     const images = Array.isArray(task.context.images) ? task.context.images : [];
     const videos = Array.isArray(task.context.videos) ? task.context.videos.map((item, index) => makeFile(item, `video-${index + 1}`)) : [];
@@ -511,29 +575,32 @@ export async function runGenerationScriptTask(task, options) {
         reasoningEffort: String(task.context.reasoningEffort || ""),
         ossPresignUrl: task.context.ossPresignUrl,
     };
-    let params = isRecord(task.context.params) ? { ...task.context.params, taskAction: "create" } : { taskAction: "create" };
-    let result = await runScript(task.script, { ...common, params }, request, scriptFetch, options.signal, timeoutMs);
-    let handle = taskHandle(result);
-    let polls = 0;
-    while (handle && polls < 1800) {
-        if (task.kind === "image" ? hasImageResult(result) : hasVideoResult(result)) break;
-        const status = isRecord(result) ? String(result.status || "").toLowerCase() : "";
-        if (["failed", "error", "cancelled", "canceled"].includes(status)) throw new Error(String(result.error?.message || result.error || result.message || "Generation task failed."));
-        if (status && !isPending(result) && !["completed", "succeeded", "success", "done"].includes(status)) throw new Error("Generation script returned an unsupported task status.");
-        options.onStatus?.("polling");
-        params = {
-            ...params,
-            taskAction: "poll",
-            taskId: handle.taskId,
-            ...(handle.taskData ? { taskData: handle.taskData } : {}),
-        };
-        await new Promise((resolve) => setTimeout(resolve, options.pollIntervalMs));
-        result = await runScript(task.script, { ...common, params }, request, scriptFetch, options.signal, timeoutMs);
-        handle = taskHandle(result) || handle;
-        polls += 1;
-    }
-    if (handle && polls >= 1800 && ! (task.kind === "image" ? hasImageResult(result) : hasVideoResult(result))) {
-        throw new Error("Generation script polling exceeded the task lifetime.");
+    const pollIntervalMs = Math.max(0, Number(options.pollIntervalMs) || 0);
+    // 护栏只表达时间：任务总时长由 timeoutMs 决定，不再用"第 N 次轮询"这种累计次数
+    const deadline = Date.now() + Math.max(1, Number(timeoutMs) || 0);
+    try {
+        let params = isRecord(task.context.params) ? { ...task.context.params, taskAction: "create" } : { taskAction: "create" };
+        let result = await runScript(task.script, { ...common, params }, request, scriptFetch, options.signal, timeoutMs);
+        throwIfTaskFailed(result, task.kind);
+        let handle = taskHandle(result);
+        while (handle) {
+            if (task.kind === "image" ? hasImageResult(result) : hasVideoResult(result)) break;
+            const remaining = deadline - Date.now();
+            if (remaining <= 0) throw new Error("Generation script polling exceeded the task lifetime.");
+            options.onStatus?.("polling");
+            params = {
+                ...params,
+                taskAction: "poll",
+                taskId: handle.taskId,
+                ...(handle.taskData ? { taskData: handle.taskData } : {}),
+            };
+            await new Promise((resolve) => setTimeout(resolve, Math.min(pollIntervalMs, remaining)));
+            result = await runScript(task.script, { ...common, params }, request, scriptFetch, options.signal, timeoutMs);
+            throwIfTaskFailed(result, task.kind);
+            handle = taskHandle(result) || handle;
+        }
+        return result;
+    } catch (error) {
+        throw decorateUpstreamFailure(error, upstreamTrace);
     }
-    return result;
 }