chatlab-cli 0.0.0 → 0.1.0

package/dist/chunk-PF4QFHC6.mjs

@@ -0,0 +1,3375 @@
+import { createRequire as __createRequire } from 'module';
+import { dirname as __pathDirname } from 'path';
+import { fileURLToPath as __fileURLToPath } from 'url';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import {
+  importData,
+  parseFile
+} from "./chunk-OC73KSMV.mjs";
+import {
+  analyzeIncrementalImport,
+  analyzeNewImport,
+  incrementalImport,
+  streamImport
+} from "./chunk-DL3BFEAH.mjs";
+import {
+  AGENT_TOOL_REGISTRY,
+  CoreDataProvider
+} from "./chunk-YAOFJ73U.mjs";
+import {
+  getVersion
+} from "./chunk-2AIOU3PW.mjs";
+import {
+  AIConversationManager,
+  ALL_MIGRATIONS,
+  AgentEventHandler,
+  AiLogger,
+  AssistantManager,
+  BUILTIN_MODELS,
+  BUILTIN_PROVIDERS,
+  BUILTIN_TOOL_CATALOG,
+  DatabaseManager,
+  MigrationRunner,
+  NodePathProvider,
+  POS_TAG_DEFINITIONS,
+  PreferencesManager,
+  SkillManager,
+  SkillManagerCore,
+  TempDbReader,
+  applyPreprocessingPipeline,
+  batchSegmentWithFrequency,
+  buildMergedOutput,
+  buildPiModel,
+  buildSystemPrompt,
+  checkAndCompress,
+  checkConflictsFromSources,
+  cleanupTempDatabases,
+  clearSessionIndex,
+  completeSimple,
+  computeWordFrequency,
+  createActivateSkillTool,
+  createAiTranslate,
+  createCompressionLlmAdapter,
+  createJiebaNlpProvider,
+  deleteDict,
+  deleteTempDatabase,
+  detectAllFormats,
+  detectFormat,
+  downloadDict,
+  ensureDefaultDict,
+  executeReadonlySql,
+  executeSql,
+  exportFilterResultToMarkdown,
+  exportSessionToJson,
+  fetchRemoteModels,
+  formatAIError,
+  generateSessionIndex,
+  generateSessionSummary,
+  getAvailableYears,
+  getBuiltinModelsByProvider,
+  getCatchphraseAnalysis,
+  getChatOverview,
+  getChatSessionList,
+  getChatSessionSummary,
+  getClusterGraph,
+  getDailyActivity,
+  getDictList,
+  getHourlyActivity,
+  getLanguagePreferenceAnalysis,
+  getLaughAnalysis,
+  getMemberActivity,
+  getMembers,
+  getMembersDetailed,
+  getMembersPaginated,
+  getMembersWithAliases,
+  getMentionAnalysis,
+  getMentionGraph,
+  getMessageLengthDistribution,
+  getMessageTypeStats,
+  getMonthlyActivity,
+  getRelationshipStats,
+  getSchemaDetailed,
+  getSessionInfo,
+  getSessionMessages,
+  getSessionMeta,
+  getSessionOverview,
+  getSupportedFormats,
+  getTimeRange,
+  getWeekdayActivity,
+  getYearlyActivity,
+  hasFtsTable,
+  hasPendingElectronDataWarning,
+  initNlpDir,
+  isDictDownloaded,
+  loadConfig,
+  openBetterSqliteDatabase,
+  parseAssistantFile,
+  queryMessages,
+  rebuildFtsIndex,
+  resolveApiKey,
+  runAgentCore,
+  runSimpleLlmStream,
+  saveChatSessionSummary,
+  scanMultiChatFile,
+  searchByFts,
+  segmentText,
+  serializeChatLabToJsonl,
+  streamParseFileInfo,
+  validateApiKey,
+  verifyCliDataPath,
+  writeAuthProfile,
+  writeConfigField
+} from "./chunk-JMRDNHIR.mjs";
+
+// src/http/index.ts
+import * as fs11 from "fs";
+import * as path11 from "path";
+import * as crypto5 from "crypto";
+
+// src/http/server.ts
+import Fastify from "fastify";
+
+// src/http/auth.ts
+import { timingSafeEqual } from "crypto";
+
+// src/http/errors.ts
+var HTTP_STATUS = {
+  ["UNAUTHORIZED" /* UNAUTHORIZED */]: 401,
+  ["SESSION_NOT_FOUND" /* SESSION_NOT_FOUND */]: 404,
+  ["INVALID_FORMAT" /* INVALID_FORMAT */]: 400,
+  ["INVALID_PAYLOAD" /* INVALID_PAYLOAD */]: 400,
+  ["SQL_READONLY_VIOLATION" /* SQL_READONLY_VIOLATION */]: 400,
+  ["SQL_EXECUTION_ERROR" /* SQL_EXECUTION_ERROR */]: 400,
+  ["EXPORT_TOO_LARGE" /* EXPORT_TOO_LARGE */]: 400,
+  ["BODY_TOO_LARGE" /* BODY_TOO_LARGE */]: 413,
+  ["SERVER_ERROR" /* SERVER_ERROR */]: 500
+};
+var ApiError = class extends Error {
+  code;
+  statusCode;
+  constructor(code, message) {
+    super(message);
+    this.name = "ApiError";
+    this.code = code;
+    this.statusCode = HTTP_STATUS[code];
+  }
+};
+function unauthorized(message = "Invalid or missing token") {
+  return new ApiError("UNAUTHORIZED" /* UNAUTHORIZED */, message);
+}
+function sessionNotFound(id) {
+  return new ApiError("SESSION_NOT_FOUND" /* SESSION_NOT_FOUND */, `Session not found: ${id}`);
+}
+function sqlExecutionError(message) {
+  return new ApiError("SQL_EXECUTION_ERROR" /* SQL_EXECUTION_ERROR */, message);
+}
+function exportTooLarge(count, limit) {
+  return new ApiError(
+    "EXPORT_TOO_LARGE" /* EXPORT_TOO_LARGE */,
+    `Message count ${count} exceeds export limit ${limit}. Use paginated /messages API instead.`
+  );
+}
+function serverError(message = "Internal server error") {
+  return new ApiError("SERVER_ERROR" /* SERVER_ERROR */, message);
+}
+function successResponse(data, meta) {
+  return {
+    success: true,
+    data,
+    meta: {
+      timestamp: Math.floor(Date.now() / 1e3),
+      version: "0.0.2",
+      ...meta
+    }
+  };
+}
+function errorResponse(error) {
+  return {
+    success: false,
+    error: {
+      code: error.code,
+      message: error.message
+    }
+  };
+}
+
+// src/http/auth.ts
+var cachedToken = null;
+var webModeEnabled = false;
+function setAuthToken(token) {
+  cachedToken = token;
+}
+function setWebMode(enabled) {
+  webModeEnabled = enabled;
+}
+function safeTokenCompare(a, b) {
+  const bufA = Buffer.from(a);
+  const bufB = Buffer.from(b);
+  if (bufA.length !== bufB.length) return false;
+  return timingSafeEqual(bufA, bufB);
+}
+async function authHook(request, reply) {
+  if (!cachedToken) return;
+  if (request.url.startsWith("/_web/")) return;
+  if (webModeEnabled && !request.url.startsWith("/api/")) return;
+  const authHeader = request.headers.authorization;
+  if (!authHeader || !authHeader.startsWith("Bearer ")) {
+    const err = unauthorized();
+    reply.code(err.statusCode).send(errorResponse(err));
+    return;
+  }
+  const token = authHeader.slice(7);
+  if (!safeTokenCompare(token, cachedToken)) {
+    const err = unauthorized();
+    reply.code(err.statusCode).send(errorResponse(err));
+    return;
+  }
+}
+
+// src/http/server.ts
+var JSON_BODY_LIMIT = 50 * 1024 * 1024;
+function createServer() {
+  const server2 = Fastify({
+    logger: false,
+    bodyLimit: JSON_BODY_LIMIT
+  });
+  server2.addHook("onRequest", authHook);
+  server2.setErrorHandler((error, _request, reply) => {
+    if (error instanceof ApiError) {
+      reply.code(error.statusCode).send(errorResponse(error));
+      return;
+    }
+    if (error.statusCode === 413) {
+      const bodyErr = new ApiError("BODY_TOO_LARGE" /* BODY_TOO_LARGE */, "Request body exceeds 50MB limit");
+      reply.code(413).send(errorResponse(bodyErr));
+      return;
+    }
+    const statusCode = error.statusCode;
+    if (statusCode && statusCode >= 400 && statusCode < 600) {
+      reply.code(statusCode).send({ success: false, error: { code: "CLIENT_ERROR", message: error.message } });
+      return;
+    }
+    const err = serverError(error.message);
+    reply.code(err.statusCode).send(errorResponse(err));
+  });
+  return server2;
+}
+
+// src/http/routes/system.ts
+function registerSystemRoutes(server2, dbManager2) {
+  server2.get("/api/v1/status", async () => {
+    let sessionCount = 0;
+    try {
+      sessionCount = dbManager2.listSessionIds().length;
+    } catch {
+    }
+    return successResponse({
+      name: "ChatLab API",
+      version: getVersion(),
+      uptime: Math.floor(process.uptime()),
+      sessionCount
+    });
+  });
+  server2.get("/api/v1/schema", async () => {
+    return successResponse({
+      format: "ChatLab Format",
+      version: "0.0.2",
+      spec: {
+        chatlab: {
+          type: "object",
+          required: ["version"],
+          properties: {
+            version: { type: "string" },
+            exportedAt: { type: "number" },
+            generator: { type: "string" }
+          }
+        },
+        meta: {
+          type: "object",
+          required: ["name", "platform", "type"],
+          properties: {
+            name: { type: "string" },
+            platform: {
+              type: "string",
+              enum: ["qq", "wechat", "telegram", "discord", "line", "whatsapp", "instagram", "unknown"]
+            },
+            type: { type: "string", enum: ["group", "private"] },
+            groupId: { type: "string" }
+          }
+        },
+        members: {
+          type: "array",
+          items: {
+            type: "object",
+            required: ["platformId", "accountName"],
+            properties: {
+              platformId: { type: "string" },
+              accountName: { type: "string" },
+              groupNickname: { type: "string" },
+              avatar: { type: "string" }
+            }
+          }
+        },
+        messages: {
+          type: "array",
+          items: {
+            type: "object",
+            required: ["sender", "timestamp", "type"],
+            properties: {
+              platformMessageId: { type: "string" },
+              sender: { type: "string" },
+              accountName: { type: "string" },
+              groupNickname: { type: "string" },
+              timestamp: { type: "number" },
+              type: { type: "number" },
+              content: { type: ["string", "null"] },
+              replyToMessageId: { type: "string" }
+            }
+          }
+        }
+      }
+    });
+  });
+}
+
+// src/http/routes/sessions.ts
+var EXPORT_MESSAGE_LIMIT = 1e5;
+function ensureDb(dbManager2, sessionId) {
+  const db = dbManager2.open(sessionId);
+  if (!db) throw sessionNotFound(sessionId);
+  return db;
+}
+function registerSessionRoutes(server2, dbManager2) {
+  server2.get("/api/v1/sessions", async () => {
+    const sessionIds = dbManager2.listSessionIds();
+    const sessions = sessionIds.map((id) => {
+      const db = dbManager2.open(id);
+      if (!db) return null;
+      const info = getSessionInfo(db);
+      if (!info) return null;
+      return {
+        id,
+        name: info.name,
+        platform: info.platform,
+        type: info.type,
+        groupId: info.groupId || void 0,
+        messageCount: info.messageCount,
+        memberCount: info.memberCount,
+        firstTimestamp: info.firstMessageTs,
+        lastTimestamp: info.lastMessageTs
+      };
+    }).filter(Boolean);
+    return successResponse(sessions);
+  });
+  server2.get("/api/v1/sessions/:id", async (request) => {
+    const db = ensureDb(dbManager2, request.params.id);
+    const info = getSessionInfo(db);
+    if (!info) throw sessionNotFound(request.params.id);
+    return successResponse({
+      id: request.params.id,
+      name: info.name,
+      platform: info.platform,
+      type: info.type,
+      groupId: info.groupId || void 0,
+      messageCount: info.messageCount,
+      memberCount: info.memberCount,
+      firstTimestamp: info.firstMessageTs,
+      lastTimestamp: info.lastMessageTs
+    });
+  });
+  server2.get("/api/v1/sessions/:id/messages", async (request) => {
+    const { id } = request.params;
+    const db = ensureDb(dbManager2, id);
+    const page = Math.max(1, parseInt(request.query.page || "1", 10) || 1);
+    const limit = Math.min(1e3, Math.max(1, parseInt(request.query.limit || "100", 10) || 100));
+    const offset = (page - 1) * limit;
+    const { startTime, endTime, keyword, senderId } = request.query;
+    const result = queryMessages(db, {
+      keyword: keyword || void 0,
+      startTs: startTime ? parseInt(startTime, 10) : void 0,
+      endTs: endTime ? parseInt(endTime, 10) : void 0,
+      senderId: senderId ? parseInt(senderId, 10) : void 0,
+      limit,
+      offset
+    });
+    return successResponse({
+      messages: result.messages,
+      total: result.total,
+      page,
+      limit,
+      totalPages: result.totalPages
+    });
+  });
+  server2.get("/api/v1/sessions/:id/members", async (request) => {
+    const db = ensureDb(dbManager2, request.params.id);
+    const members = getMembers(db);
+    return successResponse(members);
+  });
+  server2.get("/api/v1/sessions/:id/stats/overview", async (request) => {
+    const { id } = request.params;
+    const db = ensureDb(dbManager2, id);
+    const overview = getSessionOverview(db);
+    const memberActivity = getMemberActivity(db);
+    const typeDistribution = getMessageTypeStats(db);
+    const typeMap = {};
+    for (const item of typeDistribution) {
+      typeMap[String(item.type)] = item.count;
+    }
+    const topMembers = memberActivity.slice(0, 10).map((m) => ({
+      platformId: m.platformId,
+      name: m.name,
+      messageCount: m.messageCount,
+      percentage: m.percentage
+    }));
+    return successResponse({
+      messageCount: overview.totalMessages,
+      memberCount: overview.totalMembers,
+      timeRange: {
+        start: overview.firstMessageTs ?? 0,
+        end: overview.lastMessageTs ?? 0
+      },
+      messageTypeDistribution: typeMap,
+      topMembers
+    });
+  });
+  server2.post("/api/v1/sessions/:id/sql", async (request, reply) => {
+    const { id } = request.params;
+    const db = ensureDb(dbManager2, id);
+    const { sql } = request.body || {};
+    if (!sql || typeof sql !== "string") {
+      const err = sqlExecutionError("Missing sql parameter");
+      return reply.code(err.statusCode).send(errorResponse(err));
+    }
+    try {
+      const result = executeReadonlySql(db, sql);
+      return successResponse(result);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "SQL execution error";
+      if (message.includes("SELECT") || message.includes("\u53EA\u8BFB") || message.includes("readonly")) {
+        const apiErr2 = new ApiError("SQL_READONLY_VIOLATION", message);
+        apiErr2.statusCode = 400;
+        return reply.code(400).send(errorResponse(apiErr2));
+      }
+      const apiErr = sqlExecutionError(message);
+      return reply.code(apiErr.statusCode).send(errorResponse(apiErr));
+    }
+  });
+  server2.get("/api/v1/sessions/:id/export", async (request, reply) => {
+    const { id } = request.params;
+    const db = ensureDb(dbManager2, id);
+    const meta = getSessionMeta(db);
+    if (!meta) throw sessionNotFound(id);
+    const overview = getSessionOverview(db);
+    if (overview.totalMessages > EXPORT_MESSAGE_LIMIT) {
+      const err = exportTooLarge(overview.totalMessages, EXPORT_MESSAGE_LIMIT);
+      return reply.code(err.statusCode).send(errorResponse(err));
+    }
+    const members = getMembersDetailed(db);
+    const allMessages = queryMessages(db, { limit: EXPORT_MESSAGE_LIMIT, offset: 0 });
+    const chatLabFormat = {
+      chatlab: {
+        version: "0.0.2",
+        exportedAt: Math.floor(Date.now() / 1e3),
+        generator: "ChatLab API"
+      },
+      meta: {
+        name: meta.name,
+        platform: meta.platform,
+        type: meta.type,
+        groupId: meta.groupId || void 0
+      },
+      members: members.map((m) => ({
+        platformId: m.platformId,
+        accountName: m.accountName || m.platformId,
+        groupNickname: m.groupNickname || void 0
+      })),
+      messages: allMessages.messages.map((msg) => ({
+        sender: msg.senderPlatformId,
+        accountName: msg.senderName || void 0,
+        timestamp: msg.timestamp,
+        type: msg.type,
+        content: msg.content || null
+      }))
+    };
+    return successResponse(chatLabFormat);
+  });
+}
+
+// src/http/routes/web.ts
+import * as fs3 from "fs";
+import * as os from "os";
+import * as path3 from "path";
+
+// src/merger/merge-cache.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as crypto from "crypto";
+var MergeSessionCache = class {
+  cache = /* @__PURE__ */ new Map();
+  tempDir;
+  nativeBinding;
+  constructor(pathProvider, options) {
+    this.tempDir = pathProvider.getTempDir();
+    this.nativeBinding = options?.nativeBinding;
+    if (!fs.existsSync(this.tempDir)) {
+      fs.mkdirSync(this.tempDir, { recursive: true });
+    }
+  }
+  generateTempDbPath(filename) {
+    const ts = Date.now();
+    const rand = Math.random().toString(36).slice(2, 8);
+    const safeName = filename.replace(/[/\\?%*:|"<>]/g, "_").slice(0, 40);
+    return path.join(this.tempDir, `merge_${safeName}_${ts}_${rand}.db`);
+  }
+  /** Store a parsed file's temp DB and return a handle for subsequent requests. */
+  store(filename, tempDbPath) {
+    const handle = crypto.randomUUID();
+    this.cache.set(handle, { tempDbPath, filename, createdAt: Date.now() });
+    return handle;
+  }
+  /** Open a TempDbReader for a given handle. Caller must close the reader. */
+  openReader(handle) {
+    const entry = this.cache.get(handle);
+    if (!entry || !fs.existsSync(entry.tempDbPath)) return null;
+    const adapter = openBetterSqliteDatabase(entry.tempDbPath, {
+      readonly: true,
+      nativeBinding: this.nativeBinding
+    });
+    return { reader: new TempDbReader(adapter), filename: entry.filename };
+  }
+  /** Create a writable temp DB for streaming parse. */
+  createTempDatabase(filename) {
+    const tempDbPath = this.generateTempDbPath(filename);
+    const adapter = openBetterSqliteDatabase(tempDbPath, { nativeBinding: this.nativeBinding });
+    return { db: adapter, tempDbPath };
+  }
+  /** Remove a single entry and its temp DB file. */
+  delete(handle) {
+    const entry = this.cache.get(handle);
+    if (entry) {
+      deleteTempDatabase(entry.tempDbPath);
+      this.cache.delete(handle);
+    }
+  }
+  /** Clear all entries and delete their temp DB files. */
+  clear() {
+    for (const entry of this.cache.values()) {
+      deleteTempDatabase(entry.tempDbPath);
+    }
+    this.cache.clear();
+  }
+  /** Cleanup orphan temp DBs from previous runs. */
+  cleanupOrphans() {
+    cleanupTempDatabases(this.tempDir);
+  }
+  /** Auto-cleanup entries older than maxAge (default 1 hour). */
+  cleanupExpired(maxAgeMs = 36e5) {
+    const now = Date.now();
+    for (const [handle, entry] of this.cache) {
+      if (now - entry.createdAt > maxAgeMs) {
+        deleteTempDatabase(entry.tempDbPath);
+        this.cache.delete(handle);
+      }
+    }
+  }
+};
+
+// src/ai/llm-config.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+function loadLlmConfig(aiDataDir) {
+  const configPath = path2.join(aiDataDir, "llm-config.json");
+  if (!fs2.existsSync(configPath)) {
+    return { configs: [], defaultAssistant: null, fastModel: null };
+  }
+  try {
+    const data = JSON.parse(fs2.readFileSync(configPath, "utf-8"));
+    const configs = (data.configs || []).map((c) => {
+      const provider = c.provider || "";
+      const authProfile = c.authProfile;
+      const profileKey = resolveApiKey(provider, authProfile);
+      const rawKey = c.apiKey || "";
+      const fallbackKey = rawKey.startsWith("enc:") ? "" : rawKey;
+      return {
+        ...c,
+        apiKey: profileKey || fallbackKey
+      };
+    });
+    return {
+      configs,
+      defaultAssistant: data.defaultAssistant ?? null,
+      fastModel: data.fastModel ?? null
+    };
+  } catch {
+    return { configs: [], defaultAssistant: null, fastModel: null };
+  }
+}
+function resolveSlot(slot, configs) {
+  if (slot && configs.some((c) => c.id === slot.configId)) return slot;
+  const fallback = configs[0];
+  if (!fallback) return null;
+  return { configId: fallback.id, modelId: fallback.model };
+}
+function getDefaultAssistantConfig(aiDataDir) {
+  const store = loadLlmConfig(aiDataDir);
+  const slot = resolveSlot(store.defaultAssistant, store.configs);
+  if (!slot) return null;
+  const config = store.configs.find((c) => c.id === slot.configId);
+  if (!config) return null;
+  return { ...config, model: slot.modelId || config.model };
+}
+var MAX_CONFIG_COUNT = 99;
+function saveLlmConfig(aiDataDir, store) {
+  const configPath = path2.join(aiDataDir, "llm-config.json");
+  const toSave = {
+    ...store,
+    configs: store.configs.map((c) => {
+      const { apiKey: _k, ...rest } = c;
+      return rest;
+    }),
+    schemaVersion: 3
+  };
+  fs2.writeFileSync(configPath, JSON.stringify(toSave, null, 2), "utf-8");
+}
+function addLlmConfig(aiDataDir, config) {
+  const store = loadLlmConfig(aiDataDir);
+  if (store.configs.length >= MAX_CONFIG_COUNT) {
+    return { success: false, error: `Maximum ${MAX_CONFIG_COUNT} configs reached` };
+  }
+  const newConfig = {
+    ...config,
+    id: randomUUID2()
+  };
+  const storeForSave = loadRawConfigStore(aiDataDir);
+  storeForSave.configs.push({
+    ...newConfig,
+    apiKey: ""
+  });
+  if (storeForSave.configs.length === 1) {
+    storeForSave.defaultAssistant = { configId: newConfig.id, modelId: newConfig.model || "" };
+  }
+  if (config.apiKey) {
+    const profileName = config.name?.toLowerCase().replace(/\s+/g, "-") || config.provider;
+    writeAuthProfile(profileName, {
+      type: "api_key",
+      provider: config.provider,
+      key: config.apiKey
+    });
+    storeForSave.configs[storeForSave.configs.length - 1].authProfile = profileName;
+  }
+  saveLlmConfig(aiDataDir, storeForSave);
+  return { success: true, config: { ...newConfig, apiKey: "" } };
+}
+function updateLlmConfig(aiDataDir, id, updates) {
+  const storeForSave = loadRawConfigStore(aiDataDir);
+  const index = storeForSave.configs.findIndex((c) => c.id === id);
+  if (index === -1) {
+    return { success: false, error: "Config not found" };
+  }
+  const { apiKey: newApiKey, ...restUpdates } = updates;
+  const updated = {
+    ...storeForSave.configs[index],
+    ...restUpdates
+  };
+  storeForSave.configs[index] = updated;
+  if (newApiKey) {
+    const profileName = updated.name?.toLowerCase().replace(/\s+/g, "-") || updated.provider;
+    writeAuthProfile(profileName, {
+      type: "api_key",
+      provider: updated.provider,
+      key: newApiKey
+    });
+    storeForSave.configs[index].authProfile = profileName;
+  }
+  saveLlmConfig(aiDataDir, storeForSave);
+  return { success: true };
+}
+function deleteLlmConfig(aiDataDir, id) {
+  const storeForSave = loadRawConfigStore(aiDataDir);
+  const index = storeForSave.configs.findIndex((c) => c.id === id);
+  if (index === -1) {
+    return { success: false, error: "Config not found" };
+  }
+  storeForSave.configs.splice(index, 1);
+  const fallback = storeForSave.configs[0];
+  if (storeForSave.defaultAssistant?.configId === id) {
+    storeForSave.defaultAssistant = fallback ? { configId: fallback.id, modelId: fallback.model || "" } : null;
+  }
+  if (storeForSave.fastModel?.configId === id) {
+    storeForSave.fastModel = fallback ? { configId: fallback.id, modelId: fallback.model || "" } : null;
+  }
+  saveLlmConfig(aiDataDir, storeForSave);
+  return { success: true };
+}
+function setDefaultAssistantSlot(aiDataDir, configId, modelId) {
+  const storeForSave = loadRawConfigStore(aiDataDir);
+  const config = storeForSave.configs.find((c) => c.id === configId);
+  if (!config) {
+    return { success: false, error: "Config not found" };
+  }
+  storeForSave.defaultAssistant = { configId, modelId };
+  saveLlmConfig(aiDataDir, storeForSave);
+  return { success: true };
+}
+function setFastModelSlot(aiDataDir, slot) {
+  const storeForSave = loadRawConfigStore(aiDataDir);
+  if (slot !== null) {
+    const config = storeForSave.configs.find((c) => c.id === slot.configId);
+    if (!config) {
+      return { success: false, error: "Config not found" };
+    }
+  }
+  storeForSave.fastModel = slot;
+  saveLlmConfig(aiDataDir, storeForSave);
+  return { success: true };
+}
+function loadRawConfigStore(aiDataDir) {
+  const configPath = path2.join(aiDataDir, "llm-config.json");
+  if (!fs2.existsSync(configPath)) {
+    return { configs: [], defaultAssistant: null, fastModel: null };
+  }
+  try {
+    const data = JSON.parse(fs2.readFileSync(configPath, "utf-8"));
+    return {
+      configs: data.configs || [],
+      defaultAssistant: data.defaultAssistant ?? null,
+      fastModel: data.fastModel ?? null
+    };
+  } catch {
+    return { configs: [], defaultAssistant: null, fastModel: null };
+  }
+}
+function buildPiModel2(config) {
+  return buildPiModel(config);
+}
+
+// src/http/routes/web.ts
+function resolveNativeBinding() {
+  if (process.versions.electron) return void 0;
+  const nativePath = path3.resolve(__dirname, "../../../native/better_sqlite3.node");
+  if (fs3.existsSync(nativePath)) return nativePath;
+  return void 0;
+}
+function ensureDb2(dbManager2, sessionId) {
+  const db = dbManager2.open(sessionId);
+  if (!db) {
+    throw Object.assign(new Error(`Session not found: ${sessionId}`), { statusCode: 404 });
+  }
+  return db;
+}
+function ensureWritableDb(dbManager2, sessionId) {
+  dbManager2.close(sessionId);
+  const db = dbManager2.open(sessionId, { readonly: false });
+  if (!db) {
+    throw Object.assign(new Error(`Session not found: ${sessionId}`), { statusCode: 404 });
+  }
+  return db;
+}
+function parseTimeFilter(query) {
+  const { startTs, endTs, memberId } = query;
+  if (!startTs && !endTs && !memberId) return void 0;
+  const filter = {};
+  if (startTs) filter.startTs = parseInt(startTs, 10);
+  if (endTs) filter.endTs = parseInt(endTs, 10);
+  if (memberId) filter.memberId = parseInt(memberId, 10);
+  return filter;
+}
+function getAiDataDir(dbManager2) {
+  const pathProvider = dbManager2["pathProvider"];
+  if (!pathProvider) {
+    throw Object.assign(new Error("PathProvider not available"), { statusCode: 500 });
+  }
+  return pathProvider.getAiDataDir();
+}
+function buildSummaryDeps(db, llmConfig, _aiDataDir) {
+  const piModel = buildPiModel2(llmConfig);
+  return {
+    loadMessages(chatSessionId, limit = 500) {
+      const data = getSessionMessages(db, chatSessionId, limit);
+      if (!data) return null;
+      return data.messages.map((m) => ({ senderName: m.senderName, content: m.content }));
+    },
+    saveSummary(chatSessionId, summary) {
+      saveChatSessionSummary(db, chatSessionId, summary);
+    },
+    getSummary(chatSessionId) {
+      return getChatSessionSummary(db, chatSessionId);
+    },
+    async llmComplete(systemPrompt, userPrompt, options) {
+      const result = await completeSimple(
+        piModel,
+        {
+          systemPrompt,
+          messages: [{ role: "user", content: [{ type: "text", text: userPrompt }], timestamp: Date.now() }]
+        },
+        { apiKey: llmConfig.apiKey, maxTokens: options?.maxTokens, temperature: options?.temperature }
+      );
+      return result.content.filter((item) => item.type === "text").map((item) => item.text).join("");
+    },
+    t: (key) => key
+  };
+}
+function registerWebRoutes(server2, dbManager2, options) {
+  const mergeCache = options?.pathProvider ? new MergeSessionCache(options.pathProvider, { nativeBinding: options.nativeBinding }) : null;
+  mergeCache?.cleanupOrphans();
+  server2.get("/_web/sessions", async () => {
+    const sessionIds = dbManager2.listSessionIds();
+    return sessionIds.map((id) => {
+      const db = dbManager2.open(id);
+      if (!db) return null;
+      const info = getSessionInfo(db);
+      if (!info) return null;
+      return {
+        ...info,
+        id,
+        dbPath: "",
+        memberAvatar: null,
+        aiConversationCount: 0
+      };
+    }).filter(Boolean);
+  });
+  server2.get("/_web/sessions/:id", async (request) => {
+    const db = ensureDb2(dbManager2, request.params.id);
+    const info = getSessionInfo(db);
+    if (!info) return null;
+    return {
+      ...info,
+      id: request.params.id,
+      dbPath: "",
+      memberAvatar: null,
+      aiConversationCount: 0
+    };
+  });
+  server2.delete("/_web/sessions/:id", async (request, reply) => {
+    const { id } = request.params;
+    try {
+      dbManager2.close(id);
+      const dbPath = dbManager2.getDbPath(id);
+      const fs12 = await import("fs");
+      if (fs12.existsSync(dbPath)) {
+        fs12.unlinkSync(dbPath);
+        return { success: true };
+      }
+      return reply.code(404).send({ success: false, error: "File not found" });
+    } catch (err) {
+      return reply.code(500).send({ success: false, error: String(err) });
+    }
+  });
+  server2.patch("/_web/sessions/:id/name", async (request) => {
+    const db = ensureDb2(dbManager2, request.params.id);
+    const { name } = request.body;
+    db.prepare("UPDATE meta SET name = ?").run(name);
+    return { success: true };
+  });
+  server2.patch(
+    "/_web/sessions/:id/owner",
+    async (request) => {
+      const db = ensureDb2(dbManager2, request.params.id);
+      const { ownerId } = request.body;
+      db.prepare("UPDATE meta SET owner_id = ?").run(ownerId ?? null);
+      return { success: true };
+    }
+  );
+  server2.get("/_web/sessions/:id/years", async (request) => {
+    const db = ensureDb2(dbManager2, request.params.id);
+    return getAvailableYears(db);
+  });
+  server2.get("/_web/sessions/:id/time-range", async (request) => {
+    const db = ensureDb2(dbManager2, request.params.id);
+    return getTimeRange(db);
+  });
+  server2.get("/_web/sessions/:id/stats/member-activity", async (request) => {
+    const db = ensureDb2(dbManager2, request.params.id);
+    const filter = parseTimeFilter(request.query);
+    return getMemberActivity(db, filter);
+  });
+  server2.get("/_web/sessions/:id/stats/hourly", async (request) => {
+    const db = ensureDb2(dbManager2, request.params.id);
+    const filter = parseTimeFilter(request.query);
+    return getHourlyActivity(db, filter);
+  });
+  server2.get("/_web/sessions/:id/stats/daily", async (request) => {
+    const db = ensureDb2(dbManager2, request.params.id);
+    const filter = parseTimeFilter(request.query);
+    return getDailyActivity(db, filter);
+  });
+  server2.get("/_web/sessions/:id/stats/weekday", async (request) => {
+    const db = ensureDb2(dbManager2, request.params.id);
+    const filter = parseTimeFilter(request.query);
+    return getWeekdayActivity(db, filter);
+  });
+  server2.get("/_web/sessions/:id/stats/message-types", async (request) => {
+    const db = ensureDb2(dbManager2, request.params.id);
+    const filter = parseTimeFilter(request.query);
+    return getMessageTypeStats(db, filter);
+  });
+  server2.get("/_web/sessions/:id/members", async (request) => {
+    const db = ensureDb2(dbManager2, request.params.id);
+    return getMembersWithAliases(db);
+  });
+  server2.get("/_web/sessions/:id/members/paginated", async (request) => {
+    const db = ensureDb2(dbManager2, request.params.id);
+    const result = getMembersPaginated(db, {
+      page: parseInt(request.query.page || "1", 10),
+      pageSize: parseInt(request.query.pageSize || "20", 10),
+      search: request.query.search,
+      sortOrder: request.query.sortOrder === "asc" ? "asc" : "desc"
+    });
+    return {
+      items: result.members,
+      total: result.total,
+      page: result.page,
+      pageSize: result.pageSize,
+      totalPages: result.totalPages
+    };
+  });
+  server2.patch(
+    "/_web/sessions/:id/members/:memberId/aliases",
+    async (request) => {
+      const db = ensureDb2(dbManager2, request.params.id);
+      const memberId = parseInt(request.params.memberId, 10);
+      const { aliases } = request.body;
+      db.prepare("UPDATE member SET aliases = ? WHERE id = ?").run(JSON.stringify(aliases), memberId);
+      return { success: true };
+    }
+  );
+  server2.delete(
+    "/_web/sessions/:id/members/:memberId",
+    async (request) => {
+      const db = ensureDb2(dbManager2, request.params.id);
+      const memberId = parseInt(request.params.memberId, 10);
+      db.prepare("DELETE FROM message WHERE sender_id = ?").run(memberId);
+      db.prepare("DELETE FROM member WHERE id = ?").run(memberId);
+      return { success: true };
+    }
+  );
+  server2.post(
+    "/_web/sessions/:id/members/merge",
+    async (request) => {
+      const db = ensureDb2(dbManager2, request.params.id);
+      const { memberId1, memberId2 } = request.body;
+      db.prepare("UPDATE message SET sender_id = ? WHERE sender_id = ?").run(memberId1, memberId2);
+      db.prepare("DELETE FROM member WHERE id = ?").run(memberId2);
+      return { success: true };
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/members/:memberId/history",
+    async (request) => {
+      const db = ensureDb2(dbManager2, request.params.id);
+      const memberId = parseInt(request.params.memberId, 10);
+      const rows = db.prepare(
+        `SELECT
+            sender_account_name as accountName,
+            sender_group_nickname as groupNickname,
+            MIN(ts) as startTs,
+            MAX(ts) as endTs
+          FROM message
+          WHERE sender_id = ?
+          GROUP BY sender_account_name, sender_group_nickname
+          ORDER BY startTs`
+      ).all(memberId);
+      const history = [];
+      for (const row of rows) {
+        if (row.accountName) {
+          history.push({ nameType: "account_name", name: row.accountName, startTs: row.startTs, endTs: row.endTs });
+        }
+        if (row.groupNickname) {
+          history.push({ nameType: "group_nickname", name: row.groupNickname, startTs: row.startTs, endTs: row.endTs });
+        }
+      }
+      return history;
+    }
+  );
+  server2.get("/_web/sessions/:id/analytics/relationship", async (request) => {
+    const db = ensureDb2(dbManager2, request.params.id);
+    const filter = parseTimeFilter(request.query);
+    return getRelationshipStats(db, filter);
+  });
+  server2.get("/_web/sessions/:id/analytics/catchphrase", async (request) => {
+    const db = ensureDb2(dbManager2, request.params.id);
+    const filter = parseTimeFilter(request.query);
+    return getCatchphraseAnalysis(db, filter);
+  });
+  server2.get("/_web/sessions/:id/analytics/mention", async (request) => {
+    const db = ensureDb2(dbManager2, request.params.id);
+    const filter = parseTimeFilter(request.query);
+    return getMentionAnalysis(db, filter);
+  });
+  server2.get("/_web/sessions/:id/analytics/mention-graph", async (request) => {
+    const db = ensureDb2(dbManager2, request.params.id);
+    const filter = parseTimeFilter(request.query);
+    return getMentionGraph(db, filter);
+  });
+  server2.get("/_web/sessions/:id/analytics/laugh", async (request) => {
+    const db = ensureDb2(dbManager2, request.params.id);
+    const filter = parseTimeFilter(request.query);
+    return getLaughAnalysis(db, filter);
+  });
+  server2.get("/_web/sessions/:id/analytics/cluster", async (request) => {
+    const db = ensureDb2(dbManager2, request.params.id);
+    const filter = parseTimeFilter(request.query);
+    const topEdges = request.query.topEdges ? parseInt(request.query.topEdges, 10) : void 0;
+    return getClusterGraph(db, filter, topEdges ? { topEdges } : void 0);
+  });
+  server2.get("/_web/sessions/:id/analytics/language-preference", async (request) => {
+    const db = ensureDb2(dbManager2, request.params.id);
+    const filter = parseTimeFilter(request.query);
+    const locale = request.query.locale || "zh-CN";
+    const nlpProvider = createJiebaNlpProvider();
+    return getLanguagePreferenceAnalysis(db, { locale, timeFilter: filter, nlpProvider });
+  });
+  server2.get("/_web/sessions/:id/analytics/monthly-activity", async (request) => {
+    const db = ensureDb2(dbManager2, request.params.id);
+    const filter = parseTimeFilter(request.query);
+    return getMonthlyActivity(db, filter);
+  });
+  server2.get("/_web/sessions/:id/analytics/yearly-activity", async (request) => {
+    const db = ensureDb2(dbManager2, request.params.id);
+    const filter = parseTimeFilter(request.query);
+    return getYearlyActivity(db, filter);
+  });
+  server2.get("/_web/sessions/:id/analytics/message-length-distribution", async (request) => {
+    const db = ensureDb2(dbManager2, request.params.id);
+    const filter = parseTimeFilter(request.query);
+    return getMessageLengthDistribution(db, filter);
+  });
+  server2.post("/_web/sessions/:id/sql", async (request, reply) => {
+    const db = ensureDb2(dbManager2, request.params.id);
+    const { sql } = request.body || {};
+    if (!sql || typeof sql !== "string") {
+      return reply.code(400).send({ error: "Missing sql parameter" });
+    }
+    try {
+      return executeSql(db, sql, { timing: true });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "SQL execution error";
+      return reply.code(400).send({ error: message });
+    }
+  });
+  server2.get("/_web/sessions/:id/schema", async (request) => {
+    const db = ensureDb2(dbManager2, request.params.id);
+    return getSchemaDetailed(db);
+  });
+  server2.post("/_web/sessions/:id/query", async (request) => {
+    const db = ensureDb2(dbManager2, request.params.id);
+    const { sql, params = [] } = request.body;
+    if (!sql || typeof sql !== "string") {
+      throw Object.assign(new Error('Missing or invalid "sql" field'), { statusCode: 400 });
+    }
+    const stmt = db.prepare(sql.trim());
+    if (!stmt.readonly) {
+      throw Object.assign(new Error("Only READ-ONLY statements are allowed"), { statusCode: 403 });
+    }
+    if (Array.isArray(params)) {
+      return stmt.all(...params);
+    }
+    return stmt.all(params);
+  });
+  server2.post("/_web/sessions/:id/export/markdown", async (request, reply) => {
+    const { id } = request.params;
+    const body = request.body;
+    const sessionName = body?.sessionName || id;
+    const chunks = [];
+    const result = exportFilterResultToMarkdown(
+      {
+        sessionId: id,
+        sessionName,
+        filterMode: body.filterMode || "condition",
+        keywords: body.keywords,
+        timeFilter: body.timeFilter,
+        senderIds: body.senderIds,
+        contextSize: body.contextSize,
+        chatSessionIds: body.chatSessionIds
+      },
+      {
+        openDatabase(sessionId) {
+          return dbManager2.open(sessionId) ?? null;
+        }
+      },
+      {
+        write(chunk) {
+          chunks.push(chunk);
+        },
+        end() {
+        }
+      }
+    );
+    if (!result.success) {
+      return reply.code(500).send({ error: result.error });
+    }
+    reply.header("Content-Type", "text/markdown; charset=utf-8");
+    reply.header("Content-Disposition", `attachment; filename="${encodeURIComponent(sessionName)}_export.md"`);
+    return reply.send(chunks.join(""));
+  });
+  server2.post("/_web/sessions/:id/generate-index", async (request) => {
+    const db = ensureWritableDb(dbManager2, request.params.id);
+    const gapThreshold = request.body?.gapThreshold ?? 1800;
+    const sessionCount = generateSessionIndex(db, gapThreshold);
+    return { sessionCount };
+  });
+  server2.post("/_web/sessions/:id/clear-index", async (request) => {
+    const db = ensureWritableDb(dbManager2, request.params.id);
+    clearSessionIndex(db);
+    return { success: true };
+  });
+  server2.get("/_web/sessions/:id/search/fts", async (request, reply) => {
+    const db = ensureDb2(dbManager2, request.params.id);
+    if (!hasFtsTable(db)) {
+      return reply.code(400).send({ error: "FTS index not built for this session" });
+    }
+    const keywords = request.query.keywords.split(/\s+/).filter(Boolean);
+    if (keywords.length === 0) return { rowids: [], total: 0 };
+    const limit = parseInt(request.query.limit || "100", 10);
+    const offset = parseInt(request.query.offset || "0", 10);
+    return searchByFts(db, keywords, limit, offset);
+  });
+  server2.get("/_web/sessions/:id/fts/status", async (request) => {
+    const db = ensureDb2(dbManager2, request.params.id);
+    return { hasFtsIndex: hasFtsTable(db) };
+  });
+  server2.post("/_web/sessions/:id/fts/rebuild", async (request) => {
+    const db = ensureWritableDb(dbManager2, request.params.id);
+    const result = rebuildFtsIndex(db);
+    return { success: true, indexed: result.indexed };
+  });
+  server2.post("/_web/sessions/:id/summaries/generate", async (request, reply) => {
+    const sessionId = request.params.id;
+    const { chatSessionId, locale, forceRegenerate } = request.body;
+    const aiDataDir = getAiDataDir(dbManager2);
+    const llmConfig = getDefaultAssistantConfig(aiDataDir);
+    if (!llmConfig) {
+      return reply.code(400).send({ error: "No LLM configuration available" });
+    }
+    const db = ensureWritableDb(dbManager2, sessionId);
+    const deps = buildSummaryDeps(db, llmConfig, aiDataDir);
+    const result = await generateSessionSummary(deps, chatSessionId, { locale, forceRegenerate });
+    return result;
+  });
+  server2.post("/_web/sessions/:id/summaries/generate-all", async (request, reply) => {
+    const sessionId = request.params.id;
+    const { locale, forceRegenerate } = request.body;
+    const aiDataDir = getAiDataDir(dbManager2);
+    const llmConfig = getDefaultAssistantConfig(aiDataDir);
+    if (!llmConfig) {
+      return reply.code(400).send({ error: "No LLM configuration available" });
+    }
+    const db = ensureWritableDb(dbManager2, sessionId);
+    const chatSessions = getChatSessionList(db);
+    const deps = buildSummaryDeps(db, llmConfig, aiDataDir);
+    let success = 0;
+    let failed = 0;
+    for (const cs of chatSessions) {
+      const result = await generateSessionSummary(deps, cs.id, { locale, forceRegenerate });
+      if (result.success) success++;
+      else failed++;
+    }
+    return { success, failed, total: chatSessions.length };
+  });
+  const DEMO_BASE_URL = "https://chatlab.fun/assets/demo";
+  server2.post("/_web/demo/import", async (request, reply) => {
+    const locale = request.body?.locale || "en";
+    const nativeBinding = resolveNativeBinding();
+    reply.raw.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    });
+    function sendEvent(event, data) {
+      reply.raw.write(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`);
+    }
+    const tmpDir = fs3.mkdtempSync(path3.join(os.tmpdir(), "chatlab-demo-"));
+    const groupPath = path3.join(tmpDir, "demo-group.json");
+    const privatePath = path3.join(tmpDir, "demo-private.json");
+    try {
+      sendEvent("progress", { stage: "downloading", current: 1, total: 2 });
+      const groupResp = await fetch(`${DEMO_BASE_URL}/${locale}/demo-group.json`, {
+        signal: AbortSignal.timeout(6e4)
+      });
+      if (!groupResp.ok) throw new Error(`Download group demo failed: ${groupResp.status}`);
+      fs3.writeFileSync(groupPath, Buffer.from(await groupResp.arrayBuffer()));
+      sendEvent("progress", { stage: "downloading", current: 2, total: 2 });
+      const privateResp = await fetch(`${DEMO_BASE_URL}/${locale}/demo-private.json`, {
+        signal: AbortSignal.timeout(6e4)
+      });
+      if (!privateResp.ok) throw new Error(`Download private demo failed: ${privateResp.status}`);
+      fs3.writeFileSync(privatePath, Buffer.from(await privateResp.arrayBuffer()));
+      sendEvent("progress", { stage: "importing", current: 1, total: 2 });
+      const groupResult = await streamImport(dbManager2, groupPath, { nativeBinding });
+      if (!groupResult.success) throw new Error(groupResult.error || "Failed to import group demo");
+      sendEvent("progress", { stage: "importing", current: 2, total: 2 });
+      const privateResult = await streamImport(dbManager2, privatePath, { nativeBinding });
+      if (!privateResult.success) throw new Error(privateResult.error || "Failed to import private demo");
+      sendEvent("progress", { stage: "done", current: 2, total: 2 });
+      sendEvent("result", {
+        success: true,
+        groupSessionId: groupResult.sessionId,
+        privateSessionId: privateResult.sessionId
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      sendEvent("progress", { stage: "error", current: 0, total: 2, message });
+      sendEvent("result", { success: false, error: message });
+    } finally {
+      try {
+        fs3.unlinkSync(groupPath);
+      } catch {
+      }
+      try {
+        fs3.unlinkSync(privatePath);
+      } catch {
+      }
+      try {
+        fs3.rmdirSync(tmpDir);
+      } catch {
+      }
+      reply.raw.end();
+    }
+  });
+  server2.get("/_web/supported-formats", async () => {
+    return getSupportedFormats();
+  });
+  server2.post("/_web/detect-format", async (request, reply) => {
+    const data = await request.file();
+    if (!data) return reply.code(400).send({ error: "No file uploaded" });
+    const tmpDir = fs3.mkdtempSync(path3.join(os.tmpdir(), "chatlab-detect-"));
+    const tmpPath = path3.join(tmpDir, data.filename || "upload");
+    try {
+      const chunks = [];
+      for await (const chunk of data.file) {
+        chunks.push(chunk);
+      }
+      fs3.writeFileSync(tmpPath, Buffer.concat(chunks));
+      const format = detectFormat(tmpPath);
+      const allFormats = detectAllFormats(tmpPath);
+      return { format, allFormats };
+    } finally {
+      try {
+        fs3.unlinkSync(tmpPath);
+      } catch {
+      }
+      try {
+        fs3.rmdirSync(tmpDir);
+      } catch {
+      }
+    }
+  });
+  server2.post("/_web/scan-multi-chat", async (request, reply) => {
+    const data = await request.file();
+    if (!data) return reply.code(400).send({ error: "No file uploaded" });
+    const tmpDir = fs3.mkdtempSync(path3.join(os.tmpdir(), "chatlab-scan-"));
+    const tmpPath = path3.join(tmpDir, data.filename || "upload");
+    try {
+      const chunks = [];
+      for await (const chunk of data.file) {
+        chunks.push(chunk);
+      }
+      fs3.writeFileSync(tmpPath, Buffer.concat(chunks));
+      const chats = await scanMultiChatFile(tmpPath);
+      return { chats };
+    } finally {
+      try {
+        fs3.unlinkSync(tmpPath);
+      } catch {
+      }
+      try {
+        fs3.rmdirSync(tmpDir);
+      } catch {
+      }
+    }
+  });
+  server2.post("/_web/import", async (request, reply) => {
+    const data = await request.file();
+    if (!data) return reply.code(400).send({ error: "No file uploaded" });
+    const tmpDir = fs3.mkdtempSync(path3.join(os.tmpdir(), "chatlab-import-"));
+    const tmpPath = path3.join(tmpDir, data.filename || "upload");
+    const chunks = [];
+    for await (const chunk of data.file) {
+      chunks.push(chunk);
+    }
+    fs3.writeFileSync(tmpPath, Buffer.concat(chunks));
+    const formatId = data.fields?.formatId?.value;
+    const chatIndexStr = data.fields?.chatIndex?.value;
+    const chatIndex = chatIndexStr !== void 0 ? parseInt(chatIndexStr, 10) : void 0;
+    reply.raw.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    });
+    function sendEvent(event, data2) {
+      reply.raw.write(`event: ${event}
+data: ${JSON.stringify(data2)}
+
+`);
+    }
+    try {
+      const nativeBinding = resolveNativeBinding();
+      const result = await streamImport(dbManager2, tmpPath, {
+        formatId,
+        chatIndex,
+        nativeBinding,
+        onProgress: (p) => {
+          sendEvent("progress", p);
+        }
+      });
+      if (result.success) {
+        sendEvent("done", {
+          success: true,
+          sessionId: result.sessionId,
+          messageCount: result.diagnostics?.messagesWritten ?? 0,
+          memberCount: 0
+        });
+      } else {
+        sendEvent("error", { success: false, error: result.error });
+      }
+    } catch (err) {
+      sendEvent("error", { success: false, error: err instanceof Error ? err.message : String(err) });
+    } finally {
+      reply.raw.end();
+      try {
+        fs3.unlinkSync(tmpPath);
+      } catch {
+      }
+      try {
+        fs3.rmdirSync(tmpDir);
+      } catch {
+      }
+    }
+  });
+  server2.post("/_web/sessions/:id/import/incremental", async (request, reply) => {
+    const sessionId = request.params.id;
+    const data = await request.file();
+    if (!data) return reply.code(400).send({ error: "No file uploaded" });
+    const tmpDir = fs3.mkdtempSync(path3.join(os.tmpdir(), "chatlab-inc-"));
+    const tmpPath = path3.join(tmpDir, data.filename || "upload");
+    const chunks = [];
+    for await (const chunk of data.file) {
+      chunks.push(chunk);
+    }
+    fs3.writeFileSync(tmpPath, Buffer.concat(chunks));
+    reply.raw.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    });
+    function sendEvent(event, eventData) {
+      reply.raw.write(`event: ${event}
+data: ${JSON.stringify(eventData)}
+
+`);
+    }
+    try {
+      const result = await incrementalImport(dbManager2, sessionId, tmpPath, {
+        onProgress: (p) => {
+          sendEvent("progress", p);
+        }
+      });
+      if (result.success) {
+        sendEvent("done", result);
+      } else {
+        sendEvent("error", { success: false, error: result.error });
+      }
+    } catch (err) {
+      sendEvent("error", { success: false, error: err instanceof Error ? err.message : String(err) });
+    } finally {
+      reply.raw.end();
+      try {
+        fs3.unlinkSync(tmpPath);
+      } catch {
+      }
+      try {
+        fs3.rmdirSync(tmpDir);
+      } catch {
+      }
+    }
+  });
+  server2.post("/_web/sessions/:id/import/incremental/analyze", async (request, reply) => {
+    const sessionId = request.params.id;
+    const data = await request.file();
+    if (!data) return reply.code(400).send({ error: "No file uploaded" });
+    const tmpDir = fs3.mkdtempSync(path3.join(os.tmpdir(), "chatlab-analyze-"));
+    const tmpPath = path3.join(tmpDir, data.filename || "upload");
+    const chunks = [];
+    for await (const chunk of data.file) {
+      chunks.push(chunk);
+    }
+    fs3.writeFileSync(tmpPath, Buffer.concat(chunks));
+    try {
+      const result = await analyzeIncrementalImport(dbManager2, sessionId, tmpPath);
+      return result;
+    } catch (err) {
+      return reply.code(500).send({ error: err instanceof Error ? err.message : String(err) });
+    } finally {
+      try {
+        fs3.unlinkSync(tmpPath);
+      } catch {
+      }
+      try {
+        fs3.rmdirSync(tmpDir);
+      } catch {
+      }
+    }
+  });
+  server2.post("/_web/import/analyze", async (request, reply) => {
+    const data = await request.file();
+    if (!data) return reply.code(400).send({ error: "No file uploaded" });
+    const tmpDir = fs3.mkdtempSync(path3.join(os.tmpdir(), "chatlab-analyze-"));
+    const tmpPath = path3.join(tmpDir, data.filename || "upload");
+    const chunks = [];
+    for await (const chunk of data.file) {
+      chunks.push(chunk);
+    }
+    fs3.writeFileSync(tmpPath, Buffer.concat(chunks));
+    try {
+      const result = await analyzeNewImport(tmpPath);
+      return result;
+    } catch (err) {
+      return reply.code(500).send({ error: err instanceof Error ? err.message : String(err) });
+    } finally {
+      try {
+        fs3.unlinkSync(tmpPath);
+      } catch {
+      }
+      try {
+        fs3.rmdirSync(tmpDir);
+      } catch {
+      }
+    }
+  });
+  if (mergeCache) {
+    server2.post("/_web/merge/parse", async (request, reply) => {
+      const data = await request.file();
+      if (!data) return reply.code(400).send({ error: "No file uploaded" });
+      const tmpDir = fs3.mkdtempSync(path3.join(os.tmpdir(), "chatlab-merge-"));
+      const tmpPath = path3.join(tmpDir, data.filename || "upload");
+      const chunks = [];
+      for await (const chunk of data.file) {
+        chunks.push(chunk);
+      }
+      fs3.writeFileSync(tmpPath, Buffer.concat(chunks));
+      try {
+        const result = await streamParseFileInfo(tmpPath, {
+          createTempDatabase(sourceFilePath) {
+            return mergeCache.createTempDatabase(path3.basename(sourceFilePath));
+          },
+          onProgress() {
+          }
+        });
+        const handle = mergeCache.store(data.filename || "upload", result.tempDbPath);
+        return {
+          handle,
+          name: result.name,
+          format: result.format,
+          platform: result.platform,
+          messageCount: result.messageCount,
+          memberCount: result.memberCount,
+          fileSize: result.fileSize
+        };
+      } finally {
+        try {
+          fs3.unlinkSync(tmpPath);
+        } catch {
+        }
+        try {
+          fs3.rmdirSync(tmpDir);
+        } catch {
+        }
+      }
+    });
+    server2.post("/_web/merge/conflicts", async (request, reply) => {
+      const { handles } = request.body;
+      if (!handles || !Array.isArray(handles) || handles.length === 0) {
+        return reply.code(400).send({ error: "Missing or empty handles array" });
+      }
+      const readers = [];
+      try {
+        const dataSources = [];
+        for (const handle of handles) {
+          const entry = mergeCache.openReader(handle);
+          if (!entry) return reply.code(404).send({ error: `Handle not found: ${handle}` });
+          readers.push(entry.reader);
+          dataSources.push({ source: entry.reader.toDataSource(), filename: entry.filename });
+        }
+        return checkConflictsFromSources(dataSources);
+      } finally {
+        for (const r of readers) r.close();
+      }
+    });
+    server2.post("/_web/merge/execute", async (request, reply) => {
+      const { handles, outputName, format = "json", andImport } = request.body;
+      if (!handles || !Array.isArray(handles) || handles.length === 0) {
+        return reply.code(400).send({ error: "Missing handles" });
+      }
+      if (!outputName) {
+        return reply.code(400).send({ error: "Missing outputName" });
+      }
+      const readers = [];
+      try {
+        const dataSources = [];
+        for (const handle of handles) {
+          const entry = mergeCache.openReader(handle);
+          if (!entry) return reply.code(404).send({ error: `Handle not found: ${handle}` });
+          readers.push(entry.reader);
+          dataSources.push({ source: entry.reader.toDataSource(), filename: entry.filename });
+        }
+        const merged = buildMergedOutput(dataSources, outputName);
+        let sessionId;
+        if (andImport) {
+          const { streamImport: serverStreamImport } = await import("./stream-import-RP3XB6NM.mjs");
+          const jsonData = JSON.stringify(merged.chatLabData);
+          const tmpDir = fs3.mkdtempSync(path3.join(os.tmpdir(), "chatlab-merged-"));
+          const tmpPath = path3.join(tmpDir, `${outputName}.json`);
+          fs3.writeFileSync(tmpPath, jsonData, "utf-8");
+          try {
+            const importResult = await serverStreamImport(dbManager2, tmpPath);
+            sessionId = importResult.sessionId;
+          } finally {
+            try {
+              fs3.unlinkSync(tmpPath);
+            } catch {
+            }
+            try {
+              fs3.rmdirSync(tmpDir);
+            } catch {
+            }
+          }
+        }
+        for (const handle of handles) {
+          mergeCache.delete(handle);
+        }
+        if (format === "jsonl") {
+          const lines = [];
+          for (const line of serializeChatLabToJsonl(merged.chatLabData)) {
+            lines.push(line);
+          }
+          return { success: true, sessionId, data: lines.join("\n") };
+        }
+        return { success: true, sessionId, data: merged.chatLabData };
+      } finally {
+        for (const r of readers) r.close();
+      }
+    });
+    server2.post("/_web/merge/clear", async (request) => {
+      const { handle } = request.body || {};
+      if (handle) {
+        mergeCache.delete(handle);
+      } else {
+        mergeCache.clear();
+      }
+      return { success: true };
+    });
+    server2.post("/_web/sessions/export-for-merge", async (request, reply) => {
+      const { sessionIds } = request.body;
+      if (!sessionIds || !Array.isArray(sessionIds) || sessionIds.length === 0) {
+        return reply.code(400).send({ error: "Missing sessionIds" });
+      }
+      const handles = [];
+      for (const sid of sessionIds) {
+        const db = dbManager2.open(sid);
+        if (!db) return reply.code(404).send({ error: `Session not found: ${sid}` });
+        const exported = exportSessionToJson(db);
+        const { db: tempDb, tempDbPath } = mergeCache.createTempDatabase(exported.meta.name);
+        const { TempDbWriter } = await import("./src-ZELOFE7P.mjs");
+        const writer = new TempDbWriter(tempDb);
+        writer.writeMeta({
+          name: exported.meta.name,
+          platform: exported.meta.platform,
+          type: exported.meta.type,
+          groupId: exported.meta.groupId,
+          groupAvatar: exported.meta.groupAvatar
+        });
+        writer.writeMembers(
+          exported.members.map((m) => ({
+            platformId: m.platformId,
+            accountName: m.accountName,
+            groupNickname: m.groupNickname,
+            avatar: m.avatar
+          }))
+        );
+        writer.writeMessages(
+          exported.messages.map((msg) => ({
+            senderPlatformId: msg.sender,
+            senderAccountName: msg.accountName,
+            senderGroupNickname: msg.groupNickname,
+            timestamp: msg.timestamp,
+            type: msg.type,
+            content: msg.content
+          }))
+        );
+        writer.finish();
+        const handle = mergeCache.store(exported.meta.name, tempDbPath);
+        handles.push({ sessionId: sid, handle });
+      }
+      return { success: true, handles };
+    });
+  }
+  const downloadsDir = options?.pathProvider?.getDownloadsDir() || path3.join(os.homedir(), "Downloads");
+  server2.post("/_web/cache/save-to-downloads", async (request) => {
+    const { filename, dataUrl } = request.body;
+    if (!filename || !dataUrl) {
+      return { success: false, error: "filename and dataUrl are required" };
+    }
+    const base64Prefix = dataUrl.indexOf(",");
+    const base64Data = base64Prefix >= 0 ? dataUrl.slice(base64Prefix + 1) : dataUrl;
+    const buffer = Buffer.from(base64Data, "base64");
+    if (!fs3.existsSync(downloadsDir)) {
+      fs3.mkdirSync(downloadsDir, { recursive: true });
+    }
+    const filePath = path3.join(downloadsDir, filename);
+    fs3.writeFileSync(filePath, buffer);
+    return { success: true, filePath };
+  });
+  server2.post("/_web/cache/show-in-folder", async (request) => {
+    const { filePath } = request.body;
+    if (!filePath) {
+      return { success: false, error: "filePath is required" };
+    }
+    const { exec } = await import("child_process");
+    const platform = process.platform;
+    const dir = path3.dirname(filePath);
+    if (platform === "darwin") {
+      exec(`open -R "${filePath}"`);
+    } else if (platform === "win32") {
+      exec(`explorer /select,"${filePath}"`);
+    } else {
+      exec(`xdg-open "${dir}"`);
+    }
+    return { success: true };
+  });
+}
+
+// src/http/routes/nlp.ts
+import * as path4 from "path";
+function ensureDb3(dbManager2, sessionId) {
+  const db = dbManager2.open(sessionId);
+  if (!db) {
+    throw Object.assign(new Error(`Session not found: ${sessionId}`), { statusCode: 404 });
+  }
+  return db;
+}
+function registerNlpRoutes(server2, dbManager2) {
+  const pathProvider = dbManager2["pathProvider"];
+  if (pathProvider) {
+    const nlpDir = path4.join(pathProvider.getUserDataDir(), "nlp");
+    initNlpDir(nlpDir);
+    ensureDefaultDict(nlpDir).catch((err) => console.warn("[NLP] Auto-download zh-CN dict failed:", err));
+  }
+  server2.get("/_web/nlp/pos-tags", async () => {
+    return POS_TAG_DEFINITIONS;
+  });
+  server2.get("/_web/nlp/dicts", async () => {
+    const nlpDir = resolveNlpDir(dbManager2);
+    return getDictList(nlpDir);
+  });
+  server2.get("/_web/nlp/dicts/:id/status", async (request) => {
+    const nlpDir = resolveNlpDir(dbManager2);
+    return isDictDownloaded(nlpDir, request.params.id);
+  });
+  server2.post("/_web/nlp/dicts/:id/download", async (request) => {
+    const nlpDir = resolveNlpDir(dbManager2);
+    return downloadDict(nlpDir, request.params.id);
+  });
+  server2.delete("/_web/nlp/dicts/:id", async (request) => {
+    const nlpDir = resolveNlpDir(dbManager2);
+    return deleteDict(nlpDir, request.params.id);
+  });
+  server2.post("/_web/nlp/word-frequency", async (request) => {
+    const params = request.body;
+    const db = ensureDb3(dbManager2, params.sessionId);
+    return computeWordFrequency(db, params);
+  });
+  server2.post(
+    "/_web/nlp/segment",
+    async (request) => {
+      const { text, locale, minLength } = request.body;
+      return segmentText(text, locale, minLength);
+    }
+  );
+}
+function resolveNlpDir(dbManager2) {
+  const pathProvider = dbManager2["pathProvider"];
+  return path4.join(pathProvider.getUserDataDir(), "nlp");
+}
+
+// src/http/routes/ai.ts
+import * as fs7 from "fs";
+import * as path8 from "path";
+
+// src/ai/logger.ts
+var logger = null;
+function initServerAiLogger(logsDir) {
+  if (!logger) {
+    logger = new AiLogger(logsDir);
+  }
+  return logger;
+}
+function getServerAiLogger() {
+  return logger;
+}
+function closeServerAiLogger() {
+  if (logger) {
+    logger.close();
+    logger = null;
+  }
+}
+
+// src/ai/tool-adapter.ts
+var DEFAULT_MAX_TOOL_RESULT_TOKENS = 8e3;
+var TOOL_TRUNCATION_STRATEGY = {
+  search_keyword: "keep_first",
+  search_messages: "keep_first",
+  deep_search_messages: "keep_first",
+  get_recent_messages: "keep_last",
+  get_message_context: "keep_last",
+  get_session_messages: "keep_last",
+  get_conversation_between: "keep_last"
+};
+function convertJsonSchemaToParameters(schema) {
+  const properties = {};
+  for (const [key, prop] of Object.entries(schema.properties)) {
+    properties[key] = { ...prop };
+  }
+  return {
+    type: "object",
+    properties,
+    required: schema.required || []
+  };
+}
+function adaptToolsForAgent(tools, getContext, options) {
+  const tokenBudget = options?.maxToolResultTokens ?? DEFAULT_MAX_TOOL_RESULT_TOKENS;
+  return tools.map((tool) => ({
+    name: tool.name,
+    label: tool.name,
+    description: tool.description,
+    parameters: convertJsonSchemaToParameters(tool.inputSchema),
+    async execute(_toolCallId, params) {
+      const ctx = getContext();
+      const execCtx = {
+        db: ctx.db,
+        dataProvider: new CoreDataProvider(ctx.db),
+        sessionId: ctx.sessionId,
+        locale: ctx.locale,
+        segmentText: (texts, locale, options2) => batchSegmentWithFrequency(texts, locale, options2)
+      };
+      try {
+        const result = await tool.handler(params, execCtx);
+        if (result.rawMessages && result.rawMessages.length > 0) {
+          const pipelineResult = applyPreprocessingPipeline({
+            rawMessages: result.rawMessages,
+            locale: ctx.locale,
+            maxToolResultTokens: tokenBudget,
+            truncationStrategy: TOOL_TRUNCATION_STRATEGY[tool.name] ?? "keep_last",
+            extraDetails: result.data ?? {},
+            logger: getServerAiLogger() ?? void 0
+          });
+          return { content: [{ type: "text", text: pipelineResult.text }], details: null };
+        }
+        return { content: [{ type: "text", text: result.content }], details: null };
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: `Error: ${msg}` }], details: null };
+      }
+    }
+  }));
+}
+
+// src/ai/assistant-loader.ts
+import * as fs4 from "fs";
+import * as path5 from "path";
+function loadAssistantConfig(aiDataDir, assistantId) {
+  const filePath = path5.join(aiDataDir, "assistants", `${assistantId}.md`);
+  if (!fs4.existsSync(filePath)) return null;
+  try {
+    const content = fs4.readFileSync(filePath, "utf-8");
+    return parseAssistantFile(content, filePath);
+  } catch {
+    return null;
+  }
+}
+
+// src/ai/manager-factory.ts
+import * as fs5 from "fs";
+import * as path6 from "path";
+import { createHash, randomUUID as randomUUID3 } from "crypto";
+var nodeFs = {
+  ensureDir(dir) {
+    if (!fs5.existsSync(dir)) fs5.mkdirSync(dir, { recursive: true });
+  },
+  listFiles(dir, ext) {
+    if (!fs5.existsSync(dir)) return [];
+    return fs5.readdirSync(dir).filter((f) => f.endsWith(ext));
+  },
+  readFile(filePath) {
+    return fs5.readFileSync(filePath, "utf-8");
+  },
+  writeFile(filePath, content) {
+    fs5.writeFileSync(filePath, content, "utf-8");
+  },
+  deleteFile(filePath) {
+    if (fs5.existsSync(filePath)) fs5.unlinkSync(filePath);
+  },
+  fileExists(filePath) {
+    return fs5.existsSync(filePath);
+  },
+  joinPath(...parts) {
+    return path6.join(...parts);
+  }
+};
+var managerCache = /* @__PURE__ */ new Map();
+function getAssistantManager(aiDataDir) {
+  let cached = managerCache.get(aiDataDir);
+  if (!cached) {
+    cached = {
+      assistant: new AssistantManager({
+        fs: nodeFs,
+        assistantsDir: path6.join(aiDataDir, "assistants"),
+        builtinRawConfigs: [],
+        generateId: () => `custom_${randomUUID3().replace(/-/g, "").slice(0, 12)}`
+      }),
+      skill: new SkillManagerCore({
+        fs: nodeFs,
+        skillsDir: path6.join(aiDataDir, "skills"),
+        builtinRawSkills: [],
+        contentHash: (content) => createHash("md5").update(content).digest("hex")
+      })
+    };
+    managerCache.set(aiDataDir, cached);
+  }
+  return cached.assistant;
+}
+function getSkillManagerCore(aiDataDir) {
+  let cached = managerCache.get(aiDataDir);
+  if (!cached) {
+    getAssistantManager(aiDataDir);
+    cached = managerCache.get(aiDataDir);
+  }
+  return cached.skill;
+}
+
+// src/ai/agent.ts
+async function runServerAgent(options) {
+  const {
+    userMessage,
+    conversationId,
+    chatType = "group",
+    locale = "zh-CN",
+    assistantSystemPrompt,
+    skillMenu,
+    compressionConfig,
+    tools = [],
+    aiDataDir,
+    convManager: convManager2,
+    onEvent,
+    abortSignal,
+    ownerInfo,
+    mentionedMembers,
+    dataSnapshot
+  } = options;
+  const aiLogger = getServerAiLogger();
+  const llmConfig = getDefaultAssistantConfig(aiDataDir);
+  if (!llmConfig) {
+    onEvent({ type: "error", error: { name: "ConfigError", message: "LLM service not configured" } });
+    onEvent({ type: "done", isFinished: true });
+    return;
+  }
+  const piModel = buildPiModel2(llmConfig);
+  const t = createAiTranslate(locale);
+  let skillCtx;
+  if (skillMenu) {
+    skillCtx = { skillMenu };
+  }
+  const systemPrompt = buildSystemPrompt({
+    t,
+    chatType,
+    assistantSystemPrompt,
+    ownerInfo,
+    locale,
+    skillCtx,
+    mentionedMembers,
+    dataSnapshot
+  });
+  const handler = new AgentEventHandler({
+    onChunk: onEvent,
+    context: {},
+    systemPrompt
+  });
+  if (compressionConfig?.enabled) {
+    const llmAdapter = createCompressionLlmAdapter({
+      piModel,
+      apiKey: llmConfig.apiKey,
+      onCompressing: () => handler.emitStatus("compressing", [])
+    });
+    const compressionResult = await checkAndCompress(
+      conversationId,
+      compressionConfig,
+      systemPrompt,
+      llmAdapter,
+      convManager2,
+      aiLogger ?? void 0
+    );
+    if (compressionResult.compressed) {
+      onEvent({
+        type: "compression_done",
+        compressionResult: {
+          summaryContent: compressionResult.summaryContent ?? "",
+          tokensBefore: compressionResult.tokensBefore ?? 0,
+          tokensAfter: compressionResult.tokensAfter ?? 0,
+          timestamp: Date.now()
+        }
+      });
+    }
+  }
+  if (abortSignal?.aborted) {
+    handler.emitStatus("aborted", [], { force: true });
+    onEvent({ type: "done", isFinished: true, usage: handler.cloneUsage() });
+    return;
+  }
+  let history = [];
+  try {
+    history = convManager2.getHistoryForAgent(conversationId);
+  } catch {
+  }
+  handler.emitStatus("preparing", [], { pendingUserMessage: userMessage, force: true });
+  const steerMessage = t("ai.agent.answerWithoutTools");
+  let cachedMessages = [];
+  try {
+    const result = await runAgentCore({
+      piModel,
+      apiKey: llmConfig.apiKey,
+      systemPrompt,
+      tools,
+      history,
+      userMessage,
+      maxToolRounds: 5,
+      abortSignal,
+      steerMessage,
+      onConvertToLlm: (filteredMessages) => {
+        cachedMessages = filteredMessages;
+      },
+      onEvent: (coreEvent) => handler.handleCoreEvent(coreEvent, cachedMessages),
+      onDebugContext: (messages) => {
+        try {
+          convManager2.setPendingDebugContext(conversationId, JSON.stringify(messages, null, 2));
+        } catch {
+        }
+      }
+    });
+    if (result.error) {
+      const friendlyMessage = formatAIError(result.error);
+      onEvent({ type: "error", error: { name: "AgentError", message: friendlyMessage } });
+    }
+    handler.emitStatus("completed", cachedMessages, { force: true });
+    onEvent({ type: "done", isFinished: true, usage: result.usage });
+  } catch (error) {
+    const friendlyMessage = formatAIError(error);
+    aiLogger?.error("ServerAgent", "Agent execution error", { error: String(error) });
+    handler.emitStatus("error", cachedMessages, { force: true });
+    onEvent({ type: "error", error: { name: "AgentError", message: friendlyMessage } });
+    onEvent({ type: "done", isFinished: true, usage: handler.cloneUsage() });
+  }
+}
+
+// src/ai/custom-store.ts
+import * as fs6 from "fs";
+import * as path7 from "path";
+import { randomUUID as randomUUID4 } from "crypto";
+function readProviders(aiDataDir) {
+  const storePath = path7.join(aiDataDir, "custom-providers.json");
+  if (!fs6.existsSync(storePath)) return [];
+  try {
+    const content = fs6.readFileSync(storePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return [];
+  }
+}
+function writeProviders(aiDataDir, providers) {
+  const storePath = path7.join(aiDataDir, "custom-providers.json");
+  const dir = path7.dirname(storePath);
+  if (!fs6.existsSync(dir)) fs6.mkdirSync(dir, { recursive: true });
+  fs6.writeFileSync(storePath, JSON.stringify(providers, null, 2), "utf-8");
+}
+function addCustomProvider(aiDataDir, input) {
+  const providers = readProviders(aiDataDir);
+  const newProvider = {
+    ...input,
+    id: `custom:${randomUUID4()}`,
+    builtin: false,
+    enabledByDefault: false
+  };
+  providers.push(newProvider);
+  writeProviders(aiDataDir, providers);
+  return newProvider;
+}
+function updateCustomProvider(aiDataDir, id, updates) {
+  const providers = readProviders(aiDataDir);
+  const index = providers.findIndex((p) => p.id === id);
+  if (index === -1) return { success: false, error: "Custom provider not found" };
+  providers[index] = { ...providers[index], ...updates };
+  writeProviders(aiDataDir, providers);
+  return { success: true };
+}
+function deleteCustomProvider(aiDataDir, id) {
+  const providers = readProviders(aiDataDir);
+  const index = providers.findIndex((p) => p.id === id);
+  if (index === -1) return { success: false, error: "Custom provider not found" };
+  providers.splice(index, 1);
+  writeProviders(aiDataDir, providers);
+  return { success: true };
+}
+function readModels(aiDataDir) {
+  const storePath = path7.join(aiDataDir, "custom-models.json");
+  if (!fs6.existsSync(storePath)) return [];
+  try {
+    const content = fs6.readFileSync(storePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return [];
+  }
+}
+function writeModels(aiDataDir, models) {
+  const storePath = path7.join(aiDataDir, "custom-models.json");
+  const dir = path7.dirname(storePath);
+  if (!fs6.existsSync(dir)) fs6.mkdirSync(dir, { recursive: true });
+  fs6.writeFileSync(storePath, JSON.stringify(models, null, 2), "utf-8");
+}
+function addCustomModel(aiDataDir, input) {
+  const models = readModels(aiDataDir);
+  const existing = models.find((m) => m.id === input.id && m.providerId === input.providerId);
+  if (existing) {
+    return { success: false, error: `Model "${input.id}" already exists under provider "${input.providerId}"` };
+  }
+  const newModel = {
+    ...input,
+    builtin: false,
+    editable: true
+  };
+  models.push(newModel);
+  writeModels(aiDataDir, models);
+  return { success: true, model: newModel };
+}
+function updateCustomModel(aiDataDir, providerId, modelId, updates) {
+  const models = readModels(aiDataDir);
+  const index = models.findIndex((m) => m.id === modelId && m.providerId === providerId);
+  if (index === -1) return { success: false, error: "Custom model not found" };
+  models[index] = { ...models[index], ...updates };
+  writeModels(aiDataDir, models);
+  return { success: true };
+}
+function deleteCustomModel(aiDataDir, providerId, modelId) {
+  const models = readModels(aiDataDir);
+  const index = models.findIndex((m) => m.id === modelId && m.providerId === providerId);
+  if (index === -1) return { success: false, error: "Custom model not found" };
+  models.splice(index, 1);
+  writeModels(aiDataDir, models);
+  return { success: true };
+}
+
+// src/http/routes/ai.ts
+function getAiDir(dbManager2) {
+  const pathProvider = dbManager2["pathProvider"];
+  if (!pathProvider) {
+    throw Object.assign(new Error("PathProvider not available"), { statusCode: 500 });
+  }
+  return pathProvider.getAiDataDir();
+}
+function registerAiRoutes(server2, dbManager2, convManager2) {
+  server2.get("/_web/ai/assistants", async () => {
+    const mgr = getAssistantManager(getAiDir(dbManager2));
+    return mgr.getAllAssistants();
+  });
+  server2.get("/_web/ai/assistants/:id", async (request, reply) => {
+    const mgr = getAssistantManager(getAiDir(dbManager2));
+    const config = mgr.getAssistantConfig(request.params.id);
+    if (!config) return reply.code(404).send({ error: "Not found" });
+    return config;
+  });
+  server2.post("/_web/ai/assistants", async (request) => {
+    const mgr = getAssistantManager(getAiDir(dbManager2));
+    return mgr.createAssistant(request.body);
+  });
+  server2.put("/_web/ai/assistants/:id", async (request, reply) => {
+    const mgr = getAssistantManager(getAiDir(dbManager2));
+    const result = mgr.updateAssistant(request.params.id, request.body);
+    if (!result.success) return reply.code(404).send(result);
+    return result;
+  });
+  server2.delete("/_web/ai/assistants/:id", async (request, reply) => {
+    const mgr = getAssistantManager(getAiDir(dbManager2));
+    const result = mgr.deleteAssistant(request.params.id);
+    if (!result.success) return reply.code(400).send(result);
+    return result;
+  });
+  server2.post("/_web/ai/assistants/:id/reset", async (request, reply) => {
+    const mgr = getAssistantManager(getAiDir(dbManager2));
+    const result = mgr.resetAssistant(request.params.id);
+    if (!result.success) return reply.code(400).send(result);
+    return result;
+  });
+  server2.post("/_web/ai/assistants/import", async (request) => {
+    const mgr = getAssistantManager(getAiDir(dbManager2));
+    return mgr.importAssistantFromMd(request.body.rawMd);
+  });
+  server2.get("/_web/ai/skills", async () => {
+    const mgr = getSkillManagerCore(getAiDir(dbManager2));
+    return mgr.getAllSkills();
+  });
+  server2.get("/_web/ai/skills/:id", async (request, reply) => {
+    const mgr = getSkillManagerCore(getAiDir(dbManager2));
+    const config = mgr.getSkillConfig(request.params.id);
+    if (!config) return reply.code(404).send({ error: "Not found" });
+    return config;
+  });
+  server2.post("/_web/ai/skills", async (request) => {
+    const mgr = getSkillManagerCore(getAiDir(dbManager2));
+    return mgr.createSkill(request.body.rawMd);
+  });
+  server2.put("/_web/ai/skills/:id", async (request, reply) => {
+    const mgr = getSkillManagerCore(getAiDir(dbManager2));
+    const result = mgr.updateSkill(request.params.id, request.body.rawMd);
+    if (!result.success) return reply.code(404).send(result);
+    return result;
+  });
+  server2.delete("/_web/ai/skills/:id", async (request, reply) => {
+    const mgr = getSkillManagerCore(getAiDir(dbManager2));
+    const result = mgr.deleteSkill(request.params.id);
+    if (!result.success) return reply.code(400).send(result);
+    return result;
+  });
+  server2.post("/_web/ai/skills/import", async (request) => {
+    const mgr = getSkillManagerCore(getAiDir(dbManager2));
+    return mgr.importSkillFromMd(request.body.rawMd);
+  });
+  server2.get("/_web/ai/skills/builtin-catalog", async () => {
+    const mgr = getSkillManagerCore(getAiDir(dbManager2));
+    return mgr.getBuiltinCatalog();
+  });
+  server2.get("/_web/ai/llm/has-config", async () => {
+    const configPath = path8.join(getAiDir(dbManager2), "llm-config.json");
+    if (!fs7.existsSync(configPath)) return false;
+    try {
+      const data = JSON.parse(fs7.readFileSync(configPath, "utf-8"));
+      if (!data.configs || !Array.isArray(data.configs) || data.configs.length === 0) return false;
+      return data.defaultAssistant != null;
+    } catch {
+      return false;
+    }
+  });
+  server2.get("/_web/ai/llm/configs", async () => {
+    const configPath = path8.join(getAiDir(dbManager2), "llm-config.json");
+    if (!fs7.existsSync(configPath)) return { configs: [], defaultAssistant: null, fastModel: null };
+    try {
+      const data = JSON.parse(fs7.readFileSync(configPath, "utf-8"));
+      const configs = (data.configs || []).map((c) => {
+        const { apiKey: _k, ...rest } = c;
+        return { ...rest, apiKey: "" };
+      });
+      return {
+        configs,
+        defaultAssistant: data.defaultAssistant ?? null,
+        fastModel: data.fastModel ?? null
+      };
+    } catch {
+      return { configs: [], defaultAssistant: null, fastModel: null };
+    }
+  });
+  server2.get("/_web/ai/llm/providers", async () => {
+    return BUILTIN_PROVIDERS.map((p) => {
+      const models = getBuiltinModelsByProvider(p.id);
+      return {
+        id: p.id,
+        name: p.name,
+        defaultBaseUrl: p.defaultBaseUrl,
+        models: models.filter((m) => !m.capabilities.includes("embedding") && !m.capabilities.includes("ranking")).map((m) => ({ id: m.id, name: m.name, description: m.description }))
+      };
+    });
+  });
+  server2.get("/_web/ai/llm/provider-registry", async () => {
+    const customPath = path8.join(getAiDir(dbManager2), "custom-providers.json");
+    let custom = [];
+    if (fs7.existsSync(customPath)) {
+      try {
+        custom = JSON.parse(fs7.readFileSync(customPath, "utf-8"));
+        if (!Array.isArray(custom)) custom = [];
+      } catch {
+        custom = [];
+      }
+    }
+    return [...BUILTIN_PROVIDERS, ...custom];
+  });
+  server2.get("/_web/ai/llm/model-catalog", async () => {
+    const customPath = path8.join(getAiDir(dbManager2), "custom-models.json");
+    let custom = [];
+    if (fs7.existsSync(customPath)) {
+      try {
+        custom = JSON.parse(fs7.readFileSync(customPath, "utf-8"));
+        if (!Array.isArray(custom)) custom = [];
+      } catch {
+        custom = [];
+      }
+    }
+    return [...BUILTIN_MODELS, ...custom];
+  });
+  server2.get("/_web/ai/llm/default-assistant-slot", async () => {
+    const configPath = path8.join(getAiDir(dbManager2), "llm-config.json");
+    if (!fs7.existsSync(configPath)) return null;
+    try {
+      const data = JSON.parse(fs7.readFileSync(configPath, "utf-8"));
+      return data.defaultAssistant ?? null;
+    } catch {
+      return null;
+    }
+  });
+  server2.get("/_web/ai/llm/fast-model-slot", async () => {
+    const configPath = path8.join(getAiDir(dbManager2), "llm-config.json");
+    if (!fs7.existsSync(configPath)) return null;
+    try {
+      const data = JSON.parse(fs7.readFileSync(configPath, "utf-8"));
+      return data.fastModel ?? null;
+    } catch {
+      return null;
+    }
+  });
+  server2.post("/_web/ai/llm/configs", async (request) => {
+    const aiDataDir = getAiDir(dbManager2);
+    return addLlmConfig(aiDataDir, request.body);
+  });
+  server2.put("/_web/ai/llm/configs/:id", async (request) => {
+    const aiDataDir = getAiDir(dbManager2);
+    return updateLlmConfig(aiDataDir, request.params.id, request.body);
+  });
+  server2.delete("/_web/ai/llm/configs/:id", async (request) => {
+    const aiDataDir = getAiDir(dbManager2);
+    return deleteLlmConfig(aiDataDir, request.params.id);
+  });
+  server2.put("/_web/ai/llm/default-assistant-slot", async (request) => {
+    const aiDataDir = getAiDir(dbManager2);
+    return setDefaultAssistantSlot(aiDataDir, request.body.configId, request.body.modelId);
+  });
+  server2.put("/_web/ai/llm/fast-model-slot", async (request) => {
+    const aiDataDir = getAiDir(dbManager2);
+    return setFastModelSlot(aiDataDir, request.body);
+  });
+  server2.post("/_web/ai/llm/custom-providers", async (request) => {
+    const aiDataDir = getAiDir(dbManager2);
+    return addCustomProvider(aiDataDir, {
+      ...request.body,
+      kind: request.body.kind || "openai-compatible",
+      authMode: "api-key",
+      supportsCustomModels: request.body.supportsCustomModels ?? true,
+      modelIds: request.body.modelIds ?? []
+    });
+  });
+  server2.put("/_web/ai/llm/custom-providers/:id", async (request) => {
+    const aiDataDir = getAiDir(dbManager2);
+    return updateCustomProvider(aiDataDir, request.params.id, request.body);
+  });
+  server2.delete("/_web/ai/llm/custom-providers/:id", async (request) => {
+    const aiDataDir = getAiDir(dbManager2);
+    return deleteCustomProvider(aiDataDir, request.params.id);
+  });
+  server2.post("/_web/ai/llm/custom-models", async (request) => {
+    const aiDataDir = getAiDir(dbManager2);
+    return addCustomModel(aiDataDir, {
+      ...request.body,
+      capabilities: request.body.capabilities ?? ["chat"],
+      recommendedFor: request.body.recommendedFor ?? ["chat"],
+      status: request.body.status ?? "stable"
+    });
+  });
+  server2.put("/_web/ai/llm/custom-models/:providerId/:modelId", async (request) => {
+    const aiDataDir = getAiDir(dbManager2);
+    return updateCustomModel(aiDataDir, request.params.providerId, request.params.modelId, request.body);
+  });
+  server2.delete("/_web/ai/llm/custom-models/:providerId/:modelId", async (request) => {
+    const aiDataDir = getAiDir(dbManager2);
+    return deleteCustomModel(aiDataDir, request.params.providerId, request.params.modelId);
+  });
+  server2.post("/_web/ai/llm/validate-key", async (request) => {
+    const { provider, apiKey, baseUrl, model, apiFormat } = request.body;
+    return validateApiKey(provider, apiKey, baseUrl, model, apiFormat);
+  });
+  server2.post("/_web/ai/llm/remote-models", async (request) => {
+    const { provider, apiKey, baseUrl, apiFormat } = request.body;
+    return fetchRemoteModels(provider, apiKey, baseUrl, apiFormat);
+  });
+  server2.post("/_web/ai/llm/chat-stream", async (request, reply) => {
+    const { messages, options } = request.body;
+    const aiDataDir = getAiDir(dbManager2);
+    const llmConfig = getDefaultAssistantConfig(aiDataDir);
+    if (!llmConfig) {
+      return reply.code(400).send({ success: false, error: "LLM service not configured" });
+    }
+    const piModel = buildPiModel2(llmConfig);
+    reply.raw.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    });
+    const sendChunk = (data) => {
+      reply.raw.write(`event: chunk
+data: ${JSON.stringify(data)}
+
+`);
+    };
+    try {
+      await runSimpleLlmStream({
+        messages,
+        apiKey: llmConfig.apiKey,
+        piModel,
+        temperature: options?.temperature,
+        maxTokens: options?.maxTokens,
+        onChunk: sendChunk
+      });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      sendChunk({ content: "", isFinished: true, finishReason: "error", error: msg });
+    }
+    reply.raw.end();
+  });
+  server2.get("/_web/ai/tools/catalog", async () => {
+    return BUILTIN_TOOL_CATALOG;
+  });
+  if (!convManager2) return;
+  server2.post("/_web/ai/conversations", async (request) => {
+    const { sessionId, title, assistantId } = request.body;
+    return convManager2.createConversation(sessionId, title, assistantId);
+  });
+  server2.get("/_web/ai/conversations", async (request) => {
+    const { sessionId } = request.query;
+    if (!sessionId) return [];
+    return convManager2.getConversations(sessionId);
+  });
+  server2.get("/_web/ai/conversations/:id", async (request, reply) => {
+    const conv = convManager2.getConversation(request.params.id);
+    if (!conv) return reply.code(404).send({ error: "Conversation not found" });
+    return conv;
+  });
+  server2.put("/_web/ai/conversations/:id/title", async (request) => {
+    return convManager2.updateConversationTitle(request.params.id, request.body.title);
+  });
+  server2.delete("/_web/ai/conversations/:id", async (request) => {
+    return convManager2.deleteConversation(request.params.id);
+  });
+  server2.post("/_web/ai/conversations/:id/messages", async (request) => {
+    const { role, content, dataKeywords, dataMessageCount, contentBlocks, tokenUsage } = request.body;
+    return convManager2.addMessage(
+      request.params.id,
+      role,
+      content,
+      dataKeywords,
+      dataMessageCount,
+      contentBlocks,
+      tokenUsage
+    );
+  });
+  server2.get("/_web/ai/conversations/:id/messages", async (request) => {
+    return convManager2.getMessages(request.params.id);
+  });
+  server2.get("/_web/ai/conversations/:id/token-usage", async (request) => {
+    return convManager2.getConversationTokenUsage(request.params.id);
+  });
+  const activeAgentAborts = /* @__PURE__ */ new Map();
+  server2.post("/_web/ai/agent/stream", async (request, reply) => {
+    const {
+      userMessage,
+      conversationId,
+      sessionId,
+      chatType,
+      locale,
+      assistantId,
+      compressionConfig,
+      ownerInfo,
+      mentionedMembers
+    } = request.body;
+    const requestId = `req_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const abortController = new AbortController();
+    activeAgentAborts.set(requestId, abortController);
+    reply.raw.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+      "X-Request-Id": requestId
+    });
+    const sendSSE = (event, data) => {
+      reply.raw.write(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`);
+    };
+    sendSSE("meta", { requestId });
+    const aiDataDir = getAiDir(dbManager2);
+    let assistantSystemPrompt;
+    if (assistantId) {
+      const assistantConfig = loadAssistantConfig(aiDataDir, assistantId);
+      if (assistantConfig?.systemPrompt) {
+        assistantSystemPrompt = assistantConfig.systemPrompt;
+      }
+    }
+    const llmConfig = getDefaultAssistantConfig(aiDataDir);
+    const maxToolResultPercent = compressionConfig?.maxToolResultPercent ?? 50;
+    const contextWindow = llmConfig ? buildPiModel2(llmConfig).contextWindow ?? 128e3 : 128e3;
+    const maxToolResultTokens = Math.floor(contextWindow * (maxToolResultPercent / 100));
+    const db = dbManager2.open?.(sessionId);
+    const agentTools = db ? adaptToolsForAgent(AGENT_TOOL_REGISTRY, () => ({ db, sessionId, locale }), { maxToolResultTokens }) : [];
+    const skillManager = new SkillManager(aiDataDir);
+    skillManager.init();
+    const toolNames = agentTools.map((t) => t.name);
+    const skillMenu = skillManager.getSkillMenu(chatType ?? "group", toolNames);
+    if (skillMenu) {
+      const activateSkillTool = createActivateSkillTool({
+        chatType: chatType ?? "group",
+        allowedTools: toolNames,
+        locale,
+        getSkillConfig: (id) => skillManager.getSkillConfig(id)
+      });
+      agentTools.push(activateSkillTool);
+    }
+    const onEvent = (event) => {
+      sendSSE(event.type, event);
+      if (event.type === "done") {
+        activeAgentAborts.delete(requestId);
+        reply.raw.end();
+      }
+    };
+    reply.raw.on("close", () => {
+      if (!abortController.signal.aborted) {
+        abortController.abort();
+      }
+      activeAgentAborts.delete(requestId);
+    });
+    try {
+      const resolvedCompression = compressionConfig?.enabled ? {
+        enabled: true,
+        tokenThresholdPercent: compressionConfig.tokenThresholdPercent ?? 75,
+        bufferSizePercent: compressionConfig.bufferSizePercent ?? 20,
+        maxToolResultPercent: compressionConfig.maxToolResultPercent
+      } : void 0;
+      let dataSnapshot;
+      if (db) {
+        try {
+          const overview = getChatOverview(db, 5);
+          if (overview) {
+            dataSnapshot = {
+              name: overview.name,
+              platform: overview.platform,
+              type: overview.type,
+              totalMessages: overview.totalMessages,
+              totalMembers: overview.totalMembers,
+              firstMessageTs: overview.firstMessageTs,
+              lastMessageTs: overview.lastMessageTs,
+              capturedAt: Math.floor(Date.now() / 1e3)
+            };
+          }
+        } catch {
+        }
+      }
+      await runServerAgent({
+        userMessage,
+        conversationId,
+        chatType,
+        locale,
+        assistantSystemPrompt,
+        skillMenu,
+        compressionConfig: resolvedCompression,
+        tools: agentTools,
+        aiDataDir,
+        convManager: convManager2,
+        onEvent,
+        abortSignal: abortController.signal,
+        ownerInfo,
+        mentionedMembers,
+        dataSnapshot
+      });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      sendSSE("error", { type: "error", error: { name: "ServerError", message: msg } });
+      sendSSE("done", { type: "done", isFinished: true });
+      activeAgentAborts.delete(requestId);
+      reply.raw.end();
+    }
+  });
+  server2.post("/_web/ai/agent/abort", async (request) => {
+    const { requestId } = request.body;
+    const controller = activeAgentAborts.get(requestId);
+    if (controller) {
+      controller.abort();
+      activeAgentAborts.delete(requestId);
+      return { success: true };
+    }
+    return { success: false };
+  });
+  server2.get("/_web/ai/debug/schema", async (_request, reply) => {
+    if (!convManager2) {
+      return reply.code(503).send({ error: "AI conversation manager not available" });
+    }
+    return convManager2.getAiSchema();
+  });
+  server2.post("/_web/ai/debug/execute-sql", async (request, reply) => {
+    if (!convManager2) {
+      return reply.code(503).send({ error: "AI conversation manager not available" });
+    }
+    const { sql } = request.body;
+    if (!sql || typeof sql !== "string") {
+      return reply.code(400).send({ error: "sql is required" });
+    }
+    try {
+      return convManager2.executeAiSQL(sql);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      return reply.code(400).send({ error: msg });
+    }
+  });
+  server2.post("/_web/ai/debug/clear-debug-context", async (_request, reply) => {
+    if (!convManager2) {
+      return reply.code(503).send({ error: "AI conversation manager not available" });
+    }
+    const cleared = convManager2.clearAllDebugContext();
+    return { success: true, cleared };
+  });
+}
+
+// src/http/routes/preferences.ts
+var prefManager = null;
+function registerPreferencesRoutes(server2, pathProvider) {
+  if (!prefManager) {
+    prefManager = new PreferencesManager(pathProvider.getSystemDir());
+  }
+  server2.get("/_web/preferences", async () => {
+    return prefManager.load();
+  });
+  server2.patch("/_web/preferences", async (request) => {
+    return prefManager.save(request.body);
+  });
+  server2.get("/_web/preferences/ui-config", async () => {
+    const config = loadConfig();
+    return config.ui;
+  });
+  server2.patch("/_web/preferences/ui-config", async (request) => {
+    try {
+      for (const [key, value] of Object.entries(request.body)) {
+        if (value !== void 0) {
+          writeConfigField("ui", key, value);
+        }
+      }
+      return { success: true };
+    } catch (err) {
+      return { success: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  });
+  server2.get("/_web/preferences/locale", async () => {
+    const config = loadConfig();
+    return { lang: config.locale.lang };
+  });
+  server2.patch("/_web/preferences/locale", async (request) => {
+    try {
+      writeConfigField("locale", "lang", request.body.lang);
+      return { success: true };
+    } catch (err) {
+      return { success: false, error: err instanceof Error ? err.message : String(err) };
+    }
+  });
+}
+
+// ../../packages/sync/src/types.ts
+var noop = () => {
+};
+var NOOP_LOGGER = { info: noop, warn: noop, error: noop };
+
+// ../../packages/sync/src/data-source-manager.ts
+import * as fs8 from "fs";
+import * as path9 from "path";
+import * as crypto2 from "crypto";
+var CONFIG_FILE = "data-sources.json";
+function generateId(prefix = "ds") {
+  return `${prefix}_${crypto2.randomBytes(6).toString("hex")}`;
+}
+function normalizeBaseUrl(input) {
+  let url = input.trim().replace(/\/+$/, "");
+  if (url && !/^https?:\/\//i.test(url)) {
+    url = `http://${url}`;
+  }
+  if (url && !url.endsWith("/api/v1")) {
+    url = url.replace(/\/api\/v1$/, "") + "/api/v1";
+  }
+  return url;
+}
+function isValidDataSourceArray(data) {
+  if (!Array.isArray(data)) return false;
+  return data.every((item) => item && typeof item === "object" && Array.isArray(item.sessions));
+}
+var DataSourceManager = class {
+  configDir;
+  logger;
+  constructor(configDir, logger2) {
+    this.configDir = configDir;
+    this.logger = logger2 ?? NOOP_LOGGER;
+  }
+  getConfigPath() {
+    return path9.join(this.configDir, CONFIG_FILE);
+  }
+  ensureDir() {
+    fs8.mkdirSync(this.configDir, { recursive: true });
+  }
+  // ==================== Load / Save ====================
+  loadAll() {
+    try {
+      const filePath = this.getConfigPath();
+      if (fs8.existsSync(filePath)) {
+        const raw = fs8.readFileSync(filePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (!isValidDataSourceArray(parsed)) {
+          this.logger.warn("[DataSource] Incompatible config format detected, returning empty.");
+          return [];
+        }
+        for (const ds of parsed) {
+          if (!ds.pullLimit) ds.pullLimit = 1e3;
+        }
+        return parsed;
+      }
+    } catch (err) {
+      this.logger.error("[DataSource] Failed to load config", err);
+    }
+    return [];
+  }
+  saveAll(sources) {
+    try {
+      this.ensureDir();
+      fs8.writeFileSync(this.getConfigPath(), JSON.stringify(sources, null, 2), "utf-8");
+    } catch (err) {
+      this.logger.error("[DataSource] Failed to save config", err);
+    }
+  }
+  // ==================== DataSource CRUD ====================
+  get(id) {
+    return this.loadAll().find((s) => s.id === id) || null;
+  }
+  add(partial) {
+    const sources = this.loadAll();
+    const ds = {
+      id: generateId("src"),
+      name: partial.name || "",
+      baseUrl: normalizeBaseUrl(partial.baseUrl),
+      token: partial.token,
+      intervalMinutes: partial.intervalMinutes,
+      pullLimit: partial.pullLimit || 1e3,
+      enabled: true,
+      createdAt: Math.floor(Date.now() / 1e3),
+      sessions: []
+    };
+    sources.push(ds);
+    this.saveAll(sources);
+    return ds;
+  }
+  update(id, updates) {
+    const sources = this.loadAll();
+    const idx = sources.findIndex((s) => s.id === id);
+    if (idx === -1) return null;
+    const ds = sources[idx];
+    if (updates.name !== void 0) ds.name = updates.name;
+    if (updates.baseUrl !== void 0) ds.baseUrl = normalizeBaseUrl(updates.baseUrl);
+    if (updates.token !== void 0) ds.token = updates.token;
+    if (updates.intervalMinutes !== void 0) ds.intervalMinutes = updates.intervalMinutes;
+    if (updates.pullLimit !== void 0) ds.pullLimit = updates.pullLimit;
+    if (updates.enabled !== void 0) ds.enabled = updates.enabled;
+    this.saveAll(sources);
+    return ds;
+  }
+  delete(id) {
+    const sources = this.loadAll();
+    const filtered = sources.filter((s) => s.id !== id);
+    if (filtered.length === sources.length) return false;
+    this.saveAll(filtered);
+    return true;
+  }
+  // ==================== ImportSession CRUD ====================
+  addSessions(sourceId, sessions) {
+    const sources = this.loadAll();
+    const ds = sources.find((s) => s.id === sourceId);
+    if (!ds) return [];
+    const added = [];
+    for (const sess of sessions) {
+      if (ds.sessions.some((s) => s.remoteSessionId === sess.remoteSessionId)) continue;
+      const imp = {
+        id: generateId("sess"),
+        name: sess.name,
+        remoteSessionId: sess.remoteSessionId,
+        targetSessionId: "",
+        lastPullAt: 0,
+        lastStatus: "idle",
+        lastError: "",
+        lastNewMessages: 0
+      };
+      ds.sessions.push(imp);
+      added.push(imp);
+    }
+    this.saveAll(sources);
+    return added;
+  }
+  removeSession(sourceId, sessionId) {
+    const sources = this.loadAll();
+    const ds = sources.find((s) => s.id === sourceId);
+    if (!ds) return false;
+    const before = ds.sessions.length;
+    ds.sessions = ds.sessions.filter((s) => s.id !== sessionId);
+    if (ds.sessions.length === before) return false;
+    this.saveAll(sources);
+    return true;
+  }
+  updateSession(sourceId, sessionId, updates) {
+    const sources = this.loadAll();
+    const ds = sources.find((s) => s.id === sourceId);
+    if (!ds) return null;
+    const sess = ds.sessions.find((s) => s.id === sessionId);
+    if (!sess) return null;
+    Object.assign(sess, updates, { id: sessionId });
+    this.saveAll(sources);
+    return sess;
+  }
+};
+
+// ../../packages/sync/src/discovery.ts
+function buildRemoteSessionsUrl(baseUrl, query = {}) {
+  const searchParams = new URLSearchParams();
+  searchParams.set("format", "chatlab");
+  if (query.keyword?.trim()) searchParams.set("keyword", query.keyword.trim());
+  if (query.limit && query.limit > 0) searchParams.set("limit", String(query.limit));
+  if (query.cursor) searchParams.set("cursor", query.cursor);
+  return `${baseUrl}/sessions?${searchParams.toString()}`;
+}
+function parseRemoteSessionsResponse(body) {
+  const parsed = JSON.parse(body);
+  let sessions;
+  let pageSource;
+  if (Array.isArray(parsed)) {
+    sessions = parsed;
+  } else if (parsed && typeof parsed === "object") {
+    sessions = parsed.sessions ?? parsed.data?.sessions ?? parsed.data ?? [];
+    if (!Array.isArray(sessions)) sessions = [];
+    pageSource = parsed.page ?? parsed.data?.page;
+  } else {
+    sessions = [];
+  }
+  return {
+    sessions,
+    page: pageSource && typeof pageSource === "object" ? {
+      hasMore: Boolean(pageSource.hasMore),
+      nextCursor: typeof pageSource.nextCursor === "string" ? pageSource.nextCursor : void 0
+    } : void 0
+  };
+}
+
+// ../../packages/sync/src/pull-engine.ts
+import * as fs9 from "fs";
+import * as crypto3 from "crypto";
+var MAX_PAGES_PER_PULL = 50;
+var PULL_OVERLAP_SECONDS = 60;
+function buildPullUrl(baseUrl, remoteSessionId, params) {
+  const base = `${baseUrl}/sessions/${remoteSessionId}/messages`;
+  const qs = ["format=chatlab"];
+  if (params.since !== void 0 && params.since > 0) qs.push(`since=${params.since}`);
+  if (params.offset !== void 0 && params.offset > 0) qs.push(`offset=${params.offset}`);
+  if (params.end !== void 0 && params.end > 0) qs.push(`end=${params.end}`);
+  if (params.limit !== void 0 && params.limit > 0) qs.push(`limit=${params.limit}`);
+  return base + "?" + qs.join("&");
+}
+function deriveLocalSessionId(baseUrl, remoteSessionId) {
+  const hash = crypto3.createHash("sha256").update(`${baseUrl}\0${remoteSessionId}`).digest("hex").slice(0, 12);
+  return `remote_${hash}`;
+}
+function parseSyncFromFile(filePath) {
+  try {
+    const isJsonl = filePath.endsWith(".jsonl");
+    if (isJsonl) {
+      const content = fs9.readFileSync(filePath, "utf-8");
+      const lines = content.trimEnd().split("\n");
+      for (let i = lines.length - 1; i >= Math.max(0, lines.length - 5); i--) {
+        try {
+          const obj = JSON.parse(lines[i]);
+          if (obj._type === "sync") {
+            return {
+              hasMore: !!obj.hasMore,
+              nextSince: obj.nextSince,
+              nextOffset: obj.nextOffset,
+              watermark: obj.watermark
+            };
+          }
+        } catch {
+          continue;
+        }
+      }
+      return null;
+    }
+    const raw = fs9.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed.sync && typeof parsed.sync === "object") {
+      const s = parsed.sync;
+      return { hasMore: !!s.hasMore, nextSince: s.nextSince, nextOffset: s.nextOffset, watermark: s.watermark };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function cleanupTempFile(filePath) {
+  try {
+    if (fs9.existsSync(filePath)) fs9.unlinkSync(filePath);
+  } catch {
+  }
+}
+var PullEngine = class {
+  fetcher;
+  importer;
+  notifier;
+  dsManager;
+  logger;
+  isImporting;
+  constructor(options) {
+    this.fetcher = options.fetcher;
+    this.importer = options.importer;
+    this.notifier = options.notifier;
+    this.dsManager = options.dsManager;
+    this.logger = options.logger ?? NOOP_LOGGER;
+    this.isImporting = options.isImporting ?? (() => false);
+  }
+  async importTempFile(baseUrl, sess, tempFile) {
+    let targetId = sess.targetSessionId;
+    if (!targetId) {
+      const derived = deriveLocalSessionId(baseUrl, sess.remoteSessionId);
+      if (this.importer.sessionExists(derived)) {
+        targetId = derived;
+        this.logger.info(`[Pull] Reusing existing local session ${derived} for "${sess.name}"`);
+      }
+    }
+    const externalId = deriveLocalSessionId(baseUrl, sess.remoteSessionId);
+    return this.importer.importFile(tempFile, targetId || void 0, externalId);
+  }
+  async executePullSession(sourceId, ds, sess) {
+    if (this.isImporting()) {
+      this.logger.info(`[Pull] Skipping "${sess.name}": import in progress`);
+      return { success: false, newMessageCount: 0, error: "Import in progress" };
+    }
+    this.logger.info(`[Pull] Pulling "${sess.name}" from ${ds.baseUrl}`);
+    let totalNewMessages = 0;
+    let since = sess.lastPullAt;
+    let offset = 0;
+    let end;
+    let pageCount = 0;
+    let resyncAttempted = false;
+    try {
+      while (pageCount < MAX_PAGES_PER_PULL) {
+        pageCount++;
+        const tempFile = await this.fetcher.fetchToTempFile(ds.baseUrl, sess.remoteSessionId, ds.token, {
+          since,
+          offset,
+          end,
+          limit: ds.pullLimit
+        });
+        try {
+          const stat = fs9.statSync(tempFile);
+          this.logger.info(`[Pull] "${sess.name}" page ${pageCount}: fetched ${stat.size} bytes`);
+          if (stat.size === 0) {
+            cleanupTempFile(tempFile);
+            break;
+          }
+          const sync = parseSyncFromFile(tempFile);
+          const result = await this.importTempFile(ds.baseUrl, sess, tempFile);
+          cleanupTempFile(tempFile);
+          if (result.needFullResync && !resyncAttempted) {
+            resyncAttempted = true;
+            this.logger.info(`[Pull] Resetting since=0 for "${sess.name}" full resync`);
+            since = 0;
+            offset = 0;
+            pageCount = 0;
+            sess.targetSessionId = "";
+            sess.lastPullAt = 0;
+            this.dsManager.updateSession(sourceId, sess.id, { targetSessionId: "", lastPullAt: 0 });
+            continue;
+          }
+          if (result.needFullResync) {
+            const errMsg = "Full resync failed";
+            this.logger.error(`[Pull] Full resync already attempted for "${sess.name}", aborting`);
+            this.dsManager.updateSession(sourceId, sess.id, {
+              lastPullAt: Math.floor(Date.now() / 1e3),
+              lastStatus: "error",
+              lastError: errMsg
+            });
+            this.notifier.onPullResult(sourceId, sess.id, "error", errMsg);
+            return { success: false, newMessageCount: 0, error: errMsg };
+          }
+          if (!result.success) {
+            const errMsg = result.error || "Import failed";
+            this.dsManager.updateSession(sourceId, sess.id, {
+              lastPullAt: Math.floor(Date.now() / 1e3),
+              lastStatus: "error",
+              lastError: errMsg
+            });
+            this.notifier.onPullResult(sourceId, sess.id, "error", errMsg);
+            return { success: false, newMessageCount: 0, error: errMsg };
+          }
+          if (!sess.targetSessionId && result.sessionId) {
+            sess.targetSessionId = result.sessionId;
+            this.dsManager.updateSession(sourceId, sess.id, { targetSessionId: result.sessionId });
+          }
+          totalNewMessages += result.newMessageCount;
+          if (!sync || !sync.hasMore) break;
+          if (sync.nextSince !== void 0) since = sync.nextSince;
+          if (sync.nextOffset !== void 0) offset = sync.nextOffset;
+          else offset = 0;
+          if (sync.watermark !== void 0 && !end) end = sync.watermark;
+        } catch (importErr) {
+          cleanupTempFile(tempFile);
+          throw importErr;
+        }
+      }
+      if (pageCount >= MAX_PAGES_PER_PULL) {
+        this.logger.warn(`[Pull] "${sess.name}" reached page limit (${MAX_PAGES_PER_PULL}), data may be incomplete`);
+      }
+      this.dsManager.updateSession(sourceId, sess.id, {
+        lastPullAt: Math.floor(Date.now() / 1e3) - PULL_OVERLAP_SECONDS,
+        lastStatus: "success",
+        lastNewMessages: totalNewMessages,
+        lastError: ""
+      });
+      if (totalNewMessages > 0) this.notifier.onSessionListChanged();
+      this.notifier.onPullResult(sourceId, sess.id, "success", `+${totalNewMessages} messages`);
+      return { success: true, newMessageCount: totalNewMessages };
+    } catch (error) {
+      const errMsg = error.message || "Pull failed";
+      this.logger.error(`[Pull] Pull failed for "${sess.name}"`, error);
+      this.dsManager.updateSession(sourceId, sess.id, {
+        lastPullAt: Math.floor(Date.now() / 1e3),
+        lastStatus: "error",
+        lastError: errMsg
+      });
+      this.notifier.onPullResult(sourceId, sess.id, "error", errMsg);
+      return { success: false, newMessageCount: 0, error: errMsg };
+    }
+  }
+  async pullAllSessions(ds) {
+    for (const sess of ds.sessions) {
+      await this.executePullSession(ds.id, ds, sess);
+    }
+  }
+  async triggerPull(sourceId, sessionId) {
+    const ds = this.dsManager.get(sourceId);
+    if (!ds) return { success: false, error: "Data source not found" };
+    if (sessionId) {
+      const sess = ds.sessions.find((s) => s.id === sessionId);
+      if (!sess) return { success: false, error: "Session not found" };
+      const result = await this.executePullSession(sourceId, ds, sess);
+      return { success: result.success, error: result.error };
+    }
+    const errors = [];
+    for (const sess of ds.sessions) {
+      const result = await this.executePullSession(sourceId, ds, sess);
+      if (!result.success && result.error) errors.push(`${sess.name}: ${result.error}`);
+    }
+    if (errors.length > 0) {
+      return { success: false, error: errors.join("; ") };
+    }
+    return { success: true };
+  }
+  async triggerPullAll(sourceId) {
+    return this.triggerPull(sourceId);
+  }
+};
+
+// ../../packages/sync/src/scheduler.ts
+var timers = /* @__PURE__ */ new Map();
+var initialized = false;
+var _dsManager;
+var _pullEngine;
+var _logger;
+function startTimer(ds, skipInitialPull = false) {
+  stopTimer(ds.id);
+  if (!ds.enabled || ds.intervalMinutes < 1 || ds.sessions.length === 0) return;
+  const intervalMs = ds.intervalMinutes * 60 * 1e3;
+  if (!skipInitialPull) {
+    _pullEngine.pullAllSessions(ds).catch((err) => {
+      _logger.error("[Pull] Initial pull failed", err);
+    });
+  }
+  const timer = setInterval(() => {
+    const current = _dsManager.loadAll().find((s) => s.id === ds.id);
+    if (!current || !current.enabled || current.sessions.length === 0) {
+      stopTimer(ds.id);
+      return;
+    }
+    _pullEngine.pullAllSessions(current).catch((err) => {
+      _logger.error("[Pull] Scheduled pull failed", err);
+    });
+  }, intervalMs);
+  timers.set(ds.id, timer);
+  _logger.info(
+    `[Pull] Timer started for source ${ds.baseUrl} (${ds.sessions.length} sessions, every ${ds.intervalMinutes}min)`
+  );
+}
+function stopTimer(id) {
+  const timer = timers.get(id);
+  if (timer) {
+    clearInterval(timer);
+    timers.delete(id);
+  }
+}
+function initScheduler(options) {
+  if (initialized) return;
+  initialized = true;
+  _dsManager = options.dsManager;
+  _pullEngine = options.pullEngine;
+  _logger = options.logger ?? NOOP_LOGGER;
+  const sources = _dsManager.loadAll();
+  for (const ds of sources) {
+    if (ds.enabled && ds.sessions.length > 0) {
+      startTimer(ds);
+    }
+  }
+  _logger.info(`[Pull] Initialized with ${sources.filter((s) => s.enabled).length} active sources`);
+}
+function stopAllTimers() {
+  for (const [id] of timers) {
+    stopTimer(id);
+  }
+  initialized = false;
+  _logger?.info("[Pull] All timers stopped");
+}
+function reloadTimer(dsId, skipInitialPull = false) {
+  stopTimer(dsId);
+  const ds = _dsManager?.loadAll().find((s) => s.id === dsId);
+  if (ds && ds.enabled) {
+    startTimer(ds, skipInitialPull);
+  }
+}
+
+// src/sync/adapters.ts
+import * as fs10 from "fs";
+import * as os2 from "os";
+import * as path10 from "path";
+import * as crypto4 from "crypto";
+function getTempFilePath(ext) {
+  const id = crypto4.randomBytes(8).toString("hex");
+  return path10.join(os2.tmpdir(), `chatlab-pull-${id}${ext}`);
+}
+var NodeFetcher = class {
+  async fetchToTempFile(baseUrl, remoteSessionId, token, params) {
+    const url = buildPullUrl(baseUrl, remoteSessionId, params);
+    const headers = {
+      Accept: "application/json, application/x-ndjson"
+    };
+    if (token) headers["Authorization"] = `Bearer ${token}`;
+    const response = await fetch(url, { headers, signal: AbortSignal.timeout(12e4) });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const contentType = response.headers.get("content-type") || "application/json";
+    const isJsonl = contentType.includes("ndjson") || contentType.includes("jsonl");
+    const tempFile = getTempFilePath(isJsonl ? ".jsonl" : ".json");
+    const buffer = Buffer.from(await response.arrayBuffer());
+    fs10.writeFileSync(tempFile, buffer);
+    return tempFile;
+  }
+};
+function resolveNativeBinding2() {
+  if (process.versions.electron) return void 0;
+  const nativePath = path10.resolve(__dirname, "../../native/better_sqlite3.node");
+  if (fs10.existsSync(nativePath)) return nativePath;
+  return void 0;
+}
+var DirectImporter = class {
+  dbManager;
+  nativeBinding;
+  logger;
+  constructor(dbManager2, logger2) {
+    this.dbManager = dbManager2;
+    this.nativeBinding = resolveNativeBinding2();
+    this.logger = logger2 ?? NOOP_LOGGER;
+  }
+  sessionExists(sessionId) {
+    const dbPath = this.dbManager.getDbPath(sessionId);
+    return fs10.existsSync(dbPath);
+  }
+  async importFile(tempFile, targetSessionId, externalId) {
+    if (targetSessionId && this.sessionExists(targetSessionId)) {
+      return this.incrementalImportFile(targetSessionId, tempFile);
+    }
+    return this.fullImportFile(tempFile, externalId);
+  }
+  async incrementalImportFile(sessionId, tempFile) {
+    try {
+      const data = await parseFile(tempFile);
+      this.dbManager.close(sessionId);
+      const result = await importData(this.dbManager, data, {
+        sessionId,
+        nativeBinding: this.nativeBinding
+      });
+      if (result.success) {
+        this.logger.info(
+          `[DirectImporter] Incremental OK: +${result.messageCount} messages (${result.duplicateCount} duplicates skipped)`
+        );
+        return {
+          success: true,
+          newMessageCount: result.messageCount,
+          sessionId
+        };
+      }
+      if (result.error?.includes("not found") || result.error?.includes("session_not_found")) {
+        return { success: false, newMessageCount: 0, sessionId, needFullResync: true };
+      }
+      return { success: false, newMessageCount: 0, sessionId, error: result.error };
+    } catch (err) {
+      this.logger.error(`[DirectImporter] Incremental import failed`, err);
+      return { success: false, newMessageCount: 0, sessionId, error: err.message };
+    }
+  }
+  async fullImportFile(tempFile, externalId) {
+    try {
+      const data = await parseFile(tempFile);
+      const result = await importData(this.dbManager, data, {
+        sessionId: externalId,
+        nativeBinding: this.nativeBinding
+      });
+      if (result.success) {
+        this.logger.info(
+          `[DirectImporter] Full import OK: ${result.messageCount} messages, ${result.memberCount} members`
+        );
+        return { success: true, newMessageCount: result.messageCount, sessionId: externalId };
+      }
+      return { success: false, newMessageCount: 0, error: result.error };
+    } catch (err) {
+      this.logger.error(`[DirectImporter] Full import failed`, err);
+      return { success: false, newMessageCount: 0, error: err.message };
+    }
+  }
+};
+var noop2 = () => {
+};
+var NoopNotifier = class {
+  onSessionListChanged = noop2;
+  onPullResult = noop2;
+};
+
+// src/sync/routes.ts
+function registerAutomationRoutes(server2, ctx) {
+  const { dsManager: dsManager2, pullEngine: pullEngine2, serverInfo } = ctx;
+  server2.get("/_web/automation/config", async () => {
+    return {
+      enabled: true,
+      port: serverInfo.port,
+      token: serverInfo.token,
+      host: serverInfo.host
+    };
+  });
+  server2.get("/_web/automation/data-sources", async () => {
+    return dsManager2.loadAll();
+  });
+  server2.post("/_web/automation/data-sources", async (request) => {
+    const ds = dsManager2.add(request.body);
+    reloadTimer(ds.id);
+    return ds;
+  });
+  server2.patch("/_web/automation/data-sources/:id", async (request, reply) => {
+    const ds = dsManager2.update(request.params.id, request.body);
+    if (!ds) return reply.code(404).send({ error: "Data source not found" });
+    reloadTimer(ds.id);
+    return ds;
+  });
+  server2.delete("/_web/automation/data-sources/:id", async (request, reply) => {
+    stopTimer(request.params.id);
+    const ok = dsManager2.delete(request.params.id);
+    if (!ok) return reply.code(404).send({ error: "Data source not found" });
+    return { success: true };
+  });
+  server2.post("/_web/automation/data-sources/:id/sessions", async (request, reply) => {
+    const added = dsManager2.addSessions(request.params.id, request.body.sessions);
+    if (added.length === 0 && !dsManager2.get(request.params.id)) {
+      return reply.code(404).send({ error: "Data source not found" });
+    }
+    reloadTimer(request.params.id, true);
+    return added;
+  });
+  server2.delete("/_web/automation/data-sources/:id/sessions/:sessId", async (request, reply) => {
+    const ok = dsManager2.removeSession(request.params.id, request.params.sessId);
+    if (!ok) return reply.code(404).send({ error: "Session not found" });
+    reloadTimer(request.params.id);
+    return { success: true };
+  });
+  server2.post(
+    "/_web/automation/data-sources/:id/pull",
+    async (request) => {
+      return pullEngine2.triggerPull(request.params.id, request.body?.sessionId);
+    }
+  );
+  server2.post("/_web/automation/data-sources/:id/pull-all", async (request) => {
+    return pullEngine2.triggerPullAll(request.params.id);
+  });
+  server2.get("/_web/automation/remote-sessions", async (request, reply) => {
+    const { baseUrl, token, keyword, limit, cursor } = request.query;
+    if (!baseUrl) return reply.code(400).send({ error: "baseUrl is required" });
+    const normalizedUrl = normalizeBaseUrl(baseUrl);
+    const url = buildRemoteSessionsUrl(normalizedUrl, {
+      keyword,
+      limit: limit ? parseInt(limit, 10) : void 0,
+      cursor
+    });
+    const headers = { Accept: "application/json" };
+    if (token) headers["Authorization"] = `Bearer ${token}`;
+    try {
+      const resp = await fetch(url, { headers, signal: AbortSignal.timeout(3e4) });
+      if (!resp.ok) throw new Error(`Remote server returned HTTP ${resp.status}`);
+      const body = await resp.text();
+      return parseRemoteSessionsResponse(body);
+    } catch (err) {
+      return reply.code(502).send({ error: err.message || "Failed to fetch remote sessions" });
+    }
+  });
+}
+
+// src/sync/index.ts
+var syncLogger = {
+  info: (msg) => console.log(`[Sync] ${msg}`),
+  warn: (msg) => console.warn(`[Sync] ${msg}`),
+  error: (msg, err) => console.error(`[Sync] ${msg}`, err ?? "")
+};
+var dsManager = null;
+var pullEngine = null;
+function initSync(server2, dbManager2, pathProvider, serverInfo) {
+  const settingsDir = pathProvider.getSettingsDir();
+  dsManager = new DataSourceManager(settingsDir, syncLogger);
+  const fetcher = new NodeFetcher();
+  const importer = new DirectImporter(dbManager2, syncLogger);
+  const notifier = new NoopNotifier();
+  pullEngine = new PullEngine({
+    fetcher,
+    importer,
+    notifier,
+    dsManager,
+    logger: syncLogger
+  });
+  registerAutomationRoutes(server2, { dsManager, pullEngine, serverInfo });
+  initScheduler({
+    dsManager,
+    pullEngine,
+    logger: syncLogger
+  });
+}
+function cleanupSync() {
+  stopAllTimers();
+  dsManager = null;
+  pullEngine = null;
+}
+
+// src/http/index.ts
+var server = null;
+var dbManager = null;
+var convManager = null;
+function resolveNativeBinding3() {
+  if (process.versions.electron) return void 0;
+  const nativePath = path11.resolve(__dirname, "../../native/better_sqlite3.node");
+  if (fs11.existsSync(nativePath)) return nativePath;
+  return void 0;
+}
+function ensureToken(config) {
+  if (config.api.token) return config.api.token;
+  const token = `clb_${crypto5.randomBytes(32).toString("hex")}`;
+  try {
+    writeConfigField("api", "token", token);
+  } catch {
+  }
+  return token;
+}
+async function startHttpServer(options) {
+  if (server) {
+    throw new Error("HTTP server is already running");
+  }
+  const config = loadConfig();
+  const port = options?.port ?? config.api.port;
+  const host = options?.host ?? config.api.host;
+  const token = options?.token ?? ensureToken(config);
+  const userDataDir = config.data.user_data_dir || void 0;
+  const pathProvider = new NodePathProvider(userDataDir);
+  pathProvider.ensureAllDirs();
+  if (hasPendingElectronDataWarning() || !verifyCliDataPath(pathProvider.getDatabaseDir())) {
+    throw new Error(
+      "\n" + "=".repeat(68) + "\n  ChatLab: Electron desktop data not found\n" + "=".repeat(68) + '\n\n  Detected that ChatLab desktop app was installed on this machine,\n  but could not locate your chat databases.\n\n  This usually means you changed the data directory in desktop settings.\n\n  To fix this, choose one of:\n\n  1. Open ChatLab desktop app \u2014 it will auto-migrate your data\n  2. Set the data directory manually:\n     export CHATLAB_DATA_DIR="/path/to/your/data"\n  3. Edit ~/.chatlab/config.toml:\n     [data]\n     user_data_dir = "/path/to/your/data"\n\n' + "=".repeat(68) + "\n"
+    );
+  }
+  const migrationRunner = new MigrationRunner(ALL_MIGRATIONS, {
+    dataDir: pathProvider.getSystemDir(),
+    aiDataDir: pathProvider.getAiDataDir(),
+    logger: {
+      info: (_cat, msg) => console.log(`[Migration] ${msg}`),
+      warn: (_cat, msg) => console.warn(`[Migration] ${msg}`),
+      error: (_cat, msg, ...args) => console.error(`[Migration] ${msg}`, ...args)
+    }
+  });
+  await migrationRunner.run();
+  const nativeBinding = resolveNativeBinding3();
+  dbManager = new DatabaseManager(pathProvider, { nativeBinding });
+  convManager = new AIConversationManager(pathProvider.getAiDataDir(), { nativeBinding });
+  initServerAiLogger(pathProvider.getLogsDir());
+  setAuthToken(token);
+  server = createServer();
+  const multipart = await import("@fastify/multipart");
+  await server.register(multipart.default, {
+    limits: { fileSize: 1024 * 1024 * 1024 }
+    // 1GB
+  });
+  registerSystemRoutes(server, dbManager);
+  registerSessionRoutes(server, dbManager);
+  registerNlpRoutes(server, dbManager);
+  registerAiRoutes(server, dbManager, convManager);
+  registerWebRoutes(server, dbManager, { pathProvider, nativeBinding });
+  registerPreferencesRoutes(server, pathProvider);
+  initSync(server, dbManager, pathProvider, { port, host, token });
+  if (options?.webRoot && fs11.existsSync(options.webRoot)) {
+    setWebMode(true);
+    const fastifyStatic = await import("@fastify/static");
+    await server.register(fastifyStatic.default, {
+      root: options.webRoot,
+      prefix: "/",
+      wildcard: false
+    });
+    server.setNotFoundHandler(async (_request, reply) => {
+      return reply.sendFile("index.html");
+    });
+  }
+  await server.listen({ port, host });
+  return { port, host, token };
+}
+async function stopHttpServer() {
+  if (!server) return;
+  try {
+    await server.close();
+  } finally {
+    cleanupSync();
+    if (convManager) {
+      convManager.close();
+      convManager = null;
+    }
+    if (dbManager) {
+      dbManager.closeAll();
+      dbManager = null;
+    }
+    closeServerAiLogger();
+    setWebMode(false);
+    server = null;
+  }
+}
+
+export {
+  createServer,
+  registerSystemRoutes,
+  registerSessionRoutes,
+  registerWebRoutes,
+  registerNlpRoutes,
+  registerAiRoutes,
+  startHttpServer,
+  stopHttpServer
+};
+//# sourceMappingURL=chunk-PF4QFHC6.mjs.map