infinite-canvas-local-proxy 0.2.0 → 0.2.1

package/README.md

@@ -69,4 +69,41 @@ 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

@@ -226,6 +226,10 @@ 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);
@@ -774,7 +778,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.1",
   "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/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 });
         },