chattercatcher 0.1.0

package/dist/index.js

@@ -0,0 +1,3353 @@
+// src/config/schema.ts
+import os from "os";
+import path from "path";
+import { z } from "zod";
+function defaultDataDir() {
+  return path.join(process.env.CHATTERCATCHER_HOME || path.join(os.homedir(), ".chattercatcher"), "data");
+}
+var appConfigSchema = z.object({
+  feishu: z.object({
+    domain: z.enum(["feishu", "lark"]).default("feishu"),
+    appId: z.string().default(""),
+    groupPolicy: z.enum(["open", "allowlist", "disabled"]).default("open"),
+    requireMention: z.boolean().default(true)
+  }),
+  llm: z.object({
+    baseUrl: z.string().url().or(z.literal("")).default(""),
+    model: z.string().default("")
+  }),
+  embedding: z.object({
+    baseUrl: z.string().url().or(z.literal("")).default(""),
+    model: z.string().default(""),
+    dimension: z.number().int().positive().nullable().default(null)
+  }),
+  storage: z.object({
+    dataDir: z.string().default(defaultDataDir)
+  }),
+  web: z.object({
+    host: z.string().default("127.0.0.1"),
+    port: z.number().int().min(1).max(65535).default(3878)
+  }),
+  schedules: z.object({
+    indexing: z.string().default("*/10 * * * *")
+  })
+});
+var appSecretsSchema = z.object({
+  feishu: z.object({
+    appSecret: z.string().default("")
+  }),
+  llm: z.object({
+    apiKey: z.string().default("")
+  }),
+  embedding: z.object({
+    apiKey: z.string().default("")
+  })
+});
+function createDefaultConfig() {
+  return appConfigSchema.parse({
+    feishu: {},
+    llm: {},
+    embedding: {},
+    storage: {},
+    web: {},
+    schedules: {}
+  });
+}
+function createDefaultSecrets() {
+  return appSecretsSchema.parse({
+    feishu: {},
+    llm: {},
+    embedding: {}
+  });
+}
+
+// src/config/store.ts
+import fs from "fs/promises";
+import path3 from "path";
+
+// 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
+async function readJsonFile(filePath, fallback) {
+  try {
+    const raw = await fs.readFile(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return fallback;
+    }
+    throw error;
+  }
+}
+async function writeJsonFile(filePath, value) {
+  await fs.mkdir(path3.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+async function loadConfig() {
+  const raw = await readJsonFile(getConfigPath(), createDefaultConfig());
+  return appConfigSchema.parse(raw);
+}
+async function saveConfig(config) {
+  await writeJsonFile(getConfigPath(), appConfigSchema.parse(config));
+}
+async function loadSecrets() {
+  const raw = await readJsonFile(getSecretsPath(), createDefaultSecrets());
+  return appSecretsSchema.parse(raw);
+}
+async function saveSecrets(secrets) {
+  await writeJsonFile(getSecretsPath(), appSecretsSchema.parse(secrets));
+}
+async function ensureConfigFiles() {
+  await fs.mkdir(getChatterCatcherHome(), { recursive: true });
+  const config = await loadConfig();
+  const secrets = await loadSecrets();
+  await saveConfig(config);
+  await saveSecrets(secrets);
+  return { config, secrets };
+}
+async function resetConfigFiles() {
+  await saveConfig(createDefaultConfig());
+  await saveSecrets(createDefaultSecrets());
+}
+function maskSecret(value) {
+  if (!value) {
+    return "";
+  }
+  if (value.length <= 8) {
+    return "********";
+  }
+  return `${value.slice(0, 4)}...${value.slice(-4)}`;
+}
+
+// src/config/update.ts
+function applySecretInput(currentValue, nextValue) {
+  const trimmed = nextValue?.trim() ?? "";
+  return trimmed ? trimmed : currentValue;
+}
+function resolveEmbeddingApiKey(input) {
+  const explicit = applySecretInput(input.currentEmbeddingKey, input.nextEmbeddingKey);
+  return explicit || input.llmApiKey;
+}
+
+// src/data/deletion.ts
+import fs2 from "fs/promises";
+import path4 from "path";
+function emptyResult(targetType, targetId) {
+  return {
+    targetType,
+    targetId,
+    deletedMessages: 0,
+    deletedChunks: 0,
+    deletedFileJobs: 0,
+    deletedChats: 0,
+    deletedStoredFiles: [],
+    skippedStoredFiles: []
+  };
+}
+function parseStoredPathFromRawPayload(rawPayloadJson) {
+  try {
+    const parsed = JSON.parse(rawPayloadJson);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null;
+    }
+    const storedPath = parsed.storedPath;
+    return typeof storedPath === "string" ? storedPath : null;
+  } catch {
+    return null;
+  }
+}
+function isInsideDirectory(filePath, directory) {
+  const relative = path4.relative(path4.resolve(directory), path4.resolve(filePath));
+  return relative === "" || !relative.startsWith("..") && !path4.isAbsolute(relative);
+}
+async function removeStoredFiles(config, paths) {
+  const dataDir = resolveHomePath(config.storage.dataDir);
+  const deleted = [];
+  const skipped = [];
+  const uniquePaths = [...new Set(paths.filter(Boolean).map((item) => path4.resolve(item)))];
+  for (const storedPath of uniquePaths) {
+    if (!isInsideDirectory(storedPath, dataDir)) {
+      skipped.push(storedPath);
+      continue;
+    }
+    try {
+      await fs2.rm(storedPath, { force: true });
+      deleted.push(storedPath);
+    } catch {
+      skipped.push(storedPath);
+    }
+  }
+  return { deleted, skipped };
+}
+function getStoredPathsForMessages(database, messageIds) {
+  if (messageIds.length === 0) {
+    return [];
+  }
+  const rows = database.prepare(
+    `
+      SELECT raw_payload_json AS rawPayloadJson
+      FROM messages
+      WHERE id IN (${messageIds.map(() => "?").join(", ")})
+    `
+  ).all(...messageIds);
+  const fileJobRows = database.prepare(
+    `
+      SELECT stored_path AS storedPath
+      FROM file_jobs
+      WHERE message_id IN (${messageIds.map(() => "?").join(", ")})
+    `
+  ).all(...messageIds);
+  return [
+    ...rows.map((row) => parseStoredPathFromRawPayload(row.rawPayloadJson)).filter((item) => Boolean(item)),
+    ...fileJobRows.map((row) => row.storedPath).filter((item) => Boolean(item))
+  ];
+}
+function deleteMessagesByIds(database, messageIds) {
+  if (messageIds.length === 0) {
+    return {
+      deletedMessages: 0,
+      deletedChunks: 0,
+      deletedFileJobs: 0
+    };
+  }
+  const placeholders = messageIds.map(() => "?").join(", ");
+  const deletedChunks = database.prepare(`SELECT COUNT(*) AS count FROM message_chunks WHERE message_id IN (${placeholders})`).get(...messageIds).count;
+  const deletedFileJobs = database.prepare(`DELETE FROM file_jobs WHERE message_id IN (${placeholders})`).run(...messageIds).changes;
+  database.prepare(`DELETE FROM message_chunks_fts WHERE message_id IN (${placeholders})`).run(...messageIds);
+  const deletedMessages = database.prepare(`DELETE FROM messages WHERE id IN (${placeholders})`).run(...messageIds).changes;
+  return {
+    deletedMessages,
+    deletedChunks,
+    deletedFileJobs
+  };
+}
+async function deleteLocalData(input) {
+  const result = emptyResult(input.targetType, input.targetId);
+  let storedPaths = [];
+  const transaction = input.database.transaction(() => {
+    if (input.targetType === "chat") {
+      const messageIds = input.database.prepare("SELECT id FROM messages WHERE chat_id = ?").all(input.targetId).map((row) => row.id);
+      storedPaths = getStoredPathsForMessages(input.database, messageIds);
+      const deleted2 = deleteMessagesByIds(input.database, messageIds);
+      result.deletedMessages = deleted2.deletedMessages;
+      result.deletedChunks = deleted2.deletedChunks;
+      result.deletedFileJobs = deleted2.deletedFileJobs;
+      result.deletedChats = input.database.prepare("DELETE FROM chats WHERE id = ?").run(input.targetId).changes;
+      return;
+    }
+    if (input.targetType === "file") {
+      const file = input.database.prepare("SELECT id FROM messages WHERE id = ? AND message_type = 'file'").get(input.targetId);
+      if (!file) {
+        return;
+      }
+    }
+    storedPaths = getStoredPathsForMessages(input.database, [input.targetId]);
+    const deleted = deleteMessagesByIds(input.database, [input.targetId]);
+    result.deletedMessages = deleted.deletedMessages;
+    result.deletedChunks = deleted.deletedChunks;
+    result.deletedFileJobs = deleted.deletedFileJobs;
+  });
+  transaction();
+  const removed = await removeStoredFiles(input.config, storedPaths);
+  result.deletedStoredFiles = removed.deleted;
+  result.skippedStoredFiles = removed.skipped;
+  return result;
+}
+
+// src/db/database.ts
+import Database from "better-sqlite3";
+import fs3 from "fs";
+import path5 from "path";
+function getDatabasePath(config) {
+  return path5.join(resolveHomePath(config.storage.dataDir), "chattercatcher.db");
+}
+function openDatabase(config) {
+  const databasePath = getDatabasePath(config);
+  fs3.mkdirSync(path5.dirname(databasePath), { recursive: true });
+  const database = new Database(databasePath);
+  database.pragma("journal_mode = WAL");
+  database.pragma("foreign_keys = ON");
+  migrateDatabase(database);
+  return database;
+}
+function migrateDatabase(database) {
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS chats (
+      id TEXT PRIMARY KEY,
+      platform TEXT NOT NULL,
+      platform_chat_id TEXT NOT NULL,
+      name TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      UNIQUE(platform, platform_chat_id)
+    );
+
+    CREATE TABLE IF NOT EXISTS messages (
+      id TEXT PRIMARY KEY,
+      platform TEXT NOT NULL,
+      platform_message_id TEXT NOT NULL,
+      chat_id TEXT NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
+      sender_id TEXT NOT NULL,
+      sender_name TEXT NOT NULL,
+      message_type TEXT NOT NULL,
+      text TEXT NOT NULL,
+      raw_payload_json TEXT NOT NULL,
+      sent_at TEXT NOT NULL,
+      received_at TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      UNIQUE(platform, platform_message_id)
+    );
+
+    CREATE TABLE IF NOT EXISTS message_chunks (
+      id TEXT PRIMARY KEY,
+      message_id TEXT NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
+      chunk_index INTEGER NOT NULL,
+      text TEXT NOT NULL,
+      metadata_json TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      UNIQUE(message_id, chunk_index)
+    );
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS message_chunks_fts USING fts5(
+      text,
+      chunk_id UNINDEXED,
+      message_id UNINDEXED,
+      tokenize = 'unicode61'
+    );
+
+    CREATE TABLE IF NOT EXISTS file_jobs (
+      id TEXT PRIMARY KEY,
+      source_path TEXT NOT NULL,
+      stored_path TEXT,
+      file_name TEXT NOT NULL,
+      status TEXT NOT NULL,
+      parser TEXT,
+      message_id TEXT,
+      bytes INTEGER,
+      characters INTEGER,
+      warnings_json TEXT NOT NULL DEFAULT '[]',
+      error TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+  `);
+}
+
+// src/doctor/checks.ts
+import fs6 from "fs/promises";
+
+// src/files/jobs.ts
+import crypto from "crypto";
+import path6 from "path";
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function stableJobId(sourcePath) {
+  return crypto.createHash("sha256").update(path6.resolve(sourcePath)).digest("hex").slice(0, 32);
+}
+function parseWarnings(value) {
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
+  } catch {
+    return [];
+  }
+}
+var FileJobRepository = class {
+  constructor(database) {
+    this.database = database;
+  }
+  database;
+  start(input) {
+    const id = stableJobId(input.sourcePath);
+    const now = nowIso();
+    this.database.prepare(
+      `
+        INSERT INTO file_jobs (
+          id, source_path, file_name, status, warnings_json, created_at, updated_at
+        )
+        VALUES (@id, @sourcePath, @fileName, 'processing', '[]', @createdAt, @updatedAt)
+        ON CONFLICT(id) DO UPDATE SET
+          source_path = excluded.source_path,
+          file_name = excluded.file_name,
+          status = 'processing',
+          parser = NULL,
+          message_id = NULL,
+          bytes = NULL,
+          characters = NULL,
+          warnings_json = '[]',
+          error = NULL,
+          updated_at = excluded.updated_at
+      `
+    ).run({
+      id,
+      sourcePath: path6.resolve(input.sourcePath),
+      fileName: input.fileName ?? path6.basename(input.sourcePath),
+      createdAt: now,
+      updatedAt: now
+    });
+    return id;
+  }
+  complete(input) {
+    this.database.prepare(
+      `
+        UPDATE file_jobs
+        SET
+          stored_path = @storedPath,
+          status = 'indexed',
+          parser = @parser,
+          message_id = @messageId,
+          bytes = @bytes,
+          characters = @characters,
+          warnings_json = @warningsJson,
+          error = NULL,
+          updated_at = @updatedAt
+        WHERE id = @id
+      `
+    ).run({
+      id: input.id,
+      storedPath: input.storedPath,
+      parser: input.parser,
+      messageId: input.messageId,
+      bytes: input.bytes,
+      characters: input.characters,
+      warningsJson: JSON.stringify(input.warnings),
+      updatedAt: nowIso()
+    });
+  }
+  fail(input) {
+    this.database.prepare(
+      `
+        UPDATE file_jobs
+        SET status = 'failed', error = @error, updated_at = @updatedAt
+        WHERE id = @id
+      `
+    ).run({
+      id: input.id,
+      error: input.error,
+      updatedAt: nowIso()
+    });
+  }
+  get(id) {
+    return this.listByWhere("WHERE id = ?", [id], 1)[0] ?? null;
+  }
+  list(limit = 50, options = {}) {
+    return options.status ? this.listByWhere("WHERE status = ?", [options.status], limit) : this.listByWhere("", [], limit);
+  }
+  listByWhere(whereSql, params, limit) {
+    const rows = this.database.prepare(
+      `
+        SELECT
+          id,
+          source_path AS sourcePath,
+          stored_path AS storedPath,
+          file_name AS fileName,
+          status,
+          parser,
+          message_id AS messageId,
+          bytes,
+          characters,
+          warnings_json AS warningsJson,
+          error,
+          created_at AS createdAt,
+          updated_at AS updatedAt
+        FROM file_jobs
+        ${whereSql}
+        ORDER BY updated_at DESC
+        LIMIT ?
+      `
+    ).all(...params, limit);
+    return rows.map((row) => ({
+      id: row.id,
+      sourcePath: row.sourcePath,
+      storedPath: row.storedPath ?? void 0,
+      fileName: row.fileName,
+      status: row.status,
+      parser: row.parser ?? void 0,
+      messageId: row.messageId ?? void 0,
+      bytes: row.bytes ?? void 0,
+      characters: row.characters ?? void 0,
+      warnings: parseWarnings(row.warningsJson),
+      error: row.error ?? void 0,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
+    }));
+  }
+};
+
+// src/gateway/runtime.ts
+import fs4 from "fs";
+import path7 from "path";
+function getGatewayPidPath() {
+  return path7.join(getChatterCatcherHome(), "gateway.pid");
+}
+function isProcessRunning(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readGatewayPidRecord(pidFile = getGatewayPidPath()) {
+  try {
+    const raw = fs4.readFileSync(pidFile, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!Number.isInteger(parsed.pid) || typeof parsed.startedAt !== "string" || typeof parsed.command !== "string") {
+      return null;
+    }
+    const pid = parsed.pid;
+    if (pid === void 0) {
+      return null;
+    }
+    return {
+      pid,
+      startedAt: parsed.startedAt,
+      command: parsed.command
+    };
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    return null;
+  }
+}
+function writeGatewayPidRecord(pidFile = getGatewayPidPath(), record = {
+  pid: process.pid,
+  startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+  command: process.argv.join(" ")
+}) {
+  fs4.mkdirSync(path7.dirname(pidFile), { recursive: true });
+  fs4.writeFileSync(pidFile, `${JSON.stringify(record, null, 2)}
+`, "utf8");
+}
+function removeGatewayPidRecord(pidFile = getGatewayPidPath()) {
+  try {
+    fs4.rmSync(pidFile, { force: true });
+  } catch {
+  }
+}
+function getGatewayRuntimeState(pidFile = getGatewayPidPath()) {
+  const record = readGatewayPidRecord(pidFile);
+  const running = record ? isProcessRunning(record.pid) : false;
+  return {
+    pidFile,
+    record,
+    running,
+    stale: Boolean(record && !running)
+  };
+}
+function stopGatewayProcess(pidFile = getGatewayPidPath()) {
+  const state = getGatewayRuntimeState(pidFile);
+  if (!state.record) {
+    return {
+      stopped: false,
+      message: "Gateway \u6CA1\u6709\u8FD0\u884C\u8BB0\u5F55\u3002"
+    };
+  }
+  if (state.stale) {
+    removeGatewayPidRecord(pidFile);
+    return {
+      stopped: false,
+      message: `Gateway PID \u6587\u4EF6\u5DF2\u8FC7\u671F\uFF0C\u5DF2\u6E05\u7406\uFF1A${state.record.pid}`
+    };
+  }
+  if (state.record.pid === process.pid) {
+    return {
+      stopped: false,
+      message: "\u62D2\u7EDD\u505C\u6B62\u5F53\u524D CLI \u8FDB\u7A0B\uFF1B\u8BF7\u5728\u53E6\u4E00\u4E2A\u7EC8\u7AEF\u8FD0\u884C stop\uFF0C\u6216\u6309 Ctrl+C\u3002"
+    };
+  }
+  try {
+    process.kill(state.record.pid, "SIGTERM");
+    removeGatewayPidRecord(pidFile);
+    return {
+      stopped: true,
+      message: `\u5DF2\u5411 Gateway \u8FDB\u7A0B\u53D1\u9001\u505C\u6B62\u4FE1\u53F7\uFF1Apid=${state.record.pid}`
+    };
+  } catch (error) {
+    return {
+      stopped: false,
+      message: `\u505C\u6B62 Gateway \u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+
+// src/gateway/index.ts
+function getGatewayStatus(config, secrets) {
+  if (!config.feishu.appId) {
+    return {
+      configured: false,
+      connection: "not_configured",
+      message: "\u5C1A\u672A\u914D\u7F6E\u98DE\u4E66 App ID\u3002\u8BF7\u8FD0\u884C chattercatcher setup \u6216 chattercatcher settings\u3002"
+    };
+  }
+  if (secrets && !secrets.feishu.appSecret) {
+    return {
+      configured: false,
+      connection: "not_configured",
+      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
+    };
+  }
+  return {
+    configured: true,
+    connection: "ready_for_start",
+    message: "\u98DE\u4E66\u957F\u8FDE\u63A5\u914D\u7F6E\u5DF2\u5C31\u7EEA\u3002\u8FD0\u884C chattercatcher gateway start \u540E\u4F1A\u63A5\u6536 im.message.receive_v1 \u4E8B\u4EF6\u3002",
+    pidFile: runtime.pidFile
+  };
+}
+
+// src/llm/openai-compatible.ts
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.replace(/\/+$/, "");
+}
+var OpenAICompatibleChatModel = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  async complete(messages) {
+    if (!this.options.baseUrl || !this.options.apiKey || !this.options.model) {
+      throw new Error("LLM \u914D\u7F6E\u4E0D\u5B8C\u6574\u3002\u8BF7\u8FD0\u884C chattercatcher setup \u6216 chattercatcher settings\u3002");
+    }
+    const response = await fetch(`${normalizeBaseUrl(this.options.baseUrl)}/chat/completions`, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${this.options.apiKey}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        model: this.options.model,
+        messages,
+        temperature: this.options.temperature ?? 0.2
+      })
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`LLM \u8BF7\u6C42\u5931\u8D25\uFF1A${response.status} ${body}`);
+    }
+    const data = await response.json();
+    const content = data.choices?.[0]?.message?.content?.trim();
+    if (!content) {
+      throw new Error("LLM \u8FD4\u56DE\u4E3A\u7A7A\u3002");
+    }
+    return content;
+  }
+};
+var OpenAICompatibleEmbeddingModel = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  async embed(text) {
+    const [vector] = await this.embedBatch([text]);
+    return vector ?? [];
+  }
+  async embedBatch(texts) {
+    if (!this.options.baseUrl || !this.options.apiKey || !this.options.model) {
+      throw new Error("Embedding \u914D\u7F6E\u4E0D\u5B8C\u6574\u3002\u8BF7\u8FD0\u884C chattercatcher setup \u6216 chattercatcher settings\u3002");
+    }
+    const response = await fetch(`${normalizeBaseUrl(this.options.baseUrl)}/embeddings`, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${this.options.apiKey}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        model: this.options.model,
+        input: texts
+      })
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`Embedding \u8BF7\u6C42\u5931\u8D25\uFF1A${response.status} ${body}`);
+    }
+    const data = await response.json();
+    return data.data?.map((item) => item.embedding ?? []) ?? [];
+  }
+};
+function createChatModel(config, secrets) {
+  return new OpenAICompatibleChatModel({
+    baseUrl: config.llm.baseUrl,
+    apiKey: secrets.llm.apiKey,
+    model: config.llm.model
+  });
+}
+function createEmbeddingModel(config, secrets) {
+  return new OpenAICompatibleEmbeddingModel({
+    baseUrl: config.embedding.baseUrl || config.llm.baseUrl,
+    apiKey: secrets.embedding.apiKey || secrets.llm.apiKey,
+    model: config.embedding.model
+  });
+}
+
+// src/messages/repository.ts
+import crypto2 from "crypto";
+
+// src/messages/chunker.ts
+function chunkText(text, maxChars = 900, overlapChars = 120) {
+  const normalized = text.trim().replace(/\s+/g, " ");
+  if (!normalized) {
+    return [];
+  }
+  if (normalized.length <= maxChars) {
+    return [{ index: 0, text: normalized }];
+  }
+  const chunks = [];
+  let cursor = 0;
+  while (cursor < normalized.length) {
+    const end = Math.min(cursor + maxChars, normalized.length);
+    chunks.push({ index: chunks.length, text: normalized.slice(cursor, end) });
+    if (end === normalized.length) {
+      break;
+    }
+    cursor = Math.max(end - overlapChars, cursor + 1);
+  }
+  return chunks;
+}
+
+// src/messages/repository.ts
+function nowIso2() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function stableId(parts) {
+  return crypto2.createHash("sha256").update(parts.join("")).digest("hex").slice(0, 32);
+}
+function escapeFtsQuery(query) {
+  const terms = query.trim().split(/\s+/).map((term) => term.replace(/"/g, '""')).filter(Boolean);
+  if (terms.length === 0) {
+    return '""';
+  }
+  return terms.map((term) => `"${term}"`).join(" OR ");
+}
+function escapeLikeTerm(term) {
+  return term.replace(/[\\%_]/g, (match) => `\\${match}`);
+}
+function buildSearchTerms(query) {
+  const trimmed = query.trim();
+  if (!trimmed) {
+    return [];
+  }
+  const terms = trimmed.split(/\s+/).filter(Boolean);
+  if (terms.length > 1) {
+    return terms;
+  }
+  if (/[\u3400-\u9fff]/.test(trimmed) && trimmed.length > 2) {
+    const cjkTerms = /* @__PURE__ */ new Set([trimmed]);
+    for (let index = 0; index < trimmed.length - 1; index += 1) {
+      cjkTerms.add(trimmed.slice(index, index + 2));
+    }
+    return [...cjkTerms];
+  }
+  return [trimmed];
+}
+function parseRawPayload(value) {
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+var MessageRepository = class {
+  constructor(database) {
+    this.database = database;
+  }
+  database;
+  ingest(input) {
+    const createdAt = nowIso2();
+    const chatId = stableId([input.platform, input.platformChatId]);
+    const messageId = stableId([input.platform, input.platformMessageId]);
+    const rawPayloadJson = JSON.stringify(input.rawPayload ?? {});
+    const chunks = chunkText(input.text);
+    const transaction = this.database.transaction(() => {
+      this.database.prepare(
+        `
+          INSERT INTO chats (id, platform, platform_chat_id, name, created_at, updated_at)
+          VALUES (@id, @platform, @platformChatId, @name, @createdAt, @updatedAt)
+          ON CONFLICT(platform, platform_chat_id)
+          DO UPDATE SET name = excluded.name, updated_at = excluded.updated_at
+        `
+      ).run({
+        id: chatId,
+        platform: input.platform,
+        platformChatId: input.platformChatId,
+        name: input.chatName,
+        createdAt,
+        updatedAt: createdAt
+      });
+      this.database.prepare(
+        `
+          INSERT INTO messages (
+            id, platform, platform_message_id, chat_id, sender_id, sender_name,
+            message_type, text, raw_payload_json, sent_at, received_at, created_at
+          )
+          VALUES (
+            @id, @platform, @platformMessageId, @chatId, @senderId, @senderName,
+            @messageType, @text, @rawPayloadJson, @sentAt, @receivedAt, @createdAt
+          )
+          ON CONFLICT(platform, platform_message_id)
+          DO UPDATE SET
+            text = excluded.text,
+            raw_payload_json = excluded.raw_payload_json,
+            received_at = excluded.received_at
+        `
+      ).run({
+        id: messageId,
+        platform: input.platform,
+        platformMessageId: input.platformMessageId,
+        chatId,
+        senderId: input.senderId,
+        senderName: input.senderName,
+        messageType: input.messageType,
+        text: input.text,
+        rawPayloadJson,
+        sentAt: input.sentAt,
+        receivedAt: createdAt,
+        createdAt
+      });
+      this.database.prepare("DELETE FROM message_chunks_fts WHERE message_id = ?").run(messageId);
+      this.database.prepare("DELETE FROM message_chunks WHERE message_id = ?").run(messageId);
+      const insertChunk = this.database.prepare(`
+        INSERT INTO message_chunks (id, message_id, chunk_index, text, metadata_json, created_at)
+        VALUES (@id, @messageId, @chunkIndex, @text, @metadataJson, @createdAt)
+      `);
+      const insertFts = this.database.prepare(`
+        INSERT INTO message_chunks_fts (text, chunk_id, message_id)
+        VALUES (@text, @chunkId, @messageId)
+      `);
+      for (const chunk of chunks) {
+        const chunkId = stableId([messageId, String(chunk.index)]);
+        insertChunk.run({
+          id: chunkId,
+          messageId,
+          chunkIndex: chunk.index,
+          text: chunk.text,
+          metadataJson: JSON.stringify({ sourceType: "message" }),
+          createdAt
+        });
+        insertFts.run({ text: chunk.text, chunkId, messageId });
+      }
+    });
+    transaction();
+    return messageId;
+  }
+  listRecentMessages(limit = 20) {
+    return this.database.prepare(
+      `
+        SELECT
+          mc.id AS chunkId,
+          m.id AS messageId,
+          m.platform AS platform,
+          mc.text AS text,
+          1.0 AS score,
+          m.message_type AS messageType,
+          c.name AS chatName,
+          m.sender_name AS senderName,
+          m.sent_at AS sentAt
+        FROM message_chunks mc
+        JOIN messages m ON m.id = mc.message_id
+        JOIN chats c ON c.id = m.chat_id
+        ORDER BY m.sent_at DESC
+        LIMIT ?
+      `
+    ).all(limit);
+  }
+  listAllMessageChunks(limit = 1e4) {
+    return this.database.prepare(
+      `
+        SELECT
+          mc.id AS chunkId,
+          m.id AS messageId,
+          m.platform AS platform,
+          mc.text AS text,
+          1.0 AS score,
+          m.message_type AS messageType,
+          c.name AS chatName,
+          m.sender_name AS senderName,
+          m.sent_at AS sentAt
+        FROM message_chunks mc
+        JOIN messages m ON m.id = mc.message_id
+        JOIN chats c ON c.id = m.chat_id
+        ORDER BY m.sent_at DESC, mc.chunk_index ASC
+        LIMIT ?
+      `
+    ).all(limit);
+  }
+  listMessageChunksByMessageIds(messageIds, limit = 1e4) {
+    if (messageIds.length === 0) {
+      return [];
+    }
+    return this.database.prepare(
+      `
+        SELECT
+          mc.id AS chunkId,
+          m.id AS messageId,
+          m.platform AS platform,
+          mc.text AS text,
+          1.0 AS score,
+          m.message_type AS messageType,
+          c.name AS chatName,
+          m.sender_name AS senderName,
+          m.sent_at AS sentAt
+        FROM message_chunks mc
+        JOIN messages m ON m.id = mc.message_id
+        JOIN chats c ON c.id = m.chat_id
+        WHERE m.id IN (${messageIds.map(() => "?").join(", ")})
+        ORDER BY m.sent_at DESC, mc.chunk_index ASC
+        LIMIT ?
+      `
+    ).all(...messageIds, limit);
+  }
+  searchMessages(query, limit = 8, options = {}) {
+    const ftsQuery = escapeFtsQuery(query);
+    const excludedIds = options.excludeMessageIds ?? [];
+    const excludedWhere = excludedIds.length > 0 ? `AND fts.message_id NOT IN (${excludedIds.map(() => "?").join(", ")})` : "";
+    const ftsResults = this.database.prepare(
+      `
+        SELECT
+          fts.chunk_id AS chunkId,
+          fts.message_id AS messageId,
+          m.platform AS platform,
+          mc.text AS text,
+          bm25(message_chunks_fts) * -1 AS score,
+          m.message_type AS messageType,
+          c.name AS chatName,
+          m.sender_name AS senderName,
+          m.sent_at AS sentAt
+        FROM message_chunks_fts fts
+        JOIN message_chunks mc ON mc.id = fts.chunk_id
+        JOIN messages m ON m.id = fts.message_id
+        JOIN chats c ON c.id = m.chat_id
+        WHERE message_chunks_fts MATCH ?
+        ${excludedWhere}
+        ORDER BY bm25(message_chunks_fts)
+        LIMIT ?
+      `
+    ).all(ftsQuery, ...excludedIds, limit);
+    if (ftsResults.length > 0) {
+      return ftsResults;
+    }
+    const terms = buildSearchTerms(query);
+    if (terms.length === 0) {
+      return [];
+    }
+    const where = terms.map(() => "mc.text LIKE ? ESCAPE '\\'").join(" OR ");
+    const params = terms.map((term) => `%${escapeLikeTerm(term)}%`);
+    const likeExcludedWhere = excludedIds.length > 0 ? `AND m.id NOT IN (${excludedIds.map(() => "?").join(", ")})` : "";
+    return this.database.prepare(
+      `
+        SELECT
+          mc.id AS chunkId,
+          m.id AS messageId,
+          m.platform AS platform,
+          mc.text AS text,
+          0.1 AS score,
+          m.message_type AS messageType,
+          c.name AS chatName,
+          m.sender_name AS senderName,
+          m.sent_at AS sentAt
+        FROM message_chunks mc
+        JOIN messages m ON m.id = mc.message_id
+        JOIN chats c ON c.id = m.chat_id
+        WHERE (${where})
+        ${likeExcludedWhere}
+        ORDER BY m.sent_at DESC
+        LIMIT ?
+      `
+    ).all(...params, ...excludedIds, limit);
+  }
+  getChatCount() {
+    return this.database.prepare("SELECT COUNT(*) AS count FROM chats").get().count;
+  }
+  getMessageCount() {
+    return this.database.prepare("SELECT COUNT(*) AS count FROM messages").get().count;
+  }
+  hasPlatformMessage(platform, platformMessageId) {
+    const row = this.database.prepare("SELECT 1 AS existsFlag FROM messages WHERE platform = ? AND platform_message_id = ? LIMIT 1").get(platform, platformMessageId);
+    return Boolean(row);
+  }
+  listChats() {
+    return this.database.prepare(
+      `
+        SELECT
+          id,
+          platform,
+          platform_chat_id AS platformChatId,
+          name,
+          created_at AS createdAt,
+          updated_at AS updatedAt
+        FROM chats
+        ORDER BY updated_at DESC
+      `
+    ).all();
+  }
+  listFiles(limit = 50) {
+    const rows = this.database.prepare(
+      `
+        SELECT
+          id AS messageId,
+          sender_name AS fileName,
+          raw_payload_json AS rawPayloadJson,
+          length(text) AS characters,
+          created_at AS importedAt
+        FROM messages
+        WHERE message_type = 'file'
+        ORDER BY created_at DESC
+        LIMIT ?
+      `
+    ).all(limit);
+    return rows.map((row) => {
+      const payload = parseRawPayload(row.rawPayloadJson);
+      return {
+        messageId: row.messageId,
+        fileName: row.fileName,
+        sourcePath: typeof payload.sourcePath === "string" ? payload.sourcePath : void 0,
+        storedPath: typeof payload.storedPath === "string" ? payload.storedPath : void 0,
+        bytes: typeof payload.bytes === "number" ? payload.bytes : void 0,
+        characters: row.characters,
+        parser: typeof payload.parser === "string" ? payload.parser : void 0,
+        parserWarnings: Array.isArray(payload.parserWarnings) ? payload.parserWarnings.filter((item) => typeof item === "string") : void 0,
+        importedAt: row.importedAt
+      };
+    });
+  }
+};
+
+// src/rag/hybrid-retriever.ts
+function normalizeScore(score) {
+  if (!Number.isFinite(score)) {
+    return 0;
+  }
+  return Math.max(0, Math.min(1, score));
+}
+var HybridRetriever = class {
+  constructor(retrievers, options = {}) {
+    this.retrievers = retrievers;
+    this.options = options;
+  }
+  retrievers;
+  options;
+  async retrieve(question) {
+    const results = await Promise.all(this.retrievers.map((retriever) => retriever.retrieve(question)));
+    const merged = /* @__PURE__ */ new Map();
+    for (const [retrieverIndex, evidenceList] of results.entries()) {
+      for (const evidence of evidenceList) {
+        const existing = merged.get(evidence.id);
+        const weightedScore = normalizeScore(evidence.score) + (this.retrievers.length - retrieverIndex) * 0.01;
+        if (!existing || weightedScore > existing.score) {
+          merged.set(evidence.id, {
+            ...evidence,
+            score: weightedScore
+          });
+        }
+      }
+    }
+    return [...merged.values()].sort((left, right) => right.score - left.score).slice(0, this.options.limit ?? 8);
+  }
+};
+
+// src/rag/lancedb-store.ts
+import * as lancedb from "@lancedb/lancedb";
+import fs5 from "fs/promises";
+import path8 from "path";
+var DEFAULT_TABLE_NAME = "message_chunks";
+function getLanceDbPath(config) {
+  return path8.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 LanceDbVectorStore = class _LanceDbVectorStore {
+  constructor(connection, tableName) {
+    this.connection = connection;
+    this.tableName = tableName;
+  }
+  connection;
+  tableName;
+  static async connect(uri, tableName = DEFAULT_TABLE_NAME) {
+    await fs5.mkdir(uri, { recursive: true });
+    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 data = toLanceData(rows);
+    const table = await this.ensureTable(data);
+    const ids = rows.map((row) => `'${escapeSqlString(row.id)}'`).join(", ");
+    await table.delete(`id IN (${ids})`);
+    await table.add(data);
+  }
+  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/rag/message-retriever.ts
+function toEvidenceSource(result) {
+  if (result.messageType === "file") {
+    return {
+      type: "file",
+      label: result.senderName,
+      timestamp: result.sentAt
+    };
+  }
+  return {
+    type: "message",
+    label: result.chatName,
+    sender: result.senderName,
+    timestamp: result.sentAt
+  };
+}
+var MessageFtsRetriever = class {
+  constructor(messages, options = {}) {
+    this.messages = messages;
+    this.options = options;
+  }
+  messages;
+  options;
+  async retrieve(question) {
+    const results = this.messages.searchMessages(question, 8, {
+      excludeMessageIds: this.options.excludeMessageIds
+    });
+    return results.map((result) => ({
+      id: result.chunkId,
+      text: result.text,
+      score: result.score,
+      source: toEvidenceSource(result)
+    }));
+  }
+};
+
+// src/rag/vector-retriever.ts
+var VectorRetriever = class {
+  constructor(embedding, store, limit = 8) {
+    this.embedding = embedding;
+    this.store = store;
+    this.limit = limit;
+  }
+  embedding;
+  store;
+  limit;
+  async retrieve(question) {
+    const vector = await this.embedding.embed(question);
+    return this.store.search(vector, this.limit);
+  }
+};
+
+// src/rag/factory.ts
+function hasEmbeddingConfig(config, secrets) {
+  return Boolean((config.embedding.baseUrl || config.llm.baseUrl) && config.embedding.model && (secrets.embedding.apiKey || secrets.llm.apiKey));
+}
+async function createHybridRetriever(input) {
+  const retrievers = [new MessageFtsRetriever(input.messages, { excludeMessageIds: input.excludeMessageIds })];
+  const closers = [];
+  if (hasEmbeddingConfig(input.config, input.secrets)) {
+    const vectorStore = await LanceDbVectorStore.connectFromConfig(input.config);
+    retrievers.push(new VectorRetriever(createEmbeddingModel(input.config, input.secrets), vectorStore));
+    closers.push(() => vectorStore.close());
+  }
+  return {
+    retriever: new HybridRetriever(retrievers),
+    close: () => {
+      for (const closer of closers) {
+        closer();
+      }
+    }
+  };
+}
+
+// src/doctor/checks.ts
+function pass(name, message) {
+  return { name, status: "pass", message };
+}
+function warn(name, message) {
+  return { name, status: "warn", message };
+}
+function fail(name, message) {
+  return { name, status: "fail", message };
+}
+async function runDoctor(config, secrets, options = {}) {
+  const checks = [];
+  checks.push(await checkHomeDirectory());
+  checks.push(checkFeishu(config, secrets));
+  checks.push(checkLlmConfig(config, secrets));
+  checks.push(checkEmbeddingConfig(config, secrets));
+  checks.push(await checkSqlite(config));
+  checks.push(await checkFilePipeline(config));
+  checks.push(await checkLanceDb(config));
+  checks.push(checkRagPolicy());
+  if (options.online) {
+    checks.push(await checkChatModel(config, secrets));
+    checks.push(await checkEmbeddingModel(config, secrets));
+  }
+  return checks;
+}
+async function checkHomeDirectory() {
+  const home = getChatterCatcherHome();
+  try {
+    await fs6.mkdir(home, { recursive: true });
+    await fs6.access(home);
+    return pass("\u914D\u7F6E\u76EE\u5F55", home);
+  } catch (error) {
+    return fail("\u914D\u7F6E\u76EE\u5F55", error instanceof Error ? error.message : String(error));
+  }
+}
+function checkFeishu(config, secrets) {
+  const status = getGatewayStatus(config, secrets);
+  if (status.configured) {
+    return pass("\u98DE\u4E66 Gateway", status.message);
+  }
+  return warn("\u98DE\u4E66 Gateway", status.message);
+}
+function checkLlmConfig(config, secrets) {
+  if (!config.llm.baseUrl || !config.llm.model || !secrets.llm.apiKey) {
+    return warn("LLM \u914D\u7F6E", "\u672A\u914D\u7F6E\u5B8C\u6574\uFF1B@ \u63D0\u95EE\u65F6\u65E0\u6CD5\u751F\u6210\u6A21\u578B\u56DE\u7B54\u3002");
+  }
+  return pass("LLM \u914D\u7F6E", `${config.llm.model} @ ${config.llm.baseUrl}`);
+}
+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 LanceDB \u8BED\u4E49\u68C0\u7D22\u3002");
+  }
+  return pass("Embedding \u914D\u7F6E", `${config.embedding.model} @ ${config.embedding.baseUrl || config.llm.baseUrl}`);
+}
+async function checkSqlite(config) {
+  let database = null;
+  try {
+    database = openDatabase(config);
+    const messages = new MessageRepository(database);
+    return pass("SQLite", `${getDatabasePath(config)}\uFF1Bmessages=${messages.getMessageCount()}`);
+  } catch (error) {
+    return fail("SQLite", error instanceof Error ? error.message : String(error));
+  } finally {
+    database?.close();
+  }
+}
+async function checkFilePipeline(config) {
+  let database = null;
+  try {
+    database = openDatabase(config);
+    const messages = new MessageRepository(database);
+    const jobs = new FileJobRepository(database);
+    const fileCount = messages.listFiles(1e6).length;
+    const failedJobs = jobs.list(1e6, { status: "failed" });
+    if (failedJobs.length > 0) {
+      return warn("\u6587\u4EF6\u89E3\u6790", `files=${fileCount}\uFF1Bfailed_jobs=${failedJobs.length}\uFF1B\u53EF\u8FD0\u884C chattercatcher files jobs --status failed \u67E5\u770B\u3002`);
+    }
+    return pass("\u6587\u4EF6\u89E3\u6790", `files=${fileCount}\uFF1Bfailed_jobs=0`);
+  } catch (error) {
+    return fail("\u6587\u4EF6\u89E3\u6790", error instanceof Error ? error.message : String(error));
+  } finally {
+    database?.close();
+  }
+}
+async function checkLanceDb(config) {
+  let store = null;
+  try {
+    store = await LanceDbVectorStore.connectFromConfig(config);
+    const count = await store.count();
+    return pass("LanceDB", `${getLanceDbPath(config)}\uFF1Bvectors=${count}`);
+  } catch (error) {
+    return fail("LanceDB", error instanceof Error ? error.message : String(error));
+  } finally {
+    store?.close();
+  }
+}
+function checkRagPolicy() {
+  return pass("RAG \u7B56\u7565", "\u5F3A\u5236\u5148\u68C0\u7D22\u8BC1\u636E\u518D\u56DE\u7B54\uFF1B\u7981\u6B62\u5168\u91CF\u4E0A\u4E0B\u6587\u5806\u53E0\u3002");
+}
+async function checkChatModel(config, secrets) {
+  if (!config.llm.baseUrl || !config.llm.model || !secrets.llm.apiKey) {
+    return warn("LLM \u8FDE\u901A\u6027", "\u8DF3\u8FC7\uFF1ALLM \u914D\u7F6E\u4E0D\u5B8C\u6574\u3002");
+  }
+  try {
+    const answer = await createChatModel(config, secrets).complete([{ role: "user", content: "Reply with OK only." }]);
+    return pass("LLM \u8FDE\u901A\u6027", answer.slice(0, 80));
+  } catch (error) {
+    return fail("LLM \u8FDE\u901A\u6027", error instanceof Error ? error.message : String(error));
+  }
+}
+async function checkEmbeddingModel(config, secrets) {
+  if (!hasEmbeddingConfig(config, secrets)) {
+    return warn("Embedding \u8FDE\u901A\u6027", "\u8DF3\u8FC7\uFF1AEmbedding \u914D\u7F6E\u4E0D\u5B8C\u6574\u3002");
+  }
+  try {
+    const vector = await createEmbeddingModel(config, secrets).embed("chattercatcher doctor");
+    if (vector.length === 0) {
+      return fail("Embedding \u8FDE\u901A\u6027", "\u8FD4\u56DE\u5411\u91CF\u4E3A\u7A7A\u3002");
+    }
+    return pass("Embedding \u8FDE\u901A\u6027", `dimension=${vector.length}`);
+  } catch (error) {
+    return fail("Embedding \u8FDE\u901A\u6027", error instanceof Error ? error.message : String(error));
+  }
+}
+function formatDoctorChecks(checks) {
+  const icon = {
+    pass: "PASS",
+    warn: "WARN",
+    fail: "FAIL"
+  };
+  return checks.map((check) => `[${icon[check.status]}] ${check.name}: ${check.message}`).join("\n");
+}
+
+// src/export/data-export.ts
+import fs7 from "fs/promises";
+import path9 from "path";
+function parseJsonObject(value) {
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function parseJsonArray(value) {
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function defaultExportPath(config, exportedAt) {
+  const fileName = `chattercatcher-export-${exportedAt.replace(/[:.]/g, "-")}.json`;
+  return path9.join(resolveHomePath(config.storage.dataDir), "exports", fileName);
+}
+async function exportLocalData(input) {
+  const exportedAt = input.exportedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const outputPath = path9.resolve(input.outputPath ?? defaultExportPath(input.config, exportedAt));
+  const chats = input.database.prepare(
+    `
+      SELECT
+        id,
+        platform,
+        platform_chat_id AS platformChatId,
+        name,
+        created_at AS createdAt,
+        updated_at AS updatedAt
+      FROM chats
+      ORDER BY updated_at ASC
+    `
+  ).all();
+  const messages = input.database.prepare(
+    `
+        SELECT
+          id,
+          platform,
+          platform_message_id AS platformMessageId,
+          chat_id AS chatId,
+          sender_id AS senderId,
+          sender_name AS senderName,
+          message_type AS messageType,
+          text,
+          raw_payload_json AS rawPayloadJson,
+          sent_at AS sentAt,
+          received_at AS receivedAt,
+          created_at AS createdAt
+        FROM messages
+        ORDER BY sent_at ASC, created_at ASC
+      `
+  ).all().map(({ rawPayloadJson, ...message }) => ({
+    ...message,
+    rawPayload: parseJsonObject(rawPayloadJson)
+  }));
+  const chunks = input.database.prepare(
+    `
+        SELECT
+          id,
+          message_id AS messageId,
+          chunk_index AS chunkIndex,
+          text,
+          metadata_json AS metadataJson,
+          created_at AS createdAt
+        FROM message_chunks
+        ORDER BY message_id ASC, chunk_index ASC
+      `
+  ).all().map(({ metadataJson, ...chunk }) => ({
+    ...chunk,
+    metadata: parseJsonObject(metadataJson)
+  }));
+  const fileJobs = input.database.prepare(
+    `
+        SELECT
+          id,
+          source_path AS sourcePath,
+          stored_path AS storedPath,
+          file_name AS fileName,
+          status,
+          parser,
+          message_id AS messageId,
+          bytes,
+          characters,
+          warnings_json AS warningsJson,
+          error,
+          created_at AS createdAt,
+          updated_at AS updatedAt
+        FROM file_jobs
+        ORDER BY updated_at ASC
+      `
+  ).all().map(({ warningsJson, ...job }) => ({
+    ...job,
+    warnings: parseJsonArray(warningsJson).filter((item) => typeof item === "string")
+  }));
+  const payload = {
+    app: "ChatterCatcher",
+    schemaVersion: 1,
+    exportedAt,
+    note: "\u672C\u6587\u4EF6\u53EA\u5305\u542B\u672C\u5730\u77E5\u8BC6\u5E93\u6570\u636E\uFF0C\u4E0D\u5305\u542B API Key\u3001App Secret \u6216 token\u3002",
+    data: {
+      chats,
+      messages,
+      chunks,
+      fileJobs
+    }
+  };
+  await fs7.mkdir(path9.dirname(outputPath), { recursive: true });
+  await fs7.writeFile(outputPath, `${JSON.stringify(payload, null, 2)}
+`, "utf8");
+  return {
+    outputPath,
+    chats: chats.length,
+    messages: messages.length,
+    chunks: chunks.length,
+    fileJobs: fileJobs.length
+  };
+}
+
+// src/export/data-restore.ts
+import fs8 from "fs/promises";
+import path10 from "path";
+function asObject(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function asArray(value) {
+  return Array.isArray(value) ? value.map(asObject) : [];
+}
+function asString(value, field) {
+  if (typeof value !== "string") {
+    throw new Error(`\u6062\u590D\u6587\u4EF6\u5B57\u6BB5\u65E0\u6548\uFF1A${field}`);
+  }
+  return value;
+}
+function asOptionalString(value) {
+  return typeof value === "string" ? value : null;
+}
+function asOptionalNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function asJson(value, fallback) {
+  return JSON.stringify(value === void 0 ? fallback : value);
+}
+function parsePayload(raw) {
+  const parsed = asObject(JSON.parse(raw));
+  const data = asObject(parsed.data);
+  const payload = {
+    app: asString(parsed.app, "app"),
+    schemaVersion: typeof parsed.schemaVersion === "number" ? parsed.schemaVersion : NaN,
+    data: {
+      chats: asArray(data.chats),
+      messages: asArray(data.messages),
+      chunks: asArray(data.chunks),
+      fileJobs: asArray(data.fileJobs)
+    }
+  };
+  if (payload.app !== "ChatterCatcher" || payload.schemaVersion !== 1) {
+    throw new Error("\u6062\u590D\u6587\u4EF6\u4E0D\u662F ChatterCatcher schemaVersion=1 \u5BFC\u51FA\u3002");
+  }
+  return payload;
+}
+function clearDatabase(database) {
+  database.prepare("DELETE FROM message_chunks_fts").run();
+  database.prepare("DELETE FROM message_chunks").run();
+  database.prepare("DELETE FROM file_jobs").run();
+  database.prepare("DELETE FROM messages").run();
+  database.prepare("DELETE FROM chats").run();
+}
+async function restoreLocalData(input) {
+  const inputPath = path10.resolve(input.inputPath);
+  const payload = parsePayload(await fs8.readFile(inputPath, "utf8"));
+  const mode = input.replace ? "replace" : "merge";
+  const restore = input.database.transaction(() => {
+    if (input.replace) {
+      clearDatabase(input.database);
+    }
+    const upsertChat = input.database.prepare(`
+      INSERT INTO chats (id, platform, platform_chat_id, name, created_at, updated_at)
+      VALUES (@id, @platform, @platformChatId, @name, @createdAt, @updatedAt)
+      ON CONFLICT(id) DO UPDATE SET
+        platform = excluded.platform,
+        platform_chat_id = excluded.platform_chat_id,
+        name = excluded.name,
+        updated_at = excluded.updated_at
+    `);
+    const upsertMessage = input.database.prepare(`
+      INSERT INTO messages (
+        id, platform, platform_message_id, chat_id, sender_id, sender_name,
+        message_type, text, raw_payload_json, sent_at, received_at, created_at
+      )
+      VALUES (
+        @id, @platform, @platformMessageId, @chatId, @senderId, @senderName,
+        @messageType, @text, @rawPayloadJson, @sentAt, @receivedAt, @createdAt
+      )
+      ON CONFLICT(id) DO UPDATE SET
+        platform = excluded.platform,
+        platform_message_id = excluded.platform_message_id,
+        chat_id = excluded.chat_id,
+        sender_id = excluded.sender_id,
+        sender_name = excluded.sender_name,
+        message_type = excluded.message_type,
+        text = excluded.text,
+        raw_payload_json = excluded.raw_payload_json,
+        sent_at = excluded.sent_at,
+        received_at = excluded.received_at
+    `);
+    const upsertChunk = input.database.prepare(`
+      INSERT INTO message_chunks (id, message_id, chunk_index, text, metadata_json, created_at)
+      VALUES (@id, @messageId, @chunkIndex, @text, @metadataJson, @createdAt)
+      ON CONFLICT(id) DO UPDATE SET
+        message_id = excluded.message_id,
+        chunk_index = excluded.chunk_index,
+        text = excluded.text,
+        metadata_json = excluded.metadata_json
+    `);
+    const insertFts = input.database.prepare(`
+      INSERT INTO message_chunks_fts (text, chunk_id, message_id)
+      VALUES (@text, @chunkId, @messageId)
+    `);
+    const upsertFileJob = input.database.prepare(`
+      INSERT INTO file_jobs (
+        id, source_path, stored_path, file_name, status, parser, message_id,
+        bytes, characters, warnings_json, error, created_at, updated_at
+      )
+      VALUES (
+        @id, @sourcePath, @storedPath, @fileName, @status, @parser, @messageId,
+        @bytes, @characters, @warningsJson, @error, @createdAt, @updatedAt
+      )
+      ON CONFLICT(id) DO UPDATE SET
+        source_path = excluded.source_path,
+        stored_path = excluded.stored_path,
+        file_name = excluded.file_name,
+        status = excluded.status,
+        parser = excluded.parser,
+        message_id = excluded.message_id,
+        bytes = excluded.bytes,
+        characters = excluded.characters,
+        warnings_json = excluded.warnings_json,
+        error = excluded.error,
+        updated_at = excluded.updated_at
+    `);
+    for (const chat of payload.data.chats) {
+      upsertChat.run({
+        id: asString(chat.id, "chat.id"),
+        platform: asString(chat.platform, "chat.platform"),
+        platformChatId: asString(chat.platformChatId, "chat.platformChatId"),
+        name: asString(chat.name, "chat.name"),
+        createdAt: asString(chat.createdAt, "chat.createdAt"),
+        updatedAt: asString(chat.updatedAt, "chat.updatedAt")
+      });
+    }
+    for (const message of payload.data.messages) {
+      upsertMessage.run({
+        id: asString(message.id, "message.id"),
+        platform: asString(message.platform, "message.platform"),
+        platformMessageId: asString(message.platformMessageId, "message.platformMessageId"),
+        chatId: asString(message.chatId, "message.chatId"),
+        senderId: asString(message.senderId, "message.senderId"),
+        senderName: asString(message.senderName, "message.senderName"),
+        messageType: asString(message.messageType, "message.messageType"),
+        text: asString(message.text, "message.text"),
+        rawPayloadJson: asJson(message.rawPayload, {}),
+        sentAt: asString(message.sentAt, "message.sentAt"),
+        receivedAt: asString(message.receivedAt, "message.receivedAt"),
+        createdAt: asString(message.createdAt, "message.createdAt")
+      });
+      input.database.prepare("DELETE FROM message_chunks_fts WHERE message_id = ?").run(asString(message.id, "message.id"));
+    }
+    for (const chunk of payload.data.chunks) {
+      const messageId = asString(chunk.messageId, "chunk.messageId");
+      const chunkId = asString(chunk.id, "chunk.id");
+      const text = asString(chunk.text, "chunk.text");
+      upsertChunk.run({
+        id: chunkId,
+        messageId,
+        chunkIndex: asOptionalNumber(chunk.chunkIndex) ?? 0,
+        text,
+        metadataJson: asJson(chunk.metadata, {}),
+        createdAt: asString(chunk.createdAt, "chunk.createdAt")
+      });
+      insertFts.run({ text, chunkId, messageId });
+    }
+    for (const job of payload.data.fileJobs) {
+      upsertFileJob.run({
+        id: asString(job.id, "fileJob.id"),
+        sourcePath: asString(job.sourcePath, "fileJob.sourcePath"),
+        storedPath: asOptionalString(job.storedPath),
+        fileName: asString(job.fileName, "fileJob.fileName"),
+        status: asString(job.status, "fileJob.status"),
+        parser: asOptionalString(job.parser),
+        messageId: asOptionalString(job.messageId),
+        bytes: asOptionalNumber(job.bytes),
+        characters: asOptionalNumber(job.characters),
+        warningsJson: asJson(Array.isArray(job.warnings) ? job.warnings : [], []),
+        error: asOptionalString(job.error),
+        createdAt: asString(job.createdAt, "fileJob.createdAt"),
+        updatedAt: asString(job.updatedAt, "fileJob.updatedAt")
+      });
+    }
+  });
+  restore();
+  return {
+    inputPath,
+    mode,
+    chats: payload.data.chats.length,
+    messages: payload.data.messages.length,
+    chunks: payload.data.chunks.length,
+    fileJobs: payload.data.fileJobs.length
+  };
+}
+
+// src/feishu/gateway.ts
+import * as lark2 from "@larksuiteoapi/node-sdk";
+
+// src/rag/citations.ts
+function isOpaqueId(value) {
+  return Boolean(value && /^(ou|oc|om|cli|on|un|uid)_?[a-z0-9]+/i.test(value));
+}
+function formatTime(value) {
+  if (!value) {
+    return "\u672A\u77E5\u65F6\u95F4";
+  }
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    return value;
+  }
+  const pad = (input) => String(input).padStart(2, "0");
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+function formatSpeaker(source) {
+  if (source.type === "file") {
+    return isOpaqueId(source.label) ? "\u6587\u4EF6" : `\u6587\u4EF6 ${source.label}`;
+  }
+  if (source.sender && !isOpaqueId(source.sender)) {
+    return source.sender;
+  }
+  return "\u7FA4\u6210\u5458";
+}
+function clipText(value, maxLength) {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  return normalized.length > maxLength ? `${normalized.slice(0, maxLength)}...` : normalized;
+}
+function formatCitation(citation, options = {}) {
+  const maxTextLength = options.maxTextLength ?? 120;
+  const speaker = formatSpeaker(citation.source);
+  const time = formatTime(citation.source.timestamp);
+  const verb = citation.source.type === "file" ? "\u8BB0\u5F55" : "\u8BF4";
+  return `[${citation.marker}] ${speaker}\u5728 ${time} ${verb}\uFF1A\u201C${clipText(citation.text, maxTextLength)}\u201D`;
+}
+function formatCitations(citations, options = {}) {
+  return citations.map((citation) => formatCitation(citation, options)).join("\n");
+}
+
+// src/rag/answer.ts
+var DEFAULT_MAX_EVIDENCE_BLOCKS = 8;
+var DEFAULT_MAX_CHARS_PER_BLOCK = 1200;
+var SCORE_TIE_THRESHOLD = 0.15;
+function parseTimestamp(value) {
+  if (!value) {
+    return 0;
+  }
+  const time = Date.parse(value);
+  return Number.isFinite(time) ? time : 0;
+}
+function rankEvidenceForPrompt(evidence) {
+  return [...evidence].sort((left, right) => {
+    const scoreDiff = right.score - left.score;
+    if (Math.abs(scoreDiff) > SCORE_TIE_THRESHOLD) {
+      return scoreDiff;
+    }
+    const timeDiff = parseTimestamp(right.source.timestamp) - parseTimestamp(left.source.timestamp);
+    if (timeDiff !== 0) {
+      return timeDiff;
+    }
+    return scoreDiff;
+  });
+}
+function buildEvidencePrompt(question, evidence, options = {}) {
+  if (evidence.length === 0) {
+    throw new Error("RAG evidence is required before answer generation.");
+  }
+  const maxEvidenceBlocks = options.maxEvidenceBlocks ?? DEFAULT_MAX_EVIDENCE_BLOCKS;
+  const maxCharsPerBlock = options.maxCharsPerBlock ?? DEFAULT_MAX_CHARS_PER_BLOCK;
+  const selected = rankEvidenceForPrompt(evidence).slice(0, maxEvidenceBlocks);
+  const citations = selected.map((item, index) => ({
+    marker: `S${index + 1}`,
+    evidenceId: item.id,
+    source: item.source,
+    text: item.text
+  }));
+  const evidenceText = selected.map((item, index) => {
+    const marker = citations[index]?.marker;
+    const clippedText = item.text.length > maxCharsPerBlock ? `${item.text.slice(0, maxCharsPerBlock)}...` : item.text;
+    const sourceParts = [
+      item.source.label,
+      item.source.sender ? `\u53D1\u9001\u4EBA\uFF1A${item.source.sender}` : void 0,
+      item.source.timestamp ? `\u65F6\u95F4\uFF1A${item.source.timestamp}` : void 0,
+      item.source.location ? `\u4F4D\u7F6E\uFF1A${item.source.location}` : void 0
+    ].filter(Boolean);
+    return `[${marker}]
+\u6765\u6E90\uFF1A${sourceParts.join("\uFF1B")}
+\u5185\u5BB9\uFF1A${clippedText}`;
+  }).join("\n\n");
+  return {
+    citations,
+    messages: [
+      {
+        role: "system",
+        content: "\u4F60\u662F ChatterCatcher \u7684\u95EE\u7B54\u6A21\u5757\u3002\u53EA\u80FD\u6839\u636E\u63D0\u4F9B\u7684\u68C0\u7D22\u8BC1\u636E\u56DE\u7B54\uFF0C\u5FC5\u987B\u7B80\u77ED\u76F4\u63A5\u3002\u4E8B\u5B9E\u6027\u7ED3\u8BBA\u5FC5\u987B\u5F15\u7528 [S1] \u8FD9\u6837\u7684\u6765\u6E90\u6807\u8BB0\u3002\u8BC1\u636E\u4E0D\u8DB3\u65F6\u8BF4\u4E0D\u77E5\u9053\uFF0C\u4E0D\u8981\u731C\u3002\u82E5\u8BC1\u636E\u4E92\u76F8\u77DB\u76FE\uFF0C\u4F18\u5148\u91C7\u7528\u65F6\u95F4\u66F4\u65B0\u4E14\u8868\u8FF0\u660E\u786E\u7684\u8BC1\u636E\uFF1B\u5982\u679C\u8F83\u65B0\u7684\u8BC1\u636E\u53EA\u662F\u8BA8\u8BBA\u3001\u731C\u6D4B\u6216\u4E0D\u786E\u5B9A\u8868\u8FBE\uFF0C\u4E0D\u8981\u628A\u5B83\u5F53\u4F5C\u786E\u5B9A\u66F4\u65B0\u3002"
+      },
+      {
+        role: "user",
+        content: `\u95EE\u9898\uFF1A${question}
+
+\u8BC1\u636E\u5904\u7406\u89C4\u5219\uFF1A
+1. \u5148\u5224\u65AD\u8BC1\u636E\u662F\u5426\u8DB3\u4EE5\u56DE\u7B54\u95EE\u9898\u3002
+2. \u540C\u4E00\u4E8B\u9879\u51FA\u73B0\u591A\u4E2A\u7248\u672C\u65F6\uFF0C\u9ED8\u8BA4\u8F83\u65B0\u7684\u660E\u786E\u6D88\u606F\u4F18\u5148\u3002
+3. \u56DE\u7B54\u53EA\u5F15\u7528\u5B9E\u9645\u652F\u6491\u7ED3\u8BBA\u7684\u8BC1\u636E\u3002
+
+\u68C0\u7D22\u8BC1\u636E\uFF1A
+${evidenceText}`
+      }
+    ]
+  };
+}
+async function generateGroundedAnswer(input) {
+  const prompt = buildEvidencePrompt(input.question, input.evidence);
+  const answer = await input.model.complete(prompt.messages);
+  return {
+    answer,
+    citations: prompt.citations
+  };
+}
+
+// src/rag/qa-service.ts
+async function askWithRag(input) {
+  const evidence = await input.retriever.retrieve(input.question);
+  if (evidence.length === 0) {
+    return {
+      answer: "\u4E0D\u77E5\u9053\u3002\u5F53\u524D\u672C\u5730\u77E5\u8BC6\u5E93\u6CA1\u6709\u68C0\u7D22\u5230\u8DB3\u591F\u8BC1\u636E\u3002",
+      citations: []
+    };
+  }
+  return generateGroundedAnswer({
+    question: input.question,
+    evidence,
+    model: input.model
+  });
+}
+
+// src/feishu/question.ts
+function parseTextContent(content) {
+  if (!content) {
+    return "";
+  }
+  try {
+    const parsed = JSON.parse(content);
+    return typeof parsed.text === "string" ? parsed.text : "";
+  } catch {
+    return content;
+  }
+}
+function stripMentions(text, mentions) {
+  let result = text;
+  for (const mention of mentions ?? []) {
+    for (const token of [mention.key, mention.name, mention.name ? `@${mention.name}` : void 0]) {
+      if (token) {
+        result = result.replaceAll(token, " ");
+      }
+    }
+  }
+  return result.replace(/@\s*ChatterCatcher/gi, " ").replace(/@/g, " ").replace(/\s+/g, " ").trim();
+}
+function isFeishuMessageAddressedToBot(payload) {
+  const message = payload.event?.message;
+  if (!message || message.message_type !== "text") {
+    return false;
+  }
+  const mentions = message.mentions ?? [];
+  const text = parseTextContent(message.content);
+  return mentions.length > 0 || /@?ChatterCatcher/i.test(text);
+}
+function getFeishuQuestionDecision(payload, config) {
+  const message = payload.event?.message;
+  if (!message?.chat_id || message.message_type !== "text") {
+    return {
+      shouldAnswer: false,
+      reason: "\u4E0D\u662F\u53EF\u56DE\u7B54\u7684\u6587\u672C\u6D88\u606F\u3002"
+    };
+  }
+  const mentions = message.mentions ?? [];
+  const text = parseTextContent(message.content);
+  const hasMention = isFeishuMessageAddressedToBot(payload);
+  if (config.feishu.requireMention && !hasMention) {
+    return {
+      shouldAnswer: false,
+      reason: "\u7FA4\u804A\u914D\u7F6E\u4E3A\u5FC5\u987B @ \u540E\u56DE\u7B54\u3002"
+    };
+  }
+  const question = stripMentions(text, mentions);
+  if (!question) {
+    return {
+      shouldAnswer: false,
+      reason: "\u6CA1\u6709\u53EF\u56DE\u7B54\u7684\u95EE\u9898\u6587\u672C\u3002"
+    };
+  }
+  return {
+    shouldAnswer: true,
+    question,
+    chatId: message.chat_id
+  };
+}
+var FeishuQuestionHandler = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  async sendResponse(chatId, messageId, text) {
+    if (messageId && this.options.sender.replyTextToMessage) {
+      try {
+        await this.options.sender.replyTextToMessage(messageId, text);
+        return;
+      } catch (error) {
+        console.log(`\u98DE\u4E66\u56DE\u590D\u539F\u6D88\u606F\u5931\u8D25\uFF0C\u9000\u56DE\u7FA4\u6D88\u606F\uFF1A${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    await this.options.sender.sendTextToChat(chatId, text);
+  }
+  async acknowledgeQuestion(chatId, messageId) {
+    if (!messageId) {
+      return;
+    }
+    if (this.options.sender.addReactionToMessage) {
+      try {
+        await this.options.sender.addReactionToMessage(messageId, this.options.thinkingEmojiType ?? "keyboard");
+        return;
+      } catch (error) {
+        console.log(`\u98DE\u4E66\u63D0\u95EE\u8868\u60C5\u53CD\u9988\u5931\u8D25\uFF0C\u6539\u7528\u6587\u5B57\u53CD\u9988\uFF1A${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    await this.sendResponse(chatId, messageId, "\u6536\u5230\uFF0C\u6B63\u5728\u67E5\u3002");
+  }
+  async handle(payload, options = {}) {
+    const decision = getFeishuQuestionDecision(payload, this.options.config);
+    if (!decision.shouldAnswer || !decision.question || !decision.chatId) {
+      return decision;
+    }
+    const questionMessageId = payload.event?.message?.message_id;
+    await this.acknowledgeQuestion(decision.chatId, questionMessageId);
+    const { retriever, close } = await createHybridRetriever({
+      config: this.options.config,
+      secrets: this.options.secrets,
+      messages: new MessageRepository(this.options.database),
+      excludeMessageIds: options.excludeMessageIds
+    });
+    try {
+      try {
+        const result = await askWithRag({
+          question: decision.question,
+          retriever,
+          model: this.options.model
+        });
+        const citations = formatCitations(result.citations);
+        const text = citations ? `${result.answer}
+
+\u5F15\u7528\uFF1A
+${citations}` : result.answer;
+        await this.sendResponse(decision.chatId, questionMessageId, text);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        await this.sendResponse(decision.chatId, questionMessageId, `\u6682\u65F6\u65E0\u6CD5\u56DE\u7B54\uFF1A${message}`);
+      }
+      return decision;
+    } finally {
+      close();
+    }
+  }
+};
+
+// src/feishu/sender.ts
+import * as lark from "@larksuiteoapi/node-sdk";
+function mapDomain(domain) {
+  return domain === "lark" ? lark.Domain.Lark : lark.Domain.Feishu;
+}
+var FeishuMessageSender = class _FeishuMessageSender {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  static fromConfig(config, secrets) {
+    const client = new lark.Client({
+      appId: config.feishu.appId,
+      appSecret: secrets.feishu.appSecret,
+      domain: mapDomain(config.feishu.domain)
+    });
+    return new _FeishuMessageSender(client);
+  }
+  async sendTextToChat(chatId, text) {
+    const payload = {
+      data: {
+        receive_id: chatId,
+        msg_type: "text",
+        content: JSON.stringify({ text })
+      },
+      params: {
+        receive_id_type: "chat_id"
+      }
+    };
+    if (this.client.im.v1?.message.create) {
+      await this.client.im.v1.message.create(payload);
+      return;
+    }
+    if (this.client.im.message?.create) {
+      await this.client.im.message.create(payload);
+      return;
+    }
+    {
+      throw new Error("\u5F53\u524D\u98DE\u4E66 SDK \u4E0D\u652F\u6301\u6D88\u606F\u53D1\u9001\u63A5\u53E3\u3002");
+    }
+  }
+  async replyTextToMessage(messageId, text) {
+    const payload = {
+      path: {
+        message_id: messageId
+      },
+      data: {
+        msg_type: "text",
+        content: JSON.stringify({ text })
+      }
+    };
+    if (this.client.im.v1?.message.reply) {
+      await this.client.im.v1.message.reply(payload);
+      return;
+    }
+    if (this.client.im.message?.reply) {
+      await this.client.im.message.reply(payload);
+      return;
+    }
+    throw new Error("\u5F53\u524D\u98DE\u4E66 SDK \u4E0D\u652F\u6301\u6D88\u606F\u56DE\u590D\u63A5\u53E3\u3002");
+  }
+  async addReactionToMessage(messageId, emojiType) {
+    if (!this.client.im.v1?.messageReaction?.create) {
+      throw new Error("\u5F53\u524D\u98DE\u4E66 SDK \u4E0D\u652F\u6301\u6D88\u606F\u8868\u60C5\u56DE\u590D\u63A5\u53E3\u3002");
+    }
+    await this.client.im.v1.messageReaction.create({
+      path: {
+        message_id: messageId
+      },
+      data: {
+        reaction_type: {
+          emoji_type: emojiType
+        }
+      }
+    });
+  }
+};
+
+// src/feishu/gateway.ts
+function assertFeishuConfig(config, secrets) {
+  if (!config.feishu.appId || !secrets.feishu.appSecret) {
+    throw new Error("\u98DE\u4E66\u914D\u7F6E\u4E0D\u5B8C\u6574\u3002\u8BF7\u5148\u8FD0\u884C chattercatcher setup \u6216 chattercatcher settings\u3002");
+  }
+}
+function createFeishuEventDispatcher(options) {
+  const answeredMessageIds = /* @__PURE__ */ new Set();
+  return new lark2.EventDispatcher({}).register({
+    "im.message.receive_v1": async (data) => {
+      const payload = { event: data };
+      if (options.questionHandler && isFeishuMessageAddressedToBot(payload)) {
+        const platformMessageId = data?.message?.message_id;
+        if (platformMessageId && answeredMessageIds.has(platformMessageId)) {
+          console.log("\u98DE\u4E66\u63D0\u95EE\u91CD\u590D\u6295\u9012\uFF1A\u5DF2\u8DF3\u8FC7\u56DE\u7B54\u3002");
+          return;
+        }
+        const decision = getFeishuQuestionDecision(payload, options.config);
+        if (decision.shouldAnswer) {
+          if (platformMessageId) {
+            answeredMessageIds.add(platformMessageId);
+          }
+          await options.questionHandler.handle(payload);
+          console.log("\u98DE\u4E66\u63D0\u95EE\u5DF2\u56DE\u7B54\uFF1A\u8DF3\u8FC7\u77E5\u8BC6\u5E93\u5165\u5E93\u3002");
+          return;
+        }
+      }
+      const result = options.resourceDownloader ? await options.ingestor.ingestFeishuEventAndDownloadAttachments({
+        payload,
+        downloader: options.resourceDownloader,
+        config: options.config,
+        vectorIndexMessage: options.attachmentVectorIndexer
+      }) : options.ingestor.ingestFeishuEvent(payload);
+      if (!result.accepted) {
+        console.log(`\u98DE\u4E66\u6D88\u606F\u672A\u5165\u5E93\uFF1A${result.reason}`);
+        return;
+      }
+      console.log(`\u98DE\u4E66\u6D88\u606F\u5DF2\u5165\u5E93\uFF1A${result.messageId}`);
+      if (result.duplicate) {
+        console.log("\u98DE\u4E66\u6D88\u606F\u91CD\u590D\u6295\u9012\uFF1A\u5DF2\u8DF3\u8FC7\u9644\u4EF6\u5904\u7406\u548C\u56DE\u7B54\u3002");
+        return;
+      }
+      if (result.attachment?.downloaded) {
+        console.log(`\u98DE\u4E66\u9644\u4EF6\u5DF2\u4E0B\u8F7D\uFF1A${result.attachment.downloaded.storedPath}`);
+        if (result.attachment.indexedMessageId) {
+          console.log(`\u98DE\u4E66\u9644\u4EF6\u5DF2\u8FDB\u5165 RAG\uFF1A${result.attachment.indexedMessageId}`);
+          if (result.attachment.vectorIndexed) {
+            console.log(
+              `\u98DE\u4E66\u9644\u4EF6\u5411\u91CF\u7D22\u5F15\u5B8C\u6210\uFF1Achunks=${result.attachment.vectorIndexed.chunks}, vectors=${result.attachment.vectorIndexed.vectors}`
+            );
+          }
+        } else if (result.attachment.skippedReason) {
+          console.log(`\u98DE\u4E66\u9644\u4EF6\u6682\u672A\u8FDB\u5165 RAG\uFF1A${result.attachment.skippedReason}`);
+        }
+      }
+      if (options.questionHandler) {
+        const decision = await options.questionHandler.handle(payload, {
+          excludeMessageIds: result.messageId ? [result.messageId] : []
+        });
+        if (!decision.shouldAnswer) {
+          console.log(`\u98DE\u4E66\u6D88\u606F\u4E0D\u89E6\u53D1\u56DE\u7B54\uFF1A${decision.reason}`);
+        }
+      }
+    }
+  });
+}
+function createFeishuGateway(options) {
+  assertFeishuConfig(options.config, options.secrets);
+  const wsClient = options.wsClientFactory?.({
+    appId: options.config.feishu.appId,
+    appSecret: options.secrets.feishu.appSecret,
+    domain: mapDomain(options.config.feishu.domain),
+    onReady: () => console.log("\u98DE\u4E66\u957F\u8FDE\u63A5\u5DF2\u5EFA\u7ACB\u3002"),
+    onError: (error) => console.error(`\u98DE\u4E66\u957F\u8FDE\u63A5\u9519\u8BEF\uFF1A${error.message}`),
+    onReconnecting: () => console.log("\u98DE\u4E66\u957F\u8FDE\u63A5\u6B63\u5728\u91CD\u8FDE\u3002"),
+    onReconnected: () => console.log("\u98DE\u4E66\u957F\u8FDE\u63A5\u5DF2\u91CD\u8FDE\u3002")
+  }) ?? new lark2.WSClient({
+    appId: options.config.feishu.appId,
+    appSecret: options.secrets.feishu.appSecret,
+    domain: mapDomain(options.config.feishu.domain),
+    loggerLevel: lark2.LoggerLevel.info,
+    source: "chattercatcher",
+    onReady: () => console.log("\u98DE\u4E66\u957F\u8FDE\u63A5\u5DF2\u5EFA\u7ACB\u3002"),
+    onError: (error) => console.error(`\u98DE\u4E66\u957F\u8FDE\u63A5\u9519\u8BEF\uFF1A${error.message}`),
+    onReconnecting: () => console.log("\u98DE\u4E66\u957F\u8FDE\u63A5\u6B63\u5728\u91CD\u8FDE\u3002"),
+    onReconnected: () => console.log("\u98DE\u4E66\u957F\u8FDE\u63A5\u5DF2\u91CD\u8FDE\u3002")
+  });
+  const eventDispatcher = createFeishuEventDispatcher({
+    config: options.config,
+    ingestor: options.ingestor,
+    questionHandler: options.questionHandler,
+    resourceDownloader: options.resourceDownloader,
+    attachmentVectorIndexer: options.attachmentVectorIndexer
+  });
+  return {
+    async start() {
+      await wsClient.start({ eventDispatcher });
+    },
+    stop() {
+      wsClient.close({ force: true });
+    }
+  };
+}
+
+// src/feishu/normalize.ts
+function asObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
+function parseContent(content) {
+  if (!content) {
+    return {};
+  }
+  try {
+    return asObject2(JSON.parse(content));
+  } catch {
+    return { text: content };
+  }
+}
+function stringifyUnknown(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  return "";
+}
+function numberUnknown(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  return void 0;
+}
+function extractPostText(content) {
+  const post = asObject2(content.post);
+  const zhCn = asObject2(post.zh_cn ?? post["zh-CN"] ?? post.en_us ?? post["en-US"]);
+  const title = stringifyUnknown(zhCn.title);
+  const blocks = Array.isArray(zhCn.content) ? zhCn.content : [];
+  const parts = [];
+  if (title) {
+    parts.push(title);
+  }
+  for (const block of blocks) {
+    if (!Array.isArray(block)) {
+      continue;
+    }
+    for (const item of block) {
+      const object = asObject2(item);
+      const text = stringifyUnknown(object.text);
+      if (text) {
+        parts.push(text);
+      }
+    }
+  }
+  return parts.join(" ").trim();
+}
+function extractFeishuAttachment(messageType, content) {
+  if (messageType === "image") {
+    const fileKey2 = stringifyUnknown(content.image_key);
+    return fileKey2 ? { platform: "feishu", kind: "image", fileKey: fileKey2 } : void 0;
+  }
+  if (messageType === "audio") {
+    const fileKey2 = stringifyUnknown(content.file_key);
+    return fileKey2 ? { platform: "feishu", kind: "audio", fileKey: fileKey2 } : void 0;
+  }
+  if (messageType !== "file" && messageType !== "media") {
+    return void 0;
+  }
+  const fileKey = stringifyUnknown(content.file_key);
+  if (!fileKey) {
+    return void 0;
+  }
+  return {
+    platform: "feishu",
+    kind: messageType,
+    fileKey,
+    fileName: stringifyUnknown(content.file_name) || void 0,
+    mimeType: stringifyUnknown(content.mime_type) || void 0,
+    size: numberUnknown(content.file_size ?? content.size)
+  };
+}
+function extractMessageText(messageType, content) {
+  if (messageType === "text") {
+    return stringifyUnknown(content.text).trim();
+  }
+  if (messageType === "post") {
+    return extractPostText(content);
+  }
+  if (messageType === "image") {
+    return `[\u56FE\u7247] ${stringifyUnknown(content.image_key)}`.trim();
+  }
+  if (messageType === "file") {
+    return `[\u6587\u4EF6] ${stringifyUnknown(content.file_name) || stringifyUnknown(content.file_key)}`.trim();
+  }
+  if (messageType === "audio") {
+    return `[\u8BED\u97F3] ${stringifyUnknown(content.file_key)}`.trim();
+  }
+  if (messageType === "media") {
+    return `[\u5A92\u4F53] ${stringifyUnknown(content.file_name) || stringifyUnknown(content.file_key)}`.trim();
+  }
+  const fallback = Object.entries(content).map(([key, value]) => `${key}: ${stringifyUnknown(value)}`).filter((line) => !line.endsWith(": ")).join(" ");
+  return fallback || `[${messageType}]`;
+}
+function normalizeTimestamp(createTime) {
+  if (!createTime) {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+  const numeric = Number(createTime);
+  if (Number.isFinite(numeric)) {
+    const milliseconds = createTime.length <= 10 ? numeric * 1e3 : numeric;
+    return new Date(milliseconds).toISOString();
+  }
+  const date = new Date(createTime);
+  if (Number.isNaN(date.getTime())) {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+  return date.toISOString();
+}
+function normalizeFeishuReceiveMessageEvent(payload) {
+  const event = payload.event;
+  const message = event?.message;
+  if (!event || !message?.message_id || !message.chat_id) {
+    return null;
+  }
+  const messageType = message.message_type || "unknown";
+  const content = parseContent(message.content);
+  const text = extractMessageText(messageType, content);
+  if (!text) {
+    return null;
+  }
+  const senderId = event.sender?.sender_id?.open_id || event.sender?.sender_id?.user_id || event.sender?.sender_id?.union_id || "unknown";
+  return {
+    platform: "feishu",
+    platformChatId: message.chat_id,
+    chatName: message.chat_id,
+    platformMessageId: message.message_id,
+    senderId,
+    senderName: senderId,
+    messageType,
+    text,
+    sentAt: normalizeTimestamp(message.create_time),
+    rawPayload: {
+      platform: "feishu",
+      raw: payload,
+      content,
+      attachment: extractFeishuAttachment(messageType, content)
+    }
+  };
+}
+
+// src/feishu/resource-downloader.ts
+import * as lark3 from "@larksuiteoapi/node-sdk";
+import fs9 from "fs/promises";
+import path11 from "path";
+var RESOURCE_TYPE_BY_KIND = {
+  file: "file",
+  image: "image",
+  audio: "audio",
+  media: "media"
+};
+var DEFAULT_EXTENSION_BY_KIND = {
+  file: ".bin",
+  image: ".jpg",
+  audio: ".mp3",
+  media: ".mp4"
+};
+function sanitizeFileName(value) {
+  const sanitized = value.replace(/[<>:"/\\|?*\u0000-\u001f]/g, "_").trim();
+  return sanitized || "feishu-resource";
+}
+function buildStoredFileName(input) {
+  const rawName = input.attachment.fileName || `${input.attachment.fileKey}${DEFAULT_EXTENSION_BY_KIND[input.attachment.kind]}`;
+  return `${input.messageId}-${sanitizeFileName(rawName)}`;
+}
+var FeishuResourceDownloader = class _FeishuResourceDownloader {
+  constructor(client, dataDir) {
+    this.client = client;
+    this.dataDir = dataDir;
+  }
+  client;
+  dataDir;
+  static fromConfig(config, secrets) {
+    const client = new lark3.Client({
+      appId: config.feishu.appId,
+      appSecret: secrets.feishu.appSecret,
+      domain: mapDomain(config.feishu.domain)
+    });
+    return new _FeishuResourceDownloader(client, resolveHomePath(config.storage.dataDir));
+  }
+  async download(input) {
+    const resourceType = RESOURCE_TYPE_BY_KIND[input.attachment.kind];
+    const targetDir = path11.join(this.dataDir, "files", "feishu");
+    await fs9.mkdir(targetDir, { recursive: true });
+    const fileName = buildStoredFileName(input);
+    const storedPath = path11.join(targetDir, fileName);
+    const payload = {
+      params: { type: resourceType },
+      path: { message_id: input.messageId, file_key: input.attachment.fileKey }
+    };
+    const api = this.client.im.v1?.messageResource?.get ?? this.client.im.messageResource?.get;
+    if (!api) {
+      throw new Error("\u5F53\u524D\u98DE\u4E66 SDK \u4E0D\u652F\u6301 messageResource.get\uFF0C\u65E0\u6CD5\u4E0B\u8F7D\u6D88\u606F\u8D44\u6E90\u3002");
+    }
+    const response = await api(payload);
+    await response.writeFile(storedPath);
+    return {
+      messageId: input.messageId,
+      fileKey: input.attachment.fileKey,
+      fileName,
+      resourceType,
+      storedPath
+    };
+  }
+};
+
+// src/files/ingest.ts
+import crypto3 from "crypto";
+import fs11 from "fs/promises";
+import path13 from "path";
+
+// src/files/parser.ts
+import fs10 from "fs/promises";
+import path12 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 = path12.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 = path12.extname(filePath).toLowerCase();
+  if (TEXT_EXTENSIONS.has(extension)) {
+    return {
+      text: await fs10.readFile(filePath, "utf8"),
+      parser: "text",
+      warnings: []
+    };
+  }
+  if (DOCX_EXTENSIONS.has(extension)) {
+    const result = await mammoth.extractRawText({ path: filePath });
+    return {
+      text: result.value,
+      parser: "docx",
+      warnings: result.messages.map((message) => message.message)
+    };
+  }
+  if (PDF_EXTENSIONS.has(extension)) {
+    const buffer = await fs10.readFile(filePath);
+    const parser = new PDFParse({ data: buffer });
+    try {
+      const result = await parser.getText();
+      return {
+        text: result.text,
+        parser: "pdf",
+        warnings: []
+      };
+    } finally {
+      await parser.destroy();
+    }
+  }
+  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`);
+}
+
+// src/files/ingest.ts
+function isSupportedTextFile(filePath) {
+  return isSupportedParseFile(filePath);
+}
+function ensureSupportedTextFile(filePath) {
+  if (!isSupportedTextFile(filePath)) {
+    const extension = path13.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`);
+  }
+}
+function stableStoredName(sourcePath, fileName) {
+  const digest = crypto3.createHash("sha256").update(sourcePath).digest("hex").slice(0, 16);
+  return `${digest}-${fileName}`;
+}
+async function ingestLocalFile(input) {
+  const sourcePath = path13.resolve(input.filePath);
+  const fileName = path13.basename(sourcePath);
+  const jobId = input.jobs?.start({ sourcePath, fileName });
+  try {
+    ensureSupportedTextFile(sourcePath);
+    const stat = await fs11.stat(sourcePath);
+    if (!stat.isFile()) {
+      throw new Error(`\u4E0D\u662F\u6587\u4EF6\uFF1A${sourcePath}`);
+    }
+    const parsed = await parseFileToText(sourcePath);
+    const text = parsed.text.trim();
+    if (!text) {
+      throw new Error(`\u6587\u4EF6\u6CA1\u6709\u53EF\u7D22\u5F15\u6587\u672C\uFF1A${sourcePath}`);
+    }
+    const fileDir = path13.join(resolveHomePath(input.config.storage.dataDir), "files");
+    await fs11.mkdir(fileDir, { recursive: true });
+    const storedPath = path13.join(fileDir, stableStoredName(sourcePath, fileName));
+    await fs11.copyFile(sourcePath, storedPath);
+    const messageId = input.messages.ingest({
+      platform: "local-file",
+      platformChatId: "local-files",
+      chatName: "\u6587\u4EF6\u5E93",
+      platformMessageId: sourcePath,
+      senderId: "local-file",
+      senderName: fileName,
+      messageType: "file",
+      text,
+      sentAt: stat.mtime.toISOString(),
+      rawPayload: {
+        sourcePath,
+        storedPath,
+        bytes: stat.size,
+        fileName,
+        parser: parsed.parser,
+        parserWarnings: parsed.warnings
+      }
+    });
+    input.jobs?.complete({
+      id: jobId ?? "",
+      storedPath,
+      parser: parsed.parser,
+      messageId,
+      bytes: stat.size,
+      characters: text.length,
+      warnings: parsed.warnings
+    });
+    return {
+      messageId,
+      sourcePath,
+      storedPath,
+      fileName,
+      bytes: stat.size,
+      characters: text.length,
+      parser: parsed.parser,
+      warnings: parsed.warnings,
+      jobId
+    };
+  } catch (error) {
+    if (jobId) {
+      input.jobs?.fail({
+        id: jobId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+    throw error;
+  }
+}
+
+// src/gateway/ingest.ts
+function extractAttachment(message) {
+  const raw = message.rawPayload;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return void 0;
+  }
+  const attachment = raw.attachment;
+  if (!attachment || typeof attachment !== "object" || Array.isArray(attachment)) {
+    return void 0;
+  }
+  const candidate = attachment;
+  if (candidate.platform !== "feishu" || !candidate.kind || !candidate.fileKey) {
+    return void 0;
+  }
+  return candidate;
+}
+var GatewayIngestor = class {
+  messages;
+  jobs;
+  constructor(database) {
+    this.messages = new MessageRepository(database);
+    this.jobs = new FileJobRepository(database);
+  }
+  ingestFeishuEvent(payload) {
+    const normalized = normalizeFeishuReceiveMessageEvent(payload);
+    if (!normalized) {
+      return {
+        accepted: false,
+        reason: "\u4E8B\u4EF6\u4E0D\u662F\u53EF\u5165\u5E93\u7684\u98DE\u4E66\u6D88\u606F\u3002"
+      };
+    }
+    const duplicate = this.messages.hasPlatformMessage(normalized.platform, normalized.platformMessageId);
+    const messageId = this.messages.ingest(normalized);
+    return {
+      accepted: true,
+      messageId,
+      message: normalized,
+      duplicate
+    };
+  }
+  async ingestFeishuEventAndDownloadAttachments(input) {
+    const result = this.ingestFeishuEvent(input.payload);
+    if (!result.accepted || !result.messageId || !result.message || result.duplicate) {
+      return result;
+    }
+    const attachment = extractAttachment(result.message);
+    if (!attachment) {
+      return result;
+    }
+    const downloaded = await input.downloader.download({
+      messageId: result.message.platformMessageId,
+      attachment
+    });
+    if (!isSupportedTextFile(downloaded.storedPath)) {
+      return {
+        ...result,
+        attachment: {
+          downloaded,
+          skippedReason: "\u9644\u4EF6\u5DF2\u4E0B\u8F7D\uFF0C\u4F46\u5F53\u524D\u6587\u4EF6\u7C7B\u578B\u6682\u4E0D\u652F\u6301\u89E3\u6790\u3002"
+        }
+      };
+    }
+    const indexedMessageId = await ingestLocalFile({
+      config: input.config,
+      messages: this.messages,
+      jobs: this.jobs,
+      filePath: downloaded.storedPath
+    }).then((file) => file.messageId);
+    const vectorIndexed = input.vectorIndexMessage ? await input.vectorIndexMessage(indexedMessageId) : void 0;
+    return {
+      ...result,
+      attachment: {
+        downloaded,
+        indexedMessageId,
+        vectorIndexed
+      }
+    };
+  }
+};
+
+// src/logs/reader.ts
+import fs12 from "fs/promises";
+import { watch } from "fs";
+import path14 from "path";
+function getLogsDirectory() {
+  return path14.join(getChatterCatcherHome(), "logs");
+}
+function resolveLogPath(fileName, logsDir = getLogsDirectory()) {
+  return path14.isAbsolute(fileName) ? fileName : path14.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 fs12.readdir(logsDir, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+  const files = await Promise.all(
+    entries.filter((entry) => entry.isFile() && entry.name.endsWith(".log")).map(async (entry) => {
+      const filePath = path14.join(logsDir, entry.name);
+      const stats = await fs12.stat(filePath);
+      return {
+        name: entry.name,
+        path: filePath,
+        updatedAt: stats.mtime,
+        bytes: stats.size
+      };
+    })
+  );
+  return files.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(input) {
+  const stats = await fs12.stat(input.filePath);
+  const content = await fs12.readFile(input.filePath, "utf8");
+  return {
+    file: {
+      name: path14.basename(input.filePath),
+      path: input.filePath,
+      updatedAt: stats.mtime,
+      bytes: stats.size
+    },
+    content: tailLines(content, normalizeLineCount(input.lines))
+  };
+}
+async function readLatestLogTail(input = {}) {
+  if (input.fileName) {
+    return readLogTail({
+      filePath: resolveLogPath(input.fileName, input.logsDir),
+      lines: input.lines
+    });
+  }
+  const [latest] = await listLogFiles(input.logsDir);
+  if (!latest) {
+    return null;
+  }
+  return readLogTail({ filePath: latest.path, lines: input.lines });
+}
+async function followLogFile(input) {
+  let offset = (await fs12.stat(input.filePath)).size;
+  const directory = path14.dirname(input.filePath);
+  const fileName = path14.basename(input.filePath);
+  async function readAppended() {
+    const stats = await fs12.stat(input.filePath);
+    if (stats.size < offset) {
+      offset = 0;
+    }
+    if (stats.size === offset) {
+      return;
+    }
+    const handle = await fs12.open(input.filePath, "r");
+    try {
+      const length = stats.size - offset;
+      const buffer = Buffer.alloc(length);
+      await handle.read(buffer, 0, length, offset);
+      offset = stats.size;
+      input.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) => {
+      input.onError?.(error instanceof Error ? error : new Error(String(error)));
+    });
+  });
+  return () => watcher.close();
+}
+
+// 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 index = 0; index < left.length; index += 1) {
+    const leftValue = left[index] ?? 0;
+    const rightValue = right[index] ?? 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/indexer.ts
+async function indexMessageChunks(input) {
+  const chunks = input.messageIds ? input.messages.listMessageChunksByMessageIds(input.messageIds, input.limit ?? 1e4) : input.messages.listAllMessageChunks(input.limit ?? 1e4);
+  if (chunks.length === 0) {
+    return { chunks: 0, vectors: 0 };
+  }
+  const vectors = await input.embedding.embedBatch(chunks.map((chunk) => chunk.text));
+  const records = [];
+  for (const [index, chunk] of chunks.entries()) {
+    const vector = vectors[index];
+    if (!vector || vector.length === 0) {
+      continue;
+    }
+    records.push({
+      id: chunk.chunkId,
+      vector,
+      evidence: {
+        id: chunk.chunkId,
+        text: chunk.text,
+        score: 1,
+        source: toEvidenceSource2(chunk)
+      }
+    });
+  }
+  await input.store.upsert(records);
+  return {
+    chunks: chunks.length,
+    vectors: records.length
+  };
+}
+function toEvidenceSource2(chunk) {
+  if (chunk.messageType === "file") {
+    return {
+      type: "file",
+      label: chunk.senderName,
+      timestamp: chunk.sentAt
+    };
+  }
+  return {
+    type: "message",
+    label: chunk.chatName,
+    sender: chunk.senderName,
+    timestamp: chunk.sentAt
+  };
+}
+
+// src/rag/manual-index.ts
+async function processMessagesNow(input) {
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  if (!hasEmbeddingConfig(input.config, input.secrets)) {
+    return {
+      status: "skipped",
+      reason: "Embedding \u914D\u7F6E\u4E0D\u5B8C\u6574\uFF1BSQLite FTS \u5DF2\u5728\u6D88\u606F\u5165\u5E93\u65F6\u5373\u65F6\u66F4\u65B0\u3002",
+      chunks: 0,
+      vectors: 0,
+      startedAt,
+      finishedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  const vectorStore = await LanceDbVectorStore.connectFromConfig(input.config);
+  try {
+    const stats = await indexMessageChunks({
+      messages: new MessageRepository(input.database),
+      embedding: createEmbeddingModel(input.config, input.secrets),
+      store: vectorStore,
+      limit: input.limit
+    });
+    return {
+      status: "completed",
+      chunks: stats.chunks,
+      vectors: stats.vectors,
+      startedAt,
+      finishedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } finally {
+    vectorStore.close();
+  }
+}
+
+// src/rag/vector-store.ts
+var MemoryVectorStore = class {
+  records = /* @__PURE__ */ new Map();
+  async upsert(records) {
+    for (const record of records) {
+      this.records.set(record.id, record);
+    }
+  }
+  async search(vector, limit) {
+    return [...this.records.values()].map((record) => {
+      const vectorScore = cosineSimilarity(vector, record.vector);
+      return {
+        ...record.evidence,
+        score: vectorScore,
+        vectorScore
+      };
+    }).sort((left, right) => right.vectorScore - left.vectorScore).slice(0, limit);
+  }
+};
+
+// src/web/server.ts
+import Fastify from "fastify";
+function buildHtml() {
+  return `<!doctype html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>ChatterCatcher</title>
+    <style>
+      :root {
+        color-scheme: light;
+        --bg: #f6f5f0;
+        --panel: #ffffff;
+        --text: #1f2933;
+        --muted: #667085;
+        --line: #d9d7cf;
+        --accent: #1f7a5a;
+        --warn: #9a5b13;
+      }
+      * { box-sizing: border-box; }
+      body {
+        margin: 0;
+        font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+        background: var(--bg);
+        color: var(--text);
+      }
+      main { max-width: 1120px; margin: 0 auto; padding: 32px 24px 48px; overflow-x: hidden; }
+      header {
+        display: flex;
+        justify-content: space-between;
+        gap: 20px;
+        align-items: flex-start;
+        padding-bottom: 24px;
+        border-bottom: 1px solid var(--line);
+      }
+      h1 { margin: 0; font-size: 30px; line-height: 1.1; letter-spacing: 0; }
+      h2 { margin: 0 0 12px; font-size: 18px; letter-spacing: 0; }
+      p { margin: 8px 0 0; color: var(--muted); }
+      code { background: #eceae2; border-radius: 4px; padding: 2px 6px; }
+      button {
+        appearance: none;
+        border: 1px solid var(--line);
+        background: var(--panel);
+        color: var(--text);
+        border-radius: 6px;
+        padding: 8px 12px;
+        cursor: pointer;
+      }
+      button:hover { border-color: var(--accent); }
+      .actions { display: flex; gap: 10px; flex-wrap: wrap; justify-content: flex-end; }
+      .grid {
+        display: grid;
+        grid-template-columns: repeat(auto-fit, minmax(160px, 1fr));
+        gap: 12px;
+        margin: 24px 0;
+      }
+      .metric {
+        background: var(--panel);
+        border: 1px solid var(--line);
+        border-radius: 8px;
+        padding: 16px;
+        min-height: 112px;
+      }
+      .label { color: var(--muted); font-size: 13px; }
+      .value { margin-top: 10px; font-size: 22px; font-weight: 650; overflow-wrap: anywhere; line-height: 1.18; }
+      .note { margin-top: 8px; color: var(--muted); font-size: 13px; line-height: 1.45; }
+      .layout {
+        display: grid;
+        grid-template-columns: minmax(0, 1fr) minmax(280px, 380px);
+        gap: 24px;
+      }
+      .layout > * { min-width: 0; }
+      section { padding: 20px 0; border-top: 1px solid var(--line); }
+      section:first-child { border-top: 0; }
+      .message-list { background: var(--panel); border: 1px solid var(--line); border-radius: 8px; overflow: hidden; }
+      .message-item { padding: 14px 16px; border-bottom: 1px solid var(--line); }
+      .message-item:last-child { border-bottom: 0; }
+      .message-meta { display: flex; flex-wrap: wrap; gap: 8px 14px; color: var(--muted); font-size: 13px; line-height: 1.4; }
+      .message-body { margin-top: 8px; white-space: pre-wrap; overflow-wrap: anywhere; line-height: 1.55; }
+      table { width: 100%; table-layout: fixed; border-collapse: collapse; background: var(--panel); border: 1px solid var(--line); border-radius: 8px; overflow: hidden; }
+      th, td { padding: 12px; border-bottom: 1px solid var(--line); text-align: left; vertical-align: top; overflow: hidden; text-overflow: ellipsis; }
+      th { color: var(--muted); font-size: 13px; font-weight: 600; }
+      tr:last-child td { border-bottom: 0; }
+      .message { white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+      .id-text, .path { display: block; max-width: 100%; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; color: var(--muted); font-size: 13px; }
+      .compact-table th:first-child, .compact-table td:first-child { width: 120px; }
+      .compact-table th:nth-child(2), .compact-table td:nth-child(2) { width: 180px; }
+      .status-ok { color: var(--accent); }
+      .status-warn { color: var(--warn); }
+      .empty { color: var(--muted); padding: 18px; background: var(--panel); border: 1px dashed var(--line); border-radius: 8px; }
+      .status-line { margin-top: 10px; font-size: 13px; color: var(--muted); text-align: right; }
+      @media (max-width: 900px) {
+        header, .layout { display: block; }
+        .grid { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+        header button { margin-top: 16px; }
+      }
+      @media (max-width: 560px) {
+        main { padding: 24px 16px 36px; }
+        .grid { grid-template-columns: 1fr; }
+      }
+    </style>
+  </head>
+  <body>
+    <main>
+      <header>
+        <div>
+          <h1>ChatterCatcher</h1>
+          <p>\u672C\u5730\u4F18\u5148\u7684\u5BB6\u5EAD\u7FA4\u77E5\u8BC6\u5E93\u3002\u95EE\u7B54\u5FC5\u987B\u5148\u68C0\u7D22 RAG \u8BC1\u636E\uFF0C\u4E0D\u5806\u53E0\u5168\u91CF\u4E0A\u4E0B\u6587\u3002</p>
+        </div>
+        <div>
+          <div class="actions">
+            <button id="process-messages" type="button">\u7ACB\u5373\u5904\u7406</button>
+          </div>
+          <div id="action-status" class="status-line"></div>
+        </div>
+      </header>
+
+      <div class="grid" id="metrics"></div>
+
+      <div class="layout">
+        <div>
+          <section>
+            <h2>\u6700\u8FD1\u6D88\u606F</h2>
+            <div id="messages" class="empty">\u6B63\u5728\u8BFB\u53D6...</div>
+          </section>
+        </div>
+        <aside>
+          <section>
+            <h2>\u7FA4\u804A</h2>
+            <div id="chats" class="empty">\u6B63\u5728\u8BFB\u53D6...</div>
+          </section>
+          <section>
+            <h2>\u6587\u4EF6\u5E93</h2>
+            <div id="files" class="empty">\u6B63\u5728\u8BFB\u53D6...</div>
+          </section>
+          <section>
+            <h2>\u89E3\u6790\u4EFB\u52A1</h2>
+            <div id="file-jobs" class="empty">\u6B63\u5728\u8BFB\u53D6...</div>
+          </section>
+          <section>
+            <h2>\u672C\u5730\u64CD\u4F5C</h2>
+            <p><code>chattercatcher settings</code> \u4FEE\u6539\u914D\u7F6E\u3002</p>
+            <p><code>chattercatcher files add &lt;path...&gt;</code> \u5BFC\u5165\u6587\u672C\u3001DOCX \u6216 PDF \u6587\u4EF6\u3002</p>
+            <p><code>chattercatcher doctor</code> \u68C0\u67E5\u98DE\u4E66\u3001\u6A21\u578B\u3001RAG \u548C\u672C\u5730\u5B58\u50A8\u3002</p>
+          </section>
+        </aside>
+      </div>
+    </main>
+    <script>
+      const metrics = document.querySelector("#metrics");
+      const messages = document.querySelector("#messages");
+      const chats = document.querySelector("#chats");
+      const files = document.querySelector("#files");
+      const fileJobs = document.querySelector("#file-jobs");
+      const processMessages = document.querySelector("#process-messages");
+      const actionStatus = document.querySelector("#action-status");
+
+      function fmt(value) {
+        return value == null || value === "" ? "-" : String(value);
+      }
+
+      function escapeHtml(value) {
+        return fmt(value)
+          .replaceAll("&", "&amp;")
+          .replaceAll("<", "&lt;")
+          .replaceAll(">", "&gt;")
+          .replaceAll('"', "&quot;");
+      }
+
+      function isOpaqueId(value) {
+        return /^(ou|oc|om|cli|on|un|uid)_?[a-z0-9]+/i.test(fmt(value));
+      }
+
+      function formatDateTime(value) {
+        const date = new Date(value);
+        if (Number.isNaN(date.getTime())) return fmt(value);
+        const pad = (input) => String(input).padStart(2, "0");
+        return [
+          date.getFullYear(),
+          pad(date.getMonth() + 1),
+          pad(date.getDate()),
+        ].join("/") + " " + [
+          pad(date.getHours()),
+          pad(date.getMinutes()),
+          pad(date.getSeconds()),
+        ].join(":");
+      }
+
+      function displaySender(value) {
+        return isOpaqueId(value) ? "\u7FA4\u6210\u5458" : fmt(value);
+      }
+
+      function displayChatName(value, platform) {
+        if (!isOpaqueId(value)) return fmt(value);
+        return platform === "feishu" ? "\u98DE\u4E66\u7FA4\u804A" : "\u7FA4\u804A";
+      }
+
+      function formatGatewayValue(gateway) {
+        if (gateway.connection === "running") return "\u8FD0\u884C\u4E2D";
+        if (!gateway.configured) return "\u672A\u914D\u7F6E";
+        return "\u5F85\u542F\u52A8";
+      }
+
+      function formatGatewayNote(gateway) {
+        if (gateway.connection === "running" && gateway.pid) return "PID " + gateway.pid;
+        return "\u98DE\u4E66\u957F\u8FDE\u63A5";
+      }
+
+      function renderMetrics(status) {
+        const gatewayClass = status.gateway.configured ? "status-ok" : "status-warn";
+        metrics.innerHTML = [
+          ["Gateway", formatGatewayValue(status.gateway), formatGatewayNote(status.gateway), gatewayClass],
+          ["\u7FA4\u804A", status.data.chats, "\u672C\u5730\u7FA4\u804A\u6570", ""],
+          ["\u6D88\u606F", status.data.messages, "\u5DF2\u5165\u5E93\u6D88\u606F", ""],
+          ["\u6587\u4EF6", status.data.files, "\u6587\u4EF6\u77E5\u8BC6\u6E90", ""],
+        ].map(([label, value, note, extra]) => \`
+          <div class="metric">
+            <div class="label">\${escapeHtml(label)}</div>
+            <div class="value \${extra}">\${escapeHtml(value)}</div>
+            <div class="note">\${escapeHtml(note)}</div>
+          </div>
+        \`).join("");
+      }
+
+      function renderMessages(items) {
+        if (items.length === 0) {
+          messages.className = "empty";
+          messages.textContent = "\u8FD8\u6CA1\u6709\u6D88\u606F\u3002\u542F\u52A8 Gateway \u540E\uFF0C\u7FA4\u804A\u6587\u672C\u4F1A\u8FDB\u5165\u672C\u5730 RAG \u7D22\u5F15\u3002";
+          return;
+        }
+        messages.className = "";
+        messages.innerHTML = \`
+          <div class="message-list">
+              \${items.map((item) => \`
+                <article class="message-item">
+                  <div class="message-meta">
+                    <span>\${escapeHtml(formatDateTime(item.sentAt))}</span>
+                    <span>\${escapeHtml(displaySender(item.senderName))}</span>
+                    <span>\${escapeHtml(displayChatName(item.chatName, item.platform))}</span>
+                  </div>
+                  <div class="message-body">\${escapeHtml(item.text)}</div>
+                </article>
+              \`).join("")}
+          </div>
+        \`;
+      }
+
+      function renderChats(items) {
+        if (items.length === 0) {
+          chats.className = "empty";
+          chats.textContent = "\u8FD8\u6CA1\u6709\u7FA4\u804A\u8BB0\u5F55\u3002";
+          return;
+        }
+        chats.className = "";
+        chats.innerHTML = \`
+          <table>
+            <thead><tr><th>\u540D\u79F0</th><th>\u5E73\u53F0</th></tr></thead>
+            <tbody>
+              \${items.map((item) => \`
+                <tr>
+                  <td><span class="id-text" title="\${escapeHtml(item.name)}">\${escapeHtml(displayChatName(item.name, item.platform))}</span></td>
+                  <td>\${escapeHtml(item.platform)}</td>
+                </tr>
+              \`).join("")}
+            </tbody>
+          </table>
+        \`;
+      }
+
+      function renderFiles(items) {
+        if (items.length === 0) {
+          files.className = "empty";
+          files.textContent = "\u8FD8\u6CA1\u6709\u6587\u4EF6\u3002\u53EF\u5148\u8FD0\u884C chattercatcher files add <path...> \u5BFC\u5165\u6587\u672C\u3001DOCX \u6216 PDF \u6587\u4EF6\u3002";
+          return;
+        }
+        files.className = "";
+        files.innerHTML = \`
+          <table>
+            <thead><tr><th>\u6587\u4EF6</th><th>\u89E3\u6790\u5668</th><th>\u5B57\u7B26</th></tr></thead>
+            <tbody>
+              \${items.map((item) => \`
+                <tr>
+                  <td>
+                    <div>\${escapeHtml(item.fileName)}</div>
+                    <div class="path" title="\${escapeHtml(item.storedPath)}">\${escapeHtml(item.storedPath)}</div>
+                  </td>
+                  <td>\${escapeHtml(item.parser || "unknown")}</td>
+                  <td>\${escapeHtml(item.characters)}</td>
+                </tr>
+              \`).join("")}
+            </tbody>
+          </table>
+        \`;
+      }
+
+      function renderFileJobs(items) {
+        if (items.length === 0) {
+          fileJobs.className = "empty";
+          fileJobs.textContent = "\u8FD8\u6CA1\u6709\u6587\u4EF6\u89E3\u6790\u4EFB\u52A1\u3002";
+          return;
+        }
+        fileJobs.className = "";
+        fileJobs.innerHTML = \`
+          <table>
+            <thead><tr><th>\u4EFB\u52A1</th><th>\u72B6\u6001</th></tr></thead>
+            <tbody>
+              \${items.map((item) => \`
+                <tr>
+                  <td>
+                    <div>\${escapeHtml(item.fileName)}</div>
+                    <div class="path" title="\${escapeHtml(item.id)}">ID: \${escapeHtml(item.id)}</div>
+                    <div class="path" title="\${escapeHtml(item.error || item.storedPath)}">\${escapeHtml(item.error || item.storedPath)}</div>
+                  </td>
+                  <td>\${escapeHtml(item.status)}</td>
+                </tr>
+              \`).join("")}
+            </tbody>
+          </table>
+        \`;
+      }
+
+      async function load() {
+        const [status, recent, chatList, fileList, jobList] = await Promise.all([
+          fetch("/api/status").then((response) => response.json()),
+          fetch("/api/messages/recent?limit=20").then((response) => response.json()),
+          fetch("/api/chats").then((response) => response.json()),
+          fetch("/api/files").then((response) => response.json()),
+          fetch("/api/file-jobs").then((response) => response.json()),
+        ]);
+        renderMetrics(status);
+        renderMessages(recent.items);
+        renderChats(chatList.items);
+        renderFiles(fileList.items);
+        renderFileJobs(jobList.items);
+      }
+
+      async function processNow() {
+        processMessages.disabled = true;
+        actionStatus.textContent = "\u6B63\u5728\u5904\u7406\u6D88\u606F\u7D22\u5F15...";
+        try {
+          const response = await fetch("/api/process/messages", { method: "POST" });
+          const result = await response.json();
+          if (!response.ok) {
+            actionStatus.textContent = result.message || "\u5904\u7406\u5931\u8D25\u3002";
+            return;
+          }
+
+          if (result.status === "skipped") {
+            actionStatus.textContent = result.reason;
+          } else {
+            actionStatus.textContent = \`\u5904\u7406\u5B8C\u6210\uFF1Achunks=\${result.chunks}, vectors=\${result.vectors}\`;
+          }
+          await load();
+        } catch (error) {
+          actionStatus.textContent = error instanceof Error ? error.message : String(error);
+        } finally {
+          processMessages.disabled = false;
+        }
+      }
+
+      processMessages.addEventListener("click", () => void processNow());
+      void load();
+      setInterval(() => {
+        if (document.visibilityState === "visible") {
+          void load();
+        }
+      }, 5000);
+    </script>
+  </body>
+</html>`;
+}
+function parseLimit(value, fallback, max) {
+  const rawLimit = Number(value ?? fallback);
+  return Number.isFinite(rawLimit) ? Math.min(Math.max(Math.trunc(rawLimit), 1), max) : fallback;
+}
+function createWebApp(config) {
+  const app = Fastify({ logger: false });
+  const database = openDatabase(config);
+  const messages = new MessageRepository(database);
+  const fileJobs = new FileJobRepository(database);
+  app.addHook("onClose", async () => {
+    database.close();
+  });
+  app.get("/api/status", async () => ({
+    app: "ChatterCatcher",
+    gateway: getGatewayStatus(config),
+    data: {
+      chats: messages.getChatCount(),
+      messages: messages.getMessageCount(),
+      files: messages.listFiles(1e3).length
+    },
+    rag: {
+      mode: "required",
+      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: "LanceDB",
+        hybrid: true
+      }
+    },
+    web: config.web
+  }));
+  app.get("/api/chats", async () => ({
+    items: messages.listChats()
+  }));
+  app.get("/api/files", async (request) => {
+    const limit = parseLimit(request.query.limit, 50, 200);
+    return {
+      items: messages.listFiles(limit)
+    };
+  });
+  app.get("/api/file-jobs", async (request) => {
+    const limit = parseLimit(request.query.limit, 50, 200);
+    const status = request.query.status;
+    return {
+      items: fileJobs.list(limit, status === "processing" || status === "indexed" || status === "failed" ? { status } : {})
+    };
+  });
+  app.get("/api/messages/recent", async (request) => {
+    const limit = parseLimit(request.query.limit, 20, 100);
+    return {
+      items: messages.listRecentMessages(limit)
+    };
+  });
+  app.post("/api/process/messages", async (_request, reply) => {
+    try {
+      return await processMessagesNow({
+        config,
+        secrets: await loadSecrets(),
+        database,
+        limit: 1e4
+      });
+    } catch (error) {
+      reply.code(500);
+      return {
+        status: "failed",
+        message: error instanceof Error ? error.message : String(error)
+      };
+    }
+  });
+  app.get("/", async (_request, reply) => {
+    reply.type("text/html; charset=utf-8");
+    return buildHtml();
+  });
+  return app;
+}
+async function startWebServer(config) {
+  const app = createWebApp(config);
+  await app.listen({ host: config.web.host, port: config.web.port });
+  const address = app.server.address();
+  const url = typeof address === "string" ? address : `http://${config.web.host}:${address?.port ?? config.web.port}`;
+  console.log(`ChatterCatcher Web UI: ${url}`);
+}
+export {
+  FeishuMessageSender,
+  FeishuQuestionHandler,
+  FeishuResourceDownloader,
+  FileJobRepository,
+  GatewayIngestor,
+  HybridRetriever,
+  LanceDbVectorStore,
+  MemoryVectorStore,
+  MessageFtsRetriever,
+  MessageRepository,
+  OpenAICompatibleChatModel,
+  OpenAICompatibleEmbeddingModel,
+  VectorRetriever,
+  appConfigSchema,
+  appSecretsSchema,
+  applySecretInput,
+  askWithRag,
+  buildEvidencePrompt,
+  chunkText,
+  cosineSimilarity,
+  createChatModel,
+  createDefaultConfig,
+  createDefaultSecrets,
+  createEmbeddingModel,
+  createFeishuEventDispatcher,
+  createFeishuGateway,
+  createHybridRetriever,
+  createWebApp,
+  deleteLocalData,
+  describeSupportedParseTypes,
+  ensureConfigFiles,
+  exportLocalData,
+  extractFeishuAttachment,
+  followLogFile,
+  formatCitation,
+  formatCitations,
+  formatDoctorChecks,
+  generateGroundedAnswer,
+  getDatabasePath,
+  getFeishuQuestionDecision,
+  getGatewayPidPath,
+  getGatewayRuntimeState,
+  getLanceDbPath,
+  getLogsDirectory,
+  hasEmbeddingConfig,
+  indexMessageChunks,
+  ingestLocalFile,
+  isFeishuMessageAddressedToBot,
+  isProcessRunning,
+  isSupportedParseFile,
+  isSupportedTextFile,
+  listLogFiles,
+  loadConfig,
+  loadSecrets,
+  mapDomain,
+  maskSecret,
+  migrateDatabase,
+  normalizeFeishuReceiveMessageEvent,
+  normalizeLineCount,
+  openDatabase,
+  parseFileToText,
+  processMessagesNow,
+  rankEvidenceForPrompt,
+  readGatewayPidRecord,
+  readLatestLogTail,
+  readLogTail,
+  removeGatewayPidRecord,
+  resetConfigFiles,
+  resolveEmbeddingApiKey,
+  resolveLogPath,
+  restoreLocalData,
+  runDoctor,
+  saveConfig,
+  saveSecrets,
+  startWebServer,
+  stopGatewayProcess,
+  writeGatewayPidRecord
+};
+//# sourceMappingURL=index.js.map