chatlab-cli 0.1.0 → 0.21.1

package/dist/{chunk-PF4QFHC6.mjs → chunk-LI4X52E7.mjs}

@@ -7,17 +7,17 @@ const __dirname = __pathDirname(__filename);
 import {
   importData,
   parseFile
-} from "./chunk-OC73KSMV.mjs";
+} from "./chunk-OQVKZTVD.mjs";
 import {
   analyzeIncrementalImport,
   analyzeNewImport,
   incrementalImport,
   streamImport
-} from "./chunk-DL3BFEAH.mjs";
+} from "./chunk-AIR7EAF4.mjs";
 import {
   AGENT_TOOL_REGISTRY,
   CoreDataProvider
-} from "./chunk-YAOFJ73U.mjs";
+} from "./chunk-4GI2UPCS.mjs";
 import {
   getVersion
 } from "./chunk-2AIOU3PW.mjs";
@@ -46,12 +46,11 @@ import {
   checkAndCompress,
   checkConflictsFromSources,
   cleanupTempDatabases,
-  clearSessionIndex,
-  completeSimple,
   computeWordFrequency,
   createActivateSkillTool,
   createAiTranslate,
   createCompressionLlmAdapter,
+  createDatabaseManagerAdapter,
   createJiebaNlpProvider,
   deleteDict,
   deleteTempDatabase,
@@ -61,18 +60,15 @@ import {
   ensureDefaultDict,
   executeReadonlySql,
   executeSql,
-  exportFilterResultToMarkdown,
   exportSessionToJson,
+  export_service_exports,
   fetchRemoteModels,
+  findEntryFileInDirectory,
   formatAIError,
-  generateSessionIndex,
-  generateSessionSummary,
   getAvailableYears,
   getBuiltinModelsByProvider,
   getCatchphraseAnalysis,
   getChatOverview,
-  getChatSessionList,
-  getChatSessionSummary,
   getClusterGraph,
   getDailyActivity,
   getDictList,
@@ -82,8 +78,6 @@ import {
   getMemberActivity,
   getMembers,
   getMembersDetailed,
-  getMembersPaginated,
-  getMembersWithAliases,
   getMentionAnalysis,
   getMentionGraph,
   getMessageLengthDistribution,
@@ -92,40 +86,39 @@ import {
   getRelationshipStats,
   getSchemaDetailed,
   getSessionInfo,
-  getSessionMessages,
   getSessionMeta,
   getSessionOverview,
   getSupportedFormats,
   getTimeRange,
   getWeekdayActivity,
   getYearlyActivity,
-  hasFtsTable,
   hasPendingElectronDataWarning,
   initNlpDir,
   isDictDownloaded,
   loadConfig,
+  member_service_exports,
   openBetterSqliteDatabase,
   parseAssistantFile,
   queryMessages,
-  rebuildFtsIndex,
   resolveApiKey,
   runAgentCore,
   runSimpleLlmStream,
-  saveChatSessionSummary,
   scanMultiChatFile,
-  searchByFts,
   segmentText,
   serializeChatLabToJsonl,
+  session_index_service_exports,
+  session_service_exports,
   streamParseFileInfo,
+  summary_service_exports,
   validateApiKey,
   verifyCliDataPath,
   writeAuthProfile,
   writeConfigField
-} from "./chunk-JMRDNHIR.mjs";
+} from "./chunk-7HQWGLX6.mjs";
 
 // src/http/index.ts
-import * as fs11 from "fs";
-import * as path11 from "path";
+import * as fs14 from "fs";
+import * as path15 from "path";
 import * as crypto5 from "crypto";
 
 // src/http/server.ts
@@ -497,10 +490,9 @@ function registerSessionRoutes(server2, dbManager2) {
   });
 }
 
-// src/http/routes/web.ts
-import * as fs3 from "fs";
-import * as os from "os";
-import * as path3 from "path";
+// src/http/routes/web/index.ts
+import * as os3 from "os";
+import * as path7 from "path";
 
 // src/merger/merge-cache.ts
 import * as fs from "fs";
@@ -576,17 +568,326 @@ var MergeSessionCache = class {
   }
 };
 
