chatlab-cli 0.0.0 → 0.21.0

package/dist/chunk-FBTHZU55.mjs

@@ -0,0 +1,3400 @@
+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-XUHPCRVT.mjs";
+import {
+  analyzeIncrementalImport,
+  analyzeNewImport,
+  incrementalImport,
+  streamImport
+} from "./chunk-EWCSGYVT.mjs";
+import {
+  AGENT_TOOL_REGISTRY,
+  CoreDataProvider
+} from "./chunk-3DIWXYMJ.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,
+  computeWordFrequency,
+  createActivateSkillTool,
+  createAiTranslate,
+  createCompressionLlmAdapter,
+  createDatabaseManagerAdapter,
+  createJiebaNlpProvider,
+  deleteDict,
+  deleteTempDatabase,
+  detectAllFormats,
+  detectFormat,
+  downloadDict,
+  ensureDefaultDict,
+  executeReadonlySql,
+  executeSql,
+  exportSessionToJson,
+  export_service_exports,
+  fetchRemoteModels,
+  findEntryFileInDirectory,
+  formatAIError,
+  getAvailableYears,
+  getBuiltinModelsByProvider,
+  getCatchphraseAnalysis,
+  getChatOverview,
+  getClusterGraph,
+  getDailyActivity,
+  getDictList,
+  getHourlyActivity,
+  getLanguagePreferenceAnalysis,
+  getLaughAnalysis,
+  getMemberActivity,
+  getMembers,
+  getMembersDetailed,
+  getMentionAnalysis,
+  getMentionGraph,
+  getMessageLengthDistribution,
+  getMessageTypeStats,
+  getMonthlyActivity,
+  getRelationshipStats,
+  getSchemaDetailed,
+  getSessionInfo,
+  getSessionMeta,
+  getSessionOverview,
+  getSupportedFormats,
+  getTimeRange,
+  getWeekdayActivity,
+  getYearlyActivity,
+  hasPendingElectronDataWarning,
+  initNlpDir,
+  isDictDownloaded,
+  loadConfig,
+  member_service_exports,
+  openBetterSqliteDatabase,
+  parseAssistantFile,
+  queryMessages,
+  resolveApiKey,
+  runAgentCore,
+  runSimpleLlmStream,
+  scanMultiChatFile,
+  segmentText,
+  serializeChatLabToJsonl,
+  session_index_service_exports,
+  session_service_exports,
+  streamParseFileInfo,
+  summary_service_exports,
+  validateApiKey,
+  verifyCliDataPath,
+  writeAuthProfile,
+  writeConfigField
+} from "./chunk-EIRLEPXP.mjs";
+
+// src/http/index.ts
+import * as fs14 from "fs";
+import * as path15 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/index.ts
+import * as os3 from "os";
+import * as path7 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/http/routes/web/sessions.ts
+function registerSessionRoutes2(server2, adapter) {
+  server2.get("/_web/sessions", async () => {
+    return session_service_exports.listAnalysisSessions(adapter);
+  });
+  server2.get("/_web/sessions/:id", async (request) => {
+    const session = session_service_exports.getAnalysisSession(adapter, request.params.id);
+    if (!session) {
+      throw Object.assign(new Error(`Session not found: ${request.params.id}`), { statusCode: 404 });
+    }
+    return session;
+  });
+  server2.delete("/_web/sessions/:id", async (request, reply) => {
+    const { id } = request.params;
+    try {
+      const deleted = session_service_exports.deleteSession(adapter, id);
+      if (!deleted) {
+        return reply.code(404).send({ success: false, error: "File not found" });
+      }
+      return { success: true };
+    } catch (err) {
+      return reply.code(500).send({ success: false, error: String(err) });
+    }
+  });
+  server2.patch("/_web/sessions/:id/name", async (request) => {
+    session_service_exports.renameSession(adapter, request.params.id, request.body.name);
+    return { success: true };
+  });
+  server2.patch(
+    "/_web/sessions/:id/owner",
+    async (request) => {
+      session_service_exports.updateSessionOwnerId(adapter, request.params.id, request.body.ownerId ?? null);
+      return { success: true };
+    }
+  );
+}
+
+// src/http/routes/web/members.ts
+function registerMemberRoutes(server2, adapter) {
+  server2.get("/_web/sessions/:id/members", async (request) => {
+    return member_service_exports.getMembers(adapter, request.params.id);
+  });
+  server2.get("/_web/sessions/:id/members/paginated", async (request) => {
+    return member_service_exports.getMembersPaginated(adapter, request.params.id, {
+      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"
+    });
+  });
+  server2.patch(
+    "/_web/sessions/:id/members/:memberId/aliases",
+    async (request) => {
+      const memberId = parseInt(request.params.memberId, 10);
+      member_service_exports.updateMemberAliases(adapter, request.params.id, memberId, request.body.aliases);
+      return { success: true };
+    }
+  );
+  server2.delete(
+    "/_web/sessions/:id/members/:memberId",
+    async (request) => {
+      const memberId = parseInt(request.params.memberId, 10);
+      member_service_exports.deleteMember(adapter, request.params.id, memberId);
+      return { success: true };
+    }
+  );
+  server2.post(
+    "/_web/sessions/:id/members/merge",
+    async (request) => {
+      const { memberId1, memberId2 } = request.body;
+      member_service_exports.mergeMembers(adapter, request.params.id, memberId1, memberId2);
+      return { success: true };
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/members/:memberId/history",
+    async (request) => {
+      const memberId = parseInt(request.params.memberId, 10);
+      return member_service_exports.getMemberNameHistory(adapter, request.params.id, memberId);
+    }
+  );
+}
+
+// src/http/routes/web/helpers.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+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 resolveNativeBinding() {
+  if (process.versions.electron) return void 0;
+  const nativePath = path2.resolve(__dirname, "../../../../native/better_sqlite3.node");
+  if (fs2.existsSync(nativePath)) return nativePath;
+  return void 0;
+}
+function getAiDataDir(dbManager2) {
+  const pathProvider = dbManager2["pathProvider"];
+  if (!pathProvider) {
+    throw Object.assign(new Error("PathProvider not available"), { statusCode: 500 });
+  }
+  return pathProvider.getAiDataDir();
+}
+function ensureDb2(dbManager2, sessionId) {
+  const db = dbManager2.open(sessionId);
+  if (!db) {
+    throw Object.assign(new Error(`Session not found: ${sessionId}`), { statusCode: 404 });
+  }
+  return db;
+}
+
+// src/http/routes/web/analytics.ts
+function registerAnalyticsRoutes(server2, _dbManager, adapter) {
+  server2.get("/_web/sessions/:id/years", async (request) => {
+    const db = adapter.ensureReadonly(request.params.id);
+    return getAvailableYears(db);
+  });
+  server2.get("/_web/sessions/:id/time-range", async (request) => {
+    const db = adapter.ensureReadonly(request.params.id);
+    return getTimeRange(db);
+  });
+  server2.get(
+    "/_web/sessions/:id/stats/member-activity",
+    async (request) => {
+      const db = adapter.ensureReadonly(request.params.id);
+      return getMemberActivity(db, parseTimeFilter(request.query));
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/stats/hourly",
+    async (request) => {
+      const db = adapter.ensureReadonly(request.params.id);
+      return getHourlyActivity(db, parseTimeFilter(request.query));
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/stats/daily",
+    async (request) => {
+      const db = adapter.ensureReadonly(request.params.id);
+      return getDailyActivity(db, parseTimeFilter(request.query));
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/stats/weekday",
+    async (request) => {
+      const db = adapter.ensureReadonly(request.params.id);
+      return getWeekdayActivity(db, parseTimeFilter(request.query));
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/stats/message-types",
+    async (request) => {
+      const db = adapter.ensureReadonly(request.params.id);
+      return getMessageTypeStats(db, parseTimeFilter(request.query));
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/analytics/relationship",
+    async (request) => {
+      const db = adapter.ensureReadonly(request.params.id);
+      return getRelationshipStats(db, parseTimeFilter(request.query));
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/analytics/catchphrase",
+    async (request) => {
+      const db = adapter.ensureReadonly(request.params.id);
+      return getCatchphraseAnalysis(db, parseTimeFilter(request.query));
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/analytics/mention",
+    async (request) => {
+      const db = adapter.ensureReadonly(request.params.id);
+      return getMentionAnalysis(db, parseTimeFilter(request.query));
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/analytics/mention-graph",
+    async (request) => {
+      const db = adapter.ensureReadonly(request.params.id);
+      return getMentionGraph(db, parseTimeFilter(request.query));
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/analytics/laugh",
+    async (request) => {
+      const db = adapter.ensureReadonly(request.params.id);
+      return getLaughAnalysis(db, parseTimeFilter(request.query));
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/analytics/cluster",
+    async (request) => {
+      const db = adapter.ensureReadonly(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 = adapter.ensureReadonly(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 = adapter.ensureReadonly(request.params.id);
+      return getMonthlyActivity(db, parseTimeFilter(request.query));
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/analytics/yearly-activity",
+    async (request) => {
+      const db = adapter.ensureReadonly(request.params.id);
+      return getYearlyActivity(db, parseTimeFilter(request.query));
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/analytics/message-length-distribution",
+    async (request) => {
+      const db = adapter.ensureReadonly(request.params.id);
+      return getMessageLengthDistribution(db, parseTimeFilter(request.query));
+    }
+  );
+}
+
+// src/http/routes/web/sql.ts
+function registerSqlRoutes(server2, adapter) {
+  server2.post("/_web/sessions/:id/sql", async (request, reply) => {
+    const db = adapter.ensureReadonly(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 = adapter.ensureReadonly(request.params.id);
+    return getSchemaDetailed(db);
+  });
+  server2.post("/_web/sessions/:id/query", async (request) => {
+    const db = adapter.ensureReadonly(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);
+  });
+}
+
+// src/http/routes/web/session-index.ts
+function registerSessionIndexRoutes(server2, adapter) {
+  server2.post("/_web/sessions/:id/generate-index", async (request) => {
+    const gapThreshold = request.body?.gapThreshold ?? 1800;
+    const sessionCount = session_index_service_exports.generateIndex(adapter, request.params.id, gapThreshold);
+    return { sessionCount };
+  });
+  server2.post("/_web/sessions/:id/clear-index", async (request) => {
+    session_index_service_exports.clearIndex(adapter, request.params.id);
+    return { success: true };
+  });
+  server2.get("/_web/sessions/:id/search/fts", async (request, reply) => {
+    if (!session_index_service_exports.getFtsStatus(adapter, request.params.id)) {
+      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 session_index_service_exports.searchFts(adapter, request.params.id, keywords, limit, offset);
+  });
+  server2.get("/_web/sessions/:id/fts/status", async (request) => {
+    return { hasFtsIndex: session_index_service_exports.getFtsStatus(adapter, request.params.id) };
+  });
+  server2.post("/_web/sessions/:id/fts/rebuild", async (request) => {
+    const result = session_index_service_exports.rebuildFts(adapter, request.params.id);
+    return { success: true, indexed: result.indexed };
+  });
+}
+
+// src/ai/llm-config.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+function loadLlmConfig(aiDataDir) {
+  const configPath = path3.join(aiDataDir, "llm-config.json");
+  if (!fs3.existsSync(configPath)) {
+    return { configs: [], defaultAssistant: null, fastModel: null };
+  }
+  try {
+    const data = JSON.parse(fs3.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 = path3.join(aiDataDir, "llm-config.json");
+  const toSave = {
+    ...store,
+    configs: store.configs.map((c) => {
+      const { apiKey: _k, ...rest } = c;
+      return rest;
+    }),
+    schemaVersion: 3
+  };
+  fs3.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 = path3.join(aiDataDir, "llm-config.json");
+  if (!fs3.existsSync(configPath)) {
+    return { configs: [], defaultAssistant: null, fastModel: null };
+  }
+  try {
+    const data = JSON.parse(fs3.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/summaries.ts
+function createSummaryDeps(dbManager2) {
+  const aiDataDir = getAiDataDir(dbManager2);
+  return {
+    getLlmConfig() {
+      return getDefaultAssistantConfig(aiDataDir);
+    },
+    buildPiModel(config) {
+      return buildPiModel2(config);
+    }
+  };
+}
+function registerSummaryRoutes(server2, dbManager2, adapter) {
+  const deps = createSummaryDeps(dbManager2);
+  server2.post("/_web/sessions/:id/summaries/generate", async (request, reply) => {
+    const { chatSessionId, locale, forceRegenerate } = request.body;
+    const result = await summary_service_exports.generateSummary(adapter, request.params.id, chatSessionId, deps, {
+      locale,
+      forceRegenerate
+    });
+    if ("error" in result && !result.success) {
+      return reply.code(400).send({ error: result.error });
+    }
+    return result;
+  });
+  server2.post("/_web/sessions/:id/summaries/generate-all", async (request, reply) => {
+    const { locale, forceRegenerate } = request.body;
+    const result = await summary_service_exports.generateAllSummaries(adapter, request.params.id, deps, {
+      locale,
+      forceRegenerate
+    });
+    if (result.error) {
+      return reply.code(400).send({ error: result.error });
+    }
+    return result;
+  });
+}
+
+// src/http/routes/web/import.ts
+import * as fs4 from "fs";
+import * as os from "os";
+import * as path4 from "path";
+var DEMO_BASE_URL = "https://chatlab.fun/assets/demo";
+function cleanupTemp(...paths) {
+  for (const p of paths) {
+    try {
+      const stat = fs4.statSync(p);
+      if (stat.isDirectory()) {
+        fs4.rmSync(p, { recursive: true, force: true });
+      } else {
+        fs4.unlinkSync(p);
+      }
+    } catch {
+    }
+  }
+}
+function registerImportRoutes(server2, dbManager2) {
+  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 = fs4.mkdtempSync(path4.join(os.tmpdir(), "chatlab-detect-"));
+    const tmpPath = path4.join(tmpDir, data.filename || "upload");
+    try {
+      const chunks = [];
+      for await (const chunk of data.file) {
+        chunks.push(chunk);
+      }
+      fs4.writeFileSync(tmpPath, Buffer.concat(chunks));
+      const format = detectFormat(tmpPath);
+      const allFormats = detectAllFormats(tmpPath);
+      return { format, allFormats };
+    } finally {
+      cleanupTemp(tmpPath, tmpDir);
+    }
+  });
+  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 = fs4.mkdtempSync(path4.join(os.tmpdir(), "chatlab-scan-"));
+    const tmpPath = path4.join(tmpDir, data.filename || "upload");
+    try {
+      const chunks = [];
+      for await (const chunk of data.file) {
+        chunks.push(chunk);
+      }
+      fs4.writeFileSync(tmpPath, Buffer.concat(chunks));
+      const chats = await scanMultiChatFile(tmpPath);
+      return { chats };
+    } finally {
+      cleanupTemp(tmpPath, tmpDir);
+    }
+  });
+  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 = fs4.mkdtempSync(path4.join(os.tmpdir(), "chatlab-import-"));
+    const tmpPath = path4.join(tmpDir, data.filename || "upload");
+    const chunks = [];
+    for await (const chunk of data.file) {
+      chunks.push(chunk);
+    }
+    fs4.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, eventData) {
+      reply.raw.write(`event: ${event}
+data: ${JSON.stringify(eventData)}
+
+`);
+    }
+    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();
+      cleanupTemp(tmpPath, tmpDir);
+    }
+  });
+  server2.post("/_web/import-directory", async (request, reply) => {
+    const parts = request.parts();
+    if (!parts) return reply.code(400).send({ error: "No files uploaded" });
+    const tmpDir = fs4.mkdtempSync(path4.join(os.tmpdir(), "chatlab-dir-import-"));
+    const relativePaths = [];
+    const fileBuffers = [];
+    try {
+      let sendEvent2 = function(event, eventData) {
+        reply.raw.write(`event: ${event}
+data: ${JSON.stringify(eventData)}
+
+`);
+      };
+      var sendEvent = sendEvent2;
+      for await (const part of parts) {
+        if (part.type === "field" && part.fieldname === "relativePaths") {
+          relativePaths.push(String(part.value));
+        } else if (part.type === "file") {
+          const chunks = [];
+          for await (const chunk of part.file) {
+            chunks.push(chunk);
+          }
+          fileBuffers.push({ data: Buffer.concat(chunks), filename: part.filename || "" });
+        }
+      }
+      for (let i = 0; i < fileBuffers.length; i++) {
+        let relPath = relativePaths[i] || fileBuffers[i].filename || `file_${i}`;
+        const segments = relPath.split("/");
+        if (segments.length > 1) {
+          relPath = segments.slice(1).join("/");
+        }
+        const targetPath = path4.resolve(tmpDir, relPath);
+        if (!targetPath.startsWith(tmpDir + path4.sep)) continue;
+        fs4.mkdirSync(path4.dirname(targetPath), { recursive: true });
+        fs4.writeFileSync(targetPath, fileBuffers[i].data);
+      }
+      const entryPath = findEntryFileInDirectory(tmpDir);
+      if (!entryPath) {
+        return reply.code(400).send({ error: "No recognizable import format found in directory" });
+      }
+      reply.raw.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      });
+      const nativeBinding = resolveNativeBinding();
+      const result = await streamImport(dbManager2, entryPath, {
+        nativeBinding,
+        onProgress: (p) => sendEvent2("progress", p)
+      });
+      if (result.success) {
+        sendEvent2("done", {
+          success: true,
+          sessionId: result.sessionId,
+          messageCount: result.diagnostics?.messagesWritten ?? 0,
+          memberCount: 0
+        });
+      } else {
+        sendEvent2("error", { success: false, error: result.error });
+      }
+    } catch (err) {
+      if (!reply.raw.headersSent) {
+        return reply.code(500).send({ error: err instanceof Error ? err.message : String(err) });
+      }
+      reply.raw.write(
+        `event: error
+data: ${JSON.stringify({ success: false, error: err instanceof Error ? err.message : String(err) })}
+
+`
+      );
+    } finally {
+      reply.raw.end();
+      cleanupTemp(tmpDir);
+    }
+  });
+  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 = fs4.mkdtempSync(path4.join(os.tmpdir(), "chatlab-inc-"));
+    const tmpPath = path4.join(tmpDir, data.filename || "upload");
+    const chunks = [];
+    for await (const chunk of data.file) {
+      chunks.push(chunk);
+    }
+    fs4.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();
+      cleanupTemp(tmpPath, tmpDir);
+    }
+  });
+  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 = fs4.mkdtempSync(path4.join(os.tmpdir(), "chatlab-analyze-"));
+    const tmpPath = path4.join(tmpDir, data.filename || "upload");
+    const chunks = [];
+    for await (const chunk of data.file) {
+      chunks.push(chunk);
+    }
+    fs4.writeFileSync(tmpPath, Buffer.concat(chunks));
+    try {
+      return await analyzeIncrementalImport(dbManager2, sessionId, tmpPath);
+    } catch (err) {
+      return reply.code(500).send({ error: err instanceof Error ? err.message : String(err) });
+    } finally {
+      cleanupTemp(tmpPath, tmpDir);
+    }
+  });
+  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 = fs4.mkdtempSync(path4.join(os.tmpdir(), "chatlab-analyze-"));
+    const tmpPath = path4.join(tmpDir, data.filename || "upload");
+    const chunks = [];
+    for await (const chunk of data.file) {
+      chunks.push(chunk);
+    }
+    fs4.writeFileSync(tmpPath, Buffer.concat(chunks));
+    try {
+      return await analyzeNewImport(tmpPath);
+    } catch (err) {
+      return reply.code(500).send({ error: err instanceof Error ? err.message : String(err) });
+    } finally {
+      cleanupTemp(tmpPath, tmpDir);
+    }
+  });
+  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, eventData) {
+      reply.raw.write(`event: ${event}
+data: ${JSON.stringify(eventData)}
+
+`);
+    }
+    const tmpDir = fs4.mkdtempSync(path4.join(os.tmpdir(), "chatlab-demo-"));
+    const groupPath = path4.join(tmpDir, "demo-group.json");
+    const privatePath = path4.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}`);
+      fs4.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}`);
+      fs4.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 {
+      reply.raw.end();
+      cleanupTemp(tmpDir);
+    }
+  });
+}
+
+// src/http/routes/web/merge.ts
+import * as fs5 from "fs";
+import * as os2 from "os";
+import * as path5 from "path";
+function registerMergeRoutes(server2, dbManager2, 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 = fs5.mkdtempSync(path5.join(os2.tmpdir(), "chatlab-merge-"));
+    const tmpPath = path5.join(tmpDir, data.filename || "upload");
+    const chunks = [];
+    for await (const chunk of data.file) {
+      chunks.push(chunk);
+    }
+    fs5.writeFileSync(tmpPath, Buffer.concat(chunks));
+    try {
+      const result = await streamParseFileInfo(tmpPath, {
+        createTempDatabase(sourceFilePath) {
+          return mergeCache.createTempDatabase(path5.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 {
+        fs5.unlinkSync(tmpPath);
+      } catch {
+      }
+      try {
+        fs5.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-URGOCXUH.mjs");
+        const jsonData = JSON.stringify(merged.chatLabData);
+        const tmpDir = fs5.mkdtempSync(path5.join(os2.tmpdir(), "chatlab-merged-"));
+        const tmpPath = path5.join(tmpDir, `${outputName}.json`);
+        fs5.writeFileSync(tmpPath, jsonData, "utf-8");
+        try {
+          const importResult = await serverStreamImport(dbManager2, tmpPath);
+          sessionId = importResult.sessionId;
+        } finally {
+          try {
+            fs5.unlinkSync(tmpPath);
+          } catch {
+          }
+          try {
+            fs5.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 = ensureDb2(dbManager2, sid);
+      const exported = exportSessionToJson(db);
+      const { db: tempDb, tempDbPath } = mergeCache.createTempDatabase(exported.meta.name);
+      const { TempDbWriter } = await import("./src-KOIGBZJX.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 };
+  });
+}
+
+// src/http/routes/web/export.ts
+function registerExportRoutes(server2, adapter) {
+  server2.post("/_web/sessions/:id/export/markdown", async (request, reply) => {
+    const { id } = request.params;
+    const body = request.body;
+    const sessionName = body?.sessionName || id;
+    const { result, content } = export_service_exports.exportMarkdown(adapter, {
+      sessionId: id,
+      sessionName,
+      filterMode: body.filterMode || "condition",
+      keywords: body.keywords,
+      timeFilter: body.timeFilter,
+      senderIds: body.senderIds,
+      contextSize: body.contextSize,
+      chatSessionIds: body.chatSessionIds
+    });
+    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(content);
+  });
+}
+
+// src/http/routes/web/cache.ts
+import * as fs6 from "fs";
+import * as path6 from "path";
+function registerCacheRoutes(server2, downloadsDir) {
+  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 (!fs6.existsSync(downloadsDir)) {
+      fs6.mkdirSync(downloadsDir, { recursive: true });
+    }
+    const filePath = path6.join(downloadsDir, filename);
+    fs6.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 = path6.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/web/index.ts
+function registerWebRoutes(server2, dbManager2, options) {
+  const adapter = createDatabaseManagerAdapter(dbManager2);
+  const mergeCache = options?.pathProvider ? new MergeSessionCache(options.pathProvider, { nativeBinding: options.nativeBinding }) : null;
+  mergeCache?.cleanupOrphans();
+  const downloadsDir = options?.pathProvider?.getDownloadsDir() || path7.join(os3.homedir(), "Downloads");
+  registerSessionRoutes2(server2, adapter);
+  registerMemberRoutes(server2, adapter);
+  registerAnalyticsRoutes(server2, dbManager2, adapter);
+  registerSqlRoutes(server2, adapter);
+  registerSessionIndexRoutes(server2, adapter);
+  registerSummaryRoutes(server2, dbManager2, adapter);
+  registerImportRoutes(server2, dbManager2);
+  if (mergeCache) {
+    registerMergeRoutes(server2, dbManager2, mergeCache);
+  }
+  registerExportRoutes(server2, adapter);
+  registerCacheRoutes(server2, downloadsDir);
+}
+
+// src/http/routes/nlp.ts
+import * as path8 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 = path8.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 path8.join(pathProvider.getUserDataDir(), "nlp");
+}
+
+// src/http/routes/ai.ts
+import * as fs10 from "fs";
+import * as path12 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_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 fs7 from "fs";
+import * as path9 from "path";
+function loadAssistantConfig(aiDataDir, assistantId) {
+  const filePath = path9.join(aiDataDir, "assistants", `${assistantId}.md`);
+  if (!fs7.existsSync(filePath)) return null;
+  try {
+    const content = fs7.readFileSync(filePath, "utf-8");
+    return parseAssistantFile(content, filePath);
+  } catch {
+    return null;
+  }
+}
+
+// src/ai/manager-factory.ts
+import * as fs8 from "fs";
+import * as path10 from "path";
+import { createHash, randomUUID as randomUUID3 } from "crypto";
+var nodeFs = {
+  ensureDir(dir) {
+    if (!fs8.existsSync(dir)) fs8.mkdirSync(dir, { recursive: true });
+  },
+  listFiles(dir, ext) {
+    if (!fs8.existsSync(dir)) return [];
+    return fs8.readdirSync(dir).filter((f) => f.endsWith(ext));
+  },
+  readFile(filePath) {
+    return fs8.readFileSync(filePath, "utf-8");
+  },
+  writeFile(filePath, content) {
+    fs8.writeFileSync(filePath, content, "utf-8");
+  },
+  deleteFile(filePath) {
+    if (fs8.existsSync(filePath)) fs8.unlinkSync(filePath);
+  },
+  fileExists(filePath) {
+    return fs8.existsSync(filePath);
+  },
+  joinPath(...parts) {
+    return path10.join(...parts);
+  }
+};
+var managerCache = /* @__PURE__ */ new Map();
+function getAssistantManager(aiDataDir) {
+  let cached = managerCache.get(aiDataDir);
+  if (!cached) {
+    cached = {
+      assistant: new AssistantManager({
+        fs: nodeFs,
+        assistantsDir: path10.join(aiDataDir, "assistants"),
+        builtinRawConfigs: [],
+        generateId: () => `custom_${randomUUID3().replace(/-/g, "").slice(0, 12)}`
+      }),
+      skill: new SkillManagerCore({
+        fs: nodeFs,
+        skillsDir: path10.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 fs9 from "fs";
+import * as path11 from "path";
+import { randomUUID as randomUUID4 } from "crypto";
+function readProviders(aiDataDir) {
+  const storePath = path11.join(aiDataDir, "custom-providers.json");
+  if (!fs9.existsSync(storePath)) return [];
+  try {
+    const content = fs9.readFileSync(storePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return [];
+  }
+}
+function writeProviders(aiDataDir, providers) {
+  const storePath = path11.join(aiDataDir, "custom-providers.json");
+  const dir = path11.dirname(storePath);
+  if (!fs9.existsSync(dir)) fs9.mkdirSync(dir, { recursive: true });
+  fs9.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 = path11.join(aiDataDir, "custom-models.json");
+  if (!fs9.existsSync(storePath)) return [];
+  try {
+    const content = fs9.readFileSync(storePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return [];
+  }
+}
+function writeModels(aiDataDir, models) {
+  const storePath = path11.join(aiDataDir, "custom-models.json");
+  const dir = path11.dirname(storePath);
+  if (!fs9.existsSync(dir)) fs9.mkdirSync(dir, { recursive: true });
+  fs9.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 = path12.join(getAiDir(dbManager2), "llm-config.json");
+    if (!fs10.existsSync(configPath)) return false;
+    try {
+      const data = JSON.parse(fs10.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 = path12.join(getAiDir(dbManager2), "llm-config.json");
+    if (!fs10.existsSync(configPath)) return { configs: [], defaultAssistant: null, fastModel: null };
+    try {
+      const data = JSON.parse(fs10.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 = path12.join(getAiDir(dbManager2), "custom-providers.json");
+    let custom = [];
+    if (fs10.existsSync(customPath)) {
+      try {
+        custom = JSON.parse(fs10.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 = path12.join(getAiDir(dbManager2), "custom-models.json");
+    let custom = [];
+    if (fs10.existsSync(customPath)) {
+      try {
+        custom = JSON.parse(fs10.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 = path12.join(getAiDir(dbManager2), "llm-config.json");
+    if (!fs10.existsSync(configPath)) return null;
+    try {
+      const data = JSON.parse(fs10.readFileSync(configPath, "utf-8"));
+      return data.defaultAssistant ?? null;
+    } catch {
+      return null;
+    }
+  });
+  server2.get("/_web/ai/llm/fast-model-slot", async () => {
+    const configPath = path12.join(getAiDir(dbManager2), "llm-config.json");
+    if (!fs10.existsSync(configPath)) return null;
+    try {
+      const data = JSON.parse(fs10.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 fs11 from "fs";
+import * as path13 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 path13.join(this.configDir, CONFIG_FILE);
+  }
+  ensureDir() {
+    fs11.mkdirSync(this.configDir, { recursive: true });
+  }
+  // ==================== Load / Save ====================
+  loadAll() {
+    try {
+      const filePath = this.getConfigPath();
+      if (fs11.existsSync(filePath)) {
+        const raw = fs11.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();
+      fs11.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 fs12 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 = fs12.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 = fs12.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 (fs12.existsSync(filePath)) fs12.unlinkSync(filePath);
+  } catch {
+  }
+}
+var PullEngine = class {
+  fetcher;
+  importer;
+  notifier;
+  dsManager;
+  logger;
+  isImporting;
+  pullingSourceIds = /* @__PURE__ */ new Set();
+  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 = fs12.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) {
+    if (this.pullingSourceIds.has(ds.id)) {
+      this.logger.info(`[Pull] Skipping pullAllSessions for "${ds.baseUrl}": pull already in progress`);
+      return;
+    }
+    this.pullingSourceIds.add(ds.id);
+    try {
+      for (const sess of ds.sessions) {
+        await this.executePullSession(ds.id, ds, sess);
+      }
+    } finally {
+      this.pullingSourceIds.delete(ds.id);
+    }
+  }
+  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 };
+    }
+    if (this.pullingSourceIds.has(sourceId)) {
+      this.logger.info(`[Pull] Skipping triggerPull for source ${sourceId}: pull already in progress`);
+      return { success: true };
+    }
+    this.pullingSourceIds.add(sourceId);
+    try {
+      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 };
+    } finally {
+      this.pullingSourceIds.delete(sourceId);
+    }
+  }
+  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 fs13 from "fs";
+import * as os4 from "os";
+import * as path14 from "path";
+import * as crypto4 from "crypto";
+function getTempFilePath(ext) {
+  const id = crypto4.randomBytes(8).toString("hex");
+  return path14.join(os4.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());
+    fs13.writeFileSync(tempFile, buffer);
+    return tempFile;
+  }
+};
+function resolveNativeBinding2() {
+  if (process.versions.electron) return void 0;
+  const nativePath = path14.resolve(__dirname, "../../native/better_sqlite3.node");
+  if (fs13.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 fs13.existsSync(dbPath);
+  }
+  async importFile(tempFile, targetSessionId, externalId) {
+    if (targetSessionId && this.sessionExists(targetSessionId)) {
+      return this.incrementalImportFile(targetSessionId, tempFile);
+    }
+    if (targetSessionId) {
+      this.logger.info(`[DirectImporter] Session ${targetSessionId} not found locally, need full resync`);
+      return { success: false, newMessageCount: 0, needFullResync: true };
+    }
+    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);
+    for (const sess of added) {
+      pullEngine2.triggerPull(request.params.id, sess.id).catch(() => {
+      });
+    }
+    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 = path15.resolve(__dirname, "../../native/better_sqlite3.node");
+  if (fs14.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 && fs14.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-FBTHZU55.mjs.map