@leterhong/multichat 1.6.0

package/backend/lib/catalog.ts

@@ -0,0 +1,28 @@
+const fs = require('fs');
+const path = require('path');
+
+function readPackageVersion() {
+  const candidates = [
+    path.join(__dirname, '..', 'package.json'),
+    path.join(__dirname, '..', '..', 'package.json'),
+  ];
+  for (const file of candidates) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(file, 'utf8'));
+      if (pkg.version) return pkg.version;
+    } catch {
+      // Source and compiled builds have different __dirname depths.
+    }
+  }
+  return '0.0.0';
+}
+
+function safeId(value, label = 'id') {
+  const id = String(value || '').trim();
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/.test(id)) {
+    throw new Error(`invalid ${label}`);
+  }
+  return id;
+}
+
+module.exports = { readPackageVersion, safeId };

package/backend/lib/context.ts

@@ -0,0 +1,61 @@
+'use strict';
+// ── 共享上下文（单例）：集中依赖与常量，避免每个路由重复 require / 重复定义 ──
+// 注意：本模块在 require 时构造 store / workspaceStore，均为本地 IO，不启动服务，
+// 因此可被 routes / services / plugins 各层安全依赖，无循环依赖。
+const fs = require('fs');
+const path = require('path');
+const { getMcpClient, closeMcpClient, closeAllMcpClients } = require('../mcp');
+const { createRuntimeStore } = require('./runtime-store');
+const { createWorkspaceStore } = require('./workspace-store');
+const { createProviderStore } = require('./provider-store');
+const { safeFetch } = require('./ssrf');
+const { createAdapter, ADAPTER_MAP } = require('../adapters');
+const { readPackageVersion, safeId } = require('./catalog');
+
+const PORT = process.env.PORT || 3000;
+const BACKEND_ROOT = path.basename(__dirname) === 'lib' && path.basename(path.dirname(__dirname)) === 'dist'
+  ? path.dirname(path.dirname(__dirname))
+  : path.dirname(__dirname);
+const DATA_DIR = process.env.DATA_DIR || path.join(BACKEND_ROOT, 'data');
+const runtimeStore = createRuntimeStore(DATA_DIR);
+const store = runtimeStore.store;
+const STORAGE_FALLBACK = runtimeStore.fallbackReason ? 'json' : null;
+const workspaceStore = createWorkspaceStore(store);
+const providerStore = createProviderStore(store);
+const VERSION = readPackageVersion();
+
+// 插件 / 技能 / 智能体 / 运行 相关常量（原 server.ts 顶层常量集中于此）
+const SKILL_FILE = 'skills.json';
+const AGENT_FILE = 'agents.json';
+const RUN_FILE = 'runs.json';
+const MAX_RUNS = 200;
+
+// 运行中的 Agent 任务取消句柄：runId → AbortController。
+// 用于「Cancellation」：前端停止时，后端能真正中断上游 fetch 与 MCP 子进程。
+const runAborts = new Map();
+
+module.exports = {
+  fs,
+  path,
+  getMcpClient,
+  closeMcpClient,
+  closeAllMcpClients,
+  BACKEND_ROOT,
+  store,
+  workspaceStore,
+  providerStore,
+  safeFetch,
+  createAdapter,
+  ADAPTER_MAP,
+  readPackageVersion,
+  safeId,
+  PORT,
+  DATA_DIR,
+  STORAGE_FALLBACK,
+  VERSION,
+  SKILL_FILE,
+  AGENT_FILE,
+  RUN_FILE,
+  MAX_RUNS,
+  runAborts,
+};

package/backend/lib/errors.ts

