chattercatcher 0.1.6 → 0.1.8

package/dist/cli.js

@@ -1,9 +1,224 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/config/paths.ts
+import os2 from "os";
+import path2 from "path";
+function getChatterCatcherHome() {
+  return process.env.CHATTERCATCHER_HOME || path2.join(os2.homedir(), ".chattercatcher");
+}
+function resolveHomePath(value) {
+  if (value === "~") {
+    return os2.homedir();
+  }
+  if (value.startsWith("~/") || value.startsWith("~\\")) {
+    return path2.join(os2.homedir(), value.slice(2));
+  }
+  return path2.resolve(value);
+}
+function getConfigPath() {
+  return path2.join(getChatterCatcherHome(), "config.json");
+}
+function getSecretsPath() {
+  return path2.join(getChatterCatcherHome(), "secrets.json");
+}
+var init_paths = __esm({
+  "src/config/paths.ts"() {
+    "use strict";
+  }
+});
+
+// src/rag/lancedb-store.ts
+var lancedb_store_exports = {};
+__export(lancedb_store_exports, {
+  LanceDbVectorStore: () => LanceDbVectorStore,
+  getLanceDbPath: () => getLanceDbPath
+});
+import fs6 from "fs/promises";
+import path9 from "path";
+function getLanceDbPath(config) {
+  return path9.join(resolveHomePath(config.storage.dataDir), "vector", "lancedb");
+}
+function toRow(record) {
+  return {
+    id: record.id,
+    vector: record.vector,
+    text: record.evidence.text,
+    source_json: JSON.stringify(record.evidence.source)
+  };
+}
+function toLanceData(rows) {
+  return rows.map((row) => ({
+    id: row.id,
+    vector: row.vector,
+    text: row.text,
+    source_json: row.source_json
+  }));
+}
+function escapeSqlString(value) {
+  return value.replace(/'/g, "''");
+}
+function toEvidence(row) {
+  const distance = row._distance ?? 0;
+  const vectorScore = 1 / (1 + Math.max(0, distance));
+  return {
+    id: row.id,
+    text: row.text,
+    score: vectorScore,
+    vectorScore,
+    source: JSON.parse(row.source_json)
+  };
+}
+var DEFAULT_TABLE_NAME, LanceDbVectorStore;
+var init_lancedb_store = __esm({
+  "src/rag/lancedb-store.ts"() {
+    "use strict";
+    init_paths();
+    DEFAULT_TABLE_NAME = "message_chunks";
+    LanceDbVectorStore = class _LanceDbVectorStore {
+      constructor(connection, tableName) {
+        this.connection = connection;
+        this.tableName = tableName;
+      }
+      connection;
+      tableName;
+      static async connect(uri, tableName = DEFAULT_TABLE_NAME) {
+        await fs6.mkdir(uri, { recursive: true });
+        const lancedb = await import("@lancedb/lancedb");
+        const connection = await lancedb.connect(uri);
+        return new _LanceDbVectorStore(connection, tableName);
+      }
+      static async connectFromConfig(config, tableName = DEFAULT_TABLE_NAME) {
+        return _LanceDbVectorStore.connect(getLanceDbPath(config), tableName);
+      }
+      close() {
+        this.connection.close();
+      }
+      async upsert(records) {
+        if (records.length === 0) {
+          return;
+        }
+        const rows = records.map(toRow);
+        const data2 = toLanceData(rows);
+        const table = await this.ensureTable(data2);
+        const ids = rows.map((row) => `'${escapeSqlString(row.id)}'`).join(", ");
+        await table.delete(`id IN (${ids})`);
+        await table.add(data2);
+      }
+      async search(vector, limit) {
+        const table = await this.openTableIfExists();
+        if (!table) {
+          return [];
+        }
+        const rows = await table.vectorSearch(vector).limit(limit).toArray();
+        return rows.map(toEvidence);
+      }
+      async count() {
+        const table = await this.openTableIfExists();
+        if (!table) {
+          return 0;
+        }
+        return table.countRows();
+      }
+      async ensureTable(initialRows) {
+        const table = await this.openTableIfExists();
+        if (table) {
+          return table;
+        }
+        return this.connection.createTable(this.tableName, initialRows);
+      }
+      async openTableIfExists() {
+        const tableNames = await this.connection.tableNames();
+        if (!tableNames.includes(this.tableName)) {
+          return null;
+        }
+        return this.connection.openTable(this.tableName);
+      }
+    };
+  }
+});
 
 // src/cli.ts
 import { input, password, select, confirm, number } from "@inquirer/prompts";
 import { Command } from "commander";
-import fs12 from "fs/promises";
+import fs14 from "fs/promises";
+
+// package.json
+var package_default = {
+  name: "chattercatcher",
+  version: "0.1.8",
+  description: "\u672C\u5730\u4F18\u5148\u7684\u98DE\u4E66/Lark \u5BB6\u5EAD\u7FA4\u77E5\u8BC6\u5E93\u673A\u5668\u4EBA",
+  type: "module",
+  main: "dist/index.js",
+  types: "dist/index.d.ts",
+  homepage: "https://github.com/FlashingChen2024/chattercatcher#readme",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/FlashingChen2024/chattercatcher.git"
+  },
+  bugs: {
+    url: "https://github.com/FlashingChen2024/chattercatcher/issues"
+  },
+  bin: {
+    chattercatcher: "dist/cli.js"
+  },
+  files: [
+    "assets",
+    "dist",
+    "docs",
+    "README.md",
+    "AGENTS.md"
+  ],
+  directories: {
+    doc: "docs"
+  },
+  scripts: {
+    build: "tsup",
+    dev: "tsx src/cli.ts",
+    lint: "tsc --noEmit",
+    typecheck: "tsc --noEmit",
+    test: "vitest run"
+  },
+  keywords: [
+    "feishu",
+    "lark",
+    "rag",
+    "local-first",
+    "knowledge-base"
+  ],
+  author: "FlashingChen2024",
+  license: "MIT",
+  dependencies: {
+    "@inquirer/prompts": "^8.4.2",
+    "@lancedb/lancedb": "0.23.0",
+    "@larksuiteoapi/node-sdk": "^1.62.0",
+    "better-sqlite3": "^12.9.0",
+    commander: "^14.0.3",
+    fastify: "^5.8.5",
+    mammoth: "^1.12.0",
+    "pdf-parse": "^2.4.5",
+    pino: "^10.3.1",
+    zod: "^4.3.6"
+  },
+  devDependencies: {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^25.6.0",
+    "@types/yazl": "^3.3.1",
+    tsup: "^8.5.1",
+    tsx: "^4.21.0",
+    typescript: "^6.0.3",
+    vitest: "^4.1.5",
+    yazl: "^3.3.1"
+  }
+};
 
 // src/config/store.ts
 import fs from "fs/promises";
@@ -72,29 +287,8 @@ function createDefaultSecrets() {
   });
 }
 
-// src/config/paths.ts
-import os2 from "os";
-import path2 from "path";
-function getChatterCatcherHome() {
-  return process.env.CHATTERCATCHER_HOME || path2.join(os2.homedir(), ".chattercatcher");
-}
-function resolveHomePath(value) {
-  if (value === "~") {
-    return os2.homedir();
-  }
-  if (value.startsWith("~/") || value.startsWith("~\\")) {
-    return path2.join(os2.homedir(), value.slice(2));
-  }
-  return path2.resolve(value);
-}
-function getConfigPath() {
-  return path2.join(getChatterCatcherHome(), "config.json");
-}
-function getSecretsPath() {
-  return path2.join(getChatterCatcherHome(), "secrets.json");
-}
-
 // src/config/store.ts