-// src/ai/llm-config.ts
+// src/http/routes/web/sessions.ts
+function registerSessionRoutes2(server2, adapter) {
+  server2.get("/_web/sessions", async () => {
+    return session_service_exports.listAnalysisSessions(adapter);
+  });
+  server2.get("/_web/sessions/:id", async (request) => {
+    const session = session_service_exports.getAnalysisSession(adapter, request.params.id);
+    if (!session) {
+      throw Object.assign(new Error(`Session not found: ${request.params.id}`), { statusCode: 404 });
+    }
+    return session;
+  });
+  server2.delete("/_web/sessions/:id", async (request, reply) => {
+    const { id } = request.params;
+    try {
+      const deleted = session_service_exports.deleteSession(adapter, id);
+      if (!deleted) {
+        return reply.code(404).send({ success: false, error: "File not found" });
+      }
+      return { success: true };
+    } catch (err) {
+      return reply.code(500).send({ success: false, error: String(err) });
+    }
+  });
+  server2.patch("/_web/sessions/:id/name", async (request) => {
+    session_service_exports.renameSession(adapter, request.params.id, request.body.name);
+    return { success: true };
+  });
+  server2.patch(
+    "/_web/sessions/:id/owner",
+    async (request) => {
+      session_service_exports.updateSessionOwnerId(adapter, request.params.id, request.body.ownerId ?? null);
+      return { success: true };
+    }
+  );
+}
+
+// src/http/routes/web/members.ts
+function registerMemberRoutes(server2, adapter) {
+  server2.get("/_web/sessions/:id/members", async (request) => {
+    return member_service_exports.getMembers(adapter, request.params.id);
+  });
+  server2.get("/_web/sessions/:id/members/paginated", async (request) => {
+    return member_service_exports.getMembersPaginated(adapter, request.params.id, {
+      page: parseInt(request.query.page || "1", 10),
+      pageSize: parseInt(request.query.pageSize || "20", 10),
+      search: request.query.search,
+      sortOrder: request.query.sortOrder === "asc" ? "asc" : "desc"
+    });
+  });
+  server2.patch(
+    "/_web/sessions/:id/members/:memberId/aliases",
+    async (request) => {
+      const memberId = parseInt(request.params.memberId, 10);
+      member_service_exports.updateMemberAliases(adapter, request.params.id, memberId, request.body.aliases);
+      return { success: true };
+    }
+  );
+  server2.delete(
+    "/_web/sessions/:id/members/:memberId",
+    async (request) => {
+      const memberId = parseInt(request.params.memberId, 10);
+      member_service_exports.deleteMember(adapter, request.params.id, memberId);
+      return { success: true };
+    }
+  );
+  server2.post(
+    "/_web/sessions/:id/members/merge",
+    async (request) => {
+      const { memberId1, memberId2 } = request.body;
+      member_service_exports.mergeMembers(adapter, request.params.id, memberId1, memberId2);
+      return { success: true };
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/members/:memberId/history",
+    async (request) => {
+      const memberId = parseInt(request.params.memberId, 10);
+      return member_service_exports.getMemberNameHistory(adapter, request.params.id, memberId);
+    }
+  );
+}
+
+// src/http/routes/web/helpers.ts
 import * as fs2 from "fs";
 import * as path2 from "path";
+function parseTimeFilter(query) {
+  const { startTs, endTs, memberId } = query;
+  if (!startTs && !endTs && !memberId) return void 0;
+  const filter = {};
+  if (startTs) filter.startTs = parseInt(startTs, 10);
+  if (endTs) filter.endTs = parseInt(endTs, 10);
+  if (memberId) filter.memberId = parseInt(memberId, 10);
+  return filter;
+}
+function resolveNativeBinding() {
+  if (process.versions.electron) return void 0;
+  const nativePath = path2.resolve(__dirname, "../../../../native/better_sqlite3.node");
+  if (fs2.existsSync(nativePath)) return nativePath;
+  return void 0;
+}
+function getAiDataDir(dbManager2) {
+  const pathProvider = dbManager2["pathProvider"];
+  if (!pathProvider) {
+    throw Object.assign(new Error("PathProvider not available"), { statusCode: 500 });
+  }
+  return pathProvider.getAiDataDir();
+}
+function ensureDb2(dbManager2, sessionId) {
+  const db = dbManager2.open(sessionId);
+  if (!db) {
+    throw Object.assign(new Error(`Session not found: ${sessionId}`), { statusCode: 404 });
+  }
+  return db;
+}
+
+// src/http/routes/web/analytics.ts
+function registerAnalyticsRoutes(server2, _dbManager, adapter) {
+  server2.get("/_web/sessions/:id/years", async (request) => {
+    const db = adapter.ensureReadonly(request.params.id);
+    return getAvailableYears(db);
+  });
+  server2.get("/_web/sessions/:id/time-range", async (request) => {
+    const db = adapter.ensureReadonly(request.params.id);
+    return getTimeRange(db);
+  });
+  server2.get(
+    "/_web/sessions/:id/stats/member-activity",
+    async (request) => {
+      const db = adapter.ensureReadonly(request.params.id);
+      return getMemberActivity(db, parseTimeFilter(request.query));
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/stats/hourly",
+    async (request) => {
+      const db = adapter.ensureReadonly(request.params.id);
+      return getHourlyActivity(db, parseTimeFilter(request.query));
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/stats/daily",
+    async (request) => {
+      const db = adapter.ensureReadonly(request.params.id);
+      return getDailyActivity(db, parseTimeFilter(request.query));
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/stats/weekday",
+    async (request) => {
+      const db = adapter.ensureReadonly(request.params.id);
+      return getWeekdayActivity(db, parseTimeFilter(request.query));
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/stats/message-types",
+    async (request) => {
+      const db = adapter.ensureReadonly(request.params.id);
+      return getMessageTypeStats(db, parseTimeFilter(request.query));
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/analytics/relationship",
+    async (request) => {
+      const db = adapter.ensureReadonly(request.params.id);
+      return getRelationshipStats(db, parseTimeFilter(request.query));
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/analytics/catchphrase",
+    async (request) => {
+      const db = adapter.ensureReadonly(request.params.id);
+      return getCatchphraseAnalysis(db, parseTimeFilter(request.query));
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/analytics/mention",
+    async (request) => {
+      const db = adapter.ensureReadonly(request.params.id);
+      return getMentionAnalysis(db, parseTimeFilter(request.query));
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/analytics/mention-graph",
+    async (request) => {
+      const db = adapter.ensureReadonly(request.params.id);
+      return getMentionGraph(db, parseTimeFilter(request.query));
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/analytics/laugh",
+    async (request) => {
+      const db = adapter.ensureReadonly(request.params.id);
+      return getLaughAnalysis(db, parseTimeFilter(request.query));
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/analytics/cluster",
+    async (request) => {
+      const db = adapter.ensureReadonly(request.params.id);
+      const filter = parseTimeFilter(request.query);
+      const topEdges = request.query.topEdges ? parseInt(request.query.topEdges, 10) : void 0;
+      return getClusterGraph(db, filter, topEdges ? { topEdges } : void 0);
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/analytics/language-preference",
+    async (request) => {
+      const db = adapter.ensureReadonly(request.params.id);
+      const filter = parseTimeFilter(request.query);
+      const locale = request.query.locale || "zh-CN";
+      const nlpProvider = createJiebaNlpProvider();
+      return getLanguagePreferenceAnalysis(db, { locale, timeFilter: filter, nlpProvider });
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/analytics/monthly-activity",
+    async (request) => {
+      const db = adapter.ensureReadonly(request.params.id);
+      return getMonthlyActivity(db, parseTimeFilter(request.query));
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/analytics/yearly-activity",
+    async (request) => {
+      const db = adapter.ensureReadonly(request.params.id);
+      return getYearlyActivity(db, parseTimeFilter(request.query));
+    }
+  );
+  server2.get(
+    "/_web/sessions/:id/analytics/message-length-distribution",
+    async (request) => {
+      const db = adapter.ensureReadonly(request.params.id);
+      return getMessageLengthDistribution(db, parseTimeFilter(request.query));
+    }
+  );
+}
+
+// src/http/routes/web/sql.ts
+function registerSqlRoutes(server2, adapter) {
+  server2.post("/_web/sessions/:id/sql", async (request, reply) => {
+    const db = adapter.ensureReadonly(request.params.id);
+    const { sql } = request.body || {};
+    if (!sql || typeof sql !== "string") {
+      return reply.code(400).send({ error: "Missing sql parameter" });
+    }
+    try {
+      return executeSql(db, sql, { timing: true });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "SQL execution error";
+      return reply.code(400).send({ error: message });
+    }
+  });
+  server2.get("/_web/sessions/:id/schema", async (request) => {
+    const db = adapter.ensureReadonly(request.params.id);
+    return getSchemaDetailed(db);
+  });
+  server2.post("/_web/sessions/:id/query", async (request) => {
+    const db = adapter.ensureReadonly(request.params.id);
+    const { sql, params = [] } = request.body;
+    if (!sql || typeof sql !== "string") {
+      throw Object.assign(new Error('Missing or invalid "sql" field'), { statusCode: 400 });
+    }
+    const stmt = db.prepare(sql.trim());
+    if (!stmt.readonly) {
+      throw Object.assign(new Error("Only READ-ONLY statements are allowed"), { statusCode: 403 });
+    }
+    if (Array.isArray(params)) {
+      return stmt.all(...params);
+    }
+    return stmt.all(params);
+  });
+}
+
+// src/http/routes/web/session-index.ts
+function registerSessionIndexRoutes(server2, adapter) {
+  server2.post("/_web/sessions/:id/generate-index", async (request) => {
+    const gapThreshold = request.body?.gapThreshold ?? 1800;
+    const sessionCount = session_index_service_exports.generateIndex(adapter, request.params.id, gapThreshold);
+    return { sessionCount };
+  });
+  server2.post("/_web/sessions/:id/generate-incremental-index", async (request) => {
+    const gapThreshold = request.body?.gapThreshold ?? 1800;
+    const sessionCount = session_index_service_exports.generateIncrementalIndex(adapter, request.params.id, gapThreshold);
+    return { sessionCount };
+  });
+  server2.post("/_web/sessions/:id/clear-index", async (request) => {
+    session_index_service_exports.clearIndex(adapter, request.params.id);
+    return { success: true };
+  });
+  server2.get("/_web/sessions/:id/search/fts", async (request, reply) => {
+    if (!session_index_service_exports.getFtsStatus(adapter, request.params.id)) {
+      return reply.code(400).send({ error: "FTS index not built for this session" });
+    }
+    const keywords = request.query.keywords.split(/\s+/).filter(Boolean);
+    if (keywords.length === 0) return { rowids: [], total: 0 };
+    const limit = parseInt(request.query.limit || "100", 10);
+    const offset = parseInt(request.query.offset || "0", 10);
+    return session_index_service_exports.searchFts(adapter, request.params.id, keywords, limit, offset);
+  });
+  server2.get("/_web/sessions/:id/fts/status", async (request) => {
+    return { hasFtsIndex: session_index_service_exports.getFtsStatus(adapter, request.params.id) };
+  });
+  server2.post("/_web/sessions/:id/fts/rebuild", async (request) => {
+    const result = session_index_service_exports.rebuildFts(adapter, request.params.id);
+    return { success: true, indexed: result.indexed };
+  });
+}
+
+// src/ai/llm-config.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 function loadLlmConfig(aiDataDir) {
-  const configPath = path2.join(aiDataDir, "llm-config.json");
-  if (!fs2.existsSync(configPath)) {
+  const configPath = path3.join(aiDataDir, "llm-config.json");
+  if (!fs3.existsSync(configPath)) {
     return { configs: [], defaultAssistant: null, fastModel: null };
   }
   try {
-    const data = JSON.parse(fs2.readFileSync(configPath, "utf-8"));
+    const data = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
     const configs = (data.configs || []).map((c) => {
       const provider = c.provider || "";
       const authProfile = c.authProfile;
@@ -623,7 +924,7 @@ function getDefaultAssistantConfig(aiDataDir) {
 }
 var MAX_CONFIG_COUNT = 99;
 function saveLlmConfig(aiDataDir, store) {
-  const configPath = path2.join(aiDataDir, "llm-config.json");
+  const configPath = path3.join(aiDataDir, "llm-config.json");
   const toSave = {
     ...store,
     configs: store.configs.map((c) => {
@@ -632,7 +933,7 @@ function saveLlmConfig(aiDataDir, store) {
     }),
     schemaVersion: 3
   };
-  fs2.writeFileSync(configPath, JSON.stringify(toSave, null, 2), "utf-8");
+  fs3.writeFileSync(configPath, JSON.stringify(toSave, null, 2), "utf-8");
 }
 function addLlmConfig(aiDataDir, config) {
   const store = loadLlmConfig(aiDataDir);
@@ -727,12 +1028,12 @@ function setFastModelSlot(aiDataDir, slot) {
   return { success: true };
 }
 function loadRawConfigStore(aiDataDir) {
-  const configPath = path2.join(aiDataDir, "llm-config.json");
-  if (!fs2.existsSync(configPath)) {
+  const configPath = path3.join(aiDataDir, "llm-config.json");
+  if (!fs3.existsSync(configPath)) {
     return { configs: [], defaultAssistant: null, fastModel: null };
   }
   try {
-    const data = JSON.parse(fs2.readFileSync(configPath, "utf-8"));
+    const data = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
     return {
       configs: data.configs || [],
       defaultAssistant: data.defaultAssistant ?? null,
@@ -746,554 +1047,111 @@ function buildPiModel2(config) {
   return buildPiModel(config);
 }
 
-// src/http/routes/web.ts
-function resolveNativeBinding() {
-  if (process.versions.electron) return void 0;
-  const nativePath = path3.resolve(__dirname, "../../../native/better_sqlite3.node");
-  if (fs3.existsSync(nativePath)) return nativePath;
-  return void 0;
+// src/http/routes/web/summaries.ts
+function createSummaryDeps(dbManager2) {
+  const aiDataDir = getAiDataDir(dbManager2);
+  return {
+    getLlmConfig() {
+      return getDefaultAssistantConfig(aiDataDir);
+    },
+    buildPiModel(config) {
+      return buildPiModel2(config);
+    }
+  };
 }
-function ensureDb2(dbManager2, sessionId) {
-  const db = dbManager2.open(sessionId);
-  if (!db) {
-    throw Object.assign(new Error(`Session not found: ${sessionId}`), { statusCode: 404 });
-  }
-  return db;
+function registerSummaryRoutes(server2, dbManager2, adapter) {
+  const deps = createSummaryDeps(dbManager2);
+  server2.post("/_web/sessions/:id/summaries/generate", async (request, reply) => {
+    const { chatSessionId, locale, forceRegenerate } = request.body;
+    const result = await summary_service_exports.generateSummary(adapter, request.params.id, chatSessionId, deps, {
+      locale,
+      forceRegenerate
+    });
+    if ("error" in result && !result.success) {
+      return reply.code(400).send({ error: result.error });
+    }
+    return result;
+  });
+  server2.post("/_web/sessions/:id/summaries/generate-all", async (request, reply) => {
+    const { locale, forceRegenerate } = request.body;
+    const result = await summary_service_exports.generateAllSummaries(adapter, request.params.id, deps, {
+      locale,
+      forceRegenerate
+    });
+    if (result.error) {
+      return reply.code(400).send({ error: result.error });
+    }
+    return result;
+  });
 }
-function ensureWritableDb(dbManager2, sessionId) {
-  dbManager2.close(sessionId);
-  const db = dbManager2.open(sessionId, { readonly: false });
-  if (!db) {
-    throw Object.assign(new Error(`Session not found: ${sessionId}`), { statusCode: 404 });
-  }
-  return db;
-}
-function parseTimeFilter(query) {
-  const { startTs, endTs, memberId } = query;
-  if (!startTs && !endTs && !memberId) return void 0;
-  const filter = {};
-  if (startTs) filter.startTs = parseInt(startTs, 10);
-  if (endTs) filter.endTs = parseInt(endTs, 10);
-  if (memberId) filter.memberId = parseInt(memberId, 10);
-  return filter;
-}
-function getAiDataDir(dbManager2) {
-  const pathProvider = dbManager2["pathProvider"];
-  if (!pathProvider) {
-    throw Object.assign(new Error("PathProvider not available"), { statusCode: 500 });
-  }
-  return pathProvider.getAiDataDir();
-}
-function buildSummaryDeps(db, llmConfig, _aiDataDir) {
-  const piModel = buildPiModel2(llmConfig);
-  return {
-    loadMessages(chatSessionId, limit = 500) {
-      const data = getSessionMessages(db, chatSessionId, limit);
-      if (!data) return null;
-      return data.messages.map((m) => ({ senderName: m.senderName, content: m.content }));
-    },
-    saveSummary(chatSessionId, summary) {
-      saveChatSessionSummary(db, chatSessionId, summary);
-    },
-    getSummary(chatSessionId) {
-      return getChatSessionSummary(db, chatSessionId);
-    },
-    async llmComplete(systemPrompt, userPrompt, options) {
-      const result = await completeSimple(
-        piModel,
-        {
-          systemPrompt,
-          messages: [{ role: "user", content: [{ type: "text", text: userPrompt }], timestamp: Date.now() }]
-        },
-        { apiKey: llmConfig.apiKey, maxTokens: options?.maxTokens, temperature: options?.temperature }
-      );
-      return result.content.filter((item) => item.type === "text").map((item) => item.text).join("");
-    },
-    t: (key) => key
-  };
-}
-function registerWebRoutes(server2, dbManager2, options) {
-  const mergeCache = options?.pathProvider ? new MergeSessionCache(options.pathProvider, { nativeBinding: options.nativeBinding }) : null;
-  mergeCache?.cleanupOrphans();
-  server2.get("/_web/sessions", async () => {
-    const sessionIds = dbManager2.listSessionIds();
-    return sessionIds.map((id) => {
-      const db = dbManager2.open(id);
-      if (!db) return null;
-      const info = getSessionInfo(db);
-      if (!info) return null;
-      return {
-        ...info,
-        id,
-        dbPath: "",
-        memberAvatar: null,
-        aiConversationCount: 0
-      };
-    }).filter(Boolean);
-  });
-  server2.get("/_web/sessions/:id", async (request) => {
-    const db = ensureDb2(dbManager2, request.params.id);
-    const info = getSessionInfo(db);
-    if (!info) return null;
-    return {
-      ...info,
-      id: request.params.id,
-      dbPath: "",
-      memberAvatar: null,
-      aiConversationCount: 0
-    };
-  });
-  server2.delete("/_web/sessions/:id", async (request, reply) => {
-    const { id } = request.params;
-    try {
-      dbManager2.close(id);
-      const dbPath = dbManager2.getDbPath(id);
-      const fs12 = await import("fs");
-      if (fs12.existsSync(dbPath)) {
-        fs12.unlinkSync(dbPath);
-        return { success: true };
-      }
-      return reply.code(404).send({ success: false, error: "File not found" });
-    } catch (err) {
-      return reply.code(500).send({ success: false, error: String(err) });
-    }
-  });
-  server2.patch("/_web/sessions/:id/name", async (request) => {
-    const db = ensureDb2(dbManager2, request.params.id);
-    const { name } = request.body;
-    db.prepare("UPDATE meta SET name = ?").run(name);
-    return { success: true };
-  });
-  server2.patch(
-    "/_web/sessions/:id/owner",
-    async (request) => {
-      const db = ensureDb2(dbManager2, request.params.id);
-      const { ownerId } = request.body;
-      db.prepare("UPDATE meta SET owner_id = ?").run(ownerId ?? null);
-      return { success: true };
-    }
-  );
-  server2.get("/_web/sessions/:id/years", async (request) => {
-    const db = ensureDb2(dbManager2, request.params.id);
-    return getAvailableYears(db);
-  });
-  server2.get("/_web/sessions/:id/time-range", async (request) => {
-    const db = ensureDb2(dbManager2, request.params.id);
-    return getTimeRange(db);
-  });
-  server2.get("/_web/sessions/:id/stats/member-activity", async (request) => {
-    const db = ensureDb2(dbManager2, request.params.id);
-    const filter = parseTimeFilter(request.query);
-    return getMemberActivity(db, filter);
-  });
-  server2.get("/_web/sessions/:id/stats/hourly", async (request) => {
-    const db = ensureDb2(dbManager2, request.params.id);
-    const filter = parseTimeFilter(request.query);
-    return getHourlyActivity(db, filter);
-  });
-  server2.get("/_web/sessions/:id/stats/daily", async (request) => {
-    const db = ensureDb2(dbManager2, request.params.id);
-    const filter = parseTimeFilter(request.query);
-    return getDailyActivity(db, filter);
-  });
-  server2.get("/_web/sessions/:id/stats/weekday", async (request) => {
-    const db = ensureDb2(dbManager2, request.params.id);
-    const filter = parseTimeFilter(request.query);
-    return getWeekdayActivity(db, filter);
-  });
-  server2.get("/_web/sessions/:id/stats/message-types", async (request) => {
-    const db = ensureDb2(dbManager2, request.params.id);
-    const filter = parseTimeFilter(request.query);
-    return getMessageTypeStats(db, filter);
-  });
-  server2.get("/_web/sessions/:id/members", async (request) => {
-    const db = ensureDb2(dbManager2, request.params.id);
-    return getMembersWithAliases(db);
-  });
-  server2.get("/_web/sessions/:id/members/paginated", async (request) => {
-    const db = ensureDb2(dbManager2, request.params.id);
-    const result = getMembersPaginated(db, {
-      page: parseInt(request.query.page || "1", 10),
-      pageSize: parseInt(request.query.pageSize || "20", 10),
-      search: request.query.search,
-      sortOrder: request.query.sortOrder === "asc" ? "asc" : "desc"
-    });
-    return {
-      items: result.members,
-      total: result.total,
-      page: result.page,
-      pageSize: result.pageSize,
-      totalPages: result.totalPages
-    };
-  });
-  server2.patch(
-    "/_web/sessions/:id/members/:memberId/aliases",
-    async (request) => {
-      const db = ensureDb2(dbManager2, request.params.id);
-      const memberId = parseInt(request.params.memberId, 10);
-      const { aliases } = request.body;
-      db.prepare("UPDATE member SET aliases = ? WHERE id = ?").run(JSON.stringify(aliases), memberId);
-      return { success: true };
-    }
-  );
-  server2.delete(
-    "/_web/sessions/:id/members/:memberId",
-    async (request) => {
-      const db = ensureDb2(dbManager2, request.params.id);
-      const memberId = parseInt(request.params.memberId, 10);
-      db.prepare("DELETE FROM message WHERE sender_id = ?").run(memberId);
-      db.prepare("DELETE FROM member WHERE id = ?").run(memberId);
-      return { success: true };
-    }
-  );
-  server2.post(
-    "/_web/sessions/:id/members/merge",
-    async (request) => {
-      const db = ensureDb2(dbManager2, request.params.id);
-      const { memberId1, memberId2 } = request.body;
-      db.prepare("UPDATE message SET sender_id = ? WHERE sender_id = ?").run(memberId1, memberId2);
-      db.prepare("DELETE FROM member WHERE id = ?").run(memberId2);
-      return { success: true };
-    }
-  );
-  server2.get(
-    "/_web/sessions/:id/members/:memberId/history",
-    async (request) => {
-      const db = ensureDb2(dbManager2, request.params.id);
-      const memberId = parseInt(request.params.memberId, 10);
-      const rows = db.prepare(
-        `SELECT
-            sender_account_name as accountName,
-            sender_group_nickname as groupNickname,
-            MIN(ts) as startTs,
-            MAX(ts) as endTs
-          FROM message
-          WHERE sender_id = ?
-          GROUP BY sender_account_name, sender_group_nickname
-          ORDER BY startTs`
-      ).all(memberId);
-      const history = [];
-      for (const row of rows) {
-        if (row.accountName) {
-          history.push({ nameType: "account_name", name: row.accountName, startTs: row.startTs, endTs: row.endTs });
-        }
-        if (row.groupNickname) {
-          history.push({ nameType: "group_nickname", name: row.groupNickname, startTs: row.startTs, endTs: row.endTs });
-        }
-      }
-      return history;
-    }
-  );
-  server2.get("/_web/sessions/:id/analytics/relationship", async (request) => {
-    const db = ensureDb2(dbManager2, request.params.id);
-    const filter = parseTimeFilter(request.query);
-    return getRelationshipStats(db, filter);
-  });
-  server2.get("/_web/sessions/:id/analytics/catchphrase", async (request) => {
-    const db = ensureDb2(dbManager2, request.params.id);
-    const filter = parseTimeFilter(request.query);
-    return getCatchphraseAnalysis(db, filter);
-  });
-  server2.get("/_web/sessions/:id/analytics/mention", async (request) => {
-    const db = ensureDb2(dbManager2, request.params.id);
-    const filter = parseTimeFilter(request.query);
-    return getMentionAnalysis(db, filter);
-  });
-  server2.get("/_web/sessions/:id/analytics/mention-graph", async (request) => {
-    const db = ensureDb2(dbManager2, request.params.id);
-    const filter = parseTimeFilter(request.query);
-    return getMentionGraph(db, filter);
-  });
-  server2.get("/_web/sessions/:id/analytics/laugh", async (request) => {
-    const db = ensureDb2(dbManager2, request.params.id);
-    const filter = parseTimeFilter(request.query);
-    return getLaughAnalysis(db, filter);
-  });
-  server2.get("/_web/sessions/:id/analytics/cluster", async (request) => {
-    const db = ensureDb2(dbManager2, request.params.id);
-    const filter = parseTimeFilter(request.query);
-    const topEdges = request.query.topEdges ? parseInt(request.query.topEdges, 10) : void 0;
-    return getClusterGraph(db, filter, topEdges ? { topEdges } : void 0);
-  });
-  server2.get("/_web/sessions/:id/analytics/language-preference", async (request) => {
-    const db = ensureDb2(dbManager2, request.params.id);
-    const filter = parseTimeFilter(request.query);
-    const locale = request.query.locale || "zh-CN";
-    const nlpProvider = createJiebaNlpProvider();
-    return getLanguagePreferenceAnalysis(db, { locale, timeFilter: filter, nlpProvider });
-  });
-  server2.get("/_web/sessions/:id/analytics/monthly-activity", async (request) => {
-    const db = ensureDb2(dbManager2, request.params.id);
-    const filter = parseTimeFilter(request.query);
-    return getMonthlyActivity(db, filter);
-  });
-  server2.get("/_web/sessions/:id/analytics/yearly-activity", async (request) => {
-    const db = ensureDb2(dbManager2, request.params.id);
-    const filter = parseTimeFilter(request.query);
-    return getYearlyActivity(db, filter);
-  });
-  server2.get("/_web/sessions/:id/analytics/message-length-distribution", async (request) => {
-    const db = ensureDb2(dbManager2, request.params.id);
-    const filter = parseTimeFilter(request.query);
-    return getMessageLengthDistribution(db, filter);
-  });
-  server2.post("/_web/sessions/:id/sql", async (request, reply) => {
-    const db = ensureDb2(dbManager2, request.params.id);
-    const { sql } = request.body || {};
-    if (!sql || typeof sql !== "string") {
-      return reply.code(400).send({ error: "Missing sql parameter" });
-    }
-    try {
-      return executeSql(db, sql, { timing: true });
-    } catch (err) {
-      const message = err instanceof Error ? err.message : "SQL execution error";
-      return reply.code(400).send({ error: message });
-    }
-  });
-  server2.get("/_web/sessions/:id/schema", async (request) => {
-    const db = ensureDb2(dbManager2, request.params.id);
-    return getSchemaDetailed(db);
-  });
-  server2.post("/_web/sessions/:id/query", async (request) => {
-    const db = ensureDb2(dbManager2, request.params.id);
-    const { sql, params = [] } = request.body;
-    if (!sql || typeof sql !== "string") {
-      throw Object.assign(new Error('Missing or invalid "sql" field'), { statusCode: 400 });
-    }
-    const stmt = db.prepare(sql.trim());
-    if (!stmt.readonly) {
-      throw Object.assign(new Error("Only READ-ONLY statements are allowed"), { statusCode: 403 });
-    }
-    if (Array.isArray(params)) {
-      return stmt.all(...params);
-    }
-    return stmt.all(params);
-  });
-  server2.post("/_web/sessions/:id/export/markdown", async (request, reply) => {
-    const { id } = request.params;
-    const body = request.body;
-    const sessionName = body?.sessionName || id;
-    const chunks = [];
-    const result = exportFilterResultToMarkdown(
-      {
-        sessionId: id,
-        sessionName,
-        filterMode: body.filterMode || "condition",
-        keywords: body.keywords,
-        timeFilter: body.timeFilter,
-        senderIds: body.senderIds,
-        contextSize: body.contextSize,
-        chatSessionIds: body.chatSessionIds
-      },
-      {
-        openDatabase(sessionId) {
-          return dbManager2.open(sessionId) ?? null;
-        }
-      },
-      {
-        write(chunk) {
-          chunks.push(chunk);
-        },
-        end() {
-        }
-      }
-    );
-    if (!result.success) {
-      return reply.code(500).send({ error: result.error });
-    }
-    reply.header("Content-Type", "text/markdown; charset=utf-8");
-    reply.header("Content-Disposition", `attachment; filename="${encodeURIComponent(sessionName)}_export.md"`);
-    return reply.send(chunks.join(""));
-  });
-  server2.post("/_web/sessions/:id/generate-index", async (request) => {
-    const db = ensureWritableDb(dbManager2, request.params.id);
-    const gapThreshold = request.body?.gapThreshold ?? 1800;
-    const sessionCount = generateSessionIndex(db, gapThreshold);
-    return { sessionCount };
-  });
-  server2.post("/_web/sessions/:id/clear-index", async (request) => {
-    const db = ensureWritableDb(dbManager2, request.params.id);
-    clearSessionIndex(db);
-    return { success: true };
-  });
-  server2.get("/_web/sessions/:id/search/fts", async (request, reply) => {
-    const db = ensureDb2(dbManager2, request.params.id);
-    if (!hasFtsTable(db)) {
-      return reply.code(400).send({ error: "FTS index not built for this session" });
-    }
-    const keywords = request.query.keywords.split(/\s+/).filter(Boolean);
-    if (keywords.length === 0) return { rowids: [], total: 0 };
-    const limit = parseInt(request.query.limit || "100", 10);
-    const offset = parseInt(request.query.offset || "0", 10);
-    return searchByFts(db, keywords, limit, offset);
-  });
-  server2.get("/_web/sessions/:id/fts/status", async (request) => {
-    const db = ensureDb2(dbManager2, request.params.id);
-    return { hasFtsIndex: hasFtsTable(db) };
-  });
-  server2.post("/_web/sessions/:id/fts/rebuild", async (request) => {
-    const db = ensureWritableDb(dbManager2, request.params.id);
-    const result = rebuildFtsIndex(db);
-    return { success: true, indexed: result.indexed };
-  });
-  server2.post("/_web/sessions/:id/summaries/generate", async (request, reply) => {
-    const sessionId = request.params.id;
-    const { chatSessionId, locale, forceRegenerate } = request.body;
-    const aiDataDir = getAiDataDir(dbManager2);
-    const llmConfig = getDefaultAssistantConfig(aiDataDir);
-    if (!llmConfig) {
-      return reply.code(400).send({ error: "No LLM configuration available" });
-    }
-    const db = ensureWritableDb(dbManager2, sessionId);
-    const deps = buildSummaryDeps(db, llmConfig, aiDataDir);
-    const result = await generateSessionSummary(deps, chatSessionId, { locale, forceRegenerate });
-    return result;
-  });
-  server2.post("/_web/sessions/:id/summaries/generate-all", async (request, reply) => {
-    const sessionId = request.params.id;
-    const { locale, forceRegenerate } = request.body;
-    const aiDataDir = getAiDataDir(dbManager2);
-    const llmConfig = getDefaultAssistantConfig(aiDataDir);
-    if (!llmConfig) {
-      return reply.code(400).send({ error: "No LLM configuration available" });
-    }
-    const db = ensureWritableDb(dbManager2, sessionId);
-    const chatSessions = getChatSessionList(db);
-    const deps = buildSummaryDeps(db, llmConfig, aiDataDir);
-    let success = 0;
-    let failed = 0;
-    for (const cs of chatSessions) {
-      const result = await generateSessionSummary(deps, cs.id, { locale, forceRegenerate });
-      if (result.success) success++;
-      else failed++;
-    }
-    return { success, failed, total: chatSessions.length };
-  });
-  const DEMO_BASE_URL = "https://chatlab.fun/assets/demo";
-  server2.post("/_web/demo/import", async (request, reply) => {
-    const locale = request.body?.locale || "en";
-    const nativeBinding = resolveNativeBinding();
-    reply.raw.writeHead(200, {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive"
-    });
-    function sendEvent(event, data) {
-      reply.raw.write(`event: ${event}
-data: ${JSON.stringify(data)}
 
-`);
-    }
-    const tmpDir = fs3.mkdtempSync(path3.join(os.tmpdir(), "chatlab-demo-"));
-    const groupPath = path3.join(tmpDir, "demo-group.json");
-    const privatePath = path3.join(tmpDir, "demo-private.json");
+// src/http/routes/web/import.ts
+import * as fs4 from "fs";
+import * as os from "os";
+import * as path4 from "path";
+var DEMO_BASE_URL = "https://chatlab.fun/assets/demo";
+function cleanupTemp(...paths) {
+  for (const p of paths) {
     try {
-      sendEvent("progress", { stage: "downloading", current: 1, total: 2 });
-      const groupResp = await fetch(`${DEMO_BASE_URL}/${locale}/demo-group.json`, {
-        signal: AbortSignal.timeout(6e4)
-      });
-      if (!groupResp.ok) throw new Error(`Download group demo failed: ${groupResp.status}`);
-      fs3.writeFileSync(groupPath, Buffer.from(await groupResp.arrayBuffer()));
-      sendEvent("progress", { stage: "downloading", current: 2, total: 2 });
-      const privateResp = await fetch(`${DEMO_BASE_URL}/${locale}/demo-private.json`, {
-        signal: AbortSignal.timeout(6e4)
-      });
-      if (!privateResp.ok) throw new Error(`Download private demo failed: ${privateResp.status}`);
-      fs3.writeFileSync(privatePath, Buffer.from(await privateResp.arrayBuffer()));
-      sendEvent("progress", { stage: "importing", current: 1, total: 2 });
-      const groupResult = await streamImport(dbManager2, groupPath, { nativeBinding });
-      if (!groupResult.success) throw new Error(groupResult.error || "Failed to import group demo");
-      sendEvent("progress", { stage: "importing", current: 2, total: 2 });
-      const privateResult = await streamImport(dbManager2, privatePath, { nativeBinding });
-      if (!privateResult.success) throw new Error(privateResult.error || "Failed to import private demo");
-      sendEvent("progress", { stage: "done", current: 2, total: 2 });
-      sendEvent("result", {
-        success: true,
-        groupSessionId: groupResult.sessionId,
-        privateSessionId: privateResult.sessionId
-      });
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      sendEvent("progress", { stage: "error", current: 0, total: 2, message });
-      sendEvent("result", { success: false, error: message });
-    } finally {
-      try {
-        fs3.unlinkSync(groupPath);
-      } catch {
-      }
-      try {
-        fs3.unlinkSync(privatePath);
-      } catch {
-      }
-      try {
-        fs3.rmdirSync(tmpDir);
-      } catch {
+      const stat = fs4.statSync(p);
+      if (stat.isDirectory()) {
+        fs4.rmSync(p, { recursive: true, force: true });
+      } else {
+        fs4.unlinkSync(p);
       }
-      reply.raw.end();
+    } catch {
     }
-  });
+  }
+}
+function registerImportRoutes(server2, dbManager2) {
   server2.get("/_web/supported-formats", async () => {
     return getSupportedFormats();
   });
   server2.post("/_web/detect-format", async (request, reply) => {
     const data = await request.file();
     if (!data) return reply.code(400).send({ error: "No file uploaded" });
-    const tmpDir = fs3.mkdtempSync(path3.join(os.tmpdir(), "chatlab-detect-"));
-    const tmpPath = path3.join(tmpDir, data.filename || "upload");
+    const tmpDir = fs4.mkdtempSync(path4.join(os.tmpdir(), "chatlab-detect-"));
+    const tmpPath = path4.join(tmpDir, data.filename || "upload");
     try {
       const chunks = [];
       for await (const chunk of data.file) {
         chunks.push(chunk);
       }
-      fs3.writeFileSync(tmpPath, Buffer.concat(chunks));
+      fs4.writeFileSync(tmpPath, Buffer.concat(chunks));
       const format = detectFormat(tmpPath);
       const allFormats = detectAllFormats(tmpPath);
       return { format, allFormats };
     } finally {
-      try {
-        fs3.unlinkSync(tmpPath);
-      } catch {
-      }
-      try {
-        fs3.rmdirSync(tmpDir);
-      } catch {
-      }
+      cleanupTemp(tmpPath, tmpDir);
     }
   });
   server2.post("/_web/scan-multi-chat", async (request, reply) => {
     const data = await request.file();
     if (!data) return reply.code(400).send({ error: "No file uploaded" });
-    const tmpDir = fs3.mkdtempSync(path3.join(os.tmpdir(), "chatlab-scan-"));
-    const tmpPath = path3.join(tmpDir, data.filename || "upload");
+    const tmpDir = fs4.mkdtempSync(path4.join(os.tmpdir(), "chatlab-scan-"));
+    const tmpPath = path4.join(tmpDir, data.filename || "upload");
     try {
       const chunks = [];
       for await (const chunk of data.file) {
         chunks.push(chunk);
       }
-      fs3.writeFileSync(tmpPath, Buffer.concat(chunks));
+      fs4.writeFileSync(tmpPath, Buffer.concat(chunks));
       const chats = await scanMultiChatFile(tmpPath);
       return { chats };
     } finally {
-      try {
-        fs3.unlinkSync(tmpPath);
-      } catch {
-      }
-      try {
-        fs3.rmdirSync(tmpDir);
-      } catch {
-      }
+      cleanupTemp(tmpPath, tmpDir);
     }
   });
   server2.post("/_web/import", async (request, reply) => {
     const data = await request.file();
     if (!data) return reply.code(400).send({ error: "No file uploaded" });
-    const tmpDir = fs3.mkdtempSync(path3.join(os.tmpdir(), "chatlab-import-"));
-    const tmpPath = path3.join(tmpDir, data.filename || "upload");
+    const tmpDir = fs4.mkdtempSync(path4.join(os.tmpdir(), "chatlab-import-"));
+    const tmpPath = path4.join(tmpDir, data.filename || "upload");
     const chunks = [];
     for await (const chunk of data.file) {
       chunks.push(chunk);
     }
-    fs3.writeFileSync(tmpPath, Buffer.concat(chunks));
+    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;
@@ -1302,57 +1160,123 @@ data: ${JSON.stringify(data)}
       "Cache-Control": "no-cache",
       Connection: "keep-alive"
     });
-    function sendEvent(event, data2) {
+    function sendEvent(event, eventData) {
       reply.raw.write(`event: ${event}
-data: ${JSON.stringify(data2)}
+data: ${JSON.stringify(eventData)}
 
 `);
     }
     try {
       const nativeBinding = resolveNativeBinding();
-      const result = await streamImport(dbManager2, tmpPath, {
-        formatId,
-        chatIndex,
+      const result = await streamImport(dbManager2, tmpPath, {
+        formatId,
+        chatIndex,
+        nativeBinding,
+        onProgress: (p) => sendEvent("progress", p)
+      });
+      if (result.success) {
+        sendEvent("done", {
+          success: true,
+          sessionId: result.sessionId,
+          messageCount: result.diagnostics?.messagesWritten ?? 0,
+          memberCount: 0
+        });
+      } else {
+        sendEvent("error", { success: false, error: result.error });
+      }
+    } catch (err) {
+      sendEvent("error", { success: false, error: err instanceof Error ? err.message : String(err) });
+    } finally {
+      reply.raw.end();
+      cleanupTemp(tmpPath, tmpDir);
+    }
+  });
+  server2.post("/_web/import-directory", async (request, reply) => {
+    const parts = request.parts();
+    if (!parts) return reply.code(400).send({ error: "No files uploaded" });
+    const tmpDir = fs4.mkdtempSync(path4.join(os.tmpdir(), "chatlab-dir-import-"));
+    const relativePaths = [];
+    const fileBuffers = [];
+    try {
+      let sendEvent2 = function(event, eventData) {
+        reply.raw.write(`event: ${event}
+data: ${JSON.stringify(eventData)}
+
+`);
+      };
+      var sendEvent = sendEvent2;
+      for await (const part of parts) {
+        if (part.type === "field" && part.fieldname === "relativePaths") {
+          relativePaths.push(String(part.value));
+        } else if (part.type === "file") {
+          const chunks = [];
+          for await (const chunk of part.file) {
+            chunks.push(chunk);
+          }
+          fileBuffers.push({ data: Buffer.concat(chunks), filename: part.filename || "" });
+        }
+      }
+      for (let i = 0; i < fileBuffers.length; i++) {
+        let relPath = relativePaths[i] || fileBuffers[i].filename || `file_${i}`;
+        const segments = relPath.split("/");
+        if (segments.length > 1) {
+          relPath = segments.slice(1).join("/");
+        }
+        const targetPath = path4.resolve(tmpDir, relPath);
+        if (!targetPath.startsWith(tmpDir + path4.sep)) continue;
+        fs4.mkdirSync(path4.dirname(targetPath), { recursive: true });
+        fs4.writeFileSync(targetPath, fileBuffers[i].data);
+      }
+      const entryPath = findEntryFileInDirectory(tmpDir);
+      if (!entryPath) {
+        return reply.code(400).send({ error: "No recognizable import format found in directory" });
+      }
+      reply.raw.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      });
+      const nativeBinding = resolveNativeBinding();
+      const result = await streamImport(dbManager2, entryPath, {
         nativeBinding,
-        onProgress: (p) => {
-          sendEvent("progress", p);
-        }
+        onProgress: (p) => sendEvent2("progress", p)
       });
       if (result.success) {
-        sendEvent("done", {
+        sendEvent2("done", {
           success: true,
           sessionId: result.sessionId,
           messageCount: result.diagnostics?.messagesWritten ?? 0,
           memberCount: 0
         });
       } else {
-        sendEvent("error", { success: false, error: result.error });
+        sendEvent2("error", { success: false, error: result.error });
       }
     } catch (err) {
-      sendEvent("error", { success: false, error: err instanceof Error ? err.message : String(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();
-      try {
-        fs3.unlinkSync(tmpPath);
-      } catch {
-      }
-      try {
-        fs3.rmdirSync(tmpDir);
-      } catch {
-      }
+      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 = fs3.mkdtempSync(path3.join(os.tmpdir(), "chatlab-inc-"));
-    const tmpPath = path3.join(tmpDir, data.filename || "upload");
+    const tmpDir = fs4.mkdtempSync(path4.join(os.tmpdir(), "chatlab-inc-"));
+    const tmpPath = path4.join(tmpDir, data.filename || "upload");
     const chunks = [];
     for await (const chunk of data.file) {
       chunks.push(chunk);
     }
-    fs3.writeFileSync(tmpPath, Buffer.concat(chunks));
+    fs4.writeFileSync(tmpPath, Buffer.concat(chunks));
     reply.raw.writeHead(200, {
       "Content-Type": "text/event-stream",
       "Cache-Control": "no-cache",
@@ -1366,9 +1290,7 @@ data: ${JSON.stringify(eventData)}
     }
     try {
       const result = await incrementalImport(dbManager2, sessionId, tmpPath, {
-        onProgress: (p) => {
-          sendEvent("progress", p);
-        }
+        onProgress: (p) => sendEvent("progress", p)
       });
       if (result.success) {
         sendEvent("done", result);
@@ -1379,237 +1301,299 @@ data: ${JSON.stringify(eventData)}
       sendEvent("error", { success: false, error: err instanceof Error ? err.message : String(err) });
     } finally {
       reply.raw.end();
-      try {
-        fs3.unlinkSync(tmpPath);
-      } catch {
-      }
-      try {
-        fs3.rmdirSync(tmpDir);
-      } catch {
-      }
+      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 = fs3.mkdtempSync(path3.join(os.tmpdir(), "chatlab-analyze-"));
-    const tmpPath = path3.join(tmpDir, data.filename || "upload");
+    const tmpDir = fs4.mkdtempSync(path4.join(os.tmpdir(), "chatlab-analyze-"));
+    const tmpPath = path4.join(tmpDir, data.filename || "upload");
     const chunks = [];
     for await (const chunk of data.file) {
       chunks.push(chunk);
     }
-    fs3.writeFileSync(tmpPath, Buffer.concat(chunks));
+    fs4.writeFileSync(tmpPath, Buffer.concat(chunks));
     try {
-      const result = await analyzeIncrementalImport(dbManager2, sessionId, tmpPath);
-      return result;
+      return await analyzeIncrementalImport(dbManager2, sessionId, tmpPath);
     } catch (err) {
       return reply.code(500).send({ error: err instanceof Error ? err.message : String(err) });
     } finally {
-      try {
-        fs3.unlinkSync(tmpPath);
-      } catch {
-      }
-      try {
-        fs3.rmdirSync(tmpDir);
-      } catch {
-      }
+      cleanupTemp(tmpPath, tmpDir);
     }
   });
   server2.post("/_web/import/analyze", async (request, reply) => {
     const data = await request.file();
     if (!data) return reply.code(400).send({ error: "No file uploaded" });
-    const tmpDir = fs3.mkdtempSync(path3.join(os.tmpdir(), "chatlab-analyze-"));
-    const tmpPath = path3.join(tmpDir, data.filename || "upload");
+    const tmpDir = fs4.mkdtempSync(path4.join(os.tmpdir(), "chatlab-analyze-"));
+    const tmpPath = path4.join(tmpDir, data.filename || "upload");
     const chunks = [];
     for await (const chunk of data.file) {
       chunks.push(chunk);
     }
-    fs3.writeFileSync(tmpPath, Buffer.concat(chunks));
+    fs4.writeFileSync(tmpPath, Buffer.concat(chunks));
     try {
-      const result = await analyzeNewImport(tmpPath);
-      return result;
+      return await analyzeNewImport(tmpPath);
     } catch (err) {
       return reply.code(500).send({ error: err instanceof Error ? err.message : String(err) });
+    } finally {
+      cleanupTemp(tmpPath, tmpDir);
+    }
+  });
+  server2.post("/_web/demo/import", async (request, reply) => {
+    const locale = request.body?.locale || "en";
+    const nativeBinding = resolveNativeBinding();
+    reply.raw.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    });
+    function sendEvent(event, eventData) {
+      reply.raw.write(`event: ${event}
+data: ${JSON.stringify(eventData)}
+
+`);
+    }
+    const tmpDir = fs4.mkdtempSync(path4.join(os.tmpdir(), "chatlab-demo-"));
+    const groupPath = path4.join(tmpDir, "demo-group.json");
+    const privatePath = path4.join(tmpDir, "demo-private.json");
+    try {
+      sendEvent("progress", { stage: "downloading", current: 1, total: 2 });
+      const groupResp = await fetch(`${DEMO_BASE_URL}/${locale}/demo-group.json`, {
+        signal: AbortSignal.timeout(6e4)
+      });
+      if (!groupResp.ok) throw new Error(`Download group demo failed: ${groupResp.status}`);
+      fs4.writeFileSync(groupPath, Buffer.from(await groupResp.arrayBuffer()));
+      sendEvent("progress", { stage: "downloading", current: 2, total: 2 });
+      const privateResp = await fetch(`${DEMO_BASE_URL}/${locale}/demo-private.json`, {
+        signal: AbortSignal.timeout(6e4)
+      });
+      if (!privateResp.ok) throw new Error(`Download private demo failed: ${privateResp.status}`);
+      fs4.writeFileSync(privatePath, Buffer.from(await privateResp.arrayBuffer()));
+      sendEvent("progress", { stage: "importing", current: 1, total: 2 });
+      const groupResult = await streamImport(dbManager2, groupPath, { nativeBinding });
+      if (!groupResult.success) throw new Error(groupResult.error || "Failed to import group demo");
+      sendEvent("progress", { stage: "importing", current: 2, total: 2 });
+      const privateResult = await streamImport(dbManager2, privatePath, { nativeBinding });
+      if (!privateResult.success) throw new Error(privateResult.error || "Failed to import private demo");
+      sendEvent("progress", { stage: "done", current: 2, total: 2 });
+      sendEvent("result", {
+        success: true,
+        groupSessionId: groupResult.sessionId,
+        privateSessionId: privateResult.sessionId
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      sendEvent("progress", { stage: "error", current: 0, total: 2, message });
+      sendEvent("result", { success: false, error: message });
+    } finally {
+      reply.raw.end();
+      cleanupTemp(tmpDir);
+    }
+  });
+}
+
+// src/http/routes/web/merge.ts
+import * as fs5 from "fs";
+import * as os2 from "os";
+import * as path5 from "path";
+function registerMergeRoutes(server2, dbManager2, mergeCache) {
+  server2.post("/_web/merge/parse", async (request, reply) => {
+    const data = await request.file();
+    if (!data) return reply.code(400).send({ error: "No file uploaded" });
+    const tmpDir = fs5.mkdtempSync(path5.join(os2.tmpdir(), "chatlab-merge-"));
+    const tmpPath = path5.join(tmpDir, data.filename || "upload");
+    const chunks = [];
+    for await (const chunk of data.file) {
+      chunks.push(chunk);
+    }
+    fs5.writeFileSync(tmpPath, Buffer.concat(chunks));
+    try {
+      const result = await streamParseFileInfo(tmpPath, {
+        createTempDatabase(sourceFilePath) {
+          return mergeCache.createTempDatabase(path5.basename(sourceFilePath));
+        },
+        onProgress() {
+        }
+      });
+      const handle = mergeCache.store(data.filename || "upload", result.tempDbPath);
+      return {
+        handle,
+        name: result.name,
+        format: result.format,
+        platform: result.platform,
+        messageCount: result.messageCount,
+        memberCount: result.memberCount,
+        fileSize: result.fileSize
+      };
     } finally {
       try {
-        fs3.unlinkSync(tmpPath);
+        fs5.unlinkSync(tmpPath);
       } catch {
       }
       try {
-        fs3.rmdirSync(tmpDir);
+        fs5.rmdirSync(tmpDir);
       } catch {
       }
     }
   });
-  if (mergeCache) {
-    server2.post("/_web/merge/parse", async (request, reply) => {
-      const data = await request.file();
-      if (!data) return reply.code(400).send({ error: "No file uploaded" });
-      const tmpDir = fs3.mkdtempSync(path3.join(os.tmpdir(), "chatlab-merge-"));
-      const tmpPath = path3.join(tmpDir, data.filename || "upload");
-      const chunks = [];
-      for await (const chunk of data.file) {
-        chunks.push(chunk);
-      }
-      fs3.writeFileSync(tmpPath, Buffer.concat(chunks));
-      try {
-        const result = await streamParseFileInfo(tmpPath, {
-          createTempDatabase(sourceFilePath) {
-            return mergeCache.createTempDatabase(path3.basename(sourceFilePath));
-          },
-          onProgress() {
-          }
-        });
-        const handle = mergeCache.store(data.filename || "upload", result.tempDbPath);
-        return {
-          handle,
-          name: result.name,
-          format: result.format,
-          platform: result.platform,
-          messageCount: result.messageCount,
-          memberCount: result.memberCount,
-          fileSize: result.fileSize
-        };
-      } finally {
-        try {
-          fs3.unlinkSync(tmpPath);
-        } catch {
-        }
-        try {
-          fs3.rmdirSync(tmpDir);
-        } catch {
-        }
-      }
-    });
-    server2.post("/_web/merge/conflicts", async (request, reply) => {
-      const { handles } = request.body;
-      if (!handles || !Array.isArray(handles) || handles.length === 0) {
-        return reply.code(400).send({ error: "Missing or empty handles array" });
-      }
-      const readers = [];
-      try {
-        const dataSources = [];
-        for (const handle of handles) {
-          const entry = mergeCache.openReader(handle);
-          if (!entry) return reply.code(404).send({ error: `Handle not found: ${handle}` });
-          readers.push(entry.reader);
-          dataSources.push({ source: entry.reader.toDataSource(), filename: entry.filename });
-        }
-        return checkConflictsFromSources(dataSources);
-      } finally {
-        for (const r of readers) r.close();
-      }
-    });
-    server2.post("/_web/merge/execute", async (request, reply) => {
-      const { handles, outputName, format = "json", andImport } = request.body;
-      if (!handles || !Array.isArray(handles) || handles.length === 0) {
-        return reply.code(400).send({ error: "Missing handles" });
+  server2.post("/_web/merge/conflicts", async (request, reply) => {
+    const { handles } = request.body;
+    if (!handles || !Array.isArray(handles) || handles.length === 0) {
+      return reply.code(400).send({ error: "Missing or empty handles array" });
+    }
+    const readers = [];
+    try {
+      const dataSources = [];
+      for (const handle of handles) {
+        const entry = mergeCache.openReader(handle);
+        if (!entry) return reply.code(404).send({ error: `Handle not found: ${handle}` });
+        readers.push(entry.reader);
+        dataSources.push({ source: entry.reader.toDataSource(), filename: entry.filename });
       }
-      if (!outputName) {
-        return reply.code(400).send({ error: "Missing outputName" });
+      return checkConflictsFromSources(dataSources);
+    } finally {
+      for (const r of readers) r.close();
+    }
+  });
+  server2.post("/_web/merge/execute", async (request, reply) => {
+    const { handles, outputName, format = "json", andImport } = request.body;
+    if (!handles || !Array.isArray(handles) || handles.length === 0) {
+      return reply.code(400).send({ error: "Missing handles" });
+    }
+    if (!outputName) {
+      return reply.code(400).send({ error: "Missing outputName" });
+    }
+    const readers = [];
+    try {
+      const dataSources = [];
+      for (const handle of handles) {
+        const entry = mergeCache.openReader(handle);
+        if (!entry) return reply.code(404).send({ error: `Handle not found: ${handle}` });
+        readers.push(entry.reader);
+        dataSources.push({ source: entry.reader.toDataSource(), filename: entry.filename });
       }
-      const readers = [];
-      try {
-        const dataSources = [];
-        for (const handle of handles) {
-          const entry = mergeCache.openReader(handle);
-          if (!entry) return reply.code(404).send({ error: `Handle not found: ${handle}` });
-          readers.push(entry.reader);
-          dataSources.push({ source: entry.reader.toDataSource(), filename: entry.filename });
-        }
-        const merged = buildMergedOutput(dataSources, outputName);
-        let sessionId;
-        if (andImport) {
-          const { streamImport: serverStreamImport } = await import("./stream-import-RP3XB6NM.mjs");
-          const jsonData = JSON.stringify(merged.chatLabData);
-          const tmpDir = fs3.mkdtempSync(path3.join(os.tmpdir(), "chatlab-merged-"));
-          const tmpPath = path3.join(tmpDir, `${outputName}.json`);
-          fs3.writeFileSync(tmpPath, jsonData, "utf-8");
+      const merged = buildMergedOutput(dataSources, outputName);
+      let sessionId;
+      if (andImport) {
+        const { streamImport: serverStreamImport } = await import("./stream-import-VG7RP6KJ.mjs");
+        const jsonData = JSON.stringify(merged.chatLabData);
+        const tmpDir = fs5.mkdtempSync(path5.join(os2.tmpdir(), "chatlab-merged-"));
+        const tmpPath = path5.join(tmpDir, `${outputName}.json`);
+        fs5.writeFileSync(tmpPath, jsonData, "utf-8");
+        try {
+          const importResult = await serverStreamImport(dbManager2, tmpPath);
+          sessionId = importResult.sessionId;
+        } finally {
           try {
-            const importResult = await serverStreamImport(dbManager2, tmpPath);
-            sessionId = importResult.sessionId;
-          } finally {
-            try {
-              fs3.unlinkSync(tmpPath);
-            } catch {
-            }
-            try {
-              fs3.rmdirSync(tmpDir);
-            } catch {
-            }
+            fs5.unlinkSync(tmpPath);
+          } catch {
           }
-        }
-        for (const handle of handles) {
-          mergeCache.delete(handle);
-        }
-        if (format === "jsonl") {
-          const lines = [];
-          for (const line of serializeChatLabToJsonl(merged.chatLabData)) {
-            lines.push(line);
+          try {
+            fs5.rmdirSync(tmpDir);
+          } catch {
           }
-          return { success: true, sessionId, data: lines.join("\n") };
         }
-        return { success: true, sessionId, data: merged.chatLabData };
-      } finally {
-        for (const r of readers) r.close();
       }
-    });
-    server2.post("/_web/merge/clear", async (request) => {
-      const { handle } = request.body || {};
-      if (handle) {
+      for (const handle of handles) {
         mergeCache.delete(handle);
-      } else {
-        mergeCache.clear();
-      }
-      return { success: true };
-    });
-    server2.post("/_web/sessions/export-for-merge", async (request, reply) => {
-      const { sessionIds } = request.body;
-      if (!sessionIds || !Array.isArray(sessionIds) || sessionIds.length === 0) {
-        return reply.code(400).send({ error: "Missing sessionIds" });
       }
-      const handles = [];
-      for (const sid of sessionIds) {
-        const db = dbManager2.open(sid);
-        if (!db) return reply.code(404).send({ error: `Session not found: ${sid}` });
-        const exported = exportSessionToJson(db);
-        const { db: tempDb, tempDbPath } = mergeCache.createTempDatabase(exported.meta.name);
-        const { TempDbWriter } = await import("./src-ZELOFE7P.mjs");
-        const writer = new TempDbWriter(tempDb);
-        writer.writeMeta({
-          name: exported.meta.name,
-          platform: exported.meta.platform,
-          type: exported.meta.type,
-          groupId: exported.meta.groupId,
-          groupAvatar: exported.meta.groupAvatar
-        });
-        writer.writeMembers(
-          exported.members.map((m) => ({
-            platformId: m.platformId,
-            accountName: m.accountName,
-            groupNickname: m.groupNickname,
-            avatar: m.avatar
-          }))
-        );
-        writer.writeMessages(
-          exported.messages.map((msg) => ({
-            senderPlatformId: msg.sender,
-            senderAccountName: msg.accountName,
-            senderGroupNickname: msg.groupNickname,
-            timestamp: msg.timestamp,
-            type: msg.type,
-            content: msg.content
-          }))
-        );
-        writer.finish();
-        const handle = mergeCache.store(exported.meta.name, tempDbPath);
-        handles.push({ sessionId: sid, handle });
+      if (format === "jsonl") {
+        const lines = [];
+        for (const line of serializeChatLabToJsonl(merged.chatLabData)) {
+          lines.push(line);
+        }
+        return { success: true, sessionId, data: lines.join("\n") };
       }
-      return { success: true, handles };
+      return { success: true, sessionId, data: merged.chatLabData };
+    } finally {
+      for (const r of readers) r.close();
+    }
+  });
+  server2.post("/_web/merge/clear", async (request) => {
+    const { handle } = request.body || {};
+    if (handle) {
+      mergeCache.delete(handle);
+    } else {
+      mergeCache.clear();
+    }
+    return { success: true };
+  });
+  server2.post("/_web/sessions/export-for-merge", async (request, reply) => {
+    const { sessionIds } = request.body;
+    if (!sessionIds || !Array.isArray(sessionIds) || sessionIds.length === 0) {
+      return reply.code(400).send({ error: "Missing sessionIds" });
+    }
+    const handles = [];
+    for (const sid of sessionIds) {
+      const db = ensureDb2(dbManager2, sid);
+      const exported = exportSessionToJson(db);
+      const { db: tempDb, tempDbPath } = mergeCache.createTempDatabase(exported.meta.name);
+      const { TempDbWriter } = await import("./src-QBT5SYW5.mjs");
+      const writer = new TempDbWriter(tempDb);
+      writer.writeMeta({
+        name: exported.meta.name,
+        platform: exported.meta.platform,
+        type: exported.meta.type,
+        groupId: exported.meta.groupId,
+        groupAvatar: exported.meta.groupAvatar
+      });
+      writer.writeMembers(
+        exported.members.map((m) => ({
+          platformId: m.platformId,
+          accountName: m.accountName,
+          groupNickname: m.groupNickname,
+          avatar: m.avatar
+        }))
+      );
+      writer.writeMessages(
+        exported.messages.map((msg) => ({
+          senderPlatformId: msg.sender,
+          senderAccountName: msg.accountName,
+          senderGroupNickname: msg.groupNickname,
+          timestamp: msg.timestamp,
+          type: msg.type,
+          content: msg.content
+        }))
+      );
+      writer.finish();
+      const handle = mergeCache.store(exported.meta.name, tempDbPath);
+      handles.push({ sessionId: sid, handle });
+    }
+    return { success: true, handles };
+  });
+}
+
+// src/http/routes/web/export.ts
+function registerExportRoutes(server2, adapter) {
+  server2.post("/_web/sessions/:id/export/markdown", async (request, reply) => {
+    const { id } = request.params;
+    const body = request.body;
+    const sessionName = body?.sessionName || id;
+    const { result, content } = export_service_exports.exportMarkdown(adapter, {
+      sessionId: id,
+      sessionName,
+      filterMode: body.filterMode || "condition",
+      keywords: body.keywords,
+      timeFilter: body.timeFilter,
+      senderIds: body.senderIds,
+      contextSize: body.contextSize,
+      chatSessionIds: body.chatSessionIds
     });
-  }
-  const downloadsDir = options?.pathProvider?.getDownloadsDir() || path3.join(os.homedir(), "Downloads");
+    if (!result.success) {
+      return reply.code(500).send({ error: result.error });
+    }
+    reply.header("Content-Type", "text/markdown; charset=utf-8");
+    reply.header("Content-Disposition", `attachment; filename="${encodeURIComponent(sessionName)}_export.md"`);
+    return reply.send(content);
+  });
+}
+
+// src/http/routes/web/cache.ts
+import * as fs6 from "fs";
+import * as path6 from "path";
+function registerCacheRoutes(server2, downloadsDir) {
   server2.post("/_web/cache/save-to-downloads", async (request) => {
     const { filename, dataUrl } = request.body;
     if (!filename || !dataUrl) {
@@ -1618,11 +1602,11 @@ data: ${JSON.stringify(eventData)}
     const base64Prefix = dataUrl.indexOf(",");
     const base64Data = base64Prefix >= 0 ? dataUrl.slice(base64Prefix + 1) : dataUrl;
     const buffer = Buffer.from(base64Data, "base64");
-    if (!fs3.existsSync(downloadsDir)) {
-      fs3.mkdirSync(downloadsDir, { recursive: true });
+    if (!fs6.existsSync(downloadsDir)) {
+      fs6.mkdirSync(downloadsDir, { recursive: true });
     }
-    const filePath = path3.join(downloadsDir, filename);
-    fs3.writeFileSync(filePath, buffer);
+    const filePath = path6.join(downloadsDir, filename);
+    fs6.writeFileSync(filePath, buffer);
     return { success: true, filePath };
   });
   server2.post("/_web/cache/show-in-folder", async (request) => {
@@ -1632,7 +1616,7 @@ data: ${JSON.stringify(eventData)}
     }
     const { exec } = await import("child_process");
     const platform = process.platform;
-    const dir = path3.dirname(filePath);
+    const dir = path6.dirname(filePath);
     if (platform === "darwin") {
       exec(`open -R "${filePath}"`);
     } else if (platform === "win32") {
@@ -1644,8 +1628,28 @@ data: ${JSON.stringify(eventData)}
   });
 }
 
+// src/http/routes/web/index.ts
+function registerWebRoutes(server2, dbManager2, options) {
+  const adapter = createDatabaseManagerAdapter(dbManager2);
+  const mergeCache = options?.pathProvider ? new MergeSessionCache(options.pathProvider, { nativeBinding: options.nativeBinding }) : null;
+  mergeCache?.cleanupOrphans();
+  const downloadsDir = options?.pathProvider?.getDownloadsDir() || path7.join(os3.homedir(), "Downloads");
+  registerSessionRoutes2(server2, adapter);
+  registerMemberRoutes(server2, adapter);
+  registerAnalyticsRoutes(server2, dbManager2, adapter);
+  registerSqlRoutes(server2, adapter);
+  registerSessionIndexRoutes(server2, adapter);
+  registerSummaryRoutes(server2, dbManager2, adapter);
+  registerImportRoutes(server2, dbManager2);
+  if (mergeCache) {
+    registerMergeRoutes(server2, dbManager2, mergeCache);
+  }
+  registerExportRoutes(server2, adapter);
+  registerCacheRoutes(server2, downloadsDir);
+}
+
 // src/http/routes/nlp.ts
-import * as path4 from "path";
+import * as path8 from "path";
 function ensureDb3(dbManager2, sessionId) {
   const db = dbManager2.open(sessionId);
   if (!db) {
@@ -1656,7 +1660,7 @@ function ensureDb3(dbManager2, sessionId) {
 function registerNlpRoutes(server2, dbManager2) {
   const pathProvider = dbManager2["pathProvider"];
   if (pathProvider) {
-    const nlpDir = path4.join(pathProvider.getUserDataDir(), "nlp");
+    const nlpDir = path8.join(pathProvider.getUserDataDir(), "nlp");
     initNlpDir(nlpDir);
     ensureDefaultDict(nlpDir).catch((err) => console.warn("[NLP] Auto-download zh-CN dict failed:", err));
   }
@@ -1694,12 +1698,12 @@ function registerNlpRoutes(server2, dbManager2) {
 }
 function resolveNlpDir(dbManager2) {
   const pathProvider = dbManager2["pathProvider"];
-  return path4.join(pathProvider.getUserDataDir(), "nlp");
+  return path8.join(pathProvider.getUserDataDir(), "nlp");
 }
 
 // src/http/routes/ai.ts
-import * as fs7 from "fs";
-import * as path8 from "path";
+import * as fs10 from "fs";
+import * as path12 from "path";
 
 // src/ai/logger.ts
 var logger = null;
@@ -1722,7 +1726,6 @@ function closeServerAiLogger() {
 // src/ai/tool-adapter.ts
 var DEFAULT_MAX_TOOL_RESULT_TOKENS = 8e3;
 var TOOL_TRUNCATION_STRATEGY = {
-  search_keyword: "keep_first",
   search_messages: "keep_first",
   deep_search_messages: "keep_first",
   get_recent_messages: "keep_last",
@@ -1780,13 +1783,13 @@ function adaptToolsForAgent(tools, getContext, options) {
 }
 
 // src/ai/assistant-loader.ts
-import * as fs4 from "fs";
-import * as path5 from "path";
+import * as fs7 from "fs";
+import * as path9 from "path";
 function loadAssistantConfig(aiDataDir, assistantId) {
-  const filePath = path5.join(aiDataDir, "assistants", `${assistantId}.md`);
-  if (!fs4.existsSync(filePath)) return null;
+  const filePath = path9.join(aiDataDir, "assistants", `${assistantId}.md`);
+  if (!fs7.existsSync(filePath)) return null;
   try {
-    const content = fs4.readFileSync(filePath, "utf-8");
+    const content = fs7.readFileSync(filePath, "utf-8");
     return parseAssistantFile(content, filePath);
   } catch {
     return null;
@@ -1794,31 +1797,31 @@ function loadAssistantConfig(aiDataDir, assistantId) {
 }
 
 // src/ai/manager-factory.ts
-import * as fs5 from "fs";
-import * as path6 from "path";
+import * as fs8 from "fs";
+import * as path10 from "path";
 import { createHash, randomUUID as randomUUID3 } from "crypto";
 var nodeFs = {
   ensureDir(dir) {
-    if (!fs5.existsSync(dir)) fs5.mkdirSync(dir, { recursive: true });
+    if (!fs8.existsSync(dir)) fs8.mkdirSync(dir, { recursive: true });
   },
   listFiles(dir, ext) {
-    if (!fs5.existsSync(dir)) return [];
-    return fs5.readdirSync(dir).filter((f) => f.endsWith(ext));
+    if (!fs8.existsSync(dir)) return [];
+    return fs8.readdirSync(dir).filter((f) => f.endsWith(ext));
   },
   readFile(filePath) {
-    return fs5.readFileSync(filePath, "utf-8");
+    return fs8.readFileSync(filePath, "utf-8");
   },
   writeFile(filePath, content) {
-    fs5.writeFileSync(filePath, content, "utf-8");
+    fs8.writeFileSync(filePath, content, "utf-8");
   },
   deleteFile(filePath) {
-    if (fs5.existsSync(filePath)) fs5.unlinkSync(filePath);
+    if (fs8.existsSync(filePath)) fs8.unlinkSync(filePath);
   },
   fileExists(filePath) {
-    return fs5.existsSync(filePath);
+    return fs8.existsSync(filePath);
   },
   joinPath(...parts) {
-    return path6.join(...parts);
+    return path10.join(...parts);
   }
 };
 var managerCache = /* @__PURE__ */ new Map();
@@ -1828,13 +1831,13 @@ function getAssistantManager(aiDataDir) {
     cached = {
       assistant: new AssistantManager({
         fs: nodeFs,
-        assistantsDir: path6.join(aiDataDir, "assistants"),
+        assistantsDir: path10.join(aiDataDir, "assistants"),
         builtinRawConfigs: [],
         generateId: () => `custom_${randomUUID3().replace(/-/g, "").slice(0, 12)}`
       }),
       skill: new SkillManagerCore({
         fs: nodeFs,
-        skillsDir: path6.join(aiDataDir, "skills"),
+        skillsDir: path10.join(aiDataDir, "skills"),
         builtinRawSkills: [],
         contentHash: (content) => createHash("md5").update(content).digest("hex")
       })
@@ -1976,24 +1979,24 @@ async function runServerAgent(options) {
 }
 
 // src/ai/custom-store.ts
-import * as fs6 from "fs";
-import * as path7 from "path";
+import * as fs9 from "fs";
+import * as path11 from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 function readProviders(aiDataDir) {
-  const storePath = path7.join(aiDataDir, "custom-providers.json");
-  if (!fs6.existsSync(storePath)) return [];
+  const storePath = path11.join(aiDataDir, "custom-providers.json");
+  if (!fs9.existsSync(storePath)) return [];
   try {
-    const content = fs6.readFileSync(storePath, "utf-8");
+    const content = fs9.readFileSync(storePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return [];
   }
 }
 function writeProviders(aiDataDir, providers) {
-  const storePath = path7.join(aiDataDir, "custom-providers.json");
-  const dir = path7.dirname(storePath);
-  if (!fs6.existsSync(dir)) fs6.mkdirSync(dir, { recursive: true });
-  fs6.writeFileSync(storePath, JSON.stringify(providers, null, 2), "utf-8");
+  const storePath = path11.join(aiDataDir, "custom-providers.json");
+  const dir = path11.dirname(storePath);
+  if (!fs9.existsSync(dir)) fs9.mkdirSync(dir, { recursive: true });
+  fs9.writeFileSync(storePath, JSON.stringify(providers, null, 2), "utf-8");
 }
 function addCustomProvider(aiDataDir, input) {
   const providers = readProviders(aiDataDir);
@@ -2024,20 +2027,20 @@ function deleteCustomProvider(aiDataDir, id) {
   return { success: true };
 }
 function readModels(aiDataDir) {
-  const storePath = path7.join(aiDataDir, "custom-models.json");
-  if (!fs6.existsSync(storePath)) return [];
+  const storePath = path11.join(aiDataDir, "custom-models.json");
+  if (!fs9.existsSync(storePath)) return [];
   try {
-    const content = fs6.readFileSync(storePath, "utf-8");
+    const content = fs9.readFileSync(storePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return [];
   }
 }
 function writeModels(aiDataDir, models) {
-  const storePath = path7.join(aiDataDir, "custom-models.json");
-  const dir = path7.dirname(storePath);
-  if (!fs6.existsSync(dir)) fs6.mkdirSync(dir, { recursive: true });
-  fs6.writeFileSync(storePath, JSON.stringify(models, null, 2), "utf-8");
+  const storePath = path11.join(aiDataDir, "custom-models.json");
+  const dir = path11.dirname(storePath);
+  if (!fs9.existsSync(dir)) fs9.mkdirSync(dir, { recursive: true });
+  fs9.writeFileSync(storePath, JSON.stringify(models, null, 2), "utf-8");
 }
 function addCustomModel(aiDataDir, input) {
   const models = readModels(aiDataDir);
@@ -2151,10 +2154,10 @@ function registerAiRoutes(server2, dbManager2, convManager2) {
     return mgr.getBuiltinCatalog();
   });
   server2.get("/_web/ai/llm/has-config", async () => {
-    const configPath = path8.join(getAiDir(dbManager2), "llm-config.json");
-    if (!fs7.existsSync(configPath)) return false;
+    const configPath = path12.join(getAiDir(dbManager2), "llm-config.json");
+    if (!fs10.existsSync(configPath)) return false;
     try {
-      const data = JSON.parse(fs7.readFileSync(configPath, "utf-8"));
+      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 {
@@ -2162,10 +2165,10 @@ function registerAiRoutes(server2, dbManager2, convManager2) {
     }
   });
   server2.get("/_web/ai/llm/configs", async () => {
-    const configPath = path8.join(getAiDir(dbManager2), "llm-config.json");
-    if (!fs7.existsSync(configPath)) return { configs: [], defaultAssistant: null, fastModel: null };
+    const configPath = path12.join(getAiDir(dbManager2), "llm-config.json");
+    if (!fs10.existsSync(configPath)) return { configs: [], defaultAssistant: null, fastModel: null };
     try {
-      const data = JSON.parse(fs7.readFileSync(configPath, "utf-8"));
+      const data = JSON.parse(fs10.readFileSync(configPath, "utf-8"));
       const configs = (data.configs || []).map((c) => {
         const { apiKey: _k, ...rest } = c;
         return { ...rest, apiKey: "" };
@@ -2191,11 +2194,11 @@ function registerAiRoutes(server2, dbManager2, convManager2) {
     });
   });
   server2.get("/_web/ai/llm/provider-registry", async () => {
-    const customPath = path8.join(getAiDir(dbManager2), "custom-providers.json");
+    const customPath = path12.join(getAiDir(dbManager2), "custom-providers.json");
     let custom = [];
-    if (fs7.existsSync(customPath)) {
+    if (fs10.existsSync(customPath)) {
       try {
-        custom = JSON.parse(fs7.readFileSync(customPath, "utf-8"));
+        custom = JSON.parse(fs10.readFileSync(customPath, "utf-8"));
         if (!Array.isArray(custom)) custom = [];
       } catch {
         custom = [];
@@ -2204,11 +2207,11 @@ function registerAiRoutes(server2, dbManager2, convManager2) {
     return [...BUILTIN_PROVIDERS, ...custom];
   });
   server2.get("/_web/ai/llm/model-catalog", async () => {
-    const customPath = path8.join(getAiDir(dbManager2), "custom-models.json");
+    const customPath = path12.join(getAiDir(dbManager2), "custom-models.json");
     let custom = [];
-    if (fs7.existsSync(customPath)) {
+    if (fs10.existsSync(customPath)) {
       try {
-        custom = JSON.parse(fs7.readFileSync(customPath, "utf-8"));
+        custom = JSON.parse(fs10.readFileSync(customPath, "utf-8"));
         if (!Array.isArray(custom)) custom = [];
       } catch {
         custom = [];
@@ -2217,20 +2220,20 @@ function registerAiRoutes(server2, dbManager2, convManager2) {
     return [...BUILTIN_MODELS, ...custom];
   });
   server2.get("/_web/ai/llm/default-assistant-slot", async () => {
-    const configPath = path8.join(getAiDir(dbManager2), "llm-config.json");
-    if (!fs7.existsSync(configPath)) return null;
+    const configPath = path12.join(getAiDir(dbManager2), "llm-config.json");
+    if (!fs10.existsSync(configPath)) return null;
     try {
-      const data = JSON.parse(fs7.readFileSync(configPath, "utf-8"));
+      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 = path8.join(getAiDir(dbManager2), "llm-config.json");
-    if (!fs7.existsSync(configPath)) return null;
+    const configPath = path12.join(getAiDir(dbManager2), "llm-config.json");
+    if (!fs10.existsSync(configPath)) return null;
     try {
-      const data = JSON.parse(fs7.readFileSync(configPath, "utf-8"));
+      const data = JSON.parse(fs10.readFileSync(configPath, "utf-8"));
       return data.fastModel ?? null;
     } catch {
       return null;
@@ -2583,8 +2586,8 @@ var noop = () => {
 var NOOP_LOGGER = { info: noop, warn: noop, error: noop };
 
 // ../../packages/sync/src/data-source-manager.ts
-import * as fs8 from "fs";
-import * as path9 from "path";
+import * as fs11 from "fs";
+import * as path13 from "path";
 import * as crypto2 from "crypto";
 var CONFIG_FILE = "data-sources.json";
 function generateId(prefix = "ds") {
@@ -2612,17 +2615,17 @@ var DataSourceManager = class {
     this.logger = logger2 ?? NOOP_LOGGER;
   }
   getConfigPath() {
-    return path9.join(this.configDir, CONFIG_FILE);
+    return path13.join(this.configDir, CONFIG_FILE);
   }
   ensureDir() {
-    fs8.mkdirSync(this.configDir, { recursive: true });
+    fs11.mkdirSync(this.configDir, { recursive: true });
   }
   // ==================== Load / Save ====================
   loadAll() {
     try {
       const filePath = this.getConfigPath();
-      if (fs8.existsSync(filePath)) {
-        const raw = fs8.readFileSync(filePath, "utf-8");
+      if (fs11.existsSync(filePath)) {
+        const raw = fs11.readFileSync(filePath, "utf-8");
         const parsed = JSON.parse(raw);
         if (!isValidDataSourceArray(parsed)) {
           this.logger.warn("[DataSource] Incompatible config format detected, returning empty.");
@@ -2641,7 +2644,7 @@ var DataSourceManager = class {
   saveAll(sources) {
     try {
       this.ensureDir();
-      fs8.writeFileSync(this.getConfigPath(), JSON.stringify(sources, null, 2), "utf-8");
+      fs11.writeFileSync(this.getConfigPath(), JSON.stringify(sources, null, 2), "utf-8");
     } catch (err) {
       this.logger.error("[DataSource] Failed to save config", err);
     }
@@ -2715,12 +2718,12 @@ var DataSourceManager = class {
   removeSession(sourceId, sessionId) {
     const sources = this.loadAll();
     const ds = sources.find((s) => s.id === sourceId);
-    if (!ds) return false;
-    const before = ds.sessions.length;
+    if (!ds) return null;
+    const removed = ds.sessions.find((s) => s.id === sessionId);
+    if (!removed) return null;
     ds.sessions = ds.sessions.filter((s) => s.id !== sessionId);
-    if (ds.sessions.length === before) return false;
     this.saveAll(sources);
-    return true;
+    return removed;
   }
   updateSession(sourceId, sessionId, updates) {
     const sources = this.loadAll();
@@ -2766,16 +2769,15 @@ function parseRemoteSessionsResponse(body) {
 }
 
 // ../../packages/sync/src/pull-engine.ts
-import * as fs9 from "fs";
+import * as fs12 from "fs";
 import * as crypto3 from "crypto";
-var MAX_PAGES_PER_PULL = 50;
+var MAX_PAGES_PER_PULL = 5e3;
 var PULL_OVERLAP_SECONDS = 60;
 function buildPullUrl(baseUrl, remoteSessionId, params) {
   const base = `${baseUrl}/sessions/${remoteSessionId}/messages`;
   const qs = ["format=chatlab"];
   if (params.since !== void 0 && params.since > 0) qs.push(`since=${params.since}`);
   if (params.offset !== void 0 && params.offset > 0) qs.push(`offset=${params.offset}`);
-  if (params.end !== void 0 && params.end > 0) qs.push(`end=${params.end}`);
   if (params.limit !== void 0 && params.limit > 0) qs.push(`limit=${params.limit}`);
   return base + "?" + qs.join("&");
 }
@@ -2787,7 +2789,7 @@ function parseSyncFromFile(filePath) {
   try {
     const isJsonl = filePath.endsWith(".jsonl");
     if (isJsonl) {
-      const content = fs9.readFileSync(filePath, "utf-8");
+      const content = fs12.readFileSync(filePath, "utf-8");
       const lines = content.trimEnd().split("\n");
       for (let i = lines.length - 1; i >= Math.max(0, lines.length - 5); i--) {
         try {
@@ -2806,7 +2808,7 @@ function parseSyncFromFile(filePath) {
       }
       return null;
     }
-    const raw = fs9.readFileSync(filePath, "utf-8");
+    const raw = fs12.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.sync && typeof parsed.sync === "object") {
       const s = parsed.sync;
@@ -2817,9 +2819,32 @@ function parseSyncFromFile(filePath) {
     return null;
   }
 }
+function fileContainsMessages(filePath) {
+  try {
+    if (filePath.endsWith(".jsonl")) {
+      const content = fs12.readFileSync(filePath, "utf-8");
+      for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          const obj = JSON.parse(trimmed);
+          if (obj._type === "message") return true;
+        } catch {
+          continue;
+        }
+      }
+      return false;
+    }
+    const raw = fs12.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed.messages) && parsed.messages.length > 0;
+  } catch {
+    return false;
+  }
+}
 function cleanupTempFile(filePath) {
   try {
-    if (fs9.existsSync(filePath)) fs9.unlinkSync(filePath);
+    if (fs12.existsSync(filePath)) fs12.unlinkSync(filePath);
   } catch {
   }
 }
@@ -2830,6 +2855,8 @@ var PullEngine = class {
   dsManager;
   logger;
   isImporting;
+  pullingSourceIds = /* @__PURE__ */ new Set();
+  progressMap = /* @__PURE__ */ new Map();
   constructor(options) {
     this.fetcher = options.fetcher;
     this.importer = options.importer;
@@ -2838,6 +2865,9 @@ var PullEngine = class {
     this.logger = options.logger ?? NOOP_LOGGER;
     this.isImporting = options.isImporting ?? (() => false);
   }
+  getProgress() {
+    return Array.from(this.progressMap.values());
+  }
   async importTempFile(baseUrl, sess, tempFile) {
     let targetId = sess.targetSessionId;
     if (!targetId) {
@@ -2851,6 +2881,11 @@ var PullEngine = class {
     return this.importer.importFile(tempFile, targetId || void 0, externalId);
   }
   async executePullSession(sourceId, ds, sess) {
+    const currentDs = this.dsManager.get(sourceId);
+    if (!currentDs || !currentDs.sessions.some((s) => s.id === sess.id)) {
+      this.logger.info(`[Pull] Skipping "${sess.name}": session no longer exists`);
+      return { success: true, newMessageCount: 0 };
+    }
     if (this.isImporting()) {
       this.logger.info(`[Pull] Skipping "${sess.name}": import in progress`);
       return { success: false, newMessageCount: 0, error: "Import in progress" };
@@ -2858,34 +2893,114 @@ var PullEngine = class {
     this.logger.info(`[Pull] Pulling "${sess.name}" from ${ds.baseUrl}`);
     let totalNewMessages = 0;
     let since = sess.lastPullAt;
-    let offset = 0;
-    let end;
     let pageCount = 0;
     let resyncAttempted = false;
+    this.progressMap.set(sess.id, { sessionId: sess.id, sessionName: sess.name, current: 0, pages: 0, done: false });
     try {
       while (pageCount < MAX_PAGES_PER_PULL) {
         pageCount++;
         const tempFile = await this.fetcher.fetchToTempFile(ds.baseUrl, sess.remoteSessionId, ds.token, {
           since,
-          offset,
-          end,
           limit: ds.pullLimit
         });
         try {
-          const stat = fs9.statSync(tempFile);
+          const stat = fs12.statSync(tempFile);
           this.logger.info(`[Pull] "${sess.name}" page ${pageCount}: fetched ${stat.size} bytes`);
+          const sync0 = parseSyncFromFile(tempFile);
+          if (stat.size < 1024) {
+            if (!fileContainsMessages(tempFile) && sync0?.hasMore === false) {
+              cleanupTempFile(tempFile);
+              const retryDelays = [2e3, 3e3, 5e3];
+              let retrySuccess = false;
+              let retryHasMore = false;
+              for (let ri = 0; ri < retryDelays.length; ri++) {
+                this.logger.info(
+                  `[Pull] "${sess.name}" page ${pageCount} got empty response, retry ${ri + 1}/${retryDelays.length} after ${retryDelays[ri]}ms`
+                );
+                await new Promise((r) => setTimeout(r, retryDelays[ri]));
+                const retryFile = await this.fetcher.fetchToTempFile(ds.baseUrl, sess.remoteSessionId, ds.token, {
+                  since,
+                  limit: ds.pullLimit
+                });
+                const retryStat = fs12.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) {
+                  cleanupTempFile(retryFile);
+                  continue;
+                }
+                const retryResult = await this.importTempFile(ds.baseUrl, sess, retryFile);
+                cleanupTempFile(retryFile);
+                if (retryResult.needFullResync && !resyncAttempted) {
+                  resyncAttempted = true;
+                  this.logger.info(`[Pull] Resetting since=0 for "${sess.name}" full resync`);
+                  since = 0;
+                  pageCount = 0;
+                  sess.targetSessionId = "";
+                  sess.lastPullAt = 0;
+                  this.dsManager.updateSession(sourceId, sess.id, { targetSessionId: "", lastPullAt: 0 });
+                  retrySuccess = true;
+                  retryHasMore = true;
+                  break;
+                }
+                if (retryResult.needFullResync) {
+                  const errMsg = "Full resync failed";
+                  this.logger.error(`[Pull] Full resync already attempted for "${sess.name}", aborting`);
+                  this.dsManager.updateSession(sourceId, sess.id, {
+                    lastPullAt: Math.floor(Date.now() / 1e3),
+                    lastStatus: "error",
+                    lastError: errMsg
+                  });
+                  this.notifier.onPullResult(sourceId, sess.id, "error", errMsg);
+                  this.markProgressDone(sess.id);
+                  return { success: false, newMessageCount: 0, error: errMsg };
+                }
+                if (!retryResult.success) {
+                  const errMsg = retryResult.error || "Import failed";
+                  this.dsManager.updateSession(sourceId, sess.id, {
+                    lastPullAt: Math.floor(Date.now() / 1e3),
+                    lastStatus: "error",
+                    lastError: errMsg
+                  });
+                  this.notifier.onPullResult(sourceId, sess.id, "error", errMsg);
+                  this.markProgressDone(sess.id);
+                  return { success: false, newMessageCount: 0, error: errMsg };
+                }
+                if (retryResult.success && retryResult.sessionId && !sess.targetSessionId) {
+                  sess.targetSessionId = retryResult.sessionId;
+                  this.dsManager.updateSession(sourceId, sess.id, { targetSessionId: retryResult.sessionId });
+                }
+                totalNewMessages += retryResult.newMessageCount;
+                this.progressMap.set(sess.id, {
+                  sessionId: sess.id,
+                  sessionName: sess.name,
+                  current: totalNewMessages,
+                  pages: pageCount,
+                  done: false
+                });
+                if (retrySync?.hasMore && retrySync.nextSince !== void 0) {
+                  since = retrySync.nextSince;
+                }
+                retryHasMore = !!retrySync?.hasMore;
+                retrySuccess = true;
+                break;
+              }
+              if (!retrySuccess) break;
+              if (!retryHasMore) break;
+              continue;
+            }
+          }
           if (stat.size === 0) {
             cleanupTempFile(tempFile);
             break;
           }
-          const sync = parseSyncFromFile(tempFile);
+          const sync = sync0;
           const result = await this.importTempFile(ds.baseUrl, sess, tempFile);
           cleanupTempFile(tempFile);
           if (result.needFullResync && !resyncAttempted) {
             resyncAttempted = true;
             this.logger.info(`[Pull] Resetting since=0 for "${sess.name}" full resync`);
             since = 0;
-            offset = 0;
             pageCount = 0;
             sess.targetSessionId = "";
             sess.lastPullAt = 0;
@@ -2901,6 +3016,7 @@ var PullEngine = class {
               lastError: errMsg
             });
             this.notifier.onPullResult(sourceId, sess.id, "error", errMsg);
+            this.markProgressDone(sess.id);
             return { success: false, newMessageCount: 0, error: errMsg };
           }
           if (!result.success) {
@@ -2911,6 +3027,7 @@ var PullEngine = class {
               lastError: errMsg
             });
             this.notifier.onPullResult(sourceId, sess.id, "error", errMsg);
+            this.markProgressDone(sess.id);
             return { success: false, newMessageCount: 0, error: errMsg };
           }
           if (!sess.targetSessionId && result.sessionId) {
@@ -2918,11 +3035,15 @@ var PullEngine = class {
             this.dsManager.updateSession(sourceId, sess.id, { targetSessionId: result.sessionId });
           }
           totalNewMessages += result.newMessageCount;
+          this.progressMap.set(sess.id, {
+            sessionId: sess.id,
+            sessionName: sess.name,
+            current: totalNewMessages,
+            pages: pageCount,
+            done: false
+          });
           if (!sync || !sync.hasMore) break;
           if (sync.nextSince !== void 0) since = sync.nextSince;
-          if (sync.nextOffset !== void 0) offset = sync.nextOffset;
-          else offset = 0;
-          if (sync.watermark !== void 0 && !end) end = sync.watermark;
         } catch (importErr) {
           cleanupTempFile(tempFile);
           throw importErr;
@@ -2939,6 +3060,7 @@ var PullEngine = class {
       });
       if (totalNewMessages > 0) this.notifier.onSessionListChanged();
       this.notifier.onPullResult(sourceId, sess.id, "success", `+${totalNewMessages} messages`);
+      this.markProgressDone(sess.id);
       return { success: true, newMessageCount: totalNewMessages };
     } catch (error) {
       const errMsg = error.message || "Pull failed";
@@ -2949,12 +3071,29 @@ var PullEngine = class {
         lastError: errMsg
       });
       this.notifier.onPullResult(sourceId, sess.id, "error", errMsg);
+      this.markProgressDone(sess.id);
       return { success: false, newMessageCount: 0, error: errMsg };
     }
   }
+  markProgressDone(sessionId) {
+    const p = this.progressMap.get(sessionId);
+    if (p) {
+      p.done = true;
+      setTimeout(() => this.progressMap.delete(sessionId), 5e3);
+    }
+  }
   async pullAllSessions(ds) {
-    for (const sess of ds.sessions) {
-      await this.executePullSession(ds.id, ds, sess);
+    if (this.pullingSourceIds.has(ds.id)) {
+      this.logger.info(`[Pull] Skipping pullAllSessions for "${ds.baseUrl}": pull already in progress`);
+      return;
+    }
+    this.pullingSourceIds.add(ds.id);
+    try {
+      for (const sess of ds.sessions) {
+        await this.executePullSession(ds.id, ds, sess);
+      }
+    } finally {
+      this.pullingSourceIds.delete(ds.id);
     }
   }
   async triggerPull(sourceId, sessionId) {
@@ -2966,15 +3105,24 @@ var PullEngine = class {
       const result = await this.executePullSession(sourceId, ds, sess);
       return { success: result.success, error: result.error };
     }
-    const errors = [];
-    for (const sess of ds.sessions) {
-      const result = await this.executePullSession(sourceId, ds, sess);
-      if (!result.success && result.error) errors.push(`${sess.name}: ${result.error}`);
+    if (this.pullingSourceIds.has(sourceId)) {
+      this.logger.info(`[Pull] Skipping triggerPull for source ${sourceId}: pull already in progress`);
+      return { success: true };
     }
-    if (errors.length > 0) {
-      return { success: false, error: errors.join("; ") };
+    this.pullingSourceIds.add(sourceId);
+    try {
+      const errors = [];
+      for (const sess of ds.sessions) {
+        const result = await this.executePullSession(sourceId, ds, sess);
+        if (!result.success && result.error) errors.push(`${sess.name}: ${result.error}`);
+      }
+      if (errors.length > 0) {
+        return { success: false, error: errors.join("; ") };
+      }
+      return { success: true };
+    } finally {
+      this.pullingSourceIds.delete(sourceId);
     }
-    return { success: true };
   }
   async triggerPullAll(sourceId) {
     return this.triggerPull(sourceId);
@@ -3048,19 +3196,19 @@ function reloadTimer(dsId, skipInitialPull = false) {
 }
 
 // src/sync/adapters.ts
-import * as fs10 from "fs";
-import * as os2 from "os";
-import * as path10 from "path";
+import * as fs13 from "fs";
+import * as os4 from "os";
+import * as path14 from "path";
 import * as crypto4 from "crypto";
 function getTempFilePath(ext) {
   const id = crypto4.randomBytes(8).toString("hex");
-  return path10.join(os2.tmpdir(), `chatlab-pull-${id}${ext}`);
+  return path14.join(os4.tmpdir(), `chatlab-pull-${id}${ext}`);
 }
 var NodeFetcher = class {
   async fetchToTempFile(baseUrl, remoteSessionId, token, params) {
     const url = buildPullUrl(baseUrl, remoteSessionId, params);
     const headers = {
-      Accept: "application/json, application/x-ndjson"
+      Accept: "application/json"
     };
     if (token) headers["Authorization"] = `Bearer ${token}`;
     const response = await fetch(url, { headers, signal: AbortSignal.timeout(12e4) });
@@ -3071,14 +3219,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());
-    fs10.writeFileSync(tempFile, buffer);
+    fs13.writeFileSync(tempFile, buffer);
     return tempFile;
   }
 };
 function resolveNativeBinding2() {
   if (process.versions.electron) return void 0;
-  const nativePath = path10.resolve(__dirname, "../../native/better_sqlite3.node");
-  if (fs10.existsSync(nativePath)) return nativePath;
+  const nativePath = path14.resolve(__dirname, "../../native/better_sqlite3.node");
+  if (fs13.existsSync(nativePath)) return nativePath;
   return void 0;
 }
 var DirectImporter = class {
@@ -3092,12 +3240,37 @@ var DirectImporter = class {
   }
   sessionExists(sessionId) {
     const dbPath = this.dbManager.getDbPath(sessionId);
-    return fs10.existsSync(dbPath);
+    if (!fs13.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();
+      db.close();
+      if (row.cnt === 0) {
+        this.logger.warn(`[DirectImporter] DB file exists but has no message table: ${sessionId}, removing`);
+        try {
+          fs13.unlinkSync(dbPath);
+        } catch {
+        }
+        return false;
+      }
+      return true;
+    } catch {
+      this.logger.warn(`[DirectImporter] Cannot validate DB file: ${sessionId}, removing`);
+      try {
+        fs13.unlinkSync(dbPath);
+      } catch {
+      }
+      return false;
+    }
   }
   async importFile(tempFile, targetSessionId, externalId) {
     if (targetSessionId && this.sessionExists(targetSessionId)) {
       return this.incrementalImportFile(targetSessionId, tempFile);
     }
+    if (targetSessionId) {
+      this.logger.info(`[DirectImporter] Session ${targetSessionId} not found locally, need full resync`);
+      return { success: false, newMessageCount: 0, needFullResync: true };
+    }
     return this.fullImportFile(tempFile, externalId);
   }
   async incrementalImportFile(sessionId, tempFile) {
@@ -3118,7 +3291,7 @@ var DirectImporter = class {
           sessionId
         };
       }
-      if (result.error?.includes("not found") || result.error?.includes("session_not_found")) {
+      if (result.error?.includes("not found") || result.error?.includes("session_not_found") || result.error?.includes("no such table")) {
         return { success: false, newMessageCount: 0, sessionId, needFullResync: true };
       }
       return { success: false, newMessageCount: 0, sessionId, error: result.error };
@@ -3156,7 +3329,7 @@ var NoopNotifier = class {
 
 // src/sync/routes.ts
 function registerAutomationRoutes(server2, ctx) {
-  const { dsManager: dsManager2, pullEngine: pullEngine2, serverInfo } = ctx;
+  const { dsManager: dsManager2, pullEngine: pullEngine2, dbManager: dbManager2, serverInfo } = ctx;
   server2.get("/_web/automation/config", async () => {
     return {
       enabled: true,
@@ -3191,12 +3364,22 @@ function registerAutomationRoutes(server2, ctx) {
       return reply.code(404).send({ error: "Data source not found" });
     }
     reloadTimer(request.params.id, true);
+    for (const sess of added) {
+      pullEngine2.triggerPull(request.params.id, sess.id).catch(() => {
+      });
+    }
     return added;
   });
   server2.delete("/_web/automation/data-sources/:id/sessions/:sessId", async (request, reply) => {
-    const ok = dsManager2.removeSession(request.params.id, request.params.sessId);
-    if (!ok) return reply.code(404).send({ error: "Session not found" });
+    const removed = dsManager2.removeSession(request.params.id, request.params.sessId);
+    if (!removed) return reply.code(404).send({ error: "Session not found" });
     reloadTimer(request.params.id);
+    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);
+    }
     return { success: true };
   });
   server2.post(
@@ -3208,6 +3391,9 @@ function registerAutomationRoutes(server2, ctx) {
   server2.post("/_web/automation/data-sources/:id/pull-all", async (request) => {
     return pullEngine2.triggerPullAll(request.params.id);
   });
+  server2.get("/_web/automation/sync-progress", async () => {
+    return pullEngine2.getProgress();
+  });
   server2.get("/_web/automation/remote-sessions", async (request, reply) => {
     const { baseUrl, token, keyword, limit, cursor } = request.query;
     if (!baseUrl) return reply.code(400).send({ error: "baseUrl is required" });
@@ -3251,7 +3437,7 @@ function initSync(server2, dbManager2, pathProvider, serverInfo) {
     dsManager,
     logger: syncLogger
   });
-  registerAutomationRoutes(server2, { dsManager, pullEngine, serverInfo });
+  registerAutomationRoutes(server2, { dsManager, pullEngine, dbManager: dbManager2, serverInfo });
   initScheduler({
     dsManager,
     pullEngine,
@@ -3270,8 +3456,8 @@ var dbManager = null;
 var convManager = null;
 function resolveNativeBinding3() {
   if (process.versions.electron) return void 0;
-  const nativePath = path11.resolve(__dirname, "../../native/better_sqlite3.node");
-  if (fs11.existsSync(nativePath)) return nativePath;
+  const nativePath = path15.resolve(__dirname, "../../native/better_sqlite3.node");
+  if (fs14.existsSync(nativePath)) return nativePath;
   return void 0;
 }
 function ensureToken(config) {
@@ -3327,7 +3513,7 @@ async function startHttpServer(options) {
   registerWebRoutes(server, dbManager, { pathProvider, nativeBinding });
   registerPreferencesRoutes(server, pathProvider);
   initSync(server, dbManager, pathProvider, { port, host, token });
-  if (options?.webRoot && fs11.existsSync(options.webRoot)) {
+  if (options?.webRoot && fs14.existsSync(options.webRoot)) {
     setWebMode(true);
     const fastifyStatic = await import("@fastify/static");
     await server.register(fastifyStatic.default, {
@@ -3372,4 +3558,4 @@ export {
   startHttpServer,
   stopHttpServer
 };
-//# sourceMappingURL=chunk-PF4QFHC6.mjs.map
+//# sourceMappingURL=chunk-LI4X52E7.mjs.map