@@ -0,0 +1,78 @@
+// ── 统一错误码 + 请求ID 中间件（A3） ───────────────────────────────────
+// 设计目标：在不破坏既有契约（前端读 res.data.error 字符串）的前提下，
+// 为每次请求附加 requestId，并为错误响应附加 code 字段，便于排障与日志关联。
+const crypto = require('crypto');
+import type { Request, Response, NextFunction } from 'express';
+const { redactSecrets } = require('./redact');
+
+// 业务错误码 → HTTP 状态码 映射
+const ERROR_CODES: Record<string, number> = {
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  VALIDATION: 400,
+  IMPORT_FAILED: 502,
+  SSRF_BLOCKED: 403,
+  PLUGIN_NOT_FOUND: 404,
+  PROVIDER_NOT_FOUND: 404,
+  AGENT_NOT_FOUND: 404,
+  SKILL_NOT_FOUND: 404,
+  PERMISSION_DENIED: 403,
+  APPROVAL_NOT_PENDING: 409,
+  CONFLICT: 409,
+  INVALID_PACKAGE: 400,
+  MCP_CONNECTION_FAILED: 502,
+  UPSTREAM: 502,
+  INTERNAL: 500,
+};
+
+class AppError extends Error {
+  code: string;
+  statusCode: number;
+  constructor(code: string, message: string, statusCode?: number) {
+    super(message);
+    this.name = 'AppError';
+    this.code = ERROR_CODES[code] !== undefined ? code : 'INTERNAL';
+    this.statusCode = statusCode || ERROR_CODES[this.code] || 500;
+  }
+}
+
+// 请求ID 中间件：每个请求分配一个 id（允许上游透传 X-Request-Id）
+function requestIdMiddleware(req: Request, res: Response, next: NextFunction): void {
+  const supplied = typeof req.headers['x-request-id'] === 'string' ? req.headers['x-request-id'] : '';
+  const id = /^[A-Za-z0-9._:-]{1,128}$/.test(supplied)
+    ? supplied
+    : crypto.randomBytes(8).toString('hex');
+  (req as any).requestId = id;
+  res.locals.requestId = id;
+  res.setHeader('X-Request-Id', id);
+  next();
+}
+
+// 结构化失败响应：保持 error 为字符串以兼容旧前端，额外带 code / requestId
+function fail(res: Response, status: number, code: string, message: string) {
+  return res.status(status).json({
+    error: message,
+    code,
+    requestId: res.locals.requestId || null,
+  });
+}
+
+// 全局错误处理：兜底未捕获异常，统一输出 { error, code, requestId }
+function errorHandler(err: any, req: Request, res: Response, next: NextFunction): void {
+  if (res.headersSent) return next(err);
+  const status = err.statusCode || 500;
+  const code = err.code || 'INTERNAL';
+  const message = redactSecrets(err.message || 'Internal Server Error');
+  if (status >= 500) {
+    console.error('[error]', code, redactSecrets(message), 'reqId=', (req as any).requestId, err.stack ? '\n' + redactSecrets(err.stack) : '');
+  }
+  res.status(status).json({
+    error: message,
+    code,
+    requestId: (req as any).requestId || res.locals.requestId || null,
+  });
+}
+
+module.exports = { ERROR_CODES, AppError, requestIdMiddleware, fail, errorHandler };

package/backend/lib/provider-store.ts

