chatlab-cli 0.23.1 → 0.24.0

package/dist/{chunk-L37WJ33K.mjs → chunk-NE4A6PND.mjs}

@@ -7,17 +7,17 @@ const __dirname = __pathDirname(__filename);
 import {
   importData,
   parseFile
-} from "./chunk-3MX7VF2B.mjs";
+} from "./chunk-RLCFXTTS.mjs";
 import {
   analyzeIncrementalImport,
   analyzeNewImport,
   incrementalImport,
   streamImport
-} from "./chunk-643S2N2U.mjs";
+} from "./chunk-36W2HWQN.mjs";
 import {
   AGENT_TOOL_REGISTRY,
   CoreDataProvider
-} from "./chunk-WTQ7LAZR.mjs";
+} from "./chunk-KCBIBRHL.mjs";
 import {
   getVersion
 } from "./chunk-5ADKYYNA.mjs";
@@ -30,14 +30,19 @@ import {
   BUILTIN_MODELS,
   BUILTIN_PROVIDERS,
   BUILTIN_TOOL_CATALOG,
+  CustomModelStore,
+  CustomProviderStore,
   DatabaseManager,
+  LLMConfigStore,
+  MergeSessionCache,
   MigrationRunner,
   NodePathProvider,
   POS_TAG_DEFINITIONS,
   PreferencesManager,
   SkillManager,
   SkillManagerCore,
-  TempDbReader,
+  TempDbWriter,
+  applyPendingNodeDataDirMigrationIfNeeded,
   applyPreprocessingPipeline,
   batchSegmentWithFrequency,
   buildMergedOutput,
@@ -45,15 +50,15 @@ import {
   buildSystemPrompt,
   checkAndCompress,
   checkConflictsFromSources,
-  cleanupTempDatabases,
   computeWordFrequency,
+  countMessagesTokens,
   createActivateSkillTool,
   createAiTranslate,
   createCompressionLlmAdapter,
   createDatabaseManagerAdapter,
   createJiebaNlpProvider,
+  createNodeDataDirSwitch,
   deleteDict,
-  deleteTempDatabase,
   detectAllFormats,
   detectFormat,
   downloadDict,
@@ -63,6 +68,7 @@ import {
   exportSessionToJson,
   export_service_exports,
   fetchRemoteModels,
+  filterMessagesWithContext,
   findEntryFileInDirectory,
   formatAIError,
   getAvailableYears,
@@ -71,6 +77,8 @@ import {
   getChatOverview,
   getClusterGraph,
   getDailyActivity,
+  getDefaultNodeUserDataDir,
+  getDefaultRulesForLocale,
   getDictList,
   getHourlyActivity,
   getLanguagePreferenceAnalysis,
@@ -83,6 +91,8 @@ import {
   getMessageLengthDistribution,
   getMessageTypeStats,
   getMonthlyActivity,
+  getMultipleSessionsMessages,
+  getPendingNodeDataDirMigration,
   getRelationshipStats,
   getSchemaDetailed,
   getSessionInfo,
@@ -94,9 +104,11 @@ import {
   getYearlyActivity,
   hasPendingElectronDataWarning,
   initNlpDir,
+  initTokenizer,
   isDictDownloaded,
   loadConfig,
   member_service_exports,
+  mergeRulesForLocale,
   openBetterSqliteDatabase,
   parseAssistantFile,
   queryMessages,
@@ -109,27 +121,25 @@ import {
   session_index_service_exports,
   session_service_exports,
   streamParseFileInfo,
+  stripAvatarFields,
   summary_service_exports,
   validateApiKey,
   verifyCliDataPath,
   writeAuthProfile,
   writeConfigField
-} from "./chunk-G7Q7EQ3V.mjs";
+} from "./chunk-XJJXSOLO.mjs";
 import {
   resolveCliPath
 } from "./chunk-FJ35V3TE.mjs";
 
 // src/http/index.ts
-import * as fs14 from "fs";
-import * as crypto5 from "crypto";
+import * as fs11 from "fs";
+import * as crypto4 from "crypto";
 
 // src/http/server.ts
 import Fastify from "fastify";
 
-// src/http/auth.ts
-import { timingSafeEqual } from "crypto";
-
-// src/http/errors.ts
+// ../../packages/http-routes/src/errors.ts
 var HTTP_STATUS = {
   ["UNAUTHORIZED" /* UNAUTHORIZED */]: 401,
   ["SESSION_NOT_FOUND" /* SESSION_NOT_FOUND */]: 404,
@@ -190,83 +200,17 @@ function errorResponse(error) {
   };
 }
 
-// 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;
-  return requireBearerToken(request, reply);
-}
-function requireBearerToken(request, reply) {
-  if (!cachedToken) 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) {
+// ../../packages/http-routes/src/routes/system.ts
+function registerSystemRoutes(server2, ctx) {
   server2.get("/api/v1/status", async () => {
     let sessionCount = 0;
     try {
-      sessionCount = dbManager2.listSessionIds().length;
+      sessionCount = ctx.dbManager.listSessionIds().length;
     } catch {
     }
     return successResponse({
       name: "ChatLab API",
-      version: getVersion(),
+      version: ctx.getVersion(),
       uptime: Math.floor(process.uptime()),
       sessionCount
     });
@@ -333,18 +277,18 @@ function registerSystemRoutes(server2, dbManager2) {
   });
 }
 
-// src/http/routes/sessions.ts
+// ../../packages/http-routes/src/routes/sessions.ts
 var EXPORT_MESSAGE_LIMIT = 1e5;
-function ensureDb(dbManager2, sessionId) {
-  const db = dbManager2.open(sessionId);
+function ensureDb(ctx, sessionId) {
+  const db = ctx.dbManager.open(sessionId);
   if (!db) throw sessionNotFound(sessionId);
   return db;
 }
-function registerSessionRoutes(server2, dbManager2) {
+function registerRestSessionRoutes(server2, ctx) {
   server2.get("/api/v1/sessions", async () => {
-    const sessionIds = dbManager2.listSessionIds();
+    const sessionIds = ctx.dbManager.listSessionIds();
     const sessions = sessionIds.map((id) => {
-      const db = dbManager2.open(id);
+      const db = ctx.dbManager.open(id);
       if (!db) return null;
       const info = getSessionInfo(db);
       if (!info) return null;
@@ -363,7 +307,7 @@ function registerSessionRoutes(server2, dbManager2) {
     return successResponse(sessions);
   });
   server2.get("/api/v1/sessions/:id", async (request) => {
-    const db = ensureDb(dbManager2, request.params.id);
+    const db = ensureDb(ctx, request.params.id);
     const info = getSessionInfo(db);
     if (!info) throw sessionNotFound(request.params.id);
     return successResponse({
@@ -380,7 +324,7 @@ function registerSessionRoutes(server2, dbManager2) {
   });
   server2.get("/api/v1/sessions/:id/messages", async (request) => {
     const { id } = request.params;
-    const db = ensureDb(dbManager2, id);
+    const db = ensureDb(ctx, 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;
@@ -402,13 +346,13 @@ function registerSessionRoutes(server2, dbManager2) {
     });
   });
   server2.get("/api/v1/sessions/:id/members", async (request) => {
-    const db = ensureDb(dbManager2, request.params.id);
+    const db = ensureDb(ctx, 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 db = ensureDb(ctx, id);
     const overview = getSessionOverview(db);
     const memberActivity = getMemberActivity(db);
     const typeDistribution = getMessageTypeStats(db);
@@ -435,7 +379,7 @@ function registerSessionRoutes(server2, dbManager2) {
   });
   server2.post("/api/v1/sessions/:id/sql", async (request, reply) => {
     const { id } = request.params;
-    const db = ensureDb(dbManager2, id);
+    const db = ensureDb(ctx, id);
     const { sql } = request.body || {};
     if (!sql || typeof sql !== "string") {
       const err = sqlExecutionError("Missing sql parameter");
@@ -457,7 +401,7 @@ function registerSessionRoutes(server2, dbManager2) {
   });
   server2.get("/api/v1/sessions/:id/export", async (request, reply) => {
     const { id } = request.params;
-    const db = ensureDb(dbManager2, id);
+    const db = ensureDb(ctx, id);
     const meta = getSessionMeta(db);
     if (!meta) throw sessionNotFound(id);
     const overview = getSessionOverview(db);
@@ -496,86 +440,9 @@ function registerSessionRoutes(server2, dbManager2) {
   });
 }
 
-// src/http/routes/web/index.ts
-import * as os3 from "os";
-import * as path6 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) {
+// ../../packages/http-routes/src/routes/web/sessions.ts
+function registerSessionRoutes(server2, ctx) {
+  const { sessionAdapter: adapter } = ctx;
   server2.get("/_web/sessions", async () => {
     return session_service_exports.listAnalysisSessions(adapter);
   });
@@ -611,8 +478,9 @@ function registerSessionRoutes2(server2, adapter) {
   );
 }
 
-// src/http/routes/web/members.ts
-function registerMemberRoutes(server2, adapter) {
+// ../../packages/http-routes/src/routes/web/members.ts
+function registerMemberRoutes(server2, ctx) {
+  const { sessionAdapter: adapter } = ctx;
   server2.get("/_web/sessions/:id/members", async (request) => {
     return member_service_exports.getMembers(adapter, request.params.id);
   });
@@ -657,8 +525,46 @@ function registerMemberRoutes(server2, adapter) {
   );
 }
 
-// src/http/routes/web/helpers.ts
-import * as fs2 from "fs";
+// ../../packages/http-routes/src/routes/web/preferences.ts
+function registerPreferencesRoutes(server2, ctx) {
+  const prefManager = ctx.preferencesManager ?? new PreferencesManager(ctx.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/http-routes/src/helpers.ts
 function parseTimeFilter(query) {
   const { startTs, endTs, memberId } = query;
   if (!startTs && !endTs && !memberId) return void 0;
@@ -668,29 +574,10 @@ function parseTimeFilter(query) {
   if (memberId) filter.memberId = parseInt(memberId, 10);
   return filter;
 }
-function resolveNativeBinding() {
-  if (process.versions.electron) return void 0;
-  const nativePath = resolveCliPath("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) {
+// ../../packages/http-routes/src/routes/web/analytics.ts
+function registerAnalyticsRoutes(server2, ctx) {
+  const { sessionAdapter: adapter } = ctx;
   server2.get("/_web/sessions/:id/years", async (request) => {
     const db = adapter.ensureReadonly(request.params.id);
     return getAvailableYears(db);
@@ -811,8 +698,9 @@ function registerAnalyticsRoutes(server2, _dbManager, adapter) {
   );
 }
 
-// src/http/routes/web/sql.ts
-function registerSqlRoutes(server2, adapter) {
+// ../../packages/http-routes/src/routes/web/sql.ts
+function registerSqlRoutes(server2, ctx) {
+  const { sessionAdapter: adapter } = ctx;
   server2.post("/_web/sessions/:id/sql", async (request, reply) => {
     const db = adapter.ensureReadonly(request.params.id);
     const { sql } = request.body || {};
@@ -847,8 +735,9 @@ function registerSqlRoutes(server2, adapter) {
   });
 }
 
-// src/http/routes/web/session-index.ts
-function registerSessionIndexRoutes(server2, adapter) {
+// ../../packages/http-routes/src/routes/web/session-index.ts
+function registerSessionIndexRoutes(server2, ctx) {
+  const { sessionAdapter: adapter } = ctx;
   server2.get("/_web/sessions/index-stats", async () => {
     return session_index_service_exports.getAllIndexStats(adapter);
   });
@@ -885,586 +774,715 @@ function registerSessionIndexRoutes(server2, adapter) {
   });
 }
 
-// src/ai/llm-config.ts
-import * as fs3 from "fs";
-import * as path2 from "path";
-import { randomUUID as randomUUID2 } from "crypto";
-function loadLlmConfig(aiDataDir) {
-  const configPath = path2.join(aiDataDir, "llm-config.json");
-  if (!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 = path2.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
+// ../../packages/http-routes/src/routes/web/export.ts
+function registerExportRoutes(server2, ctx) {
+  const { sessionAdapter: adapter } = ctx;
+  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
     });
-    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" };
+    if (!result.success) {
+      return reply.code(500).send({ error: result.error });
     }
-  }
-  storeForSave.fastModel = slot;
-  saveLlmConfig(aiDataDir, storeForSave);
-  return { success: true };
-}
-function loadRawConfigStore(aiDataDir) {
-  const configPath = path2.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);
+    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/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, strategy } = request.body;
-    const result = await summary_service_exports.generateSummary(adapter, request.params.id, chatSessionId, deps, {
-      locale,
-      forceRegenerate,
-      strategy
-    });
-    if ("error" in result && !result.success) {
-      return reply.code(400).send({ error: result.error });
-    }
-    return result;
+// ../../packages/http-routes/src/routes/web/nlp.ts
+import * as path from "path";
+function registerNlpRoutes(server2, ctx) {
+  const nlpDir = path.join(ctx.pathProvider.getSystemDir(), "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.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;
+  server2.get("/_web/nlp/dicts", async () => {
+    return getDictList(nlpDir);
   });
-  server2.post("/_web/sessions/:id/summaries/check-can-generate", async (request) => {
-    const { chatSessionIds } = request.body;
-    return summary_service_exports.checkCanGenerate(adapter, request.params.id, chatSessionIds);
+  server2.get("/_web/nlp/dicts/:id/status", async (request) => {
+    return isDictDownloaded(nlpDir, request.params.id);
   });
-}
-
-// src/http/routes/web/import.ts
-import * as fs4 from "fs";
-import * as os from "os";
-import * as path3 from "path";
-var DEMO_BASE_URL = "https://chatlab.fun/assets/demo";
-function cleanupTemp(...paths) {
-  for (const p of paths) {
-    try {
-      const stat2 = fs4.statSync(p);
-      if (stat2.isDirectory()) {
-        fs4.rmSync(p, { recursive: true, force: true });
-      } else {
-        fs4.unlinkSync(p);
-      }
-    } catch {
+  server2.post("/_web/nlp/dicts/:id/download", async (request) => {
+    return downloadDict(nlpDir, request.params.id);
+  });
+  server2.delete("/_web/nlp/dicts/:id", async (request) => {
+    return deleteDict(nlpDir, request.params.id);
+  });
+  server2.post("/_web/nlp/word-frequency", async (request) => {
+    const params = request.body;
+    const db = ctx.dbManager.open(params.sessionId);
+    if (!db) {
+      throw Object.assign(new Error(`Session not found: ${params.sessionId}`), { statusCode: 404 });
     }
-  }
-}
-function registerImportRoutes(server2, dbManager2) {
-  server2.get("/_web/supported-formats", async () => {
-    return getSupportedFormats();
+    return computeWordFrequency(db, params);
   });
-  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(path3.join(os.tmpdir(), "chatlab-detect-"));
-    const tmpPath = path3.join(tmpDir, data.filename || "upload");
-    try {
-      const chunks = [];
-      for await (const chunk of data.file) {
-        chunks.push(chunk);
-      }
-      fs4.writeFileSync(tmpPath, Buffer.concat(chunks));
-      const format = detectFormat(tmpPath);
-      const allFormats = detectAllFormats(tmpPath);
-      return { format, allFormats };
-    } finally {
-      cleanupTemp(tmpPath, tmpDir);
+  server2.post(
+    "/_web/nlp/segment",
+    async (request) => {
+      const { text, locale, minLength } = request.body;
+      return segmentText(text, locale, minLength);
     }
+  );
+}
+
+// ../../packages/http-routes/src/routes/web/ai-assistants.ts
+function registerAiAssistantRoutes(server2, ctx) {
+  server2.get("/_web/ai/tools/catalog", async () => {
+    return BUILTIN_TOOL_CATALOG;
   });
-  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(path3.join(os.tmpdir(), "chatlab-scan-"));
-    const tmpPath = path3.join(tmpDir, data.filename || "upload");
-    try {
-      const chunks = [];
-      for await (const chunk of data.file) {
-        chunks.push(chunk);
-      }
-      fs4.writeFileSync(tmpPath, Buffer.concat(chunks));
-      const chats = await scanMultiChatFile(tmpPath);
-      return { chats };
-    } finally {
-      cleanupTemp(tmpPath, tmpDir);
+  const mgr = ctx.assistantManager;
+  if (!mgr) return;
+  server2.get("/_web/ai/assistants", async () => {
+    return mgr.getAllAssistants();
+  });
+  server2.get("/_web/ai/assistants/:id", async (request, reply) => {
+    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) => {
+    return mgr.createAssistant(request.body);
+  });
+  server2.put("/_web/ai/assistants/:id", async (request, reply) => {
+    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 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 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) => {
+    return mgr.importAssistantFromMd(request.body.rawMd);
+  });
+  server2.post("/_web/ai/assistants/import-builtin", async (request, reply) => {
+    const result = mgr.importAssistant(request.body.builtinId);
+    if (!result.success) return reply.code(400).send(result);
+    return result;
+  });
+  server2.post("/_web/ai/assistants/:id/reimport", async (request, reply) => {
+    const result = mgr.reimportAssistant(request.params.id);
+    if (!result.success) return reply.code(400).send(result);
+    return result;
+  });
+}
+
+// ../../packages/http-routes/src/routes/web/ai-skills.ts
+function registerAiSkillRoutes(server2, ctx) {
+  const mgr = ctx.skillManagerCore;
+  if (!mgr) return;
+  server2.get("/_web/ai/skills", async () => {
+    return mgr.getAllSkills();
+  });
+  server2.get("/_web/ai/skills/:id", async (request, reply) => {
+    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) => {
+    return mgr.createSkill(request.body.rawMd);
+  });
+  server2.put("/_web/ai/skills/:id", async (request, reply) => {
+    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 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) => {
+    return mgr.importSkillFromMd(request.body.rawMd);
+  });
+  server2.get("/_web/ai/skills/builtin-catalog", async () => {
+    return mgr.getBuiltinCatalog();
+  });
+  server2.post("/_web/ai/skills/import-builtin", async (request, reply) => {
+    const result = mgr.importSkill(request.body.builtinId);
+    if (!result.success) return reply.code(400).send(result);
+    return result;
+  });
+  server2.post("/_web/ai/skills/:id/reimport", async (request, reply) => {
+    const result = mgr.reimportSkill(request.params.id);
+    if (!result.success) return reply.code(400).send(result);
+    return result;
+  });
+}
+
+// ../../packages/http-routes/src/routes/web/ai-llm.ts
+function hasRealApiKey(apiKey) {
+  return !!apiKey && apiKey !== "sk-no-key-required";
+}
+function toConfigDisplay(config) {
+  const { apiKey: _raw, ...rest } = config;
+  return { ...rest, apiKey: "", apiKeySet: hasRealApiKey(String(_raw || "")) };
+}
+function registerAiLlmRoutes(server2, ctx) {
+  const store = ctx.llmConfigStore;
+  const aiDataDir = ctx.aiDataDir;
+  if (!store || !aiDataDir) return;
+  server2.get("/_web/ai/llm/has-config", async () => {
+    return store.hasActiveConfig();
+  });
+  server2.get("/_web/ai/llm/configs", async () => {
+    const data = store.loadStore();
+    return {
+      configs: data.configs.map((c) => toConfigDisplay(c)),
+      defaultAssistant: data.defaultAssistant,
+      fastModel: data.fastModel
+    };
+  });
+  server2.post("/_web/ai/llm/configs", async (request) => {
+    const result = store.addConfig(request.body);
+    if (result.success && result.config) {
+      return { ...result, config: toConfigDisplay(result.config) };
     }
+    return result;
   });
-  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(path3.join(os.tmpdir(), "chatlab-import-"));
-    const tmpPath = path3.join(tmpDir, data.filename || "upload");
-    const chunks = [];
-    for await (const chunk of data.file) {
-      chunks.push(chunk);
+  server2.put("/_web/ai/llm/configs/:id", async (request) => {
+    return store.updateConfig(request.params.id, request.body);
+  });
+  server2.delete("/_web/ai/llm/configs/:id", async (request) => {
+    return store.deleteConfig(request.params.id);
+  });
+  server2.get("/_web/ai/llm/default-assistant-slot", async () => {
+    return store.getDefaultAssistantSlot();
+  });
+  server2.put("/_web/ai/llm/default-assistant-slot", async (request) => {
+    return store.setDefaultAssistantModel(request.body.configId, request.body.modelId);
+  });
+  server2.get("/_web/ai/llm/fast-model-slot", async () => {
+    return store.getFastModelSlot();
+  });
+  server2.put("/_web/ai/llm/fast-model-slot", async (request) => {
+    return store.setFastModel(request.body);
+  });
+  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 custom = ctx.customProviderStore?.getAll() ?? [];
+    return [...BUILTIN_PROVIDERS, ...custom];
+  });
+  server2.get("/_web/ai/llm/model-catalog", async () => {
+    const custom = ctx.customModelStore?.getAll() ?? [];
+    return [...BUILTIN_MODELS, ...custom];
+  });
+  server2.post("/_web/ai/llm/custom-providers", async (request, reply) => {
+    if (!ctx.customProviderStore)
+      return reply.code(501).send({ success: false, error: "Custom providers not available" });
+    return ctx.customProviderStore.add(request.body);
+  });
+  server2.put("/_web/ai/llm/custom-providers/:id", async (request, reply) => {
+    if (!ctx.customProviderStore)
+      return reply.code(501).send({ success: false, error: "Custom providers not available" });
+    const result = ctx.customProviderStore.update(request.params.id, request.body);
+    if (!result.success) return reply.code(404).send(result);
+    return result;
+  });
+  server2.delete("/_web/ai/llm/custom-providers/:id", async (request, reply) => {
+    if (!ctx.customProviderStore)
+      return reply.code(501).send({ success: false, error: "Custom providers not available" });
+    const result = ctx.customProviderStore.delete(request.params.id);
+    if (!result.success) return reply.code(404).send(result);
+    return result;
+  });
+  server2.post("/_web/ai/llm/custom-models", async (request, reply) => {
+    if (!ctx.customModelStore) return reply.code(501).send({ success: false, error: "Custom models not available" });
+    const result = ctx.customModelStore.add(request.body);
+    if (!result.success) return reply.code(409).send(result);
+    return result;
+  });
+  server2.put("/_web/ai/llm/custom-models/:providerId/:modelId", async (request, reply) => {
+    if (!ctx.customModelStore) return reply.code(501).send({ success: false, error: "Custom models not available" });
+    const result = ctx.customModelStore.update(request.params.providerId, request.params.modelId, request.body);
+    if (!result.success) return reply.code(404).send(result);
+    return result;
+  });
+  server2.delete("/_web/ai/llm/custom-models/:providerId/:modelId", async (request, reply) => {
+    if (!ctx.customModelStore) return reply.code(501).send({ success: false, error: "Custom models not available" });
+    const result = ctx.customModelStore.delete(request.params.providerId, request.params.modelId);
+    if (!result.success) return reply.code(404).send(result);
+    return result;
+  });
+  server2.post("/_web/ai/llm/validate-key", async (request) => {
+    const { provider, apiKey, baseUrl, model, apiFormat, configId } = request.body;
+    const resolvedKey = apiKey?.trim() ? apiKey : configId ? store.getConfigById(configId)?.apiKey || "" : "";
+    return validateApiKey(provider, resolvedKey, baseUrl, model, apiFormat);
+  });
+  server2.post("/_web/ai/llm/remote-models", async (request) => {
+    const { provider, apiKey, baseUrl, apiFormat, configId } = request.body;
+    const resolvedKey = apiKey?.trim() ? apiKey : configId ? store.getConfigById(configId)?.apiKey || "" : "";
+    return fetchRemoteModels(provider, resolvedKey, baseUrl, apiFormat);
+  });
+  server2.get("/_web/ai/desensitize-rules/defaults", async (request) => {
+    return getDefaultRulesForLocale(request.query.locale ?? "zh-CN");
+  });
+  server2.post("/_web/ai/desensitize-rules/merge", async (request) => {
+    return mergeRulesForLocale(request.body.existingRules, request.body.locale);
+  });
+}
+
+// ../../packages/http-routes/src/routes/web/ai-llm-stream.ts
+function registerAiLlmStreamRoutes(server2, ctx) {
+  const store = ctx.llmConfigStore;
+  if (!store) return;
+  server2.post("/_web/ai/llm/chat-stream", async (request, reply) => {
+    const { messages, options } = request.body;
+    const llmConfig = store.getDefaultAssistantConfig();
+    if (!llmConfig) {
+      return reply.code(400).send({ success: false, error: "LLM service not configured" });
     }
-    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;
+    const piModel = buildPiModel(llmConfig);
+    const abortController = new AbortController();
     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)}
+    reply.raw.on("close", () => {
+      if (!abortController.signal.aborted) abortController.abort();
+    });
+    const sendChunk = (data) => {
+      if (reply.raw.writableEnded || reply.raw.destroyed) return;
+      reply.raw.write(`event: chunk
+data: ${JSON.stringify(data)}
 
 `);
-    }
+    };
     try {
-      const nativeBinding = resolveNativeBinding();
-      const result = await streamImport(dbManager2, tmpPath, {
-        formatId,
-        chatIndex,
-        nativeBinding,
-        onProgress: (p) => sendEvent("progress", p)
+      await runSimpleLlmStream({
+        messages,
+        apiKey: llmConfig.apiKey,
+        piModel,
+        temperature: options?.temperature,
+        maxTokens: options?.maxTokens,
+        onChunk: sendChunk,
+        abortSignal: abortController.signal
       });
-      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) });
+    } catch (error) {
+      if (abortController.signal.aborted) return;
+      const msg = error instanceof Error ? error.message : String(error);
+      sendChunk({ content: "", isFinished: true, finishReason: "error", error: msg });
     } finally {
-      reply.raw.end();
-      cleanupTemp(tmpPath, tmpDir);
+      if (!reply.raw.writableEnded && !reply.raw.destroyed) reply.raw.end();
     }
   });
-  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(path3.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 = path3.resolve(tmpDir, relPath);
-        if (!targetPath.startsWith(tmpDir + path3.sep)) continue;
-        fs4.mkdirSync(path3.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(path3.join(os.tmpdir(), "chatlab-inc-"));
-    const tmpPath = path3.join(tmpDir, data.filename || "upload");
-    const chunks = [];
-    for await (const chunk of data.file) {
-      chunks.push(chunk);
-    }
-    fs4.writeFileSync(tmpPath, Buffer.concat(chunks));
+// ../../packages/http-routes/src/routes/web/ai-agent-stream.ts
+var activeAgentAborts = /* @__PURE__ */ new Map();
+function registerAiAgentStreamRoutes(server2, ctx) {
+  if (!ctx.runAgentStream) return;
+  const runAgentStream = ctx.runAgentStream;
+  server2.post("/_web/ai/agent/stream", async (request, reply) => {
+    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"
+      Connection: "keep-alive",
+      "X-Request-Id": requestId
     });
-    function sendEvent(event, eventData) {
+    let emittedDone = false;
+    const safeSendSSE = (event, data) => {
+      if (reply.raw.writableEnded || reply.raw.destroyed) return;
       reply.raw.write(`event: ${event}
-data: ${JSON.stringify(eventData)}
+data: ${JSON.stringify(data)}
 
 `);
-    }
-    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 {
+    };
+    const safeEnd = () => {
+      if (reply.raw.writableEnded || reply.raw.destroyed) return;
       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(path3.join(os.tmpdir(), "chatlab-analyze-"));
-    const tmpPath = path3.join(tmpDir, data.filename || "upload");
-    const chunks = [];
-    for await (const chunk of data.file) {
-      chunks.push(chunk);
-    }
-    fs4.writeFileSync(tmpPath, Buffer.concat(chunks));
+    };
+    safeSendSSE("meta", { requestId });
+    reply.raw.on("close", () => {
+      if (!abortController.signal.aborted) {
+        abortController.abort();
+      }
+      activeAgentAborts.delete(requestId);
+    });
     try {
-      return await analyzeIncrementalImport(dbManager2, sessionId, tmpPath);
-    } catch (err) {
-      return reply.code(500).send({ error: err instanceof Error ? err.message : String(err) });
+      await runAgentStream(
+        request.body,
+        (chunk) => {
+          if (chunk.type === "done") emittedDone = true;
+          safeSendSSE(chunk.type, chunk);
+        },
+        abortController.signal
+      );
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      safeSendSSE("error", { type: "error", error: { name: "ServerError", message: msg } });
     } finally {
-      cleanupTemp(tmpPath, tmpDir);
+      if (!emittedDone) safeSendSSE("done", { type: "done", isFinished: true });
+      activeAgentAborts.delete(requestId);
+      safeEnd();
     }
   });
-  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(path3.join(os.tmpdir(), "chatlab-analyze-"));
-    const tmpPath = path3.join(tmpDir, data.filename || "upload");
-    const chunks = [];
-    for await (const chunk of data.file) {
-      chunks.push(chunk);
-    }
-    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/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 };
   });
-  const DEMO_FILES = [
-    "demo-group.json",
-    "demo-private-A-cuilan.json",
-    "demo-private-B-wukong.json",
-    "demo-private-C-spider.json"
-  ];
-  server2.post("/_web/demo/import", async (request, reply) => {
-    const locale = request.body?.locale || "en";
-    const nativeBinding = resolveNativeBinding();
-    const total = DEMO_FILES.length;
-    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(path3.join(os.tmpdir(), "chatlab-demo-"));
-    try {
-      const localPaths = [];
-      for (let i = 0; i < total; i++) {
-        sendEvent("progress", { stage: "downloading", current: i + 1, total });
-        const localPath = path3.join(tmpDir, DEMO_FILES[i]);
-        const resp = await fetch(`${DEMO_BASE_URL}/${locale}/${DEMO_FILES[i]}`, {
-          signal: AbortSignal.timeout(6e4)
-        });
-        if (!resp.ok) throw new Error(`Download demo failed (${DEMO_FILES[i]}): ${resp.status}`);
-        fs4.writeFileSync(localPath, Buffer.from(await resp.arrayBuffer()));
-        localPaths.push(localPath);
-      }
-      sendEvent("progress", { stage: "importing", current: 1, total });
-      const groupResult = await streamImport(dbManager2, localPaths[0], { nativeBinding });
-      if (!groupResult.success) throw new Error(groupResult.error || "Failed to import group demo");
-      const privateSessionIds = [];
-      for (let i = 1; i < localPaths.length; i++) {
-        sendEvent("progress", { stage: "importing", current: i + 1, total });
-        const result = await streamImport(dbManager2, localPaths[i], { nativeBinding });
-        if (!result.success) throw new Error(result.error || `Failed to import private demo: ${DEMO_FILES[i]}`);
-        if (result.sessionId) privateSessionIds.push(result.sessionId);
-      }
-      sendEvent("progress", { stage: "done", current: total, total });
-      sendEvent("result", {
-        success: true,
-        groupSessionId: groupResult.sessionId,
-        privateSessionIds
-      });
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      sendEvent("progress", { stage: "error", current: 0, total, message });
-      sendEvent("result", { success: false, error: message });
-    } finally {
-      reply.raw.end();
-      cleanupTemp(tmpDir);
-    }
+// ../../packages/http-routes/src/routes/web/ai-filter.ts
+function registerAiFilterRoutes(server2, ctx) {
+  server2.post("/_web/ai/filter-messages", async (request, reply) => {
+    const { sessionId, keywords, timeFilter, senderIds, contextSize, page, pageSize } = request.body;
+    const db = ctx.dbManager.open(sessionId);
+    if (!db) return reply.code(404).send({ error: `Session not found: ${sessionId}` });
+    return filterMessagesWithContext(db, { keywords, timeFilter, senderIds, contextSize, page, pageSize });
+  });
+  server2.post("/_web/ai/multiple-sessions-messages", async (request, reply) => {
+    const { sessionId, chatSessionIds, page, pageSize } = request.body;
+    const db = ctx.dbManager.open(sessionId);
+    if (!db) return reply.code(404).send({ error: `Session not found: ${sessionId}` });
+    return getMultipleSessionsMessages(db, chatSessionIds, page, pageSize);
   });
 }
 
-// src/http/routes/web/merge.ts
-import * as fs5 from "fs";
-import * as os2 from "os";
-import * as path4 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(path4.join(os2.tmpdir(), "chatlab-merge-"));
-    const tmpPath = path4.join(tmpDir, data.filename || "upload");
-    const chunks = [];
-    for await (const chunk of data.file) {
-      chunks.push(chunk);
+// ../../packages/http-routes/src/routes/web/ai-tools.ts
+var MAX_RESULT_CHARS = 5e5;
+var activeToolTests = /* @__PURE__ */ new Map();
+function registerAiToolRoutes(server2, ctx) {
+  server2.get("/_web/ai/tools/full-catalog", async () => {
+    return AGENT_TOOL_REGISTRY.map((tool) => ({
+      name: tool.name,
+      category: tool.category ?? "core",
+      description: tool.description,
+      parameters: tool.inputSchema ?? {}
+    }));
+  });
+  server2.post("/_web/ai/tools/execute", async (request, reply) => {
+    const { testId, toolName, params, sessionId } = request.body;
+    const entry = AGENT_TOOL_REGISTRY.find((t) => t.name === toolName);
+    if (!entry) {
+      return reply.code(404).send({ success: false, error: `Tool not found: ${toolName}` });
+    }
+    const db = ctx.dbManager.open(sessionId);
+    if (!db) {
+      return reply.code(404).send({ success: false, error: `Session not found: ${sessionId}` });
     }
-    fs5.writeFileSync(tmpPath, Buffer.concat(chunks));
+    const abortController = new AbortController();
+    activeToolTests.set(testId, abortController);
     try {
-      const result = await streamParseFileInfo(tmpPath, {
-        createTempDatabase(sourceFilePath) {
-          return mergeCache.createTempDatabase(path4.basename(sourceFilePath));
-        },
-        onProgress() {
+      const execCtx = {
+        sessionId,
+        db,
+        dataProvider: new CoreDataProvider(db)
+      };
+      const startTime = Date.now();
+      const result = await entry.handler(params, execCtx);
+      const elapsed = Date.now() - startTime;
+      if (abortController.signal.aborted) {
+        return { success: false, error: "cancelled" };
+      }
+      let details = result.data ?? void 0;
+      let truncated = false;
+      if (details) {
+        stripAvatarFields(details);
+        const raw = JSON.stringify(details);
+        if (raw.length > MAX_RESULT_CHARS) {
+          truncated = true;
+          details = { _truncated: true, _originalSize: raw.length, _preview: raw.slice(0, MAX_RESULT_CHARS) };
         }
-      });
-      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
+        success: true,
+        elapsed,
+        content: [{ type: "text", text: result.content }],
+        details,
+        truncated
       };
-    } finally {
-      try {
-        fs5.unlinkSync(tmpPath);
-      } catch {
-      }
-      try {
-        fs5.rmdirSync(tmpDir);
-      } catch {
+    } catch (error) {
+      if (abortController.signal.aborted) {
+        return { success: false, error: "cancelled" };
       }
+      console.error(`Failed to execute tool ${toolName}:`, error);
+      return { success: false, error: String(error) };
+    } finally {
+      activeToolTests.delete(testId);
     }
   });
-  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 = [];
+  server2.post("/_web/ai/tools/cancel", async (request) => {
+    const { testId } = request.body;
+    const controller = activeToolTests.get(testId);
+    if (controller) {
+      controller.abort();
+      activeToolTests.delete(testId);
+      return { success: true };
+    }
+    return { success: false };
+  });
+}
+
+// ../../packages/http-routes/src/routes/web/ai-conversations.ts
+function registerAiConversationRoutes(server2, ctx) {
+  const cm = ctx.conversationManager;
+  if (!cm) return;
+  server2.post("/_web/ai/conversations", async (request) => {
+    const { sessionId, title, assistantId } = request.body;
+    return cm.createConversation(sessionId, title, assistantId);
+  });
+  server2.get("/_web/ai/conversations", async (request) => {
+    const { sessionId } = request.query;
+    if (!sessionId) return [];
+    return cm.getConversations(sessionId);
+  });
+  server2.get("/_web/ai/conversations/:id", async (request, reply) => {
+    const conv = cm.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 cm.updateConversationTitle(request.params.id, request.body.title);
+  });
+  server2.delete("/_web/ai/conversations/:id", async (request) => {
+    return cm.deleteConversation(request.params.id);
+  });
+  server2.post("/_web/ai/conversations/:id/messages", async (request) => {
+    const { role, content, dataKeywords, dataMessageCount, contentBlocks, tokenUsage } = request.body;
+    return cm.addMessage(
+      request.params.id,
+      role,
+      content,
+      dataKeywords,
+      dataMessageCount,
+      contentBlocks,
+      tokenUsage
+    );
+  });
+  server2.get("/_web/ai/conversations/:id/messages", async (request) => {
+    return cm.getMessages(request.params.id);
+  });
+  server2.post("/_web/ai/conversations/:id/messages/:messageId/delete-from", async (request, reply) => {
+    const { id, messageId } = request.params;
+    if (!id || typeof id !== "string" || !messageId || typeof messageId !== "string") {
+      return reply.code(400).send({ error: "conversation id and messageId are required" });
+    }
+    cm.deleteMessagesFrom(id, messageId);
+    return { success: true };
+  });
+  server2.post("/_web/ai/conversations/:id/fork", async (request, reply) => {
+    const { upToMessageId, title } = request.body;
+    if (!upToMessageId || typeof upToMessageId !== "string") {
+      return reply.code(400).send({ error: "upToMessageId is required" });
+    }
+    return cm.forkConversation(request.params.id, upToMessageId, title);
+  });
+  server2.put("/_web/ai/messages/:messageId/content", async (request, reply) => {
+    const { content } = request.body;
+    if (!content || typeof content !== "string") {
+      return reply.code(400).send({ error: "content is required" });
+    }
+    cm.updateMessageContent(request.params.messageId, content);
+    return { success: true };
+  });
+  server2.post("/_web/ai/conversations/:id/messages/:messageId/delete-relink", async (request, reply) => {
+    const { id, messageId } = request.params;
+    if (!id || !messageId) {
+      return reply.code(400).send({ error: "conversation id and messageId are required" });
+    }
+    cm.deleteAndRelinkMessage(id, messageId);
+    return { success: true };
+  });
+  server2.post("/_web/ai/conversations/:id/messages/insert-after", async (request, reply) => {
+    const { afterMessageId, role, content, contentBlocks, tokenUsage } = request.body;
+    if (!afterMessageId || typeof afterMessageId !== "string") {
+      return reply.code(400).send({ error: "afterMessageId is required" });
+    }
+    return cm.insertMessageAfter(request.params.id, afterMessageId, role, content, contentBlocks, tokenUsage);
+  });
+  server2.get("/_web/ai/conversations/:id/token-usage", async (request) => {
+    return cm.getConversationTokenUsage(request.params.id);
+  });
+  server2.get("/_web/ai/debug/schema", async () => {
+    return cm.getAiSchema();
+  });
+  server2.post("/_web/ai/debug/execute-sql", async (request, reply) => {
+    const { sql } = request.body;
+    if (!sql || typeof sql !== "string") {
+      return reply.code(400).send({ error: "sql is required" });
+    }
+    try {
+      return cm.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 () => {
+    const cleared = cm.clearAllDebugContext();
+    return { success: true, cleared };
+  });
+  server2.get("/_web/ai/conversations/:id/estimate-tokens", async (request) => {
+    const history = cm.getHistoryForAgent(request.params.id);
+    const tokens = countMessagesTokens(history.map((m) => ({ role: m.role, content: m.content })));
+    return { success: true, tokens, messageCount: history.length };
+  });
+}
+
+// ../../packages/http-routes/src/routes/web/ai-summaries.ts
+function createSummaryDeps(ctx) {
+  const store = ctx.llmConfigStore;
+  if (!store) return null;
+  return {
+    getLlmConfig() {
+      const config = store.getDefaultAssistantConfig();
+      if (!config) return null;
+      return config;
+    },
+    buildPiModel(config) {
+      return buildPiModel(config);
+    }
+  };
+}
+function registerAiSummaryRoutes(server2, ctx) {
+  const deps = createSummaryDeps(ctx);
+  if (!deps) return;
+  const { sessionAdapter: adapter } = ctx;
+  server2.post("/_web/sessions/:id/summaries/generate", async (request, reply) => {
+    const { chatSessionId, locale, forceRegenerate, strategy } = request.body;
+    const result = await summary_service_exports.generateSummary(adapter, request.params.id, chatSessionId, deps, {
+      locale,
+      forceRegenerate,
+      strategy
+    });
+    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;
+  });
+  server2.post("/_web/sessions/:id/summaries/check-can-generate", async (request) => {
+    const { chatSessionIds } = request.body;
+    return summary_service_exports.checkCanGenerate(adapter, request.params.id, chatSessionIds);
+  });
+}
+
+// ../../packages/http-routes/src/routes/web/merge.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path2 from "path";
+function ensureDb2(ctx, sessionId) {
+  const db = ctx.dbManager.open(sessionId);
+  if (!db) throw sessionNotFound(sessionId);
+  return db;
+}
+function registerMergeRoutes(server2, ctx) {
+  const { dbManager: dbManager2, mergeSessionCache: mergeCache, streamImport: streamImport2 } = ctx;
+  if (!mergeCache) return;
+  server2.post("/_web/merge/parse", async (request, reply) => {
+    const contentType = request.headers["content-type"] || "";
+    let filePath;
+    let cleanupFile = false;
+    let cleanupDir;
+    if (contentType.includes("multipart/form-data")) {
+      const data = await request.file();
+      if (!data) return reply.code(400).send({ error: "No file uploaded" });
+      const tmpDir = fs.mkdtempSync(path2.join(os.tmpdir(), "chatlab-merge-"));
+      const tmpPath = path2.join(tmpDir, data.filename || "upload");
+      const chunks = [];
+      for await (const chunk of data.file) {
+        chunks.push(chunk);
+      }
+      fs.writeFileSync(tmpPath, Buffer.concat(chunks));
+      filePath = tmpPath;
+      cleanupFile = true;
+      cleanupDir = tmpDir;
+    } else {
+      const body = request.body;
+      if (!body?.filePath) return reply.code(400).send({ error: "Missing filePath in body" });
+      if (!fs.existsSync(body.filePath)) return reply.code(400).send({ error: "File not found" });
+      filePath = body.filePath;
+    }
+    try {
+      const result = await streamParseFileInfo(filePath, {
+        createTempDatabase(sourceFilePath) {
+          return mergeCache.createTempDatabase(path2.basename(sourceFilePath));
+        },
+        onProgress() {
+        }
+      });
+      const filename = path2.basename(filePath);
+      const handle = mergeCache.store(filename, result.tempDbPath);
+      return {
+        handle,
+        name: result.name,
+        format: result.format,
+        platform: result.platform,
+        messageCount: result.messageCount,
+        memberCount: result.memberCount,
+        fileSize: result.fileSize
+      };
+    } finally {
+      if (cleanupFile) {
+        try {
+          fs.unlinkSync(filePath);
+        } catch {
+        }
+      }
+      if (cleanupDir) {
+        try {
+          fs.rmdirSync(cleanupDir);
+        } 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) {
@@ -1498,21 +1516,24 @@ function registerMergeRoutes(server2, dbManager2, mergeCache) {
       const merged = buildMergedOutput(dataSources, outputName);
       let sessionId;
       if (andImport) {
-        const { streamImport: serverStreamImport } = await import("./stream-import-QM5R5FDG.mjs");
+        if (!streamImport2) {
+          return reply.code(501).send({ error: "Import not available on this server" });
+        }
         const jsonData = JSON.stringify(merged.chatLabData);
-        const tmpDir = fs5.mkdtempSync(path4.join(os2.tmpdir(), "chatlab-merged-"));
-        const tmpPath = path4.join(tmpDir, `${outputName}.json`);
-        fs5.writeFileSync(tmpPath, jsonData, "utf-8");
+        const tmpDir = fs.mkdtempSync(path2.join(os.tmpdir(), "chatlab-merged-"));
+        const safeName = path2.basename(outputName).replace(/[/\\?%*:|"<>]/g, "_") || "merged";
+        const tmpPath = path2.join(tmpDir, `${safeName}.json`);
+        fs.writeFileSync(tmpPath, jsonData, "utf-8");
         try {
-          const importResult = await serverStreamImport(dbManager2, tmpPath);
+          const importResult = await streamImport2(dbManager2, tmpPath);
           sessionId = importResult.sessionId;
         } finally {
           try {
-            fs5.unlinkSync(tmpPath);
+            fs.unlinkSync(tmpPath);
           } catch {
           }
           try {
-            fs5.rmdirSync(tmpDir);
+            fs.rmdirSync(tmpDir);
           } catch {
           }
         }
@@ -1548,10 +1569,9 @@ function registerMergeRoutes(server2, dbManager2, mergeCache) {
     }
     const handles = [];
     for (const sid of sessionIds) {
-      const db = ensureDb2(dbManager2, sid);
+      const db = ensureDb2(ctx, sid);
       const exported = exportSessionToJson(db);
       const { db: tempDb, tempDbPath } = mergeCache.createTempDatabase(exported.meta.name);
-      const { TempDbWriter } = await import("./src-EGXULYFQ.mjs");
       const writer = new TempDbWriter(tempDb);
       writer.writeMeta({
         name: exported.meta.name,
@@ -1586,72 +1606,17 @@ function registerMergeRoutes(server2, dbManager2, mergeCache) {
   });
 }
 
-// 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";
+// ../../packages/http-routes/src/routes/web/cache.ts
+import * as fs2 from "fs";
 import * as fsp from "fs/promises";
-import * as path5 from "path";
-import { execFile } from "child_process";
-function runExecFile(file, args, runner = execFile) {
-  return new Promise((resolve2, reject) => {
-    runner(file, args, (error) => {
-      if (error) {
-        reject(error);
-        return;
-      }
-      resolve2();
-    });
-  });
-}
-async function openDirectoryPath(dirPath, platform = process.platform, runner) {
-  if (platform === "darwin") {
-    await runExecFile("open", [dirPath], runner);
-  } else if (platform === "win32") {
-    await runExecFile("explorer.exe", [dirPath], runner);
-  } else {
-    await runExecFile("xdg-open", [dirPath], runner);
-  }
-}
-async function showPathInFolder(filePath, platform = process.platform, runner) {
-  if (platform === "darwin") {
-    await runExecFile("open", ["-R", filePath], runner);
-  } else if (platform === "win32") {
-    await runExecFile("explorer.exe", [`/select,${filePath}`], runner);
-  } else {
-    await runExecFile("xdg-open", [path5.dirname(filePath)], runner);
-  }
-}
+import * as path3 from "path";
 async function getDirSize(dirPath) {
   let totalSize = 0;
   try {
-    if (!fs6.existsSync(dirPath)) return 0;
+    if (!fs2.existsSync(dirPath)) return 0;
     const files = await fsp.readdir(dirPath, { withFileTypes: true });
     for (const file of files) {
-      const filePath = path5.join(dirPath, file.name);
+      const filePath = path3.join(dirPath, file.name);
       if (file.isDirectory()) {
         totalSize += await getDirSize(filePath);
       } else {
@@ -1666,10 +1631,10 @@ async function getDirSize(dirPath) {
 async function getFileCount(dirPath) {
   let count = 0;
   try {
-    if (!fs6.existsSync(dirPath)) return 0;
+    if (!fs2.existsSync(dirPath)) return 0;
     const files = await fsp.readdir(dirPath, { withFileTypes: true });
     for (const file of files) {
-      const filePath = path5.join(dirPath, file.name);
+      const filePath = path3.join(dirPath, file.name);
       if (file.isDirectory()) {
         count += await getFileCount(filePath);
       } else {
@@ -1680,15 +1645,26 @@ async function getFileCount(dirPath) {
   }
   return count;
 }
-function registerCacheRoutes(server2, pathProvider) {
-  const downloadsDir = pathProvider.getDownloadsDir();
+function hasChatLabDatabases(dirPath) {
+  try {
+    const markerPath = path3.join(dirPath, ".chatlab");
+    const dbDir = path3.join(dirPath, "databases");
+    if (!fs2.existsSync(markerPath) || !fs2.existsSync(dbDir)) return false;
+    return fs2.readdirSync(dbDir).some((file) => file.endsWith(".db"));
+  } catch {
+    return false;
+  }
+}
+function registerCacheRoutes(server2, ctx) {
+  const pp = ctx.pathProvider;
+  const downloadsDir = ctx.downloadsDir ?? pp.getDownloadsDir();
   server2.get("/_web/cache/info", async () => {
     const directories = [
       {
         id: "databases",
         name: "settings.storage.cache.databases.name",
         description: "settings.storage.cache.databases.description",
-        path: pathProvider.getDatabaseDir(),
+        path: pp.getDatabaseDir(),
         icon: "i-heroicons-circle-stack",
         canClear: false
       },
@@ -1696,7 +1672,7 @@ function registerCacheRoutes(server2, pathProvider) {
         id: "ai",
         name: "settings.storage.cache.ai.name",
         description: "settings.storage.cache.ai.description",
-        path: pathProvider.getAiDataDir(),
+        path: pp.getAiDataDir(),
         icon: "i-heroicons-sparkles",
         canClear: false
       },
@@ -1704,7 +1680,7 @@ function registerCacheRoutes(server2, pathProvider) {
         id: "cache",
         name: "settings.storage.cache.statsCache.name",
         description: "settings.storage.cache.statsCache.description",
-        path: pathProvider.getCacheDir(),
+        path: pp.getCacheDir(),
         icon: "i-heroicons-bolt",
         canClear: true
       },
@@ -1712,7 +1688,7 @@ function registerCacheRoutes(server2, pathProvider) {
         id: "logs",
         name: "settings.storage.cache.logs.name",
         description: "settings.storage.cache.logs.description",
-        path: pathProvider.getLogsDir(),
+        path: pp.getLogsDir(),
         icon: "i-heroicons-document-text",
         canClear: true
       }
@@ -1720,12 +1696,11 @@ function registerCacheRoutes(server2, pathProvider) {
     const results = await Promise.all(
       directories.map(async (dir) => {
         const [size, fileCount] = await Promise.all([getDirSize(dir.path), getFileCount(dir.path)]);
-        return { ...dir, size, fileCount, exists: fs6.existsSync(dir.path) };
+        return { ...dir, size, fileCount, exists: fs2.existsSync(dir.path) };
       })
     );
     return {
-      baseDir: pathProvider.getUserDataDir(),
-      systemDir: pathProvider.getSystemDir(),
+      baseDir: pp.getUserDataDir(),
       directories: results,
       totalSize: results.reduce((sum, d) => sum + d.size, 0)
     };
@@ -1733,15 +1708,15 @@ function registerCacheRoutes(server2, pathProvider) {
   server2.post("/_web/cache/clear", async (request) => {
     const { cacheId } = request.body;
     const allowedDirs = {
-      cache: pathProvider.getCacheDir(),
-      logs: pathProvider.getLogsDir()
+      cache: pp.getCacheDir(),
+      logs: pp.getLogsDir()
     };
     const dirPath = allowedDirs[cacheId];
     if (!dirPath) return { success: false, error: "Not allowed to clear this directory" };
-    if (!fs6.existsSync(dirPath)) return { success: true };
+    if (!fs2.existsSync(dirPath)) return { success: true };
     const files = await fsp.readdir(dirPath);
     for (const file of files) {
-      const filePath = path5.join(dirPath, file);
+      const filePath = path3.join(dirPath, file);
       const stat2 = await fsp.stat(filePath);
       if (stat2.isDirectory()) {
         await fsp.rm(filePath, { recursive: true });
@@ -1751,37 +1726,32 @@ function registerCacheRoutes(server2, pathProvider) {
     }
     return { success: true };
   });
-  server2.post("/_web/cache/open-dir", async (request) => {
-    const { cacheId } = request.body;
-    const dirPaths = {
-      base: pathProvider.getUserDataDir(),
-      system: pathProvider.getSystemDir(),
-      databases: pathProvider.getDatabaseDir(),
-      cache: pathProvider.getCacheDir(),
-      ai: pathProvider.getAiDataDir(),
-      logs: pathProvider.getLogsDir(),
-      downloads: downloadsDir
+  server2.get("/_web/cache/data-dir", async () => {
+    const pending = ctx.getPendingDataDirMigration?.();
+    return {
+      path: pp.getUserDataDir(),
+      defaultPath: ctx.defaultUserDataDir,
+      isCustom: ctx.isCustomDataDir ?? false,
+      canSetDataDir: ctx.canSetDataDir ?? Boolean(ctx.setDataDir),
+      hasLegacyDataAtDefaultDir: Boolean(ctx.defaultUserDataDir) && path3.resolve(pp.getUserDataDir()) !== path3.resolve(ctx.defaultUserDataDir ?? "") && hasChatLabDatabases(ctx.defaultUserDataDir ?? ""),
+      pendingMigration: pending ? {
+        from: pending.from,
+        to: pending.to,
+        createdAt: pending.createdAt
+      } : void 0
     };
-    const dirPath = dirPaths[cacheId];
-    if (!dirPath) return { success: false, error: "Unknown directory" };
-    if (!fs6.existsSync(dirPath)) {
-      await fsp.mkdir(dirPath, { recursive: true });
-    }
-    try {
-      await openDirectoryPath(dirPath);
-    } catch (error) {
-      return { success: false, error: error instanceof Error ? error.message : String(error) };
-    }
-    return { success: true };
   });
-  server2.get("/_web/cache/data-dir", async () => {
-    const config = loadConfig();
-    const isCustom = Boolean(config.data.user_data_dir || process.env.CHATLAB_DATA_DIR);
-    return { path: pathProvider.getUserDataDir(), isCustom };
+  server2.post("/_web/cache/data-dir", async (request, reply) => {
+    if (!ctx.setDataDir) {
+      return reply.code(501).send({ success: false, error: "Data directory changes are not supported" });
+    }
+    const targetPath = typeof request.body?.path === "string" ? request.body.path : null;
+    const migrate = request.body?.migrate !== false;
+    return ctx.setDataDir(targetPath, migrate);
   });
   server2.get("/_web/cache/latest-import-log", async () => {
-    const importLogDir = path5.join(pathProvider.getLogsDir(), "import");
-    if (!fs6.existsSync(importLogDir)) {
+    const importLogDir = path3.join(pp.getLogsDir(), "import");
+    if (!fs2.existsSync(importLogDir)) {
       return { success: false, error: "Log directory not found" };
     }
     const files = await fsp.readdir(importLogDir);
@@ -1791,7 +1761,7 @@ function registerCacheRoutes(server2, pathProvider) {
     }
     const fileStats = await Promise.all(
       logFiles.map(async (f) => {
-        const filePath = path5.join(importLogDir, f);
+        const filePath = path3.join(importLogDir, f);
         const stat2 = await fsp.stat(filePath);
         return { name: f, path: filePath, mtime: stat2.mtime.getTime() };
       })
@@ -1804,898 +1774,1012 @@ function registerCacheRoutes(server2, pathProvider) {
     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 });
+    let buffer;
+    if (dataUrl.includes(";base64,")) {
+      const base64Data = dataUrl.split(";base64,")[1];
+      buffer = Buffer.from(base64Data, "base64");
+    } else if (dataUrl.includes("charset=utf-8,")) {
+      const textData = dataUrl.split("charset=utf-8,")[1];
+      buffer = Buffer.from(decodeURIComponent(textData), "utf-8");
+    } else {
+      const base64Data = dataUrl.replace(/^data:[^,]+,/, "");
+      buffer = Buffer.from(base64Data, "base64");
+    }
+    if (!fs2.existsSync(downloadsDir)) {
+      fs2.mkdirSync(downloadsDir, { recursive: true });
     }
-    const filePath = path5.join(downloadsDir, filename);
-    fs6.writeFileSync(filePath, buffer);
+    const filePath = path3.join(downloadsDir, filename);
+    fs2.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" };
-    }
-    try {
-      await showPathInFolder(filePath);
-    } catch (error) {
-      return { success: false, error: error instanceof Error ? error.message : String(error) };
-    }
+  server2.post("/_web/cache/open-dir", async (request, reply) => {
+    if (!ctx.openDirectory) return reply.code(501).send({ success: false, error: "Not supported" });
+    const { cacheId } = request.body;
+    const dirPaths = {
+      base: pp.getUserDataDir(),
+      databases: pp.getDatabaseDir(),
+      cache: pp.getCacheDir(),
+      ai: pp.getAiDataDir(),
+      logs: pp.getLogsDir(),
+      downloads: downloadsDir
+    };
+    const dirPath = dirPaths[cacheId];
+    if (!dirPath) return { success: false, error: "Unknown directory" };
+    if (!fs2.existsSync(dirPath)) {
+      await fsp.mkdir(dirPath, { recursive: true });
+    }
+    try {
+      await ctx.openDirectory(dirPath);
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
     return { success: true };
   });
-}
-
-// src/http/routes/web/index.ts
-function isNewerVersion(latest, current) {
-  const parse = (v) => {
-    const [core, pre] = v.split("-", 2);
-    const parts = core.split(".").map(Number);
-    return { major: parts[0] || 0, minor: parts[1] || 0, patch: parts[2] || 0, pre };
-  };
-  const l = parse(latest);
-  const c = parse(current);
-  if (l.major !== c.major) return l.major > c.major;
-  if (l.minor !== c.minor) return l.minor > c.minor;
-  if (l.patch !== c.patch) return l.patch > c.patch;
-  if (c.pre && !l.pre) return true;
-  return false;
-}
-function registerWebRoutes(server2, dbManager2, options) {
-  const adapter = createDatabaseManagerAdapter(dbManager2);
-  const mergeCache = options?.pathProvider ? new MergeSessionCache(options.pathProvider, { nativeBinding: options.nativeBinding }) : null;
-  mergeCache?.cleanupOrphans();
-  const fallbackPathProvider = {
-    getSystemDir: () => path6.join(os3.homedir(), ".chatlab"),
-    getUserDataDir: () => path6.join(os3.homedir(), ".chatlab", "data"),
-    getDatabaseDir: () => path6.join(os3.homedir(), ".chatlab", "data", "databases"),
-    getAiDataDir: () => path6.join(os3.homedir(), ".chatlab", "ai"),
-    getSettingsDir: () => path6.join(os3.homedir(), ".chatlab", "settings"),
-    getCacheDir: () => path6.join(os3.homedir(), ".chatlab", "cache"),
-    getTempDir: () => path6.join(os3.homedir(), ".chatlab", "temp"),
-    getLogsDir: () => path6.join(os3.homedir(), ".chatlab", "logs"),
-    getDownloadsDir: () => path6.join(os3.homedir(), "Downloads")
-  };
-  const resolvedPathProvider = options?.pathProvider ?? fallbackPathProvider;
-  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, resolvedPathProvider);
-  server2.get("/_web/system/check-update", async () => {
-    const currentVersion = getVersion();
-    const packageName = "chatlab-cli";
+  server2.post("/_web/cache/show-in-folder", async (request, reply) => {
+    if (!ctx.showInFolder) return reply.code(501).send({ success: false, error: "Not supported" });
+    const { filePath } = request.body;
+    if (!filePath) return { success: false, error: "filePath is required" };
     try {
-      const resp = await fetch(`https://registry.npmjs.org/${packageName}/latest`, {
-        headers: { Accept: "application/json" },
-        signal: AbortSignal.timeout(1e4)
-      });
-      if (!resp.ok) {
-        return { hasUpdate: false, currentVersion, error: `npm registry HTTP ${resp.status}` };
-      }
-      const data = await resp.json();
-      const latestVersion = data.version || currentVersion;
-      const hasUpdate = isNewerVersion(latestVersion, currentVersion);
-      return { hasUpdate, currentVersion, latestVersion };
-    } catch (err) {
-      return {
-        hasUpdate: false,
-        currentVersion,
-        error: err instanceof Error ? err.message : String(err)
-      };
+      await ctx.showInFolder(filePath);
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : String(error) };
     }
+    return { success: true };
   });
 }
 
-// src/http/routes/nlp.ts
-import * as path7 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 = path7.join(pathProvider.getSystemDir(), "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 path7.join(pathProvider.getSystemDir(), "nlp");
+// ../../packages/http-routes/src/register.ts
+function registerSharedRoutes(server2, ctx, options) {
+  registerSystemRoutes(server2, ctx);
+  registerRestSessionRoutes(server2, ctx);
+  registerSessionRoutes(server2, ctx);
+  registerMemberRoutes(server2, ctx);
+  registerPreferencesRoutes(server2, ctx);
+  registerAnalyticsRoutes(server2, ctx);
+  registerSqlRoutes(server2, ctx);
+  registerSessionIndexRoutes(server2, ctx);
+  registerExportRoutes(server2, ctx);
+  registerNlpRoutes(server2, ctx);
+  if (options?.requireAi) {
+    const missing = [];
+    if (!ctx.aiDataDir) missing.push("aiDataDir");
+    if (!ctx.conversationManager) missing.push("conversationManager");
+    if (!ctx.assistantManager) missing.push("assistantManager");
+    if (!ctx.skillManagerCore) missing.push("skillManagerCore");
+    if (!ctx.llmConfigStore) missing.push("llmConfigStore");
+    if (!ctx.customProviderStore) missing.push("customProviderStore");
+    if (!ctx.customModelStore) missing.push("customModelStore");
+    if (!ctx.runAgentStream) missing.push("runAgentStream");
+    if (missing.length > 0) {
+      throw new Error(`[http-routes] requireAi is set but missing AI dependencies: ${missing.join(", ")}`);
+    }
+  }
+  registerAiAssistantRoutes(server2, ctx);
+  registerAiSkillRoutes(server2, ctx);
+  registerAiLlmRoutes(server2, ctx);
+  registerAiLlmStreamRoutes(server2, ctx);
+  registerAiAgentStreamRoutes(server2, ctx);
+  registerAiFilterRoutes(server2, ctx);
+  registerAiToolRoutes(server2, ctx);
+  registerAiConversationRoutes(server2, ctx);
+  registerAiSummaryRoutes(server2, ctx);
+  registerMergeRoutes(server2, ctx);
+  registerCacheRoutes(server2, ctx);
 }
 
-// src/http/routes/ai.ts
-import * as fs10 from "fs";
-import * as path11 from "path";
-
-// src/ai/logger.ts
-var logger = null;
-function initServerAiLogger(logsDir) {
-  if (!logger) {
-    logger = new AiLogger(logsDir);
-  }
-  return logger;
+// ../../packages/http-routes/src/auth.ts
+import { timingSafeEqual, createHmac, randomBytes } from "crypto";
+var cachedToken = null;
+var requireAuthEnabled = false;
+function setAuthToken(token) {
+  cachedToken = token;
 }
-function getServerAiLogger() {
-  return logger;
+function setRequireAuth(enabled) {
+  requireAuthEnabled = enabled;
 }
-function closeServerAiLogger() {
-  if (logger) {
-    logger.close();
-    logger = null;
+var hmacKey = randomBytes(32);
+function safeTokenCompare(a, b) {
+  const hashA = createHmac("sha256", hmacKey).update(a).digest();
+  const hashB = createHmac("sha256", hmacKey).update(b).digest();
+  return timingSafeEqual(hashA, hashB);
+}
+async function authHook(request, reply) {
+  if (!cachedToken) return;
+  const url = request.url;
+  if (url.startsWith("/api/")) {
+    return requireBearerToken(request, reply);
+  }
+  if (url.startsWith("/_web/")) {
+    if (requireAuthEnabled) return requireBearerToken(request, reply);
+    return;
   }
 }
-
-// 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 };
+function requireBearerToken(request, reply) {
+  if (!cachedToken) 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;
   }
-  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 toolParams = params && typeof params === "object" ? 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(toolParams, 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/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/ai/assistant-loader.ts
-import * as fs7 from "fs";
-import * as path8 from "path";
-function loadAssistantConfig(aiDataDir, assistantId) {
-  const filePath = path8.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/http/routes/web/index.ts
+import * as os3 from "os";
+import * as path6 from "path";
+
+// src/http/routes/web/import.ts
+import * as fs4 from "fs";
+import * as os2 from "os";
+import * as path4 from "path";
+
+// src/http/routes/web/helpers.ts
+import * as fs3 from "fs";
+function resolveNativeBinding() {
+  if (process.versions.electron) return void 0;
+  const nativePath = resolveCliPath("native/better_sqlite3.node");
+  if (fs3.existsSync(nativePath)) return nativePath;
+  return void 0;
 }
 
-// src/ai/manager-factory.ts
-import * as fs8 from "fs";
-import * as path9 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 path9.join(...parts);
-  }
-};
-var managerCache = /* @__PURE__ */ new Map();
-function getAssistantManager(aiDataDir) {
-  let cached = managerCache.get(aiDataDir);
-  if (!cached) {
-    cached = {
-      assistant: new AssistantManager({
-        fs: nodeFs,
-        assistantsDir: path9.join(aiDataDir, "assistants"),
-        builtinRawConfigs: [],
-        generateId: () => `custom_${randomUUID3().replace(/-/g, "").slice(0, 12)}`
-      }),
-      skill: new SkillManagerCore({
-        fs: nodeFs,
-        skillsDir: path9.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);
+// src/http/routes/web/import.ts
+var DEMO_BASE_URL = "https://chatlab.fun/assets/demo";
+function cleanupTemp(...paths) {
+  for (const p of paths) {
+    try {
+      const stat2 = fs4.statSync(p);
+      if (stat2.isDirectory()) {
+        fs4.rmSync(p, { recursive: true, force: true });
+      } else {
+        fs4.unlinkSync(p);
+      }
+    } catch {
+    }
   }
-  return cached.skill;
 }
-
-// src/ai/agent.ts
-async function runServerAgent(options) {
-  const {
-    userMessage,
-    conversationId,
-    historyLeafMessageId,
-    chatType = "group",
-    locale = "zh-CN",
-    assistantSystemPrompt,
-    skillMenu,
-    compressionConfig,
-    tools = [],
-    aiDataDir,
-    convManager: convManager2,
-    onEvent,
-    abortSignal,
-    ownerInfo,
-    mentionedMembers,
-    dataSnapshot,
-    thinkingLevel
-  } = 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
+function registerImportRoutes(server2, dbManager2) {
+  server2.get("/_web/supported-formats", async () => {
+    return getSupportedFormats();
   });
-  const handler = new AgentEventHandler({
-    onChunk: onEvent,
-    context: {},
-    systemPrompt
+  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(os2.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);
+    }
   });
-  if (compressionConfig?.enabled && historyLeafMessageId === void 0) {
-    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()
-        }
-      });
+  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(os2.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);
     }
-  } else if (compressionConfig?.enabled && historyLeafMessageId !== void 0) {
-    aiLogger?.info?.("Compression", "Skipping compression for edited branch request", {
-      conversationId,
-      historyLeafMessageId
+  });
+  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(os2.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"
     });
-  }
-  if (abortSignal?.aborted) {
-    handler.emitStatus("aborted", [], { force: true });
-    onEvent({ type: "done", isFinished: true, usage: handler.cloneUsage() });
-    return;
-  }
-  let history = [];
-  try {
-    history = convManager2.getHistoryForAgent(conversationId, void 0, historyLeafMessageId);
-  } 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,
-      thinkingLevel,
-      onConvertToLlm: (filteredMessages) => {
-        cachedMessages = filteredMessages;
-      },
-      onEvent: (coreEvent) => handler.handleCoreEvent(coreEvent, cachedMessages),
-      onDebugContext: (messages) => {
-        try {
-          convManager2.setPendingDebugContext(conversationId, JSON.stringify(messages, null, 2));
-        } catch {
-        }
+    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 });
       }
-    });
-    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 path10 from "path";
-import { randomUUID as randomUUID4 } from "crypto";
-function readProviders(aiDataDir) {
-  const storePath = path10.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 = path10.join(aiDataDir, "custom-providers.json");
-  const dir = path10.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 = path10.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 = path10.join(aiDataDir, "custom-models.json");
-  const dir = path10.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-config-display.ts
-var NO_KEY_PLACEHOLDER = "sk-no-key-required";
-function hasRealApiKey(apiKey) {
-  return !!apiKey && apiKey !== NO_KEY_PLACEHOLDER;
-}
-function toLlmConfigDisplay(config, resolveApiKey2) {
-  const { apiKey: _rawApiKey, ...rest } = config;
-  const provider = typeof config.provider === "string" ? config.provider : "";
-  const authProfile = typeof config.authProfile === "string" ? config.authProfile : void 0;
-  const resolvedApiKey = provider ? resolveApiKey2(provider, authProfile) : "";
-  return {
-    ...rest,
-    apiKey: "",
-    apiKeySet: hasRealApiKey(resolvedApiKey || "")
-  };
-}
-
-// 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 = path11.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;
+    } catch (err) {
+      sendEvent("error", { success: false, error: err instanceof Error ? err.message : String(err) });
+    } finally {
+      reply.raw.end();
+      cleanupTemp(tmpPath, tmpDir);
     }
   });
-  server2.get("/_web/ai/llm/configs", async () => {
-    const configPath = path11.join(getAiDir(dbManager2), "llm-config.json");
-    if (!fs10.existsSync(configPath)) return { configs: [], defaultAssistant: null, fastModel: null };
+  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(os2.tmpdir(), "chatlab-dir-import-"));
+    const relativePaths = [];
+    const fileBuffers = [];
     try {
-      const data = JSON.parse(fs10.readFileSync(configPath, "utf-8"));
-      const configs = (data.configs || []).map((c) => toLlmConfigDisplay(c, resolveApiKey));
-      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 }))
+      let sendEvent2 = function(event, eventData) {
+        reply.raw.write(`event: ${event}
+data: ${JSON.stringify(eventData)}
+
+`);
       };
-    });
-  });
-  server2.get("/_web/ai/llm/provider-registry", async () => {
-    const customPath = path11.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 = [];
+      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 || "" });
+        }
       }
-    }
-    return [...BUILTIN_PROVIDERS, ...custom];
-  });
-  server2.get("/_web/ai/llm/model-catalog", async () => {
-    const customPath = path11.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 = [];
+      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);
     }
-    return [...BUILTIN_MODELS, ...custom];
-  });
-  server2.get("/_web/ai/llm/default-assistant-slot", async () => {
-    const configPath = path11.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 = path11.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" });
+  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(os2.tmpdir(), "chatlab-inc-"));
+    const tmpPath = path4.join(tmpDir, data.filename || "upload");
+    const chunks = [];
+    for await (const chunk of data.file) {
+      chunks.push(chunk);
     }
-    const piModel = buildPiModel2(llmConfig);
+    fs4.writeFileSync(tmpPath, Buffer.concat(chunks));
     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)}
+    function sendEvent(event, eventData) {
+      reply.raw.write(`event: ${event}
+data: ${JSON.stringify(eventData)}
 
 `);
-    };
+    }
     try {
-      await runSimpleLlmStream({
-        messages,
-        apiKey: llmConfig.apiKey,
-        piModel,
-        temperature: options?.temperature,
-        maxTokens: options?.maxTokens,
-        onChunk: sendChunk
+      const result = await incrementalImport(dbManager2, sessionId, tmpPath, {
+        onProgress: (p) => sendEvent("progress", p)
       });
-    } catch (error) {
-      const msg = error instanceof Error ? error.message : String(error);
-      sendChunk({ content: "", isFinished: true, finishReason: "error", error: msg });
+      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);
     }
-    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.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(os2.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.delete("/_web/ai/conversations/:id", async (request) => {
-    return convManager2.deleteConversation(request.params.id);
+  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(os2.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/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
-    );
+  const DEMO_FILES = [
+    "demo-group.json",
+    "demo-private-A-cuilan.json",
+    "demo-private-B-wukong.json",
+    "demo-private-C-spider.json"
+  ];
+  server2.post("/_web/demo/import", async (request, reply) => {
+    const locale = request.body?.locale || "en";
+    const nativeBinding = resolveNativeBinding();
+    const total = DEMO_FILES.length;
+    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(os2.tmpdir(), "chatlab-demo-"));
+    try {
+      const localPaths = [];
+      for (let i = 0; i < total; i++) {
+        sendEvent("progress", { stage: "downloading", current: i + 1, total });
+        const localPath = path4.join(tmpDir, DEMO_FILES[i]);
+        const resp = await fetch(`${DEMO_BASE_URL}/${locale}/${DEMO_FILES[i]}`, {
+          signal: AbortSignal.timeout(6e4)
+        });
+        if (!resp.ok) throw new Error(`Download demo failed (${DEMO_FILES[i]}): ${resp.status}`);
+        fs4.writeFileSync(localPath, Buffer.from(await resp.arrayBuffer()));
+        localPaths.push(localPath);
+      }
+      sendEvent("progress", { stage: "importing", current: 1, total });
+      const groupResult = await streamImport(dbManager2, localPaths[0], { nativeBinding });
+      if (!groupResult.success) throw new Error(groupResult.error || "Failed to import group demo");
+      const privateSessionIds = [];
+      for (let i = 1; i < localPaths.length; i++) {
+        sendEvent("progress", { stage: "importing", current: i + 1, total });
+        const result = await streamImport(dbManager2, localPaths[i], { nativeBinding });
+        if (!result.success) throw new Error(result.error || `Failed to import private demo: ${DEMO_FILES[i]}`);
+        if (result.sessionId) privateSessionIds.push(result.sessionId);
+      }
+      sendEvent("progress", { stage: "done", current: total, total });
+      sendEvent("result", {
+        success: true,
+        groupSessionId: groupResult.sessionId,
+        privateSessionIds
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      sendEvent("progress", { stage: "error", current: 0, total, message });
+      sendEvent("result", { success: false, error: message });
+    } finally {
+      reply.raw.end();
+      cleanupTemp(tmpDir);
+    }
   });
-  server2.get("/_web/ai/conversations/:id/messages", async (request) => {
-    return convManager2.getMessages(request.params.id);
+}
+
+// src/http/routes/web/cache.ts
+import * as path5 from "path";
+import { execFile } from "child_process";
+function runExecFile(file, args, runner = execFile) {
+  return new Promise((resolve4, reject) => {
+    runner(file, args, (error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve4();
+    });
   });
-  server2.post("/_web/ai/conversations/:id/messages/:messageId/delete-from", async (request, reply) => {
-    const { id, messageId } = request.params;
-    if (!id || typeof id !== "string" || !messageId || typeof messageId !== "string") {
-      return reply.code(400).send({ error: "conversation id and messageId are required" });
+}
+async function openDirectoryPath(dirPath, platform = process.platform, runner) {
+  if (platform === "darwin") {
+    await runExecFile("open", [dirPath], runner);
+  } else if (platform === "win32") {
+    await runExecFile("explorer.exe", [dirPath], runner);
+  } else {
+    await runExecFile("xdg-open", [dirPath], runner);
+  }
+}
+async function showPathInFolder(filePath, platform = process.platform, runner) {
+  if (platform === "darwin") {
+    await runExecFile("open", ["-R", filePath], runner);
+  } else if (platform === "win32") {
+    await runExecFile("explorer.exe", [`/select,${filePath}`], runner);
+  } else {
+    await runExecFile("xdg-open", [path5.dirname(filePath)], runner);
+  }
+}
+
+// src/http/routes/web/index.ts
+function isNewerVersion(latest, current) {
+  const parse = (v) => {
+    const [core, pre] = v.split("-", 2);
+    const parts = core.split(".").map(Number);
+    return { major: parts[0] || 0, minor: parts[1] || 0, patch: parts[2] || 0, pre };
+  };
+  const l = parse(latest);
+  const c = parse(current);
+  if (l.major !== c.major) return l.major > c.major;
+  if (l.minor !== c.minor) return l.minor > c.minor;
+  if (l.patch !== c.patch) return l.patch > c.patch;
+  if (c.pre && !l.pre) return true;
+  return false;
+}
+function registerWebRoutes(server2, dbManager2, options) {
+  const adapter = createDatabaseManagerAdapter(dbManager2);
+  const mergeCache = options?.pathProvider ? new MergeSessionCache(options.pathProvider, { nativeBinding: options.nativeBinding }) : null;
+  mergeCache?.cleanupOrphans();
+  const fallbackPathProvider = {
+    getSystemDir: () => path6.join(os3.homedir(), ".chatlab"),
+    getUserDataDir: () => path6.join(os3.homedir(), ".chatlab", "data"),
+    getDatabaseDir: () => path6.join(os3.homedir(), ".chatlab", "data", "databases"),
+    getAiDataDir: () => path6.join(os3.homedir(), ".chatlab", "ai"),
+    getSettingsDir: () => path6.join(os3.homedir(), ".chatlab", "settings"),
+    getCacheDir: () => path6.join(os3.homedir(), ".chatlab", "cache"),
+    getTempDir: () => path6.join(os3.homedir(), ".chatlab", "temp"),
+    getLogsDir: () => path6.join(os3.homedir(), ".chatlab", "logs"),
+    getDownloadsDir: () => path6.join(os3.homedir(), "Downloads")
+  };
+  const resolvedPathProvider = options?.pathProvider ?? fallbackPathProvider;
+  const ai = options?.aiContext;
+  const cliStreamImport = async (dm, filePath) => {
+    const { streamImport: streamImport2 } = await import("./stream-import-RDDB3N7B.mjs");
+    const result = await streamImport2(dm, filePath);
+    if (!result.sessionId) throw new Error("Import succeeded but no sessionId returned");
+    return { sessionId: result.sessionId };
+  };
+  const defaultUserDataDir = getDefaultNodeUserDataDir();
+  const isCustom = path6.resolve(resolvedPathProvider.getUserDataDir()) !== path6.resolve(defaultUserDataDir);
+  registerSharedRoutes(
+    server2,
+    {
+      dbManager: dbManager2,
+      sessionAdapter: adapter,
+      pathProvider: resolvedPathProvider,
+      getVersion,
+      nativeBinding: options?.nativeBinding,
+      openDirectory: openDirectoryPath,
+      showInFolder: showPathInFolder,
+      downloadsDir: resolvedPathProvider.getDownloadsDir(),
+      defaultUserDataDir,
+      isCustomDataDir: isCustom,
+      canSetDataDir: !process.env.CHATLAB_DATA_DIR,
+      getPendingDataDirMigration: () => getPendingNodeDataDirMigration(resolvedPathProvider.getSystemDir()),
+      setDataDir: (dirPath, migrate) => createNodeDataDirSwitch({
+        systemDir: resolvedPathProvider.getSystemDir(),
+        currentDir: resolvedPathProvider.getUserDataDir(),
+        targetDir: dirPath,
+        defaultDir: defaultUserDataDir,
+        migrate,
+        envDataDir: process.env.CHATLAB_DATA_DIR
+      }),
+      ...mergeCache && {
+        mergeSessionCache: mergeCache,
+        streamImport: cliStreamImport
+      },
+      ...ai && {
+        aiDataDir: ai.aiDataDir,
+        conversationManager: ai.convManager,
+        assistantManager: ai.assistantManager,
+        skillManagerCore: ai.skillManagerCore,
+        llmConfigStore: ai.llmConfigStore,
+        customProviderStore: ai.customProviderStore,
+        customModelStore: ai.customModelStore,
+        runAgentStream: ai.runAgentStream
+      }
+    },
+    ai ? { requireAi: true } : void 0
+  );
+  registerImportRoutes(server2, dbManager2);
+  server2.get("/_web/system/check-update", async () => {
+    const currentVersion = getVersion();
+    const packageName = "chatlab-cli";
+    try {
+      const resp = await fetch(`https://registry.npmjs.org/${packageName}/latest`, {
+        headers: { Accept: "application/json" },
+        signal: AbortSignal.timeout(1e4)
+      });
+      if (!resp.ok) {
+        return { hasUpdate: false, currentVersion, error: `npm registry HTTP ${resp.status}` };
+      }
+      const data = await resp.json();
+      const latestVersion = data.version || currentVersion;
+      const hasUpdate = isNewerVersion(latestVersion, currentVersion);
+      return { hasUpdate, currentVersion, latestVersion };
+    } catch (err) {
+      return {
+        hasUpdate: false,
+        currentVersion,
+        error: err instanceof Error ? err.message : String(err)
+      };
     }
-    convManager2.deleteMessagesFrom(id, messageId);
-    return { success: true };
   });
-  server2.post("/_web/ai/conversations/:id/fork", async (request, reply) => {
-    const { upToMessageId, title } = request.body;
-    if (!upToMessageId || typeof upToMessageId !== "string") {
-      return reply.code(400).send({ error: "upToMessageId is required" });
+}
+
+// src/http/routes/proxy.ts
+var PROXY_TARGET = "https://chatlab.fun";
+function registerProxyRoutes(server2) {
+  server2.get("/_proxy/chatlab.fun/*", async (request, reply) => {
+    const subPath = request.params["*"] ?? "";
+    const queryString = new URLSearchParams(
+      request.query
+    ).toString();
+    const targetUrl = queryString ? `${PROXY_TARGET}/${subPath}?${queryString}` : `${PROXY_TARGET}/${subPath}`;
+    try {
+      const upstream = await fetch(targetUrl, {
+        headers: { Accept: request.headers.accept ?? "*/*" },
+        signal: AbortSignal.timeout(1e4)
+      });
+      const contentType = upstream.headers.get("content-type") ?? "application/octet-stream";
+      const body = Buffer.from(await upstream.arrayBuffer());
+      reply.code(upstream.status).header("content-type", contentType).send(body);
+    } catch (err) {
+      reply.code(502).send({
+        error: "Proxy error",
+        message: err instanceof Error ? err.message : String(err)
+      });
     }
-    return convManager2.forkConversation(request.params.id, upToMessageId, title);
   });
-  server2.put("/_web/ai/messages/:messageId/content", async (request, reply) => {
-    const { content } = request.body;
-    if (!content || typeof content !== "string") {
-      return reply.code(400).send({ error: "content is required" });
+}
+
+// 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/manager-factory.ts
+import * as fs5 from "fs";
+import * as path7 from "path";
+import { createHash, randomUUID } from "crypto";
+var nodeFs = {
+  ensureDir(dir) {
+    if (!fs5.existsSync(dir)) fs5.mkdirSync(dir, { recursive: true });
+  },
+  listFiles(dir, ext) {
+    if (!fs5.existsSync(dir)) return [];
+    return fs5.readdirSync(dir).filter((f) => f.endsWith(ext));
+  },
+  readFile(filePath) {
+    return fs5.readFileSync(filePath, "utf-8");
+  },
+  writeFile(filePath, content) {
+    fs5.writeFileSync(filePath, content, "utf-8");
+  },
+  deleteFile(filePath) {
+    if (fs5.existsSync(filePath)) fs5.unlinkSync(filePath);
+  },
+  fileExists(filePath) {
+    return fs5.existsSync(filePath);
+  },
+  joinPath(...parts) {
+    return path7.join(...parts);
+  }
+};
+var managerCache = /* @__PURE__ */ new Map();
+function getAssistantManager(aiDataDir) {
+  let cached = managerCache.get(aiDataDir);
+  if (!cached) {
+    cached = {
+      assistant: new AssistantManager({
+        fs: nodeFs,
+        assistantsDir: path7.join(aiDataDir, "assistants"),
+        builtinRawConfigs: [],
+        generateId: () => `custom_${randomUUID().replace(/-/g, "").slice(0, 12)}`
+      }),
+      skill: new SkillManagerCore({
+        fs: nodeFs,
+        skillsDir: path7.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/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 toolParams = params && typeof params === "object" ? 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(toolParams, 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 };
+      }
     }
-    convManager2.updateMessageContent(request.params.messageId, content);
-    return { success: true };
+  }));
+}
+
+// src/ai/llm-config.ts
+import * as fs6 from "fs";
+import * as path8 from "path";
+function loadLlmConfig(aiDataDir) {
+  const configPath = path8.join(aiDataDir, "llm-config.json");
+  if (!fs6.existsSync(configPath)) {
+    return { configs: [], defaultAssistant: null, fastModel: null };
+  }
+  try {
+    const data = JSON.parse(fs6.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 };
+}
+function buildPiModel2(config) {
+  return buildPiModel(config);
+}
+
+// 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/agent.ts
+async function runServerAgent(options) {
+  const {
+    userMessage,
+    conversationId,
+    historyLeafMessageId,
+    chatType = "group",
+    locale = "zh-CN",
+    assistantSystemPrompt,
+    skillMenu,
+    skillDef,
+    compressionConfig,
+    tools = [],
+    aiDataDir,
+    convManager: convManager2,
+    onEvent,
+    abortSignal,
+    ownerInfo,
+    mentionedMembers,
+    dataSnapshot,
+    thinkingLevel
+  } = options;
+  const aiLogger = getServerAiLogger();
+  await initTokenizer();
+  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 (skillDef) {
+    skillCtx = { skillDef };
+  } else if (skillMenu) {
+    skillCtx = { skillMenu };
+  }
+  const systemPrompt = buildSystemPrompt({
+    t,
+    chatType,
+    assistantSystemPrompt,
+    ownerInfo,
+    locale,
+    skillCtx,
+    mentionedMembers,
+    dataSnapshot
   });
-  server2.post("/_web/ai/conversations/:id/messages/:messageId/delete-relink", async (request, reply) => {
-    const { id, messageId } = request.params;
-    if (!id || !messageId) {
-      return reply.code(400).send({ error: "conversation id and messageId are required" });
+  const handler = new AgentEventHandler({
+    onChunk: onEvent,
+    context: {},
+    systemPrompt
+  });
+  if (compressionConfig?.enabled && historyLeafMessageId === void 0) {
+    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()
+        }
+      });
     }
-    convManager2.deleteAndRelinkMessage(id, messageId);
-    return { success: true };
-  });
-  server2.post("/_web/ai/conversations/:id/messages/insert-after", async (request, reply) => {
-    const { afterMessageId, role, content, contentBlocks, tokenUsage } = request.body;
-    if (!afterMessageId || typeof afterMessageId !== "string") {
-      return reply.code(400).send({ error: "afterMessageId is required" });
+  } else if (compressionConfig?.enabled && historyLeafMessageId !== void 0) {
+    aiLogger?.info?.("Compression", "Skipping compression for edited branch request", {
+      conversationId,
+      historyLeafMessageId
+    });
+  }
+  if (abortSignal?.aborted) {
+    handler.emitStatus("aborted", [], { force: true });
+    onEvent({ type: "done", isFinished: true, usage: handler.cloneUsage() });
+    return;
+  }
+  let history = [];
+  try {
+    history = convManager2.getHistoryForAgent(conversationId, void 0, historyLeafMessageId);
+  } 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,
+      thinkingLevel,
+      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 } });
     }
-    return convManager2.insertMessageAfter(
-      request.params.id,
-      afterMessageId,
-      role,
-      content,
-      contentBlocks,
-      tokenUsage
-    );
-  });
-  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) => {
+    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/agent-stream-runner.ts
+function getAiDir(dbManager2) {
+  const pathProvider = dbManager2["pathProvider"];
+  if (!pathProvider) {
+    throw Object.assign(new Error("PathProvider not available"), { statusCode: 500 });
+  }
+  return pathProvider.getAiDataDir();
+}
+function createCliRunAgentStream(dbManager2, convManager2) {
+  return async (params, onEvent, abortSignal) => {
     const {
       userMessage,
       conversationId,
@@ -2704,27 +2788,13 @@ data: ${JSON.stringify(data)}
       chatType,
       locale,
       assistantId,
+      skillId,
+      enableAutoSkill,
       compressionConfig,
       ownerInfo,
       mentionedMembers,
       thinkingLevel
-    } = 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 });
+    } = params;
     const aiDataDir = getAiDir(dbManager2);
     let assistantSystemPrompt;
     if (assistantId) {
@@ -2739,191 +2809,73 @@ data: ${JSON.stringify(data)}
     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 skillMgr = new SkillManager(aiDataDir);
+    skillMgr.init();
     const toolNames = agentTools.map((t) => t.name);
-    const skillMenu = skillManager.getSkillMenu(chatType ?? "group", toolNames);
-    if (skillMenu) {
+    let resolvedSkillDef;
+    let resolvedSkillMenu;
+    if (skillId) {
+      const def = skillMgr.getSkillConfig(skillId);
+      if (def) resolvedSkillDef = { name: def.name, prompt: def.prompt };
+    } else if (enableAutoSkill) {
+      const menu = skillMgr.getSkillMenu(chatType ?? "group", toolNames);
+      if (menu) resolvedSkillMenu = menu;
+    }
+    if (resolvedSkillMenu) {
       const activateSkillTool = createActivateSkillTool({
         chatType: chatType ?? "group",
         allowedTools: toolNames,
         locale,
-        getSkillConfig: (id) => skillManager.getSkillConfig(id)
+        getSkillConfig: (id) => skillMgr.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,
-        historyLeafMessageId,
-        chatType,
-        locale,
-        assistantSystemPrompt,
-        skillMenu,
-        compressionConfig: resolvedCompression,
-        tools: agentTools,
-        aiDataDir,
-        convManager: convManager2,
-        onEvent,
-        abortSignal: abortController.signal,
-        ownerInfo,
-        mentionedMembers,
-        dataSnapshot,
-        thinkingLevel
-      });
-    } 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);
+    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 {
       }
-      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) };
-    }
-  });
-}
-
-// src/http/routes/proxy.ts
-var PROXY_TARGET = "https://chatlab.fun";
-function registerProxyRoutes(server2) {
-  server2.get("/_proxy/chatlab.fun/*", async (request, reply) => {
-    const subPath = request.params["*"] ?? "";
-    const queryString = new URLSearchParams(
-      request.query
-    ).toString();
-    const targetUrl = queryString ? `${PROXY_TARGET}/${subPath}?${queryString}` : `${PROXY_TARGET}/${subPath}`;
-    try {
-      const upstream = await fetch(targetUrl, {
-        headers: { Accept: request.headers.accept ?? "*/*" },
-        signal: AbortSignal.timeout(1e4)
-      });
-      const contentType = upstream.headers.get("content-type") ?? "application/octet-stream";
-      const body = Buffer.from(await upstream.arrayBuffer());
-      reply.code(upstream.status).header("content-type", contentType).send(body);
-    } catch (err) {
-      reply.code(502).send({
-        error: "Proxy error",
-        message: err instanceof Error ? err.message : String(err)
-      });
     }
-  });
+    await runServerAgent({
+      userMessage,
+      conversationId,
+      historyLeafMessageId,
+      chatType,
+      locale,
+      assistantSystemPrompt,
+      skillMenu: resolvedSkillMenu,
+      skillDef: resolvedSkillDef,
+      compressionConfig: resolvedCompression,
+      tools: agentTools,
+      aiDataDir,
+      convManager: convManager2,
+      onEvent,
+      abortSignal,
+      ownerInfo,
+      mentionedMembers,
+      dataSnapshot,
+      thinkingLevel
+    });
+  };
 }
 
 // ../../packages/sync/src/types.ts
@@ -2932,12 +2884,12 @@ 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 path12 from "path";
-import * as crypto2 from "crypto";
+import * as fs8 from "fs";
+import * as path10 from "path";
+import * as crypto from "crypto";
 var CONFIG_FILE = "data-sources.json";
 function generateId(prefix = "ds") {
-  return `${prefix}_${crypto2.randomBytes(6).toString("hex")}`;
+  return `${prefix}_${crypto.randomBytes(6).toString("hex")}`;
 }
 function normalizeBaseUrl(input) {
   let url = input.trim().replace(/\/+$/, "");
@@ -2961,17 +2913,17 @@ var DataSourceManager = class {
     this.logger = logger2 ?? NOOP_LOGGER;
   }
   getConfigPath() {
-    return path12.join(this.configDir, CONFIG_FILE);
+    return path10.join(this.configDir, CONFIG_FILE);
   }
   ensureDir() {
-    fs11.mkdirSync(this.configDir, { recursive: true });
+    fs8.mkdirSync(this.configDir, { recursive: true });
   }
   // ==================== Load / Save ====================
   loadAll() {
     try {
       const filePath = this.getConfigPath();
-      if (fs11.existsSync(filePath)) {
-        const raw = fs11.readFileSync(filePath, "utf-8");
+      if (fs8.existsSync(filePath)) {
+        const raw = fs8.readFileSync(filePath, "utf-8");
         const parsed = JSON.parse(raw);
         if (!isValidDataSourceArray(parsed)) {
           this.logger.warn("[DataSource] Incompatible config format detected, returning empty.");
@@ -2990,7 +2942,7 @@ var DataSourceManager = class {
   saveAll(sources) {
     try {
       this.ensureDir();
-      fs11.writeFileSync(this.getConfigPath(), JSON.stringify(sources, null, 2), "utf-8");
+      fs8.writeFileSync(this.getConfigPath(), JSON.stringify(sources, null, 2), "utf-8");
     } catch (err) {
       this.logger.error("[DataSource] Failed to save config", err);
     }
@@ -3115,8 +3067,8 @@ function parseRemoteSessionsResponse(body) {
 }
 
 // ../../packages/sync/src/pull-engine.ts
-import * as fs12 from "fs";
-import * as crypto3 from "crypto";
+import * as fs9 from "fs";
+import * as crypto2 from "crypto";
 var MAX_PAGES_PER_PULL = 5e3;
 var PULL_OVERLAP_SECONDS = 60;
 function buildPullUrl(baseUrl, remoteSessionId, params) {
@@ -3128,14 +3080,14 @@ function buildPullUrl(baseUrl, remoteSessionId, params) {
   return base + "?" + qs.join("&");
 }
 function deriveLocalSessionId(baseUrl, remoteSessionId) {
-  const hash = crypto3.createHash("sha256").update(`${baseUrl}\0${remoteSessionId}`).digest("hex").slice(0, 12);
+  const hash = crypto2.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 content = fs9.readFileSync(filePath, "utf-8");
       const lines = content.trimEnd().split("\n");
       for (let i = lines.length - 1; i >= Math.max(0, lines.length - 5); i--) {
         try {
@@ -3154,7 +3106,7 @@ function parseSyncFromFile(filePath) {
       }
       return null;
     }
-    const raw = fs12.readFileSync(filePath, "utf-8");
+    const raw = fs9.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.sync && typeof parsed.sync === "object") {
       const s = parsed.sync;
@@ -3168,7 +3120,7 @@ function parseSyncFromFile(filePath) {
 function fileContainsMessages(filePath) {
   try {
     if (filePath.endsWith(".jsonl")) {
-      const content = fs12.readFileSync(filePath, "utf-8");
+      const content = fs9.readFileSync(filePath, "utf-8");
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
         if (!trimmed) continue;
@@ -3181,7 +3133,7 @@ function fileContainsMessages(filePath) {
       }
       return false;
     }
-    const raw = fs12.readFileSync(filePath, "utf-8");
+    const raw = fs9.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed.messages) && parsed.messages.length > 0;
   } catch {
@@ -3190,7 +3142,7 @@ function fileContainsMessages(filePath) {
 }
 function cleanupTempFile(filePath) {
   try {
-    if (fs12.existsSync(filePath)) fs12.unlinkSync(filePath);
+    if (fs9.existsSync(filePath)) fs9.unlinkSync(filePath);
   } catch {
   }
 }
@@ -3250,7 +3202,7 @@ var PullEngine = class {
           limit: ds.pullLimit
         });
         try {
-          const stat2 = fs12.statSync(tempFile);
+          const stat2 = fs9.statSync(tempFile);
           this.logger.info(`[Pull] "${sess.name}" page ${pageCount}: fetched ${stat2.size} bytes`);
           const sync0 = parseSyncFromFile(tempFile);
           if (stat2.size < 1024) {
@@ -3268,7 +3220,7 @@ var PullEngine = class {
                   since,
                   limit: ds.pullLimit
                 });
-                const retryStat = fs12.statSync(retryFile);
+                const retryStat = fs9.statSync(retryFile);
                 this.logger.info(`[Pull] "${sess.name}" retry ${ri + 1}: fetched ${retryStat.size} bytes`);
                 const retrySync = parseSyncFromFile(retryFile);
                 if (retryStat.size < 1024 && !fileContainsMessages(retryFile) && retrySync?.hasMore === false) {
@@ -3542,13 +3494,13 @@ function reloadTimer(dsId, skipInitialPull = false) {
 }
 
 // src/sync/adapters.ts
-import * as fs13 from "fs";
+import * as fs10 from "fs";
 import * as os4 from "os";
-import * as path13 from "path";
-import * as crypto4 from "crypto";
+import * as path11 from "path";
+import * as crypto3 from "crypto";
 function getTempFilePath(ext) {
-  const id = crypto4.randomBytes(8).toString("hex");
-  return path13.join(os4.tmpdir(), `chatlab-pull-${id}${ext}`);
+  const id = crypto3.randomBytes(8).toString("hex");
+  return path11.join(os4.tmpdir(), `chatlab-pull-${id}${ext}`);
 }
 var NodeFetcher = class {
   async fetchToTempFile(baseUrl, remoteSessionId, token, params) {
@@ -3565,14 +3517,14 @@ var NodeFetcher = class {
     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);
+    fs10.writeFileSync(tempFile, buffer);
     return tempFile;
   }
 };
 function resolveNativeBinding2() {
   if (process.versions.electron) return void 0;
   const nativePath = resolveCliPath("native/better_sqlite3.node");
-  if (fs13.existsSync(nativePath)) return nativePath;
+  if (fs10.existsSync(nativePath)) return nativePath;
   return void 0;
 }
 var DirectImporter = class {
@@ -3586,7 +3538,7 @@ var DirectImporter = class {
   }
   sessionExists(sessionId) {
     const dbPath = this.dbManager.getDbPath(sessionId);
-    if (!fs13.existsSync(dbPath)) return false;
+    if (!fs10.existsSync(dbPath)) return false;
     try {
       const db = openBetterSqliteDatabase(dbPath, { readonly: true, nativeBinding: this.nativeBinding });
       const row = db.prepare("SELECT COUNT(*) as cnt FROM sqlite_master WHERE type='table' AND name='message'").get();
@@ -3594,7 +3546,7 @@ var DirectImporter = class {
       if (row.cnt === 0) {
         this.logger.warn(`[DirectImporter] DB file exists but has no message table: ${sessionId}, removing`);
         try {
-          fs13.unlinkSync(dbPath);
+          fs10.unlinkSync(dbPath);
         } catch {
         }
         return false;
@@ -3603,7 +3555,7 @@ var DirectImporter = class {
     } catch {
       this.logger.warn(`[DirectImporter] Cannot validate DB file: ${sessionId}, removing`);
       try {
-        fs13.unlinkSync(dbPath);
+        fs10.unlinkSync(dbPath);
       } catch {
       }
       return false;
@@ -3723,8 +3675,8 @@ function registerAutomationRoutes(server2, ctx) {
     if (request.query.deleteData === "true" && removed.targetSessionId) {
       dbManager2.close(removed.targetSessionId);
       const dbPath = dbManager2.getDbPath(removed.targetSessionId);
-      const fs15 = await import("fs");
-      if (fs15.existsSync(dbPath)) fs15.unlinkSync(dbPath);
+      const fs12 = await import("fs");
+      if (fs12.existsSync(dbPath)) fs12.unlinkSync(dbPath);
     }
     return { success: true };
   });
@@ -3800,15 +3752,30 @@ function cleanupSync() {
 var server = null;
 var dbManager = null;
 var convManager = null;
+function createFileConfigStorage(aiDataDir) {
+  return {
+    readJson(key) {
+      try {
+        return JSON.parse(fs11.readFileSync(`${aiDataDir}/${key}.json`, "utf-8"));
+      } catch {
+        return null;
+      }
+    },
+    writeJson(key, data) {
+      if (!fs11.existsSync(aiDataDir)) fs11.mkdirSync(aiDataDir, { recursive: true });
+      fs11.writeFileSync(`${aiDataDir}/${key}.json`, JSON.stringify(data, null, 2), "utf-8");
+    }
+  };
+}
 function resolveNativeBinding3() {
   if (process.versions.electron) return void 0;
   const nativePath = resolveCliPath("native/better_sqlite3.node");
-  if (fs14.existsSync(nativePath)) return nativePath;
+  if (fs11.existsSync(nativePath)) return nativePath;
   return void 0;
 }
 function ensureToken(config) {
   if (config.api.token) return config.api.token;
-  const token = `clb_${crypto5.randomBytes(32).toString("hex")}`;
+  const token = `clb_${crypto4.randomBytes(32).toString("hex")}`;
   try {
     writeConfigField("api", "token", token);
   } catch {
@@ -3819,10 +3786,19 @@ async function startHttpServer(options) {
   if (server) {
     throw new Error("HTTP server is already running");
   }
-  const config = loadConfig();
+  let config = loadConfig();
   const port = options?.port ?? config.api.port;
   const host = options?.host ?? config.api.host;
   const token = options?.token ?? ensureToken(config);
+  const pendingMigration = applyPendingNodeDataDirMigrationIfNeeded();
+  if (!pendingMigration.skipped) {
+    if (pendingMigration.success) {
+      console.log("[Migration] Pending data directory migration completed");
+      config = loadConfig();
+    } else {
+      console.error("[Migration] Pending data directory migration failed:", pendingMigration.error);
+    }
+  }
   const userDataDir = config.data.user_data_dir || void 0;
   const pathProvider = new NodePathProvider(userDataDir);
   pathProvider.ensureAllDirs();
@@ -3843,24 +3819,43 @@ async function startHttpServer(options) {
   await migrationRunner.run();
   const nativeBinding = resolveNativeBinding3();
   dbManager = new DatabaseManager(pathProvider, { nativeBinding });
-  convManager = new AIConversationManager(pathProvider.getAiDataDir(), { nativeBinding });
+  const aiDataDir = pathProvider.getAiDataDir();
+  convManager = new AIConversationManager(aiDataDir, { nativeBinding });
+  const assistantManager = getAssistantManager(aiDataDir);
+  const skillManagerCore = getSkillManagerCore(aiDataDir);
+  const llmConfigStore = new LLMConfigStore(createFileConfigStorage(aiDataDir), {
+    resolveApiKey: (provider, authProfile) => resolveApiKey(provider, authProfile) || void 0,
+    onApiKeyCreated: (config2, apiKey) => {
+      const profileName = config2.name?.toLowerCase().replace(/\s+/g, "-") || config2.provider;
+      writeAuthProfile(profileName, { type: "api_key", provider: config2.provider, key: apiKey });
+      return profileName;
+    }
+  });
   initServerAiLogger(pathProvider.getLogsDir());
   setAuthToken(token);
+  setRequireAuth(!!(options?.requireAuth ?? config.api.require_auth));
   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);
+  registerWebRoutes(server, dbManager, {
+    pathProvider,
+    nativeBinding,
+    aiContext: {
+      aiDataDir,
+      convManager,
+      assistantManager,
+      skillManagerCore,
+      llmConfigStore,
+      customProviderStore: new CustomProviderStore(createFileConfigStorage(aiDataDir)),
+      customModelStore: new CustomModelStore(createFileConfigStorage(aiDataDir)),
+      runAgentStream: createCliRunAgentStream(dbManager, convManager)
+    }
+  });
   initSync(server, dbManager, pathProvider, { port, host, token });
-  if (options?.webRoot && fs14.existsSync(options.webRoot)) {
-    setWebMode(true);
+  if (options?.webRoot && fs11.existsSync(options.webRoot)) {
     registerProxyRoutes(server);
     const fastifyStatic = await import("@fastify/static");
     await server.register(fastifyStatic.default, {
@@ -3890,19 +3885,15 @@ async function stopHttpServer() {
       dbManager = null;
     }
     closeServerAiLogger();
-    setWebMode(false);
+    setRequireAuth(false);
     server = null;
   }
 }
 
 export {
   createServer,
-  registerSystemRoutes,
-  registerSessionRoutes,
   registerWebRoutes,
-  registerNlpRoutes,
-  registerAiRoutes,
   startHttpServer,
   stopHttpServer
 };
-//# sourceMappingURL=chunk-L37WJ33K.mjs.map
+//# sourceMappingURL=chunk-NE4A6PND.mjs.map