infinite-canvas-local-proxy 0.2.1 → 0.2.2

package/README.md

@@ -56,8 +56,8 @@ 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；独立二进制请求体不支持。
-- 默认最多同时执行 2 个任务、最多保留 4 个排队/运行任务；请求体上限 80 MiB、上游响应上限 100 MiB、单任务等待上限 30 分钟，成功/失败记录保留 24 小时。
-- 可通过环境变量 `CANVAS_PROXY_DATA_DIR`、`CANVAS_PROXY_TASK_CONCURRENCY`、`CANVAS_PROXY_TASK_OUTSTANDING_LIMIT`、`CANVAS_PROXY_TASK_REQUEST_LIMIT_BYTES`、`CANVAS_PROXY_TASK_RESPONSE_LIMIT_BYTES`、`CANVAS_PROXY_TASK_TIMEOUT_MS` 和 `CANVAS_PROXY_TASK_RETENTION_MS` 调整目录与限制。
+- 任务数量、并发数和单个生成脚本的请求次数均不设上限；任务提交后会立即启动。生成任务仍受单任务 30 分钟等待时限、单次上游请求 10 分钟超时、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/完成/失败等本地状态，不提供或伪造供应商生成百分比。代理必须保持运行，才能在浏览器关闭后继续执行代理持有的请求或自定义脚本轮询。
 
@@ -106,4 +106,3 @@ Node 22.5 及以上首次加载内置 SQLite 时会打印一行 `ExperimentalWar
 rmdir /s /q "%LocalAppData%\npm-cache\_npx"     # Windows
 npm cache clean --force
 ```
-

package/index.js

@@ -28,8 +28,6 @@ const TASK_TIMEOUT_MS = 30 * 60 * 1000;
 const TASK_RETENTION_MS = 24 * 60 * 60 * 1000;
 const TASK_REQUEST_LIMIT = 80 * 1024 * 1024;
 const TASK_RESPONSE_LIMIT = 100 * 1024 * 1024;