@@ -0,0 +1,116 @@
+const crypto = require('crypto');
+const fs = require('fs');
+import type { JsonRecord, JsonStore } from '../types';
+
+const PROVIDER_FILE = 'providers.json';
+const KEY_FILE = '.provider-secrets.key';
+const PREFIX = 'enc:v1:';
+
+function protectFile(file: string) {
+  try { fs.chmodSync(file, 0o600); } catch {}
+}
+
+function keyFor(store: JsonStore): Buffer {
+  const file = store.resolve(KEY_FILE);
+  if (!fs.existsSync(file)) {
+    fs.writeFileSync(file, crypto.randomBytes(32), { mode: 0o600 });
+  }
+  const key = fs.readFileSync(file);
+  if (key.length !== 32) throw new Error('provider secret key is invalid');
+  protectFile(file);
+  return key;
+}
+
+function encrypt(store: JsonStore, value: string): string {
+  if (!value || value.startsWith(PREFIX)) return value;
+  const iv = crypto.randomBytes(12);
+  const cipher = crypto.createCipheriv('aes-256-gcm', keyFor(store), iv);
+  const encrypted = Buffer.concat([cipher.update(value, 'utf8'), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return PREFIX + [iv, tag, encrypted].map(part => part.toString('base64url')).join(':');
+}
+
+function decrypt(store: JsonStore, value: string): string {
+  if (!value || !value.startsWith(PREFIX)) return value || '';
+  const [ivText, tagText, payloadText] = value.slice(PREFIX.length).split(':');
+  if (!ivText || !tagText || !payloadText) throw new Error('provider secret payload is invalid');
+  const decipher = crypto.createDecipheriv('aes-256-gcm', keyFor(store), Buffer.from(ivText, 'base64url'));
+  decipher.setAuthTag(Buffer.from(tagText, 'base64url'));
+  return Buffer.concat([decipher.update(Buffer.from(payloadText, 'base64url')), decipher.final()]).toString('utf8');
+}
+
+function createProviderStore(store: JsonStore) {
+  function stored(): JsonRecord[] {
+    const rows = store.read<JsonRecord[]>(PROVIDER_FILE, []);
+    let migrated = false;
+    const protectedRows = rows.map(row => {
+      if (row.apiKey && !String(row.apiKey).startsWith(PREFIX)) {
+        migrated = true;
+        return { ...row, apiKey: encrypt(store, String(row.apiKey)) };
+      }
+      return row;
+    });
+    if (migrated) {
+      store.write(PROVIDER_FILE, protectedRows);
+      // The generic store created its recovery copy from the legacy plaintext
+      // file. Replace that copy immediately so no API key remains in a .bak.
+      const legacyFile = store.resolve(PROVIDER_FILE);
+      if (store.kind === 'json' || fs.existsSync(legacyFile)) {
+        fs.writeFileSync(legacyFile, JSON.stringify(protectedRows, null, 2), { mode: 0o600 });
+        fs.writeFileSync(`${legacyFile}.bak`, JSON.stringify(protectedRows, null, 2), { mode: 0o600 });
+        protectFile(legacyFile);
+        protectFile(`${legacyFile}.bak`);
+      }
+    }
+    return protectedRows;
+  }
+
+  function list(): JsonRecord[] {
+    return stored().map(row => {
+      const apiKey = row.apiKey ? decrypt(store, String(row.apiKey)) : '';
+      return { ...row, apiKey };
+    });
+  }
+
+  function save(rows: JsonRecord[]) {
+    const protectedRows = rows.map(row => ({
+      ...row,
+      apiKey: row.apiKey ? encrypt(store, String(row.apiKey)) : '',
+    }));
+    store.write(PROVIDER_FILE, protectedRows);
+    if (store.kind === 'json') protectFile(store.resolve(PROVIDER_FILE));
+    const backup = `${store.resolve(PROVIDER_FILE)}.bak`;
+    if (fs.existsSync(backup)) protectFile(backup);
+  }
+
+  function publicRecord(row: JsonRecord) {
+    if (!row) return row;
+    const { apiKey, ...rest } = row;
+    const capabilities = providerCapabilities(row);
+    if (!apiKey) return { ...rest, capabilities };
+    const preview = String(apiKey).length > 4 ? String(apiKey).slice(-4) : String(apiKey);
+    return { ...rest, capabilities, apiKeyMasked: true, apiKeyPreview: preview };
+  }
+
+  function publicList() { return list().map(publicRecord); }
+
+  return { list, save, publicRecord, publicList };
+}
+
+function providerCapabilities(provider: JsonRecord) {
+  const type = String(provider.apiType || 'openai').toLowerCase();
+  const models = Array.isArray(provider.models) ? provider.models.map(String) : [];
+  const modelText = models.join(' ').toLowerCase();
+  const local = ['ollama', 'lmstudio'].includes(type);
+  return {
+    streaming: true,
+    tools: !['wenxin'].includes(type),
+    vision: /vision|vl|gpt-4o|gemini|claude-3/.test(modelText),
+    reasoning: /reason|r1|thinking|qwq/.test(modelText),
+    usage: 'provider-or-estimated',
+    local,
+    privateNetwork: Boolean(provider.allowPrivate) || local,
+  };
+}
+
+module.exports = { PROVIDER_FILE, createProviderStore, providerCapabilities };

package/backend/lib/redact.ts

@@ -0,0 +1,9 @@
+function redactSecrets(value: unknown): string {
+  return String(value ?? '')
+    .replace(/\b(Bearer|Basic)\s+[A-Za-z0-9._~+\/-]{8,}={0,2}/gi, '$1 ***')
+    .replace(/\bsk-[A-Za-z0-9_-]{8,}\b/g, 'sk-***')
+    .replace(/([?&](?:access_token|client_secret|api_?key|token|password)=)[^&#\s]+/gi, '$1***')
+    .replace(/\b((?:api_?key|access_?token|client_?secret|authorization|password)\s*[:=]\s*)[^\s,;]+/gi, '$1***');
+}
+
+module.exports = { redactSecrets };

package/backend/lib/runtime-store.ts

@@ -0,0 +1,38 @@
+'use strict';
+
+import type { JsonStore } from '../types';
+
+type StoreFactory = (rootDir: string) => JsonStore;
+type RuntimeStoreOptions = {
+  preferred?: 'sqlite' | 'json';
+  createJsonStore?: StoreFactory;
+  createSqliteStore?: StoreFactory;
+  warn?: (message: string) => void;
+};
+
+function errorMessage(error: unknown) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+/**
+ * Selects the local persistence backend without making SQLite a hard startup
+ * dependency. The SQLite module is loaded lazily so older or restricted Node
+ * runtimes can still reach the JSON recovery path.
+ */
+function createRuntimeStore(rootDir: string, options: RuntimeStoreOptions = {}) {
+  const preferred = options.preferred || (process.env.MULTICHAT_STORE === 'json' ? 'json' : 'sqlite');
+  const createJson = options.createJsonStore || (require('./store').createJsonStore as StoreFactory);
+  if (preferred === 'json') return { store: createJson(rootDir), fallbackReason: null };
+
+  try {
+    const createSqlite = options.createSqliteStore || (require('./sqlite-store').createSqliteStore as StoreFactory);
+    return { store: createSqlite(rootDir), fallbackReason: null };
+  } catch (error) {
+    const fallbackReason = errorMessage(error);
+    const message = `[MultiChat] SQLite 初始化失败，已降级为 JSON 存储：${fallbackReason}`;
+    (options.warn || console.warn)(message);
+    return { store: createJson(rootDir), fallbackReason };
+  }
+}
+
+module.exports = { createRuntimeStore };

package/backend/lib/sqlite-store.ts

@@ -0,0 +1,220 @@
+const fs = require('fs');
+const path = require('path');
+const { DatabaseSync } = require('node:sqlite');
+import type { JsonRecord, JsonStore } from '../types';
+
+type SearchRow = {
+  entityId: string;
+  projectId: string;
+  title: string;
+  snippet: string;
+  rank: number;
+  source: string;
+};
+
+function createSqliteStore(rootDir: string): JsonStore {
+  fs.mkdirSync(rootDir, { recursive: true });
+  const databaseFile = path.join(rootDir, 'multichat.sqlite3');
+  const database = new DatabaseSync(databaseFile);
+  const chains = new Map<string, Promise<unknown>>();
+
+  database.exec(`
+    PRAGMA journal_mode = WAL;
+    PRAGMA synchronous = NORMAL;
+    PRAGMA busy_timeout = 5000;
+    CREATE TABLE IF NOT EXISTS kv_store (
+      name TEXT PRIMARY KEY,
+      value TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS store_meta (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+  `);
+
+  let ftsEnabled = false;
+  try {
+    database.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS search_fts USING fts5(
+      source UNINDEXED,
+      entity_id UNINDEXED,
+      project_id UNINDEXED,
+      title,
+      content,
+      tokenize='trigram'
+    );`);
+    ftsEnabled = true;
+  } catch {
+    try {
+      database.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS search_fts USING fts5(
+        source UNINDEXED,
+        entity_id UNINDEXED,
+        project_id UNINDEXED,
+        title,
+        content
+      );`);
+      ftsEnabled = true;
+    } catch {
+      database.exec(`
+        CREATE TABLE IF NOT EXISTS search_documents (
+          source TEXT NOT NULL,
+          entity_id TEXT NOT NULL,
+          project_id TEXT NOT NULL,
+          title TEXT NOT NULL,
+          content TEXT NOT NULL,
+          PRIMARY KEY(source, entity_id)
+        );
+        CREATE INDEX IF NOT EXISTS search_documents_project ON search_documents(project_id);
+      `);
+    }
+  }
+
+  const selectValue = database.prepare('SELECT value FROM kv_store WHERE name = ?');
+  const upsertValue = database.prepare(`
+    INSERT INTO kv_store(name, value, updated_at) VALUES (?, ?, ?)
+    ON CONFLICT(name) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at
+  `);
+  const deleteValue = database.prepare('DELETE FROM kv_store WHERE name = ?');
+  const migrationValue = database.prepare("SELECT value FROM store_meta WHERE key = 'json_migration_v1'");
+
+  function validName(name: string) {
+    if (typeof name !== 'string' || !name || path.basename(name) !== name) throw new Error('invalid data file name');
+    return name;
+  }
+
+  function resolve(name: string) {
+    return path.join(rootDir, validName(name));
+  }
+
+  function importJsonFiles() {
+    if (migrationValue.get()) return;
+    database.exec('BEGIN IMMEDIATE');
+    try {
+      const names = fs.readdirSync(rootDir).filter((name: string) => name.endsWith('.json') && path.basename(name) === name);
+      for (const name of names) {
+        if (selectValue.get(name)) continue;
+        try {
+          const parsed = JSON.parse(fs.readFileSync(path.join(rootDir, name), 'utf8'));
+          upsertValue.run(name, JSON.stringify(parsed), new Date().toISOString());
+        } catch {
+          // Corrupt legacy files remain untouched for manual recovery.
+        }
+      }
+      database.prepare("INSERT OR REPLACE INTO store_meta(key, value) VALUES ('json_migration_v1', ?)").run(new Date().toISOString());
+      database.exec('COMMIT');
+    } catch (error) {
+      database.exec('ROLLBACK');
+      throw error;
+    }
+  }
+
+  function read<T>(name: string, fallback: T): T {
+    validName(name);
+    const row = selectValue.get(name) as { value?: string } | undefined;
+    if (!row?.value) return fallback;
+    try { return JSON.parse(row.value) as T; }
+    catch { return fallback; }
+  }
+
+  function reindex(source: string, value: unknown) {
+    if (!['assets.json', 'memories.json'].includes(source)) return;
+    const rows = Array.isArray(value) ? value : [];
+    const table = ftsEnabled ? 'search_fts' : 'search_documents';
+    const removeSource = database.prepare(`DELETE FROM ${table} WHERE source = ?`);
+    const insert = database.prepare(`INSERT INTO ${table}(source, entity_id, project_id, title, content) VALUES (?, ?, ?, ?, ?)`);
+    database.exec('SAVEPOINT reindex_source');
+    try {
+      removeSource.run(source);
+      for (const row of rows as JsonRecord[]) {
+        if (!row?.id || !row?.content) continue;
+        insert.run(source, String(row.id), String(row.projectId || ''), String(row.name || row.title || ''), String(row.content));
+      }
+      database.exec('RELEASE reindex_source');
+    } catch (error) {
+      database.exec('ROLLBACK TO reindex_source');
+      database.exec('RELEASE reindex_source');
+      throw error;
+    }
+  }
+
+  function write(name: string, value: unknown) {
+    validName(name);
+    database.exec('BEGIN IMMEDIATE');
+    try {
+      upsertValue.run(name, JSON.stringify(value), new Date().toISOString());
+      reindex(name, value);
+      database.exec('COMMIT');
+    } catch (error) {
+      database.exec('ROLLBACK');
+      throw error;
+    }
+  }
+
+  function remove(name: string) {
+    validName(name);
+    database.exec('BEGIN IMMEDIATE');
+    try {
+      deleteValue.run(name);
+      database.prepare(`DELETE FROM ${ftsEnabled ? 'search_fts' : 'search_documents'} WHERE source = ?`).run(name);
+      database.exec('COMMIT');
+    } catch (error) {
+      database.exec('ROLLBACK');
+      throw error;
+    }
+  }
+
+  function mutate<T>(name: string, update: (current: T) => T | undefined | Promise<T | undefined>, fallback: T) {
+    const previous = chains.get(name) || Promise.resolve();
+    const run = previous
+      .then(() => update(read(name, fallback)))
+      .then((result) => {
+        if (result !== undefined) write(name, result);
+        return result;
+      });
+    chains.set(name, run.then(() => {}, () => {}));
+    return run;
+  }
+
+  function searchDocuments(query: string, options: { projectId?: string; limit?: number } = {}): SearchRow[] {
+    const text = String(query || '').trim();
+    if (!text) return [];
+    const projectId = String(options.projectId || '');
+    const limit = Math.max(1, Math.min(100, Number(options.limit) || 12));
+    const commonSelect = `SELECT source, entity_id AS entityId, project_id AS projectId, title,
+      snippet(search_fts, 4, '', '', ' … ', 56) AS snippet,
+      bm25(search_fts) AS rank FROM search_fts`;
+    try {
+      if (!ftsEnabled) throw new Error('fts5 unavailable');
+      if ([...text].length >= 3) {
+        const phrase = `"${text.replace(/"/g, '""')}"`;
+        return database.prepare(`${commonSelect}
+          WHERE search_fts MATCH ? AND (? = '' OR project_id = ?)
+          ORDER BY rank LIMIT ?`).all(phrase, projectId, projectId, limit) as SearchRow[];
+      }
+    } catch {
+      // Invalid FTS syntax and short queries use the bounded LIKE fallback.
+    }
+    const like = `%${text.replace(/[\\%_]/g, '\\$&')}%`;
+    return database.prepare(`SELECT source, entity_id AS entityId, project_id AS projectId, title,
+      substr(content, 1, 2400) AS snippet, 0 AS rank FROM ${ftsEnabled ? 'search_fts' : 'search_documents'}
+      WHERE (title LIKE ? ESCAPE '\\' OR content LIKE ? ESCAPE '\\') AND (? = '' OR project_id = ?)
+      LIMIT ?`).all(like, like, projectId, projectId, limit) as SearchRow[];
+  }
+
+  importJsonFiles();
+  reindex('assets.json', read('assets.json', []));
+  reindex('memories.json', read('memories.json', []));
+
+  return {
+    kind: 'sqlite',
+    read,
+    write,
+    remove,
+    resolve,
+    mutate,
+    searchDocuments,
+    close: () => database.close(),
+  };
+}
+
+module.exports = { createSqliteStore };

package/backend/lib/sse.ts

@@ -0,0 +1,42 @@
+/** Incremental WHATWG-style SSE decoder for arbitrarily split byte chunks. */
+class SSEDecoder {
+  private buffer = '';
+
+  push(chunk: string): string[] {
+    this.buffer += String(chunk || '').replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    const events: string[] = [];
+    let boundary = this.buffer.indexOf('\n\n');
+    while (boundary >= 0) {
+      const block = this.buffer.slice(0, boundary);
+      this.buffer = this.buffer.slice(boundary + 2);
+      const data = this.dataFrom(block);
+      if (data !== null) events.push(`data: ${data}`);
+      boundary = this.buffer.indexOf('\n\n');
+    }
+    return events;
+  }
+
+  flush(): string[] {
+    const block = this.buffer;
+    this.buffer = '';
+    const data = this.dataFrom(block);
+    return data === null ? [] : [`data: ${data}`];
+  }
+
+  private dataFrom(block: string): string | null {
+    if (!block.trim()) return null;
+    const values: string[] = [];
+    for (const line of block.split('\n')) {
+      if (!line || line.startsWith(':')) continue;
+      const separator = line.indexOf(':');
+      const field = separator < 0 ? line : line.slice(0, separator);
+      if (field !== 'data') continue;
+      let value = separator < 0 ? '' : line.slice(separator + 1);
+      if (value.startsWith(' ')) value = value.slice(1);
+      values.push(value);
+    }
+    return values.length ? values.join('\n') : null;
+  }
+}
+
+module.exports = { SSEDecoder };