+init_paths();
 async function readJsonFile(filePath, fallback) {
   try {
     const raw = await fs.readFile(filePath, "utf8");
@@ -157,7 +351,11 @@ function resolveEmbeddingApiKey(input2) {
   return explicit || input2.llmApiKey;
 }
 
+// src/cli.ts
+init_paths();
+
 // src/data/deletion.ts
+init_paths();
 import fs2 from "fs/promises";
 import path4 from "path";
 function emptyResult(targetType, targetId) {
@@ -283,6 +481,7 @@ async function deleteLocalData(input2) {
 }
 
 // src/db/database.ts
+init_paths();
 import Database from "better-sqlite3";
 import fs3 from "fs";
 import path5 from "path";
@@ -343,13 +542,6 @@ function migrateDatabase(database) {
       tokenize = 'unicode61'
     );
 
-    CREATE TABLE IF NOT EXISTS message_chunk_vectors (
-      chunk_id TEXT PRIMARY KEY REFERENCES message_chunks(id) ON DELETE CASCADE,
-      vector_json TEXT NOT NULL,
-      evidence_json TEXT NOT NULL,
-      updated_at TEXT NOT NULL
-    );
-
     CREATE TABLE IF NOT EXISTS file_jobs (
       id TEXT PRIMARY KEY,
       source_path TEXT NOT NULL,
@@ -369,7 +561,8 @@ function migrateDatabase(database) {
 }
 
 // src/doctor/checks.ts
-import fs5 from "fs/promises";
+init_paths();
+import fs7 from "fs/promises";
 
 // src/files/jobs.ts
 import crypto from "crypto";
@@ -511,10 +704,120 @@ var FileJobRepository = class {
 };
 
 // src/gateway/runtime.ts
-import fs4 from "fs";
+init_paths();
+import fs5 from "fs";
+import path8 from "path";
+
+// src/logs/reader.ts
+init_paths();
+import fs4 from "fs/promises";
+import { watch } from "fs";
 import path7 from "path";
+function getLogsDirectory() {
+  return path7.join(getChatterCatcherHome(), "logs");
+}
+function resolveLogPath(fileName, logsDir = getLogsDirectory()) {
+  return path7.isAbsolute(fileName) ? fileName : path7.join(logsDir, fileName);
+}
+function normalizeLineCount(value, fallback = 200) {
+  const parsed = Number(value ?? fallback);
+  return Number.isFinite(parsed) ? Math.min(Math.max(Math.trunc(parsed), 1), 1e4) : fallback;
+}
+async function listLogFiles(logsDir = getLogsDirectory()) {
+  let entries;
+  try {
+    entries = await fs4.readdir(logsDir, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+  const files2 = await Promise.all(
+    entries.filter((entry) => entry.isFile() && entry.name.endsWith(".log")).map(async (entry) => {
+      const filePath = path7.join(logsDir, entry.name);
+      const stats = await fs4.stat(filePath);
+      return {
+        name: entry.name,
+        path: filePath,
+        updatedAt: stats.mtime,
+        bytes: stats.size
+      };
+    })
+  );
+  return files2.sort((left, right) => right.updatedAt.getTime() - left.updatedAt.getTime());
+}
+function tailLines(content, lines) {
+  const normalized = content.replace(/\r\n/g, "\n");
+  const parts = normalized.endsWith("\n") ? normalized.slice(0, -1).split("\n") : normalized.split("\n");
+  return parts.slice(-lines).join("\n");
+}
+async function readLogTail(input2) {
+  const stats = await fs4.stat(input2.filePath);
+  const content = await fs4.readFile(input2.filePath, "utf8");
+  return {
+    file: {
+      name: path7.basename(input2.filePath),
+      path: input2.filePath,
+      updatedAt: stats.mtime,
+      bytes: stats.size
+    },
+    content: tailLines(content, normalizeLineCount(input2.lines))
+  };
+}
+async function readLatestLogTail(input2 = {}) {
+  if (input2.fileName) {
+    return readLogTail({
+      filePath: resolveLogPath(input2.fileName, input2.logsDir),
+      lines: input2.lines
+    });
+  }
+  const [latest] = await listLogFiles(input2.logsDir);
+  if (!latest) {
+    return null;
+  }
+  return readLogTail({ filePath: latest.path, lines: input2.lines });
+}
+async function followLogFile(input2) {
+  let offset = (await fs4.stat(input2.filePath)).size;
+  const directory = path7.dirname(input2.filePath);
+  const fileName = path7.basename(input2.filePath);
+  async function readAppended() {
+    const stats = await fs4.stat(input2.filePath);
+    if (stats.size < offset) {
+      offset = 0;
+    }
+    if (stats.size === offset) {
+      return;
+    }
+    const handle = await fs4.open(input2.filePath, "r");
+    try {
+      const length = stats.size - offset;
+      const buffer = Buffer.alloc(length);
+      await handle.read(buffer, 0, length, offset);
+      offset = stats.size;
+      input2.onChunk(buffer.toString("utf8"));
+    } finally {
+      await handle.close();
+    }
+  }
+  const watcher = watch(directory, (eventType, changedFileName) => {
+    if (eventType !== "change" || changedFileName?.toString() !== fileName) {
+      return;
+    }
+    void readAppended().catch((error) => {
+      input2.onError?.(error instanceof Error ? error : new Error(String(error)));
+    });
+  });
+  return () => watcher.close();
+}
+
+// src/gateway/runtime.ts
 function getGatewayPidPath() {
-  return path7.join(getChatterCatcherHome(), "gateway.pid");
+  return path8.join(getChatterCatcherHome(), "gateway.pid");
+}
+function getGatewayLogPath() {
+  return path8.join(getLogsDirectory(), "gateway.log");
 }
 function isProcessRunning(pid) {
   if (!Number.isInteger(pid) || pid <= 0) {
@@ -529,7 +832,7 @@ function isProcessRunning(pid) {
 }
 function readGatewayPidRecord(pidFile = getGatewayPidPath()) {
   try {
-    const raw = fs4.readFileSync(pidFile, "utf8");
+    const raw = fs5.readFileSync(pidFile, "utf8");
     const parsed = JSON.parse(raw);
     if (!Number.isInteger(parsed.pid) || typeof parsed.startedAt !== "string" || typeof parsed.command !== "string") {
       return null;
@@ -541,7 +844,9 @@ function readGatewayPidRecord(pidFile = getGatewayPidPath()) {
     return {
       pid,
       startedAt: parsed.startedAt,
-      command: parsed.command
+      command: parsed.command,
+      ...typeof parsed.logFile === "string" ? { logFile: parsed.logFile } : {},
+      ...parsed.mode === "gateway" || parsed.mode === "web" ? { mode: parsed.mode } : {}
     };
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -555,13 +860,13 @@ function writeGatewayPidRecord(pidFile = getGatewayPidPath(), record = {
   startedAt: (/* @__PURE__ */ new Date()).toISOString(),
   command: process.argv.join(" ")
 }) {
-  fs4.mkdirSync(path7.dirname(pidFile), { recursive: true });
-  fs4.writeFileSync(pidFile, `${JSON.stringify(record, null, 2)}
+  fs5.mkdirSync(path8.dirname(pidFile), { recursive: true });
+  fs5.writeFileSync(pidFile, `${JSON.stringify(record, null, 2)}
 `, "utf8");
 }
 function removeGatewayPidRecord(pidFile = getGatewayPidPath()) {
   try {
-    fs4.rmSync(pidFile, { force: true });
+    fs5.rmSync(pidFile, { force: true });
   } catch {
   }
 }
@@ -613,6 +918,28 @@ function stopGatewayProcess(pidFile = getGatewayPidPath()) {
 
 // src/gateway/index.ts
 function getGatewayStatus(config, secrets) {
+  const runtime = getGatewayRuntimeState();
+  const configured = Boolean(config.feishu.appId && (!secrets || secrets.feishu.appSecret));
+  if (runtime.running && runtime.record) {
+    if (runtime.record.mode === "web" && !configured) {
+      return {
+        configured,
+        connection: "running",
+        message: `\u672C\u5730 Web UI \u8FDB\u7A0B\u6B63\u5728\u8FD0\u884C\uFF1Apid=${runtime.record.pid}\uFF0CstartedAt=${runtime.record.startedAt}\uFF1B\u98DE\u4E66\u914D\u7F6E\u5C1A\u672A\u5B8C\u6210\u3002`,
+        pid: runtime.record.pid,
+        pidFile: runtime.pidFile,
+        logFile: runtime.record.logFile
+      };
+    }
+    return {
+      configured: true,
+      connection: "running",
+      message: `\u98DE\u4E66 Gateway \u6B63\u5728\u8FD0\u884C\uFF1Apid=${runtime.record.pid}\uFF0CstartedAt=${runtime.record.startedAt}`,
+      pid: runtime.record.pid,
+      pidFile: runtime.pidFile,
+      logFile: runtime.record.logFile
+    };
+  }
   if (!config.feishu.appId) {
     return {
       configured: false,
@@ -627,23 +954,14 @@ function getGatewayStatus(config, secrets) {
       message: "\u5C1A\u672A\u914D\u7F6E\u98DE\u4E66 App Secret\u3002\u8BF7\u8FD0\u884C chattercatcher setup \u6216 chattercatcher settings\u3002"
     };
   }
-  const runtime = getGatewayRuntimeState();
-  if (runtime.running && runtime.record) {
-    return {
-      configured: true,
-      connection: "running",
-      message: `\u98DE\u4E66 Gateway \u6B63\u5728\u8FD0\u884C\uFF1Apid=${runtime.record.pid}\uFF0CstartedAt=${runtime.record.startedAt}`,
-      pid: runtime.record.pid,
-      pidFile: runtime.pidFile
-    };
-  }
   if (runtime.stale && runtime.record) {
     return {
       configured: true,
       connection: "ready_for_start",
       message: `\u98DE\u4E66\u957F\u8FDE\u63A5\u914D\u7F6E\u5DF2\u5C31\u7EEA\uFF1B\u53D1\u73B0\u8FC7\u671F PID \u6587\u4EF6\uFF1Apid=${runtime.record.pid}\u3002\u8FD0\u884C chattercatcher gateway start \u4F1A\u8986\u76D6\u8FD0\u884C\u8BB0\u5F55\u3002`,
       pid: runtime.record.pid,
-      pidFile: runtime.pidFile
+      pidFile: runtime.pidFile,
+      logFile: runtime.record.logFile
     };
   }
   return {
@@ -1140,82 +1458,6 @@ var MessageFtsRetriever = class {
   }
 };
 
-// src/rag/embedding.ts
-function cosineSimilarity(left, right) {
-  if (left.length === 0 || right.length === 0 || left.length !== right.length) {
-    return 0;
-  }
-  let dot = 0;
-  let leftNorm = 0;
-  let rightNorm = 0;
-  for (let index2 = 0; index2 < left.length; index2 += 1) {
-    const leftValue = left[index2] ?? 0;
-    const rightValue = right[index2] ?? 0;
-    dot += leftValue * rightValue;
-    leftNorm += leftValue * leftValue;
-    rightNorm += rightValue * rightValue;
-  }
-  if (leftNorm === 0 || rightNorm === 0) {
-    return 0;
-  }
-  return dot / (Math.sqrt(leftNorm) * Math.sqrt(rightNorm));
-}
-
-// src/rag/sqlite-vector-store.ts
-var SQLiteVectorStore = class {
-  constructor(database) {
-    this.database = database;
-  }
-  database;
-  async upsert(records) {
-    if (records.length === 0) {
-      return;
-    }
-    const statement = this.database.prepare(`
-      INSERT INTO message_chunk_vectors (chunk_id, vector_json, evidence_json, updated_at)
-      VALUES (@chunkId, @vectorJson, @evidenceJson, @updatedAt)
-      ON CONFLICT(chunk_id) DO UPDATE SET
-        vector_json = excluded.vector_json,
-        evidence_json = excluded.evidence_json,
-        updated_at = excluded.updated_at
-    `);
-    const upsertMany = this.database.transaction((items) => {
-      const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-      for (const item of items) {
-        statement.run({
-          chunkId: item.id,
-          vectorJson: JSON.stringify(item.vector),
-          evidenceJson: JSON.stringify(item.evidence),
-          updatedAt
-        });
-      }
-    });
-    upsertMany(records);
-  }
-  async search(vector, limit) {
-    if (limit <= 0) {
-      return [];
-    }
-    const rows = this.database.prepare("SELECT chunk_id, vector_json, evidence_json FROM message_chunk_vectors").all();
-    return rows.map((row) => {
-      const storedVector = JSON.parse(row.vector_json);
-      const evidence = JSON.parse(row.evidence_json);
-      const vectorScore = cosineSimilarity(vector, storedVector);
-      return {
-        ...evidence,
-        score: vectorScore,
-        vectorScore
-      };
-    }).sort((left, right) => right.vectorScore - left.vectorScore).slice(0, limit);
-  }
-  async count() {
-    const row = this.database.prepare("SELECT COUNT(*) AS count FROM message_chunk_vectors").get();
-    return row.count;
-  }
-  close() {
-  }
-};
-
 // src/rag/vector-retriever.ts
 var VectorRetriever = class {
   constructor(embedding, store, limit = 8) {
@@ -1240,7 +1482,8 @@ async function createHybridRetriever(input2) {
   const retrievers = [new MessageFtsRetriever(input2.messages, { excludeMessageIds: input2.excludeMessageIds })];
   const closers = [];
   if (hasEmbeddingConfig(input2.config, input2.secrets)) {
-    const vectorStore = new SQLiteVectorStore(input2.messages.database);
+    const { LanceDbVectorStore: LanceDbVectorStore2 } = await Promise.resolve().then(() => (init_lancedb_store(), lancedb_store_exports));
+    const vectorStore = await LanceDbVectorStore2.connectFromConfig(input2.config);
     retrievers.push(new VectorRetriever(createEmbeddingModel(input2.config, input2.secrets), vectorStore));
     closers.push(() => vectorStore.close());
   }
@@ -1272,7 +1515,7 @@ async function runDoctor(config, secrets, options = {}) {
   checks.push(checkEmbeddingConfig(config, secrets));
   checks.push(await checkSqlite(config));
   checks.push(await checkFilePipeline(config));
-  checks.push(await checkSqliteVector(config));
+  checks.push(await checkLanceDb(config));
   checks.push(checkRagPolicy());
   if (options.online) {
     checks.push(await checkChatModel(config, secrets));
@@ -1283,8 +1526,8 @@ async function runDoctor(config, secrets, options = {}) {
 async function checkHomeDirectory() {
   const home = getChatterCatcherHome();
   try {
-    await fs5.mkdir(home, { recursive: true });
-    await fs5.access(home);
+    await fs7.mkdir(home, { recursive: true });
+    await fs7.access(home);
     return pass("\u914D\u7F6E\u76EE\u5F55", home);
   } catch (error) {
     return fail("\u914D\u7F6E\u76EE\u5F55", error instanceof Error ? error.message : String(error));
@@ -1305,7 +1548,7 @@ function checkLlmConfig(config, secrets) {
 }
 function checkEmbeddingConfig(config, secrets) {
   if (!hasEmbeddingConfig(config, secrets)) {
-    return warn("Embedding \u914D\u7F6E", "\u672A\u914D\u7F6E\u5B8C\u6574\uFF1BRAG \u4F1A\u4F7F\u7528 SQLite FTS\uFF0C\u65E0\u6CD5\u4F7F\u7528 SQLite Vector \u8BED\u4E49\u68C0\u7D22\u3002");
+    return warn("Embedding \u914D\u7F6E", "\u672A\u914D\u7F6E\u5B8C\u6574\uFF1BRAG \u4F1A\u4F7F\u7528 SQLite FTS\uFF0C\u65E0\u6CD5\u4F7F\u7528 LanceDB \u8BED\u4E49\u68C0\u7D22\u3002");
   }
   return pass("Embedding \u914D\u7F6E", `${config.embedding.model} @ ${config.embedding.baseUrl || config.llm.baseUrl}`);
 }
@@ -1339,17 +1582,17 @@ async function checkFilePipeline(config) {
     database?.close();
   }
 }
-async function checkSqliteVector(config) {
-  let database = null;
+async function checkLanceDb(config) {
+  let store = null;
   try {
-    database = openDatabase(config);
-    const store = new SQLiteVectorStore(database);
+    const { getLanceDbPath: getLanceDbPath2, LanceDbVectorStore: LanceDbVectorStore2 } = await Promise.resolve().then(() => (init_lancedb_store(), lancedb_store_exports));
+    store = await LanceDbVectorStore2.connectFromConfig(config);
     const count = await store.count();
-    return pass("SQLite Vector", `${getDatabasePath(config)}\uFF1Bvectors=${count}`);
+    return pass("LanceDB", `${getLanceDbPath2(config)}\uFF1Bvectors=${count}`);
   } catch (error) {
-    return fail("SQLite Vector", error instanceof Error ? error.message : String(error));
+    return fail("LanceDB", error instanceof Error ? error.message : String(error));
   } finally {
-    database?.close();
+    store?.close();
   }
 }
 function checkRagPolicy() {
@@ -1390,8 +1633,9 @@ function formatDoctorChecks(checks) {
 }
 
 // src/export/data-export.ts
-import fs6 from "fs/promises";
-import path8 from "path";
+init_paths();
+import fs8 from "fs/promises";
+import path10 from "path";
 function parseJsonObject(value) {
   try {
     const parsed = JSON.parse(value);
@@ -1410,11 +1654,11 @@ function parseJsonArray(value) {
 }
 function defaultExportPath(config, exportedAt) {
   const fileName = `chattercatcher-export-${exportedAt.replace(/[:.]/g, "-")}.json`;
-  return path8.join(resolveHomePath(config.storage.dataDir), "exports", fileName);
+  return path10.join(resolveHomePath(config.storage.dataDir), "exports", fileName);
 }
 async function exportLocalData(input2) {
   const exportedAt = input2.exportedAt ?? (/* @__PURE__ */ new Date()).toISOString();
-  const outputPath = path8.resolve(input2.outputPath ?? defaultExportPath(input2.config, exportedAt));
+  const outputPath = path10.resolve(input2.outputPath ?? defaultExportPath(input2.config, exportedAt));
   const chats = input2.database.prepare(
     `
       SELECT
@@ -1501,8 +1745,8 @@ async function exportLocalData(input2) {
       fileJobs
     }
   };
-  await fs6.mkdir(path8.dirname(outputPath), { recursive: true });
-  await fs6.writeFile(outputPath, `${JSON.stringify(payload, null, 2)}
+  await fs8.mkdir(path10.dirname(outputPath), { recursive: true });
+  await fs8.writeFile(outputPath, `${JSON.stringify(payload, null, 2)}
 `, "utf8");
   return {
     outputPath,
@@ -1514,8 +1758,8 @@ async function exportLocalData(input2) {
 }
 
 // src/export/data-restore.ts
-import fs7 from "fs/promises";
-import path9 from "path";
+import fs9 from "fs/promises";
+import path11 from "path";
 function asObject(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
@@ -1563,8 +1807,8 @@ function clearDatabase(database) {
   database.prepare("DELETE FROM chats").run();
 }
 async function restoreLocalData(input2) {
-  const inputPath = path9.resolve(input2.inputPath);
-  const payload = parsePayload(await fs7.readFile(inputPath, "utf8"));
+  const inputPath = path11.resolve(input2.inputPath);
+  const payload = parsePayload(await fs9.readFile(inputPath, "utf8"));
   const mode = input2.replace ? "replace" : "merge";
   const restore = input2.database.transaction(() => {
     if (input2.replace) {
@@ -2156,9 +2400,10 @@ function createFeishuGateway(options) {
 }
 
 // src/feishu/resource-downloader.ts
+init_paths();
 import * as lark3 from "@larksuiteoapi/node-sdk";
-import fs8 from "fs/promises";
-import path10 from "path";
+import fs10 from "fs/promises";
+import path12 from "path";
 var RESOURCE_TYPE_BY_KIND = {
   file: "file",
   image: "image",
@@ -2196,10 +2441,10 @@ var FeishuResourceDownloader = class _FeishuResourceDownloader {
   }
   async download(input2) {
     const resourceType = RESOURCE_TYPE_BY_KIND[input2.attachment.kind];
-    const targetDir = path10.join(this.dataDir, "files", "feishu");
-    await fs8.mkdir(targetDir, { recursive: true });
+    const targetDir = path12.join(this.dataDir, "files", "feishu");
+    await fs10.mkdir(targetDir, { recursive: true });
     const fileName = buildStoredFileName(input2);
-    const storedPath = path10.join(targetDir, fileName);
+    const storedPath = path12.join(targetDir, fileName);
     const payload = {
       params: { type: resourceType },
       path: { message_id: input2.messageId, file_key: input2.attachment.fileKey }
@@ -2221,30 +2466,31 @@ var FeishuResourceDownloader = class _FeishuResourceDownloader {
 };
 
 // src/files/ingest.ts
+init_paths();
 import crypto3 from "crypto";
-import fs10 from "fs/promises";
-import path12 from "path";
+import fs12 from "fs/promises";
+import path14 from "path";
 
 // src/files/parser.ts
-import fs9 from "fs/promises";
-import path11 from "path";
+import fs11 from "fs/promises";
+import path13 from "path";
 import mammoth from "mammoth";
 import { PDFParse } from "pdf-parse";
 var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([".txt", ".md", ".markdown", ".json", ".csv", ".tsv", ".log"]);
 var DOCX_EXTENSIONS = /* @__PURE__ */ new Set([".docx"]);
 var PDF_EXTENSIONS = /* @__PURE__ */ new Set([".pdf"]);
 function isSupportedParseFile(filePath) {
-  const extension = path11.extname(filePath).toLowerCase();
+  const extension = path13.extname(filePath).toLowerCase();
   return TEXT_EXTENSIONS.has(extension) || DOCX_EXTENSIONS.has(extension) || PDF_EXTENSIONS.has(extension);
 }
 function describeSupportedParseTypes() {
   return "txt\u3001md\u3001json\u3001csv\u3001tsv\u3001log\u3001docx\u3001pdf";
 }
 async function parseFileToText(filePath) {
-  const extension = path11.extname(filePath).toLowerCase();
+  const extension = path13.extname(filePath).toLowerCase();
   if (TEXT_EXTENSIONS.has(extension)) {
     return {
-      text: await fs9.readFile(filePath, "utf8"),
+      text: await fs11.readFile(filePath, "utf8"),
       parser: "text",
       warnings: []
     };
@@ -2258,7 +2504,7 @@ async function parseFileToText(filePath) {
     };
   }
   if (PDF_EXTENSIONS.has(extension)) {
-    const buffer = await fs9.readFile(filePath);
+    const buffer = await fs11.readFile(filePath);
     const parser = new PDFParse({ data: buffer });
     try {
       const result = await parser.getText();
@@ -2280,7 +2526,7 @@ function isSupportedTextFile(filePath) {
 }
 function ensureSupportedTextFile(filePath) {
   if (!isSupportedTextFile(filePath)) {
-    const extension = path12.extname(filePath).toLowerCase();
+    const extension = path14.extname(filePath).toLowerCase();
     throw new Error(`\u6682\u4E0D\u652F\u6301\u8BE5\u6587\u4EF6\u7C7B\u578B\uFF1A${extension || "\u65E0\u6269\u5C55\u540D"}\u3002\u5F53\u524D\u652F\u6301 ${describeSupportedParseTypes()}\u3002`);
   }
 }
@@ -2289,12 +2535,12 @@ function stableStoredName(sourcePath, fileName) {
   return `${digest}-${fileName}`;
 }
 async function ingestLocalFile(input2) {
-  const sourcePath = path12.resolve(input2.filePath);
-  const fileName = path12.basename(sourcePath);
+  const sourcePath = path14.resolve(input2.filePath);
+  const fileName = path14.basename(sourcePath);
   const jobId = input2.jobs?.start({ sourcePath, fileName });
   try {
     ensureSupportedTextFile(sourcePath);
-    const stat = await fs10.stat(sourcePath);
+    const stat = await fs12.stat(sourcePath);
     if (!stat.isFile()) {
       throw new Error(`\u4E0D\u662F\u6587\u4EF6\uFF1A${sourcePath}`);
     }
@@ -2303,10 +2549,10 @@ async function ingestLocalFile(input2) {
     if (!text) {
       throw new Error(`\u6587\u4EF6\u6CA1\u6709\u53EF\u7D22\u5F15\u6587\u672C\uFF1A${sourcePath}`);
     }
-    const fileDir = path12.join(resolveHomePath(input2.config.storage.dataDir), "files");
-    await fs10.mkdir(fileDir, { recursive: true });
-    const storedPath = path12.join(fileDir, stableStoredName(sourcePath, fileName));
-    await fs10.copyFile(sourcePath, storedPath);
+    const fileDir = path14.join(resolveHomePath(input2.config.storage.dataDir), "files");
+    await fs12.mkdir(fileDir, { recursive: true });
+    const storedPath = path14.join(fileDir, stableStoredName(sourcePath, fileName));
+    await fs12.copyFile(sourcePath, storedPath);
     const messageId = input2.messages.ingest({
       platform: "local-file",
       platformChatId: "local-files",
@@ -2587,107 +2833,72 @@ var GatewayIngestor = class {
   }
 };
 
-// src/logs/reader.ts
-import fs11 from "fs/promises";
-import { watch } from "fs";
-import path13 from "path";
-function getLogsDirectory() {
-  return path13.join(getChatterCatcherHome(), "logs");
-}
-function resolveLogPath(fileName, logsDir = getLogsDirectory()) {
-  return path13.isAbsolute(fileName) ? fileName : path13.join(logsDir, fileName);
-}
-function normalizeLineCount(value, fallback = 200) {
-  const parsed = Number(value ?? fallback);
-  return Number.isFinite(parsed) ? Math.min(Math.max(Math.trunc(parsed), 1), 1e4) : fallback;
-}
-async function listLogFiles(logsDir = getLogsDirectory()) {
-  let entries;
-  try {
-    entries = await fs11.readdir(logsDir, { withFileTypes: true });
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return [];
-    }
-    throw error;
+// src/gateway/detached.ts
+import { spawn } from "child_process";
+import fs13 from "fs";
+import path15 from "path";
+function buildGatewayForegroundSpawnCommand(argv = process.argv) {
+  const [command = process.execPath, ...rawArgs] = argv;
+  const args = [...rawArgs];
+  while (args.at(-1) === "--foreground") {
+    args.pop();
+  }
+  if (args.at(-1) === "start" && args.at(-2) === "gateway") {
+    args.splice(-2, 2);
   }
-  const files2 = await Promise.all(
-    entries.filter((entry) => entry.isFile() && entry.name.endsWith(".log")).map(async (entry) => {
-      const filePath = path13.join(logsDir, entry.name);
-      const stats = await fs11.stat(filePath);
-      return {
-        name: entry.name,
-        path: filePath,
-        updatedAt: stats.mtime,
-        bytes: stats.size
-      };
-    })
-  );
-  return files2.sort((left, right) => right.updatedAt.getTime() - left.updatedAt.getTime());
-}
-function tailLines(content, lines) {
-  const normalized = content.replace(/\r\n/g, "\n");
-  const parts = normalized.endsWith("\n") ? normalized.slice(0, -1).split("\n") : normalized.split("\n");
-  return parts.slice(-lines).join("\n");
-}
-async function readLogTail(input2) {
-  const stats = await fs11.stat(input2.filePath);
-  const content = await fs11.readFile(input2.filePath, "utf8");
   return {
-    file: {
-      name: path13.basename(input2.filePath),
-      path: input2.filePath,
-      updatedAt: stats.mtime,
-      bytes: stats.size
-    },
-    content: tailLines(content, normalizeLineCount(input2.lines))
+    command,
+    args: [...args, "gateway", "start", "--foreground"]
   };
 }
-async function readLatestLogTail(input2 = {}) {
-  if (input2.fileName) {
-    return readLogTail({
-      filePath: resolveLogPath(input2.fileName, input2.logsDir),
-      lines: input2.lines
-    });
-  }
-  const [latest] = await listLogFiles(input2.logsDir);
-  if (!latest) {
-    return null;
+function startDetachedGateway(input2) {
+  const status = getGatewayStatus(input2.config, input2.secrets);
+  const logFile = getGatewayLogPath();
+  if (status.connection === "running") {
+    return {
+      started: false,
+      message: `\u98DE\u4E66 Gateway \u5DF2\u7ECF\u6B63\u5728\u8FD0\u884C\uFF1Apid=${status.pid ?? "unknown"}`,
+      logFile,
+      ...status.pid ? { pid: status.pid } : {}
+    };
   }
-  return readLogTail({ filePath: latest.path, lines: input2.lines });
-}
-async function followLogFile(input2) {
-  let offset = (await fs11.stat(input2.filePath)).size;
-  const directory = path13.dirname(input2.filePath);
-  const fileName = path13.basename(input2.filePath);
-  async function readAppended() {
-    const stats = await fs11.stat(input2.filePath);
-    if (stats.size < offset) {
-      offset = 0;
-    }
-    if (stats.size === offset) {
+  fs13.mkdirSync(path15.dirname(logFile), { recursive: true });
+  let out;
+  let err;
+  let stdioClosed = false;
+  const closeStdio = () => {
+    if (stdioClosed) {
       return;
     }
-    const handle = await fs11.open(input2.filePath, "r");
-    try {
-      const length = stats.size - offset;
-      const buffer = Buffer.alloc(length);
-      await handle.read(buffer, 0, length, offset);
-      offset = stats.size;
-      input2.onChunk(buffer.toString("utf8"));
-    } finally {
-      await handle.close();
+    stdioClosed = true;
+    if (typeof out === "number") {
+      fs13.closeSync(out);
     }
-  }
-  const watcher = watch(directory, (eventType, changedFileName) => {
-    if (eventType !== "change" || changedFileName?.toString() !== fileName) {
-      return;
+    if (typeof err === "number") {
+      fs13.closeSync(err);
     }
-    void readAppended().catch((error) => {
-      input2.onError?.(error instanceof Error ? error : new Error(String(error)));
+  };
+  try {
+    out = fs13.openSync(logFile, "a");
+    err = fs13.openSync(logFile, "a");
+    const foreground = buildGatewayForegroundSpawnCommand(input2.argv);
+    const child = spawn(foreground.command, foreground.args, {
+      detached: true,
+      stdio: ["ignore", out, err],
+      windowsHide: true
     });
-  });
-  return () => watcher.close();
+    closeStdio();
+    child.unref();
+    return {
+      started: true,
+      message: `\u5DF2\u5728\u540E\u53F0\u542F\u52A8\u98DE\u4E66 Gateway\uFF1Apid=${child.pid}`,
+      pid: child.pid,
+      logFile
+    };
+  } catch (error) {
+    closeStdio();
+    throw error;
+  }
 }
 
 // src/rag/indexer.ts
@@ -2749,7 +2960,8 @@ async function processMessagesNow(input2) {
       finishedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
   }
-  const vectorStore = new SQLiteVectorStore(input2.database);
+  const { LanceDbVectorStore: LanceDbVectorStore2 } = await Promise.resolve().then(() => (init_lancedb_store(), lancedb_store_exports));
+  const vectorStore = await LanceDbVectorStore2.connectFromConfig(input2.config);
   try {
     const stats = await indexMessageChunks({
       messages: new MessageRepository(input2.database),
@@ -2769,6 +2981,108 @@ async function processMessagesNow(input2) {
   }
 }
 
+// src/update/npm-updater.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var packageName = "chattercatcher";
+var installArgs = ["install", "-g", `${packageName}@latest`];
+var latestVersionArgs = ["view", packageName, "version", "--json"];
+function formatCommand(command, args) {
+  return [command, ...args].join(" ");
+}
+function getErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function parseLatestVersion(stdout) {
+  const trimmed = stdout.trim();
+  if (!trimmed) {
+    throw new Error("npm registry returned an empty version");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    throw new Error("npm registry returned an invalid version");
+  }
+  if (typeof parsed !== "string" || !parsed) {
+    throw new Error("npm registry returned an invalid version");
+  }
+  return parsed;
+}
+function compareVersions(left, right) {
+  const leftParts = left.split(".").map((part) => Number(part));
+  const rightParts = right.split(".").map((part) => Number(part));
+  const length = Math.max(leftParts.length, rightParts.length);
+  for (let index2 = 0; index2 < length; index2 += 1) {
+    const leftPart = leftParts[index2] ?? 0;
+    const rightPart = rightParts[index2] ?? 0;
+    if (leftPart > rightPart) {
+      return 1;
+    }
+    if (leftPart < rightPart) {
+      return -1;
+    }
+  }
+  return 0;
+}
+async function defaultUpdateCommandRunner(command, args) {
+  const { stdout, stderr } = await execFileAsync(command, args);
+  return { stdout, stderr };
+}
+async function updateChatterCatcher(options) {
+  const runner = options.runner ?? defaultUpdateCommandRunner;
+  const command = formatCommand("npm", installArgs);
+  let latestVersion;
+  try {
+    const output = await runner("npm", latestVersionArgs);
+    latestVersion = parseLatestVersion(output.stdout);
+  } catch (error) {
+    return {
+      status: "query-failed",
+      currentVersion: options.currentVersion,
+      command,
+      error: getErrorMessage(error)
+    };
+  }
+  if (compareVersions(latestVersion, options.currentVersion) <= 0) {
+    return {
+      status: "up-to-date",
+      currentVersion: options.currentVersion,
+      latestVersion,
+      command
+    };
+  }
+  if (options.dryRun) {
+    return {
+      status: "dry-run",
+      currentVersion: options.currentVersion,
+      latestVersion,
+      command
+    };
+  }
+  try {
+    await runner("npm", installArgs);
+  } catch (error) {
+    return {
+      status: "install-failed",
+      currentVersion: options.currentVersion,
+      latestVersion,
+      command,
+      error: getErrorMessage(error)
+    };
+  }
+  return {
+    status: "updated",
+    currentVersion: options.currentVersion,
+    latestVersion,
+    command
+  };
+}
+
 // src/web/server.ts
 import Fastify from "fastify";
 function buildHtml() {
@@ -3166,7 +3480,7 @@ function createWebApp(config) {
       note: "\u95EE\u7B54\u5FC5\u987B\u5148\u68C0\u7D22\u8BC1\u636E\uFF0C\u7981\u6B62\u5168\u91CF\u4E0A\u4E0B\u6587\u5806\u53E0\u3002",
       retrieval: {
         keyword: "SQLite FTS5",
-        vector: "SQLite Vector",
+        vector: "LanceDB",
         hybrid: true
       }
     },
@@ -3286,7 +3600,7 @@ function printSettings(config, secrets) {
     2
   ));
 }
-program.name("chattercatcher").description("\u672C\u5730\u4F18\u5148\u7684\u98DE\u4E66/Lark \u5BB6\u5EAD\u7FA4\u77E5\u8BC6\u673A\u5668\u4EBA").version("0.1.6");
+program.name("chattercatcher").description("\u672C\u5730\u4F18\u5148\u7684\u98DE\u4E66/Lark \u5BB6\u5EAD\u7FA4\u77E5\u8BC6\u673A\u5668\u4EBA").version(package_default.version);
 program.command("setup").description("\u4EA4\u4E92\u5F0F\u521D\u59CB\u5316\u914D\u7F6E").action(async () => {
   const { config, secrets } = await ensureConfigFiles();
   await promptForConfiguration(config, secrets);
@@ -3322,19 +3636,60 @@ program.command("doctor").description("\u68C0\u67E5\u672C\u5730\u914D\u7F6E\u300
   const checks = await runDoctor(config, secrets, { online: options.online });
   console.log(formatDoctorChecks(checks));
 });
+program.command("update").description("\u5347\u7EA7 ChatterCatcher \u5230 npm \u6700\u65B0\u7248\u672C").option("--dry-run", "\u53EA\u68C0\u67E5\u5E76\u663E\u793A\u5C06\u6267\u884C\u7684\u5347\u7EA7\u547D\u4EE4").action(async (options) => {
+  const result = await updateChatterCatcher({ currentVersion: package_default.version, dryRun: options.dryRun });
+  if (result.status === "up-to-date") {
+    console.log(`ChatterCatcher \u5DF2\u662F\u6700\u65B0\u7248\u672C\uFF1A${result.currentVersion}`);
+    return;
+  }
+  if (result.status === "dry-run") {
+    console.log(`\u5F53\u524D\u7248\u672C\uFF1A${result.currentVersion}`);
+    console.log(`\u6700\u65B0\u7248\u672C\uFF1A${result.latestVersion}`);
+    console.log(`\u5C06\u6267\u884C\uFF1A${result.command}`);
+    return;
+  }
+  if (result.status === "updated") {
+    console.log(`\u5347\u7EA7\u5B8C\u6210\uFF1A${result.currentVersion} -> ${result.latestVersion}`);
+    console.log("\u8BF7\u91CD\u65B0\u6253\u5F00\u7EC8\u7AEF\u6216\u91CD\u65B0\u8FD0\u884C chattercatcher --version \u786E\u8BA4\u7248\u672C\u3002");
+    return;
+  }
+  if (result.status === "query-failed") {
+    console.error(`\u65E0\u6CD5\u83B7\u53D6\u6700\u65B0\u7248\u672C\uFF1A${result.error}`);
+    process.exitCode = 1;
+    return;
+  }
+  console.error(`\u5347\u7EA7\u5931\u8D25\uFF1A${result.error}`);
+  console.error(`\u53EF\u624B\u52A8\u8FD0\u884C\uFF1A${result.command}`);
+  process.exitCode = 1;
+});
 var gateway = program.command("gateway").description("\u7BA1\u7406\u672C\u5730\u98DE\u4E66 Gateway");
-async function startGatewayCommand() {
+async function startGatewayForegroundCommand() {
   const config = await loadConfig();
   const secrets = await loadSecrets();
   const status = getGatewayStatus(config, secrets);
+  const pidRecordBase = {
+    pid: process.pid,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    command: process.argv.join(" "),
+    logFile: getGatewayLogPath()
+  };
   if (!status.configured) {
+    writeGatewayPidRecord(void 0, {
+      ...pidRecordBase,
+      mode: "web"
+    });
     console.log(status.message);
     console.log("\u672C\u5730 Web UI \u4ECD\u4F1A\u542F\u52A8\uFF0C\u65B9\u4FBF\u7EE7\u7EED\u914D\u7F6E\u3002");
     await startWebServer(config);
     return;
   }
+  writeGatewayPidRecord(void 0, {
+    ...pidRecordBase,
+    mode: "gateway"
+  });
   const database = openDatabase(config);
-  const vectorStore = hasEmbeddingConfig(config, secrets) ? new SQLiteVectorStore(database) : null;
+  const { LanceDbVectorStore: LanceDbVectorStore2 } = hasEmbeddingConfig(config, secrets) ? await Promise.resolve().then(() => (init_lancedb_store(), lancedb_store_exports)) : { LanceDbVectorStore: null };
+  const vectorStore = LanceDbVectorStore2 ? await LanceDbVectorStore2.connectFromConfig(config) : null;
   const gatewayRuntime = createFeishuGateway({
     config,
     secrets,
@@ -3369,7 +3724,6 @@ async function startGatewayCommand() {
     process.exit(0);
   });
   console.log(status.message);
-  writeGatewayPidRecord();
   try {
     await gatewayRuntime.start();
     await startWebServer(config);
@@ -3378,12 +3732,28 @@ async function startGatewayCommand() {
     throw error;
   }
 }
+async function startGatewayCommand(options = {}) {
+  if (options.foreground) {
+    await startGatewayForegroundCommand();
+    return;
+  }
+  const config = await loadConfig();
+  const secrets = await loadSecrets();
+  const result = startDetachedGateway({ config, secrets });
+  console.log(result.message);
+  if (result.pid) {
+    console.log(`PID\uFF1A${result.pid}`);
+  }
+  console.log(`\u65E5\u5FD7\u6587\u4EF6\uFF1A${result.logFile}`);
+  console.log("\u67E5\u770B\u65E5\u5FD7\uFF1Achattercatcher logs --follow --file gateway.log");
+  console.log("\u505C\u6B62 Gateway\uFF1Achattercatcher gateway stop");
+}
 gateway.command("status").description("\u67E5\u770B Gateway \u72B6\u6001").action(async () => {
   const config = await loadConfig();
   const secrets = await loadSecrets();
   console.log(JSON.stringify(getGatewayStatus(config, secrets), null, 2));
 });
-gateway.command("start").description("\u542F\u52A8\u98DE\u4E66\u957F\u8FDE\u63A5 Gateway \u548C\u672C\u5730 Web UI").action(startGatewayCommand);
+gateway.command("start").description("\u542F\u52A8\u98DE\u4E66\u957F\u8FDE\u63A5 Gateway \u548C\u672C\u5730 Web UI").option("--foreground", "\u5728\u5F53\u524D\u7EC8\u7AEF\u4EE5\u524D\u53F0\u6A21\u5F0F\u8FD0\u884C").action(startGatewayCommand);
 gateway.command("stop").description("\u505C\u6B62 Gateway").action(() => {
   console.log(stopGatewayProcess().message);
 });
@@ -3419,7 +3789,7 @@ async function deleteDataCommand(targetType, targetId, options) {
     if (result.skippedStoredFiles.length > 0) {
       console.log(`\u8DF3\u8FC7\u975E\u6570\u636E\u76EE\u5F55\u6587\u4EF6\uFF1A${result.skippedStoredFiles.join("\uFF1B")}`);
     }
-    console.log("SQLite FTS \u5DF2\u540C\u6B65\u5220\u9664\uFF1B\u5982\u4F7F\u7528\u8BED\u4E49\u68C0\u7D22\uFF0C\u8BF7\u8FD0\u884C chattercatcher index rebuild \u91CD\u5EFA SQLite Vector\u3002");
+    console.log("SQLite FTS \u5DF2\u540C\u6B65\u5220\u9664\uFF1B\u5982\u4F7F\u7528 LanceDB \u8BED\u4E49\u68C0\u7D22\uFF0C\u8BF7\u8FD0\u884C chattercatcher index rebuild\u3002");
   } finally {
     database.close();
   }
@@ -3434,19 +3804,20 @@ index.command("status").description("\u67E5\u770B\u7D22\u5F15\u72B6\u6001").acti
   const secrets = await loadSecrets();
   const database = openDatabase(config);
   const messages = new MessageRepository(database);
-  const vectorStore = new SQLiteVectorStore(database);
+  const { getLanceDbPath: getLanceDbPath2, LanceDbVectorStore: LanceDbVectorStore2 } = await Promise.resolve().then(() => (init_lancedb_store(), lancedb_store_exports));
+  const vectorStore = await LanceDbVectorStore2.connectFromConfig(config);
   const vectors = await vectorStore.count();
   console.log(JSON.stringify(
     {
       database: getDatabasePath(config),
-      vectorDatabase: getDatabasePath(config),
+      vectorDatabase: getLanceDbPath2(config),
       chats: messages.getChatCount(),
       messages: messages.getMessageCount(),
       vectors,
       retrieval: {
         keyword: "SQLite FTS5",
-        vector: hasEmbeddingConfig(config, secrets) ? "SQLite Vector \u5DF2\u53EF\u7528\u4E8E\u8BED\u4E49\u68C0\u7D22" : "SQLite Vector \u5DF2\u63A5\u5165\uFF1B\u9700\u914D\u7F6E embedding \u540E\u542F\u7528\u8BED\u4E49\u68C0\u7D22",
-        hybrid: "\u542F\u7528\uFF1ASQLite FTS + SQLite Vector",
+        vector: hasEmbeddingConfig(config, secrets) ? "LanceDB \u5DF2\u53EF\u7528\u4E8E\u8BED\u4E49\u68C0\u7D22" : "LanceDB \u5DF2\u63A5\u5165\uFF1B\u9700\u914D\u7F6E embedding \u540E\u542F\u7528\u8BED\u4E49\u68C0\u7D22",
+        hybrid: "\u542F\u7528\uFF1ASQLite FTS + LanceDB Vector",
         rag: "\u5F3A\u5236\u5148\u68C0\u7D22\u8BC1\u636E\u518D\u56DE\u7B54\uFF0C\u7981\u6B62\u5168\u91CF\u4E0A\u4E0B\u6587\u5806\u53E0"
       }
     },
@@ -3456,7 +3827,7 @@ index.command("status").description("\u67E5\u770B\u7D22\u5F15\u72B6\u6001").acti
   vectorStore.close();
   database.close();
 });
-index.command("rebuild").description("\u91CD\u5EFA SQLite \u5411\u91CF\u7D22\u5F15").option("--limit <number>", "\u6700\u591A\u7D22\u5F15\u7684 chunk \u6570", "10000").action(async (options) => {
+index.command("rebuild").description("\u91CD\u5EFA LanceDB \u5411\u91CF\u7D22\u5F15").option("--limit <number>", "\u6700\u591A\u7D22\u5F15\u7684 chunk \u6570", "10000").action(async (options) => {
   const config = await loadConfig();
   const secrets = await loadSecrets();
   if (!hasEmbeddingConfig(config, secrets)) {
@@ -3464,7 +3835,8 @@ index.command("rebuild").description("\u91CD\u5EFA SQLite \u5411\u91CF\u7D22\u5F
     return;
   }
   const database = openDatabase(config);
-  const vectorStore = new SQLiteVectorStore(database);
+  const { LanceDbVectorStore: LanceDbVectorStore2 } = await Promise.resolve().then(() => (init_lancedb_store(), lancedb_store_exports));
+  const vectorStore = await LanceDbVectorStore2.connectFromConfig(config);
   try {
     const stats = await indexMessageChunks({
       messages: new MessageRepository(database),
@@ -3479,7 +3851,7 @@ index.command("rebuild").description("\u91CD\u5EFA SQLite \u5411\u91CF\u7D22\u5F
   }
 });
 var processCommand = program.command("process").description("\u7ACB\u5373\u5904\u7406\u540E\u53F0\u4EFB\u52A1");
-processCommand.command("messages").description("\u7ACB\u5373\u5904\u7406\u6D88\u606F\u7D22\u5F15\u4EFB\u52A1\uFF0C\u628A\u6D88\u606F chunks \u5199\u5165 SQLite \u5411\u91CF\u7D22\u5F15").option("--limit <number>", "\u6700\u591A\u5904\u7406\u7684 chunk \u6570", "10000").action(async (options) => {
+processCommand.command("messages").description("\u7ACB\u5373\u5904\u7406\u6D88\u606F\u7D22\u5F15\u4EFB\u52A1\uFF0C\u628A\u6D88\u606F chunks \u5199\u5165 LanceDB \u5411\u91CF\u7D22\u5F15").option("--limit <number>", "\u6700\u591A\u5904\u7406\u7684 chunk \u6570", "10000").action(async (options) => {
   const config = await loadConfig();
   const secrets = await loadSecrets();
   const database = openDatabase(config);
@@ -3513,7 +3885,7 @@ files.command("add").description("\u628A\u672C\u5730\u6587\u4EF6\u89E3\u6790\u30
         `\u5DF2\u5BFC\u5165\u6587\u4EF6\uFF1A${result.fileName}\uFF0C\u89E3\u6790\u5668=${result.parser}\uFF0C\u5B57\u7B26\u6570=${result.characters}\uFF0C\u6D88\u606FID=${result.messageId}`
       );
     }
-    console.log("\u6587\u4EF6\u5DF2\u8FDB\u5165 SQLite FTS \u68C0\u7D22\uFF1B\u5982\u5DF2\u914D\u7F6E embedding\uFF0C\u53EF\u8FD0\u884C chattercatcher index rebuild \u66F4\u65B0 SQLite \u5411\u91CF\u7D22\u5F15\u3002");
+    console.log("\u6587\u4EF6\u5DF2\u8FDB\u5165 SQLite FTS \u68C0\u7D22\uFF1B\u5982\u5DF2\u914D\u7F6E embedding\uFF0C\u53EF\u8FD0\u884C chattercatcher index rebuild \u66F4\u65B0 LanceDB \u5411\u91CF\u7D22\u5F15\u3002");
   } finally {
     database.close();
   }
@@ -3642,7 +4014,7 @@ program.command("restore").description("\u4ECE ChatterCatcher \u5BFC\u51FA\u6587
     console.log(`\u6062\u590D\u5B8C\u6210\uFF1A${result.inputPath}`);
     console.log(`\u6A21\u5F0F\uFF1A${result.mode === "replace" ? "\u66FF\u6362" : "\u5408\u5E76"}`);
     console.log(`\u5305\u542B\uFF1A\u7FA4\u804A=${result.chats}\uFF0C\u6D88\u606F=${result.messages}\uFF0Cchunks=${result.chunks}\uFF0C\u6587\u4EF6\u4EFB\u52A1=${result.fileJobs}`);
-    console.log("SQLite FTS \u5DF2\u91CD\u5EFA\uFF1B\u5982\u4F7F\u7528\u8BED\u4E49\u68C0\u7D22\uFF0C\u8BF7\u8FD0\u884C chattercatcher index rebuild \u91CD\u5EFA SQLite Vector\u3002");
+    console.log("SQLite FTS \u5DF2\u91CD\u5EFA\uFF1B\u5982\u4F7F\u7528 LanceDB \u8BED\u4E49\u68C0\u7D22\uFF0C\u8BF7\u8FD0\u884C chattercatcher index rebuild\u3002");
   } finally {
     database.close();
   }
@@ -3672,7 +4044,7 @@ dev.command("ingest-feishu-event").description("\u4ECE JSON \u6587\u4EF6\u6A21\u
   const config = await loadConfig();
   const database = openDatabase(config);
   try {
-    const raw = await fs12.readFile(options.file, "utf8");
+    const raw = await fs14.readFile(options.file, "utf8");
     const payload = JSON.parse(raw);
     const result = new GatewayIngestor(database).ingestFeishuEvent(payload);
     if (!result.accepted) {