-const TASK_CONCURRENCY = 2;
-const TASK_OUTSTANDING_LIMIT = 4;
 
 function positiveInteger(value, fallback) {
     const parsed = Number(value);
@@ -236,20 +234,16 @@ export function createProxyServer(options = {}) {
     const taskRetentionMs = positiveInteger(options.taskRetentionMs ?? process.env.CANVAS_PROXY_TASK_RETENTION_MS, TASK_RETENTION_MS);
     const taskRequestLimit = positiveInteger(options.taskRequestLimit ?? process.env.CANVAS_PROXY_TASK_REQUEST_LIMIT_BYTES, TASK_REQUEST_LIMIT);
     const taskResponseLimit = positiveInteger(options.taskResponseLimit ?? process.env.CANVAS_PROXY_TASK_RESPONSE_LIMIT_BYTES, TASK_RESPONSE_LIMIT);
-    const taskConcurrency = positiveInteger(options.taskConcurrency ?? process.env.CANVAS_PROXY_TASK_CONCURRENCY, TASK_CONCURRENCY);
-    const taskOutstandingLimit = positiveInteger(options.taskOutstandingLimit ?? process.env.CANVAS_PROXY_TASK_OUTSTANDING_LIMIT, TASK_OUTSTANDING_LIMIT);
     const queuedRequests = new Map();
-    let runningTasks = 0;
 
     const sendTaskError = (res, status, error) => sendJson(res, status, { error });
 
     const startQueuedTasks = () => {
-        while (runningTasks < taskConcurrency) {
+        while (true) {
             const next = queuedRequests.entries().next();
             if (next.done) return;
             const [taskId, taskRequest] = next.value;
             queuedRequests.delete(taskId);
-            runningTasks += 1;
             const execute = taskRequest.runner === "script" ? executeScriptTask : taskRequest.runner === "video" ? executeVideoTask : executeTask;
             void execute(taskId, taskRequest)
                 .catch(() => {
@@ -260,10 +254,7 @@ export function createProxyServer(options = {}) {
                     }
                     console.error("Persistent task worker failed; it will not be retried automatically.");
                 })
-                .finally(() => {
-                    runningTasks -= 1;
-                    startQueuedTasks();
-                });
+                .finally(startQueuedTasks);
         }
     };
 
@@ -713,10 +704,6 @@ export function createProxyServer(options = {}) {
                         return;
                     }
                 }
-                if (runningTasks + queuedRequests.size >= taskOutstandingLimit) {
-                    sendTaskError(res, 429, "The local image task queue is full.");
-                    return;
-                }
                 const taskId = randomBytes(32).toString("base64url");
                 const createdAt = Date.now();
                 const created = store.createOrGet({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinite-canvas-local-proxy",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "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

@@ -4,9 +4,27 @@ import vm from "node:vm";
 
 const SCRIPT_TIMEOUT_MS = 30 * 60 * 1000;
 const REQUEST_TIMEOUT_MS = 10 * 60 * 1000;
-const MAX_SCRIPT_REQUESTS = 32;
 const mediaUploadCache = new Map();
 const MEDIA_UPLOAD_CACHE_LIMIT = 500;
+const abortPromises = new WeakMap();
+
+/** 每个任务信号只注册一次 abort 监听：轮询会反复执行脚本，逐次注册会累积成内存泄漏。 */
+function abortPromiseFor(signal) {
+    if (!signal) return new Promise(() => {});
+    const cached = abortPromises.get(signal);
+    if (cached) return cached;
+    const promise = new Promise((_, reject) => {
+        const fail = () => reject(new DOMException("Aborted", "AbortError"));
+        if (signal.aborted) {
+            fail();
+            return;
+        }
+        signal.addEventListener("abort", fail, { once: true });
+    });
+    promise.catch(() => {});
+    abortPromises.set(signal, promise);
+    return promise;
+}
 
 class ScriptFileReader {
     result = null;
@@ -75,6 +93,100 @@ function makeFile(value, fallbackName) {
     });
 }
 
+function sniffMime(bytes) {
+    const ascii = (start, end) => bytes.toString("ascii", start, end);
+    if (bytes.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))) return "image/png";
+    if (bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff) return "image/jpeg";
+    if (ascii(0, 4) === "RIFF" && ascii(8, 12) === "WEBP") return "image/webp";
+    if (ascii(0, 4) === "GIF8") return "image/gif";
+    if (ascii(0, 4) === "RIFF" && ascii(8, 12) === "WAVE") return "audio/wav";
+    if (ascii(0, 3) === "ID3" || (bytes[0] === 0xff && (bytes[1] & 0xe0) === 0xe0 && (bytes[1] & 0x06) !== 0)) return "audio/mpeg";
+    if (bytes.subarray(0, 4).equals(Buffer.from([0x1a, 0x45, 0xdf, 0xa3]))) return "video/webm";
+    if (ascii(0, 4) === "OggS") return "audio/ogg";
+    if (ascii(4, 8) === "ftyp") {
+        const brands = [ascii(8, 12), ...Array.from({ length: Math.floor(Math.max(0, bytes.length - 16) / 4) }, (_, index) => ascii(16 + index * 4, 20 + index * 4))];
+        if (brands.includes("qt  ")) return "video/quicktime";
+        if (brands.some((brand) => ["M4A ", "M4B ", "M4P "].includes(brand))) return "audio/mp4";
+        if (brands.some((brand) => ["avif", "avis"].includes(brand))) return "image/avif";
+        if (brands.some((brand) => ["heic", "heix", "hevc", "hevx"].includes(brand))) return "image/heic";
+        if (brands.some((brand) => ["mif1", "msf1"].includes(brand))) return "image/heif";
+        return "video/mp4";
+    }
+    return null;
+}
+
+export function createScriptOssUploader(endpoint, namespace, scriptFetch, signal) {
+    const mimeExtensions = {
+        "image/avif": "avif",
+        "image/gif": "gif",
+        "image/heic": "heic",
+        "image/heif": "heif",
+        "image/jpeg": "jpg",
+        "image/png": "png",
+        "image/webp": "webp",
+        "video/mp4": "mp4",
+        "video/quicktime": "mov",
+        "video/webm": "webm",
+        "audio/mp4": "m4a",
+        "audio/mpeg": "mp3",
+        "audio/ogg": "ogg",
+        "audio/wav": "wav",
+        "audio/x-wav": "wav",
+    };
+    return async (file) => {
+        if (!(file instanceof Blob)) throw new Error("uploadToOss requires a Blob or File.");
+        if (typeof endpoint !== "string" || !endpoint.trim()) throw new Error("The application OSS presign endpoint was not provided to the local proxy.");
+        let presignEndpoint;
+        try {
+            presignEndpoint = new URL(endpoint);
+        } catch {
+            throw new Error("The application OSS presign endpoint must be an absolute URL.");
+        }
+        if (!["http:", "https:"].includes(presignEndpoint.protocol)) throw new Error("The application OSS presign endpoint must use HTTP or HTTPS.");
+        return cacheMediaUpload(file, `${namespace}:oss-mime-v2`, async () => {
+            const declaredType = file.type.split(";", 1)[0].trim().toLowerCase();
+            const contentType = declaredType && declaredType !== "application/octet-stream" ? declaredType : sniffMime(Buffer.from(await file.slice(0, 32).arrayBuffer()));
+            if (!contentType) throw new Error("Could not identify the reference media type from its content.");
+            const extension = mimeExtensions[contentType];
+            if (!extension) throw new Error(`OSS upload does not support MIME type "${contentType}".`);
+            const originalName = typeof file.name === "string" ? file.name : "reference";
+            const basename = originalName.split(/[\\/]/).at(-1)?.replace(/\.[^.]*$/, "") || "reference";
+            const presignResponse = await scriptFetch(endpoint, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ filename: `${basename}.${extension}`, contentType }),
+                signal,
+            });
+            const presignText = await presignResponse.text();
+            let presign;
+            try {
+                presign = presignText ? JSON.parse(presignText) : {};
+            } catch {
+                throw new Error(`OSS presign returned non-JSON (HTTP ${presignResponse.status}).`);
+            }
+            if (!presignResponse.ok) {
+                const detail = typeof presign.error === "string" ? presign.error : typeof presign.message === "string" ? presign.message : "";
+                throw new Error(detail || `Could not get OSS upload URL (HTTP ${presignResponse.status}).`);
+            }
+            if (typeof presign.uploadUrl !== "string" || typeof presign.publicUrl !== "string") {
+                throw new Error("OSS presign response must include uploadUrl and publicUrl.");
+            }
+            if (new URL(presign.uploadUrl).protocol !== "https:" || new URL(presign.publicUrl).protocol !== "https:") {
+                throw new Error("OSS upload and public media URLs must use HTTPS.");
+            }
+            const uploadContentType = typeof presign.contentType === "string" && presign.contentType ? presign.contentType : contentType;
+            const uploaded = await scriptFetch(presign.uploadUrl, {
+                method: "PUT",
+                headers: { "Content-Type": uploadContentType },
+                body: file,
+                signal,
+            });
+            if (!uploaded.ok) throw new Error(`OSS upload failed: HTTP ${uploaded.status}.`);
+            return presign.publicUrl;
+        });
+    };
+}
+
 function bodySize(data) {
     if (data === undefined || data === null) return 0;
     if (typeof data === "string") return Buffer.byteLength(data);
@@ -90,6 +202,29 @@ function bodySize(data) {
     return Buffer.byteLength(JSON.stringify(data));
 }
 
+function composeAbortSignal(signals, timeoutMs) {
+    const controller = new AbortController();
+    const listeners = [];
+    for (const signal of signals) {
+        if (!signal) continue;
+        if (signal.aborted) {
+            controller.abort(signal.reason);
+            break;
+        }
+        const abort = () => controller.abort(signal.reason);
+        signal.addEventListener("abort", abort, { once: true });
+        listeners.push([signal, abort]);
+    }
+    const timeout = setTimeout(() => controller.abort(new DOMException("The operation timed out.", "TimeoutError")), timeoutMs);
+    return {
+        signal: controller.signal,
+        dispose() {
+            clearTimeout(timeout);
+            for (const [signal, abort] of listeners) signal.removeEventListener("abort", abort);
+        },
+    };
+}
+
 async function responseData(response, responseType, limitBytes) {
     const contentType = response.headers.get("content-type") || "";
     const bytes = Buffer.from(await response.arrayBuffer());
@@ -108,11 +243,6 @@ async function responseData(response, responseType, limitBytes) {
 }
 
 function createRequest({ signal, requestLimitBytes, responseLimitBytes, credentials, baseUrl }) {
-    let requestCount = 0;
-    const countRequest = () => {
-        requestCount += 1;
-        if (requestCount > MAX_SCRIPT_REQUESTS) throw new Error("A generation script exceeded the request count limit.");
-    };
     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, ""));
@@ -124,7 +254,6 @@ function createRequest({ signal, requestLimitBytes, responseLimitBytes, credenti
         }
     };
     const request = async (options) => {
-        countRequest();
         if (!isRecord(options) || typeof options.url !== "string") throw new Error("A generation script request needs a URL.");
         const requestBase = String(baseUrl || "").trim();
         const target = /^https?:\/\//i.test(options.url) ? new URL(options.url) : new URL(options.url, `${requestBase.replace(/\/+$/, "")}/`);
@@ -180,7 +309,6 @@ function createRequest({ signal, requestLimitBytes, responseLimitBytes, credenti
         }
     };
     const scriptFetch = async (input, init = {}) => {
-        countRequest();
         const requestInput = input instanceof Request ? input : null;
         const target = new URL(requestInput ? requestInput.url : String(input));
         if (!["http:", "https:", "data:"].includes(target.protocol)) throw new Error("Generation scripts may only fetch HTTP, HTTPS or data URLs.");
@@ -190,17 +318,53 @@ function createRequest({ signal, requestLimitBytes, responseLimitBytes, credenti
         if (init.body instanceof FormData && /^multipart\/form-data\s*$/i.test(headers.get("content-type") || "")) headers.delete("content-type");
         recordCredentials(target, headers);
         if (bodySize(init.body) > requestLimitBytes) throw new Error("Generation script request exceeds the configured size limit.");
-        const signals = [signal, init.signal || requestInput?.signal, AbortSignal.timeout(REQUEST_TIMEOUT_MS)].filter(Boolean);
-        const response = await fetch(input, { ...init, headers, signal: AbortSignal.any(signals) });
-        if (!response.body) return response;
+        const composed = composeAbortSignal([signal, init.signal || requestInput?.signal], REQUEST_TIMEOUT_MS);
+        let response;
+        try {
+            response = await fetch(input, { ...init, headers, signal: composed.signal });
+        } catch (error) {
+            composed.dispose();
+            throw error;
+        }
+        if (!response.body) {
+            composed.dispose();
+            return response;
+        }
+        const reader = response.body.getReader();
         let received = 0;
-        const limited = response.body.pipeThrough(new TransformStream({
-            transform(chunk, controller) {
-                received += chunk.byteLength;
-                if (received > responseLimitBytes) throw new Error("Script response exceeds the configured size limit.");
-                controller.enqueue(chunk);
+        const limited = new ReadableStream({
+            async pull(controller) {
+                try {
+                    const { done, value } = await reader.read();
+                    if (done) {
+                        controller.close();
+                        composed.dispose();
+                        return;
+                    }
+                    received += value.byteLength;
+                    if (received > responseLimitBytes) {
+                        try {
+                            await reader.cancel();
+                        } finally {
+                            composed.dispose();
+                        }
+                        controller.error(new Error("Script response exceeds the configured size limit."));
+                        return;
+                    }
+                    controller.enqueue(value);
+                } catch (error) {
+                    controller.error(error);
+                    composed.dispose();
+                }
             },
-        }));
+            async cancel(reason) {
+                try {
+                    await reader.cancel(reason);
+                } finally {
+                    composed.dispose();
+                }
+            },
+        });
         const wrapped = new Response(limited, { status: response.status, statusText: response.statusText, headers: response.headers });
         Object.defineProperties(wrapped, {
             url: { value: response.url },
@@ -282,6 +446,7 @@ async function runScript(script, input, request, scriptFetch, signal, timeoutMs)
         sleep,
         signal,
         cacheMediaUpload,
+        uploadToOss: createScriptOssUploader(input.ossPresignUrl, input.baseUrl, scriptFetch, signal),
         console: Object.freeze({ log() {}, warn() {}, error() {} }),
     });
     const context = vm.createContext(sandbox, { codeGeneration: { strings: false, wasm: false } });
@@ -291,7 +456,7 @@ async function runScript(script, input, request, scriptFetch, signal, timeoutMs)
     const timedOut = new Promise((_, reject) => {
         timeout = setTimeout(() => reject(new Error("Generation script timed out.")), timeoutMs);
     });
-    const aborted = signal ? new Promise((_, reject) => signal.addEventListener("abort", () => reject(new DOMException("Aborted", "AbortError")), { once: true })) : new Promise(() => {});
+    const aborted = abortPromiseFor(signal);
     try {
         return await Promise.race([result, timedOut, aborted]);
     } finally {
@@ -344,6 +509,7 @@ export async function runGenerationScriptTask(task, options) {
         apiKey: String(task.context.apiKey || ""),
         systemPrompt: String(task.context.systemPrompt || ""),
         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);