infinite-canvas-local-proxy 0.2.0 → 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/完成/失败等本地状态，不提供或伪造供应商生成百分比。代理必须保持运行，才能在浏览器关闭后继续执行代理持有的请求或自定义脚本轮询。
 
@@ -69,4 +69,40 @@ http://127.0.0.1:23210/https://api.openai.com/v1/models
 
 ## 环境要求
 
-Node.js >= 18。
+Node.js >= 18。不需要 Python、Visual Studio 编译工具，也不需要任何原生模块通过编译——安装阶段不会触发 `node-gyp`。
+
+### 任务存储的三种后端
+
+代理会按顺序自动挑选，不需要手动配置：
+
+| 后端 | 条件 | 任务是否持久化 |
+|---|---|---|
+| `better-sqlite3` | 安装成功且与当前 Node 的 ABI 匹配 | 是 |
+| `node:sqlite` | Node 22.5 及以上（内置） | 是 |
+| `memory` | 上面两者都不可用 | 否，重启后清空 |
+
+启动日志和根路径 `GET /` 会显示当前使用的后端，例如：
+
+```json
+{"taskStore":"node:sqlite","persistentTasks":true,"node":"22.22.2"}
+```
+
+`better-sqlite3` 是可选依赖。某些 Node 版本（如 24）没有对应的预编译产物，安装时会尝试本地编译并失败，但 **npm 会跳过它并继续**，代理随后自动改用内置的 `node:sqlite`，功能不受影响。
+
+Node 22.5 及以上首次加载内置 SQLite 时会打印一行 `ExperimentalWarning: SQLite is an experimental feature`，这是 Node 自身的提示，不影响使用。
+
+### 安装报错的排查
+
+如果看到 `prebuild-install warn install No prebuilt binaries found` 并跟着一长串 `gyp ERR! find Python`，说明当前 Node 版本没有 `better-sqlite3` 的预编译产物，于是退回到本地编译，而机器上又没装 Python。这种情况在新版本 Node 上很常见。
+
+0.2.1 起这个错误不会再中断安装。如果仍想彻底消除，任选其一：
+
+- 升级到 Node 22 LTS 或更高，走内置 `node:sqlite`，完全不需要编译
+- 或者安装 Python 3 与 Visual Studio Build Tools，让 `better-sqlite3` 能编译
+
+清除安装残留：
+
+```bash
+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);
@@ -226,26 +224,26 @@ async function forward(req, res, target) {
 export function createProxyServer(options = {}) {
     const dataDir = options.dataDir || process.env.CANVAS_PROXY_DATA_DIR || path.join(os.homedir(), ".canvas-proxy");
     const store = createTaskStore(dataDir);
+    if (!store.persistent) {
+        console.warn(`任务存储: 内存模式（未找到可用的 SQLite），重启后任务记录不会保留。升级到 Node 22.5+ 可自动启用内置 SQLite。`);
+        console.warn(`当前 Node ${process.versions.node}。`);
+    }
     const now = Date.now();
     store.recover(now);
     const taskTimeoutMs = positiveInteger(options.taskTimeoutMs ?? process.env.CANVAS_PROXY_TASK_TIMEOUT_MS, TASK_TIMEOUT_MS);
     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(() => {
@@ -256,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);
         }
     };
 
@@ -709,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({
@@ -774,7 +765,7 @@ export function createProxyServer(options = {}) {
 
         const target = readTarget(req.url || "/");
         if (!target) {
-            sendJson(res, 200, { app: "infinite-canvas", proxy: pkg.name, version: pkg.version, taskApiVersion: 1, usage: "/<full-target-url>" });
+            sendJson(res, 200, { app: "infinite-canvas", proxy: pkg.name, version: pkg.version, taskApiVersion: 1, taskStore: store.backend, persistentTasks: store.persistent, node: process.versions.node, usage: "/<full-target-url>" });
             return;
         }
         const startedAt = Date.now();

package/memory-task-store.js

@@ -0,0 +1,132 @@
+/**
+ * 内存版任务存储。只在 better-sqlite3 与 node:sqlite 都不可用时启用，
+ * 目的是让代理仍然能启动、转发照常工作，代价是重启后任务记录不再保留。
+ * 接口与基于 SQLite 的实现保持一致，主程序无需区分。
+ */
+export function createMemoryTaskStore(resultDir) {
+    const tasks = new Map();
+
+    function toTask(row) {
+        if (!row) return null;
+        let metadata;
+        if (row.metadata_json) {
+            metadata = JSON.parse(row.metadata_json);
+        }
+        return {
+            id: row.id,
+            status: row.status,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+            expiresAt: row.expires_at,
+            responseStatus: row.response_status,
+            responseContentType: row.response_content_type,
+            responseFile: row.response_file,
+            error: row.error,
+            ...(row.client_request_id ? { clientRequestId: row.client_request_id } : {}),
+            ...(row.kind !== "request" ? { kind: row.kind } : {}),
+            ...(row.source ? { source: row.source } : {}),
+            ...(metadata ? { metadata } : {}),
+        };
+    }
+
+    function insert(task) {
+        const row = {
+            id: task.id,
+            status: "queued",
+            created_at: task.now,
+            updated_at: task.now,
+            expires_at: task.expiresAt,
+            response_status: null,
+            response_content_type: null,
+            response_file: null,
+            error: null,
+            client_request_id: task.clientRequestId || null,
+            kind: task.kind || "request",
+            source: task.source || null,
+            metadata_json: task.metadata ? JSON.stringify(task.metadata) : null,
+        };
+        tasks.set(row.id, row);
+        return row;
+    }
+
+    function findByClientRequestId(clientRequestId) {
+        if (!clientRequestId) return null;
+        for (const row of tasks.values()) {
+            if (row.client_request_id === clientRequestId) return row;
+        }
+        return null;
+    }
+
+    return {
+        resultDir,
+        backend: "memory",
+        persistent: false,
+        create(id, now, expiresAt) {
+            insert({ id, now, expiresAt, clientRequestId: null, kind: "request", source: null, metadata: null });
+        },
+        createOrGet(task) {
+            const resolved = { kind: "request", source: null, metadata: null, ...task };
+            if (resolved.clientRequestId) {
+                const existing = findByClientRequestId(resolved.clientRequestId);
+                if (existing) return { task: toTask(existing), created: false };
+            }
+            const row = insert(resolved);
+            return { task: toTask(row), created: true };
+        },
+        setStatus(id, status, now, error = null) {
+            const row = tasks.get(id);
+            if (!row) return;
+            row.status = status;
+            row.updated_at = now;
+            row.error = error;
+        },
+        setSucceeded(id, now, status, contentType, file) {
+            const row = tasks.get(id);
+            if (!row) return;
+            row.status = "succeeded";
+            row.updated_at = now;
+            row.response_status = status;
+            row.response_content_type = contentType;
+            row.response_file = file;
+            row.error = null;
+        },
+        get(id) {
+            return toTask(tasks.get(id));
+        },
+        getByClientRequestId(clientRequestId) {
+            return toTask(findByClientRequestId(clientRequestId));
+        },
+        listActive(now, limit = 100) {
+            const active = ["queued", "running", "submitting", "polling"];
+            return [...tasks.values()]
+                .filter((row) => row.expires_at > now && active.includes(row.status))
+                .sort((a, b) => b.created_at - a.created_at)
+                .slice(0, limit)
+                .map(toTask);
+        },
+        recover(now) {
+            const active = ["queued", "running", "submitting", "polling"];
+            let changes = 0;
+            for (const row of tasks.values()) {
+                if (!active.includes(row.status)) continue;
+                row.status = "unknown";
+                row.updated_at = now;
+                row.error = "Proxy restarted while the upstream request was running; its outcome is unknown.";
+                changes += 1;
+            }
+            return changes;
+        },
+        removeExpired(now) {
+            const finished = ["succeeded", "failed", "unknown"];
+            return [...tasks.values()]
+                .filter((row) => row.expires_at <= now && finished.includes(row.status))
+                .map((row) => ({ id: row.id, response_file: row.response_file }));
+        },
+        remove(id) {
+            tasks.delete(id);
+        },
+        close() {
+            tasks.clear();
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infinite-canvas-local-proxy",
-  "version": "0.2.0",
+  "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",
@@ -11,6 +11,8 @@
   "files": [
     "index.js",
     "task-store.js",
+    "sqlite-backend.js",
+    "memory-task-store.js",
     "script-runner.js",
     "README.md"
   ],
@@ -21,7 +23,7 @@
   "engines": {
     "node": ">=18"
   },
-  "dependencies": {
+  "optionalDependencies": {
     "better-sqlite3": "^11.8.1"
   },
   "publishConfig": {

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);

package/sqlite-backend.js

@@ -0,0 +1,102 @@
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+
+/**
+ * 尽量拿到一个可用的 SQLite 实现，按优先级：
+ *   1. better-sqlite3 —— Node 18/20/22 有预编译产物，装上即用
+ *   2. node:sqlite    —— Node 22.5+ 内置，不需要任何依赖
+ * 都不可用时返回 null，由调用方降级为内存存储，保证代理仍能启动。
+ *
+ * 返回的对象只暴露 task-store 用到的最小接口：
+ *   pragma(sql) / exec(sql) / prepare(sql).run|get|all / transaction(fn) / close()
+ */
+
+export function openSqlite(file) {
+    const better = loadBetterSqlite3();
+    if (better) {
+        try {
+            return { db: new better(file), backend: "better-sqlite3" };
+        } catch {
+            // 二进制与当前 Node ABI 不匹配等情况，继续尝试内置实现
+        }
+    }
+
+    const nodeSqlite = loadNodeSqlite();
+    if (nodeSqlite) {
+        try {
+            return { db: new NodeSqliteAdapter(file, nodeSqlite), backend: "node:sqlite" };
+        } catch {
+            // 内置实现不可用，走内存降级
+        }
+    }
+
+    return null;
+}
+
+function loadBetterSqlite3() {
+    try {
+        const mod = require("better-sqlite3");
+        return typeof mod === "function" ? mod : mod.default;
+    } catch {
+        return null;
+    }
+}
+
+function loadNodeSqlite() {
+    try {
+        const mod = require("node:sqlite");
+        return mod && mod.DatabaseSync ? mod : null;
+    } catch {
+        return null;
+    }
+}
+
+/** 把 node:sqlite 的 DatabaseSync 适配成 better-sqlite3 的调用习惯 */
+class NodeSqliteAdapter {
+    #db;
+
+    constructor(file, { DatabaseSync }) {
+        this.#db = new DatabaseSync(file);
+    }
+
+    pragma(statement) {
+        this.#db.exec(`PRAGMA ${statement}`);
+    }
+
+    exec(sql) {
+        this.#db.exec(sql);
+    }
+
+    prepare(sql) {
+        const statement = this.#db.prepare(sql);
+        return {
+            run: (...args) => statement.run(...args),
+            get: (...args) => statement.get(...args),
+            all: (...args) => statement.all(...args),
+        };
+    }
+
+    transaction(fn) {
+        const db = this.#db;
+        return (...args) => {
+            db.exec("BEGIN");
+            try {
+                const result = fn(...args);
+                db.exec("COMMIT");
+                return result;
+            } catch (error) {
+                try {
+                    db.exec("ROLLBACK");
+                } catch {
+                    // 事务可能已经失效，保留原始错误
+                }
+                throw error;
+            }
+        };
+    }
+
+    close() {
+        this.#db.close();
+    }
+}

package/task-store.js

@@ -1,15 +1,17 @@
 import { mkdirSync } from "node:fs";
-import { createRequire } from "node:module";
 import path from "node:path";
-
-const require = createRequire(import.meta.url);
-const Database = require("better-sqlite3");
+import { openSqlite } from "./sqlite-backend.js";
+import { createMemoryTaskStore } from "./memory-task-store.js";
 
 export function createTaskStore(dataDir) {
     mkdirSync(dataDir, { recursive: true, mode: 0o700 });
     const resultDir = path.join(dataDir, "results");
     mkdirSync(resultDir, { recursive: true, mode: 0o700 });
-    const db = new Database(path.join(dataDir, "tasks.sqlite"));
+
+    const opened = openSqlite(path.join(dataDir, "tasks.sqlite"));
+    if (!opened) return createMemoryTaskStore(resultDir);
+    const { db, backend } = opened;
+
     db.pragma("journal_mode = WAL");
     db.pragma("synchronous = FULL");
     db.exec(`
@@ -100,6 +102,8 @@ export function createTaskStore(dataDir) {
 
     return {
         resultDir,
+        backend,
+        persistent: true,
         create(id, now, expiresAt) {
             insert.run({ id, now, expiresAt, clientRequestId: null, kind: "request", source: null, metadataJson: null });
         },