chatlab-cli 0.21.0 → 0.22.0

package/dist/{chunk-FBTHZU55.mjs → chunk-AMMSVJG4.mjs}

@@ -7,20 +7,21 @@ const __dirname = __pathDirname(__filename);
 import {
   importData,
   parseFile
-} from "./chunk-XUHPCRVT.mjs";
+} from "./chunk-3UBWLWXB.mjs";
 import {
   analyzeIncrementalImport,
   analyzeNewImport,
   incrementalImport,
   streamImport
-} from "./chunk-EWCSGYVT.mjs";
+} from "./chunk-4U45E7TO.mjs";
 import {
   AGENT_TOOL_REGISTRY,
   CoreDataProvider
-} from "./chunk-3DIWXYMJ.mjs";
+} from "./chunk-D2XJ4Z7G.mjs";
 import {
-  getVersion
-} from "./chunk-2AIOU3PW.mjs";
+  getVersion,
+  resolveCliPath
+} from "./chunk-6NB475AA.mjs";
 import {
   AIConversationManager,
   ALL_MIGRATIONS,
@@ -114,11 +115,10 @@ import {
   verifyCliDataPath,
   writeAuthProfile,
   writeConfigField
-} from "./chunk-EIRLEPXP.mjs";
+} from "./chunk-QJQJIUUS.mjs";
 
 // src/http/index.ts
 import * as fs14 from "fs";
-import * as path15 from "path";
 import * as crypto5 from "crypto";
 
 // src/http/server.ts
@@ -207,6 +207,10 @@ async function authHook(request, reply) {
   if (!cachedToken) return;
   if (request.url.startsWith("/_web/")) return;
   if (webModeEnabled && !request.url.startsWith("/api/")) return;
+  return requireBearerToken(request, reply);
+}
+function requireBearerToken(request, reply) {
+  if (!cachedToken) return;
   const authHeader = request.headers.authorization;
   if (!authHeader || !authHeader.startsWith("Bearer ")) {
     const err = unauthorized();
@@ -492,7 +496,7 @@ function registerSessionRoutes(server2, dbManager2) {
 
 // src/http/routes/web/index.ts
 import * as os3 from "os";
-import * as path7 from "path";
+import * as path6 from "path";
 
 // src/merger/merge-cache.ts
 import * as fs from "fs";
@@ -653,7 +657,6 @@ function registerMemberRoutes(server2, adapter) {
 
 // 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;
@@ -665,7 +668,7 @@ function parseTimeFilter(query) {
 }
 function resolveNativeBinding() {
   if (process.versions.electron) return void 0;
-  const nativePath = path2.resolve(__dirname, "../../../../native/better_sqlite3.node");
+  const nativePath = resolveCliPath("native/better_sqlite3.node");
   if (fs2.existsSync(nativePath)) return nativePath;
   return void 0;
 }
@@ -849,6 +852,11 @@ function registerSessionIndexRoutes(server2, adapter) {
     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 };
@@ -874,10 +882,10 @@ function registerSessionIndexRoutes(server2, adapter) {
 
 // src/ai/llm-config.ts
 import * as fs3 from "fs";
-import * as path3 from "path";
+import * as path2 from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 function loadLlmConfig(aiDataDir) {
-  const configPath = path3.join(aiDataDir, "llm-config.json");
+  const configPath = path2.join(aiDataDir, "llm-config.json");
   if (!fs3.existsSync(configPath)) {
     return { configs: [], defaultAssistant: null, fastModel: null };
   }
@@ -919,7 +927,7 @@ function getDefaultAssistantConfig(aiDataDir) {
 }
 var MAX_CONFIG_COUNT = 99;
 function saveLlmConfig(aiDataDir, store) {
-  const configPath = path3.join(aiDataDir, "llm-config.json");
+  const configPath = path2.join(aiDataDir, "llm-config.json");
   const toSave = {
     ...store,
     configs: store.configs.map((c) => {
@@ -1023,7 +1031,7 @@ function setFastModelSlot(aiDataDir, slot) {
   return { success: true };
 }
 function loadRawConfigStore(aiDataDir) {
-  const configPath = path3.join(aiDataDir, "llm-config.json");
+  const configPath = path2.join(aiDataDir, "llm-config.json");
   if (!fs3.existsSync(configPath)) {
     return { configs: [], defaultAssistant: null, fastModel: null };
   }
@@ -1083,13 +1091,13 @@ function registerSummaryRoutes(server2, dbManager2, adapter) {
 // src/http/routes/web/import.ts
 import * as fs4 from "fs";
 import * as os from "os";
-import * as path4 from "path";
+import * as path3 from "path";
 var DEMO_BASE_URL = "https://chatlab.fun/assets/demo";
 function cleanupTemp(...paths) {
   for (const p of paths) {
     try {
-      const stat = fs4.statSync(p);
-      if (stat.isDirectory()) {
+      const stat2 = fs4.statSync(p);
+      if (stat2.isDirectory()) {
         fs4.rmSync(p, { recursive: true, force: true });
       } else {
         fs4.unlinkSync(p);
@@ -1105,8 +1113,8 @@ function registerImportRoutes(server2, dbManager2) {
   server2.post("/_web/detect-format", async (request, reply) => {
     const data = await request.file();
     if (!data) return reply.code(400).send({ error: "No file uploaded" });
-    const tmpDir = fs4.mkdtempSync(path4.join(os.tmpdir(), "chatlab-detect-"));
-    const tmpPath = path4.join(tmpDir, data.filename || "upload");
+    const tmpDir = fs4.mkdtempSync(path3.join(os.tmpdir(), "chatlab-detect-"));
+    const tmpPath = path3.join(tmpDir, data.filename || "upload");
     try {
       const chunks = [];
       for await (const chunk of data.file) {
@@ -1123,8 +1131,8 @@ function registerImportRoutes(server2, dbManager2) {
   server2.post("/_web/scan-multi-chat", async (request, reply) => {
     const data = await request.file();
     if (!data) return reply.code(400).send({ error: "No file uploaded" });
-    const tmpDir = fs4.mkdtempSync(path4.join(os.tmpdir(), "chatlab-scan-"));
-    const tmpPath = path4.join(tmpDir, data.filename || "upload");
+    const tmpDir = fs4.mkdtempSync(path3.join(os.tmpdir(), "chatlab-scan-"));
+    const tmpPath = path3.join(tmpDir, data.filename || "upload");
     try {
       const chunks = [];
       for await (const chunk of data.file) {
@@ -1140,8 +1148,8 @@ function registerImportRoutes(server2, dbManager2) {
   server2.post("/_web/import", async (request, reply) => {
     const data = await request.file();
     if (!data) return reply.code(400).send({ error: "No file uploaded" });
-    const tmpDir = fs4.mkdtempSync(path4.join(os.tmpdir(), "chatlab-import-"));
-    const tmpPath = path4.join(tmpDir, data.filename || "upload");
+    const tmpDir = fs4.mkdtempSync(path3.join(os.tmpdir(), "chatlab-import-"));
+    const tmpPath = path3.join(tmpDir, data.filename || "upload");
     const chunks = [];
     for await (const chunk of data.file) {
       chunks.push(chunk);
@@ -1189,7 +1197,7 @@ data: ${JSON.stringify(eventData)}
   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 tmpDir = fs4.mkdtempSync(path3.join(os.tmpdir(), "chatlab-dir-import-"));
     const relativePaths = [];
     const fileBuffers = [];
     try {
@@ -1217,9 +1225,9 @@ data: ${JSON.stringify(eventData)}
         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 });
+        const targetPath = path3.resolve(tmpDir, relPath);
+        if (!targetPath.startsWith(tmpDir + path3.sep)) continue;
+        fs4.mkdirSync(path3.dirname(targetPath), { recursive: true });
         fs4.writeFileSync(targetPath, fileBuffers[i].data);
       }
       const entryPath = findEntryFileInDirectory(tmpDir);
@@ -1265,8 +1273,8 @@ data: ${JSON.stringify({ success: false, error: err instanceof Error ? err.messa
     const sessionId = request.params.id;
     const data = await request.file();
     if (!data) return reply.code(400).send({ error: "No file uploaded" });
-    const tmpDir = fs4.mkdtempSync(path4.join(os.tmpdir(), "chatlab-inc-"));
-    const tmpPath = path4.join(tmpDir, data.filename || "upload");
+    const tmpDir = fs4.mkdtempSync(path3.join(os.tmpdir(), "chatlab-inc-"));
+    const tmpPath = path3.join(tmpDir, data.filename || "upload");
     const chunks = [];
     for await (const chunk of data.file) {
       chunks.push(chunk);
@@ -1303,8 +1311,8 @@ data: ${JSON.stringify(eventData)}
     const sessionId = request.params.id;
     const data = await request.file();
     if (!data) return reply.code(400).send({ error: "No file uploaded" });
-    const tmpDir = fs4.mkdtempSync(path4.join(os.tmpdir(), "chatlab-analyze-"));
-    const tmpPath = path4.join(tmpDir, data.filename || "upload");
+    const tmpDir = fs4.mkdtempSync(path3.join(os.tmpdir(), "chatlab-analyze-"));
+    const tmpPath = path3.join(tmpDir, data.filename || "upload");
     const chunks = [];
     for await (const chunk of data.file) {
       chunks.push(chunk);
@@ -1321,8 +1329,8 @@ data: ${JSON.stringify(eventData)}
   server2.post("/_web/import/analyze", async (request, reply) => {
     const data = await request.file();
     if (!data) return reply.code(400).send({ error: "No file uploaded" });
-    const tmpDir = fs4.mkdtempSync(path4.join(os.tmpdir(), "chatlab-analyze-"));
-    const tmpPath = path4.join(tmpDir, data.filename || "upload");
+    const tmpDir = fs4.mkdtempSync(path3.join(os.tmpdir(), "chatlab-analyze-"));
+    const tmpPath = path3.join(tmpDir, data.filename || "upload");
     const chunks = [];
     for await (const chunk of data.file) {
       chunks.push(chunk);
@@ -1350,9 +1358,9 @@ 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");
+    const tmpDir = fs4.mkdtempSync(path3.join(os.tmpdir(), "chatlab-demo-"));
+    const groupPath = path3.join(tmpDir, "demo-group.json");
+    const privatePath = path3.join(tmpDir, "demo-private.json");
     try {
       sendEvent("progress", { stage: "downloading", current: 1, total: 2 });
       const groupResp = await fetch(`${DEMO_BASE_URL}/${locale}/demo-group.json`, {
@@ -1392,13 +1400,13 @@ data: ${JSON.stringify(eventData)}
 // src/http/routes/web/merge.ts
 import * as fs5 from "fs";
 import * as os2 from "os";
-import * as path5 from "path";
+import * as path4 from "path";
 function registerMergeRoutes(server2, dbManager2, mergeCache) {
   server2.post("/_web/merge/parse", async (request, reply) => {
     const data = await request.file();
     if (!data) return reply.code(400).send({ error: "No file uploaded" });
-    const tmpDir = fs5.mkdtempSync(path5.join(os2.tmpdir(), "chatlab-merge-"));
-    const tmpPath = path5.join(tmpDir, data.filename || "upload");
+    const tmpDir = fs5.mkdtempSync(path4.join(os2.tmpdir(), "chatlab-merge-"));
+    const tmpPath = path4.join(tmpDir, data.filename || "upload");
     const chunks = [];
     for await (const chunk of data.file) {
       chunks.push(chunk);
@@ -1407,7 +1415,7 @@ function registerMergeRoutes(server2, dbManager2, mergeCache) {
     try {
       const result = await streamParseFileInfo(tmpPath, {
         createTempDatabase(sourceFilePath) {
-          return mergeCache.createTempDatabase(path5.basename(sourceFilePath));
+          return mergeCache.createTempDatabase(path4.basename(sourceFilePath));
         },
         onProgress() {
         }
@@ -1472,10 +1480,10 @@ function registerMergeRoutes(server2, dbManager2, mergeCache) {
       const merged = buildMergedOutput(dataSources, outputName);
       let sessionId;
       if (andImport) {
-        const { streamImport: serverStreamImport } = await import("./stream-import-URGOCXUH.mjs");
+        const { streamImport: serverStreamImport } = await import("./stream-import-V6Z7DXSW.mjs");
         const jsonData = JSON.stringify(merged.chatLabData);
-        const tmpDir = fs5.mkdtempSync(path5.join(os2.tmpdir(), "chatlab-merged-"));
-        const tmpPath = path5.join(tmpDir, `${outputName}.json`);
+        const tmpDir = fs5.mkdtempSync(path4.join(os2.tmpdir(), "chatlab-merged-"));
+        const tmpPath = path4.join(tmpDir, `${outputName}.json`);
         fs5.writeFileSync(tmpPath, jsonData, "utf-8");
         try {
           const importResult = await serverStreamImport(dbManager2, tmpPath);
@@ -1525,7 +1533,7 @@ function registerMergeRoutes(server2, dbManager2, mergeCache) {
       const db = ensureDb2(dbManager2, sid);
       const exported = exportSessionToJson(db);
       const { db: tempDb, tempDbPath } = mergeCache.createTempDatabase(exported.meta.name);
-      const { TempDbWriter } = await import("./src-KOIGBZJX.mjs");
+      const { TempDbWriter } = await import("./src-UHM2UDRD.mjs");
       const writer = new TempDbWriter(tempDb);
       writer.writeMeta({
         name: exported.meta.name,
@@ -1587,8 +1595,192 @@ function registerExportRoutes(server2, adapter) {
 
 // src/http/routes/web/cache.ts
 import * as fs6 from "fs";
-import * as path6 from "path";
-function registerCacheRoutes(server2, downloadsDir) {
+import * as fsp from "fs/promises";
+import * as path5 from "path";
+import { execFile } from "child_process";
+function runExecFile(file, args, runner = execFile) {
+  return new Promise((resolve2, reject) => {
+    runner(file, args, (error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve2();
+    });
+  });
+}
+async function openDirectoryPath(dirPath, platform = process.platform, runner) {
+  if (platform === "darwin") {
+    await runExecFile("open", [dirPath], runner);
+  } else if (platform === "win32") {
+    await runExecFile("explorer.exe", [dirPath], runner);
+  } else {
+    await runExecFile("xdg-open", [dirPath], runner);
+  }
+}
+async function showPathInFolder(filePath, platform = process.platform, runner) {
+  if (platform === "darwin") {
+    await runExecFile("open", ["-R", filePath], runner);
+  } else if (platform === "win32") {
+    await runExecFile("explorer.exe", [`/select,${filePath}`], runner);
+  } else {
+    await runExecFile("xdg-open", [path5.dirname(filePath)], runner);
+  }
+}
+async function getDirSize(dirPath) {
+  let totalSize = 0;
+  try {
+    if (!fs6.existsSync(dirPath)) return 0;
+    const files = await fsp.readdir(dirPath, { withFileTypes: true });
+    for (const file of files) {
+      const filePath = path5.join(dirPath, file.name);
+      if (file.isDirectory()) {
+        totalSize += await getDirSize(filePath);
+      } else {
+        const stat2 = await fsp.stat(filePath);
+        totalSize += stat2.size;
+      }
+    }
+  } catch {
+  }
+  return totalSize;
+}
+async function getFileCount(dirPath) {
+  let count = 0;
+  try {
+    if (!fs6.existsSync(dirPath)) return 0;
+    const files = await fsp.readdir(dirPath, { withFileTypes: true });
+    for (const file of files) {
+      const filePath = path5.join(dirPath, file.name);
+      if (file.isDirectory()) {
+        count += await getFileCount(filePath);
+      } else {
+        count++;
+      }
+    }
+  } catch {
+  }
+  return count;
+}
+function registerCacheRoutes(server2, pathProvider) {
+  const downloadsDir = pathProvider.getDownloadsDir();
+  server2.get("/_web/cache/info", async () => {
+    const directories = [
+      {
+        id: "databases",
+        name: "settings.storage.cache.databases.name",
+        description: "settings.storage.cache.databases.description",
+        path: pathProvider.getDatabaseDir(),
+        icon: "i-heroicons-circle-stack",
+        canClear: false
+      },
+      {
+        id: "ai",
+        name: "settings.storage.cache.ai.name",
+        description: "settings.storage.cache.ai.description",
+        path: pathProvider.getAiDataDir(),
+        icon: "i-heroicons-sparkles",
+        canClear: false
+      },
+      {
+        id: "cache",
+        name: "settings.storage.cache.statsCache.name",
+        description: "settings.storage.cache.statsCache.description",
+        path: pathProvider.getCacheDir(),
+        icon: "i-heroicons-bolt",
+        canClear: true
+      },
+      {
+        id: "logs",
+        name: "settings.storage.cache.logs.name",
+        description: "settings.storage.cache.logs.description",
+        path: pathProvider.getLogsDir(),
+        icon: "i-heroicons-document-text",
+        canClear: true
+      }
+    ];
+    const results = await Promise.all(
+      directories.map(async (dir) => {
+        const [size, fileCount] = await Promise.all([getDirSize(dir.path), getFileCount(dir.path)]);
+        return { ...dir, size, fileCount, exists: fs6.existsSync(dir.path) };
+      })
+    );
+    return {
+      baseDir: pathProvider.getUserDataDir(),
+      systemDir: pathProvider.getSystemDir(),
+      directories: results,
+      totalSize: results.reduce((sum, d) => sum + d.size, 0)
+    };
+  });
+  server2.post("/_web/cache/clear", async (request) => {
+    const { cacheId } = request.body;
+    const allowedDirs = {
+      cache: pathProvider.getCacheDir(),
+      logs: pathProvider.getLogsDir()
+    };
+    const dirPath = allowedDirs[cacheId];
+    if (!dirPath) return { success: false, error: "Not allowed to clear this directory" };
+    if (!fs6.existsSync(dirPath)) return { success: true };
+    const files = await fsp.readdir(dirPath);
+    for (const file of files) {
+      const filePath = path5.join(dirPath, file);
+      const stat2 = await fsp.stat(filePath);
+      if (stat2.isDirectory()) {
+        await fsp.rm(filePath, { recursive: true });
+      } else {
+        await fsp.unlink(filePath);
+      }
+    }
+    return { success: true };
+  });
+  server2.post("/_web/cache/open-dir", async (request) => {
+    const { cacheId } = request.body;
+    const dirPaths = {
+      base: pathProvider.getUserDataDir(),
+      system: pathProvider.getSystemDir(),
+      databases: pathProvider.getDatabaseDir(),
+      cache: pathProvider.getCacheDir(),
+      ai: pathProvider.getAiDataDir(),
+      logs: pathProvider.getLogsDir(),
+      downloads: downloadsDir
+    };
+    const dirPath = dirPaths[cacheId];
+    if (!dirPath) return { success: false, error: "Unknown directory" };
+    if (!fs6.existsSync(dirPath)) {
+      await fsp.mkdir(dirPath, { recursive: true });
+    }
+    try {
+      await openDirectoryPath(dirPath);
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
+    return { success: true };
+  });
+  server2.get("/_web/cache/data-dir", async () => {
+    const config = loadConfig();
+    const isCustom = Boolean(config.data.user_data_dir || process.env.CHATLAB_DATA_DIR);
+    return { path: pathProvider.getUserDataDir(), isCustom };
+  });
+  server2.get("/_web/cache/latest-import-log", async () => {
+    const importLogDir = path5.join(pathProvider.getLogsDir(), "import");
+    if (!fs6.existsSync(importLogDir)) {
+      return { success: false, error: "Log directory not found" };
+    }
+    const files = await fsp.readdir(importLogDir);
+    const logFiles = files.filter((f) => f.startsWith("import_") && f.endsWith(".log"));
+    if (logFiles.length === 0) {
+      return { success: false, error: "No import logs found" };
+    }
+    const fileStats = await Promise.all(
+      logFiles.map(async (f) => {
+        const filePath = path5.join(importLogDir, f);
+        const stat2 = await fsp.stat(filePath);
+        return { name: f, path: filePath, mtime: stat2.mtime.getTime() };
+      })
+    );
+    fileStats.sort((a, b) => b.mtime - a.mtime);
+    return { success: true, path: fileStats[0].path, name: fileStats[0].name };
+  });
   server2.post("/_web/cache/save-to-downloads", async (request) => {
     const { filename, dataUrl } = request.body;
     if (!filename || !dataUrl) {
@@ -1600,7 +1792,7 @@ function registerCacheRoutes(server2, downloadsDir) {
     if (!fs6.existsSync(downloadsDir)) {
       fs6.mkdirSync(downloadsDir, { recursive: true });
     }
-    const filePath = path6.join(downloadsDir, filename);
+    const filePath = path5.join(downloadsDir, filename);
     fs6.writeFileSync(filePath, buffer);
     return { success: true, filePath };
   });
@@ -1609,26 +1801,46 @@ function registerCacheRoutes(server2, downloadsDir) {
     if (!filePath) {
       return { success: false, error: "filePath is required" };
     }
-    const { exec } = await import("child_process");
-    const platform = process.platform;
-    const dir = path6.dirname(filePath);
-    if (platform === "darwin") {
-      exec(`open -R "${filePath}"`);
-    } else if (platform === "win32") {
-      exec(`explorer /select,"${filePath}"`);
-    } else {
-      exec(`xdg-open "${dir}"`);
+    try {
+      await showPathInFolder(filePath);
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : String(error) };
     }
     return { success: true };
   });
 }
 
 // src/http/routes/web/index.ts
+function isNewerVersion(latest, current) {
+  const parse = (v) => {
+    const [core, pre] = v.split("-", 2);
+    const parts = core.split(".").map(Number);
+    return { major: parts[0] || 0, minor: parts[1] || 0, patch: parts[2] || 0, pre };
+  };
+  const l = parse(latest);
+  const c = parse(current);
+  if (l.major !== c.major) return l.major > c.major;
+  if (l.minor !== c.minor) return l.minor > c.minor;
+  if (l.patch !== c.patch) return l.patch > c.patch;
+  if (c.pre && !l.pre) return true;
+  return false;
+}
 function registerWebRoutes(server2, dbManager2, options) {
   const adapter = createDatabaseManagerAdapter(dbManager2);
   const mergeCache = options?.pathProvider ? new MergeSessionCache(options.pathProvider, { nativeBinding: options.nativeBinding }) : null;
   mergeCache?.cleanupOrphans();
-  const downloadsDir = options?.pathProvider?.getDownloadsDir() || path7.join(os3.homedir(), "Downloads");
+  const fallbackPathProvider = {
+    getSystemDir: () => path6.join(os3.homedir(), ".chatlab"),
+    getUserDataDir: () => path6.join(os3.homedir(), ".chatlab", "data"),
+    getDatabaseDir: () => path6.join(os3.homedir(), ".chatlab", "data", "databases"),
+    getAiDataDir: () => path6.join(os3.homedir(), ".chatlab", "ai"),
+    getSettingsDir: () => path6.join(os3.homedir(), ".chatlab", "settings"),
+    getCacheDir: () => path6.join(os3.homedir(), ".chatlab", "cache"),
+    getTempDir: () => path6.join(os3.homedir(), ".chatlab", "temp"),
+    getLogsDir: () => path6.join(os3.homedir(), ".chatlab", "logs"),
+    getDownloadsDir: () => path6.join(os3.homedir(), "Downloads")
+  };
+  const resolvedPathProvider = options?.pathProvider ?? fallbackPathProvider;
   registerSessionRoutes2(server2, adapter);
   registerMemberRoutes(server2, adapter);
   registerAnalyticsRoutes(server2, dbManager2, adapter);
@@ -1640,11 +1852,34 @@ function registerWebRoutes(server2, dbManager2, options) {
     registerMergeRoutes(server2, dbManager2, mergeCache);
   }
   registerExportRoutes(server2, adapter);
-  registerCacheRoutes(server2, downloadsDir);
+  registerCacheRoutes(server2, resolvedPathProvider);
+  server2.get("/_web/system/check-update", async () => {
+    const currentVersion = getVersion();
+    const packageName = "chatlab-cli";
+    try {
+      const resp = await fetch(`https://registry.npmjs.org/${packageName}/latest`, {
+        headers: { Accept: "application/json" },
+        signal: AbortSignal.timeout(1e4)
+      });
+      if (!resp.ok) {
+        return { hasUpdate: false, currentVersion, error: `npm registry HTTP ${resp.status}` };
+      }
+      const data = await resp.json();
+      const latestVersion = data.version || currentVersion;
+      const hasUpdate = isNewerVersion(latestVersion, currentVersion);
+      return { hasUpdate, currentVersion, latestVersion };
+    } catch (err) {
+      return {
+        hasUpdate: false,
+        currentVersion,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  });
 }
 
 // src/http/routes/nlp.ts
-import * as path8 from "path";
+import * as path7 from "path";
 function ensureDb3(dbManager2, sessionId) {
   const db = dbManager2.open(sessionId);
   if (!db) {
@@ -1655,7 +1890,7 @@ function ensureDb3(dbManager2, sessionId) {
 function registerNlpRoutes(server2, dbManager2) {
   const pathProvider = dbManager2["pathProvider"];
   if (pathProvider) {
-    const nlpDir = path8.join(pathProvider.getUserDataDir(), "nlp");
+    const nlpDir = path7.join(pathProvider.getSystemDir(), "nlp");
     initNlpDir(nlpDir);
     ensureDefaultDict(nlpDir).catch((err) => console.warn("[NLP] Auto-download zh-CN dict failed:", err));
   }
@@ -1693,12 +1928,12 @@ function registerNlpRoutes(server2, dbManager2) {
 }
 function resolveNlpDir(dbManager2) {
   const pathProvider = dbManager2["pathProvider"];
-  return path8.join(pathProvider.getUserDataDir(), "nlp");
+  return path7.join(pathProvider.getSystemDir(), "nlp");
 }
 
 // src/http/routes/ai.ts
 import * as fs10 from "fs";
-import * as path12 from "path";
+import * as path11 from "path";
 
 // src/ai/logger.ts
 var logger = null;
@@ -1747,6 +1982,7 @@ function adaptToolsForAgent(tools, getContext, options) {
     description: tool.description,
     parameters: convertJsonSchemaToParameters(tool.inputSchema),
     async execute(_toolCallId, params) {
+      const toolParams = params && typeof params === "object" ? params : {};
       const ctx = getContext();
       const execCtx = {
         db: ctx.db,
@@ -1756,7 +1992,7 @@ function adaptToolsForAgent(tools, getContext, options) {
         segmentText: (texts, locale, options2) => batchSegmentWithFrequency(texts, locale, options2)
       };
       try {
-        const result = await tool.handler(params, execCtx);
+        const result = await tool.handler(toolParams, execCtx);
         if (result.rawMessages && result.rawMessages.length > 0) {
           const pipelineResult = applyPreprocessingPipeline({
             rawMessages: result.rawMessages,
@@ -1779,9 +2015,9 @@ function adaptToolsForAgent(tools, getContext, options) {
 
 // src/ai/assistant-loader.ts
 import * as fs7 from "fs";
-import * as path9 from "path";
+import * as path8 from "path";
 function loadAssistantConfig(aiDataDir, assistantId) {
-  const filePath = path9.join(aiDataDir, "assistants", `${assistantId}.md`);
+  const filePath = path8.join(aiDataDir, "assistants", `${assistantId}.md`);
   if (!fs7.existsSync(filePath)) return null;
   try {
     const content = fs7.readFileSync(filePath, "utf-8");
@@ -1793,7 +2029,7 @@ function loadAssistantConfig(aiDataDir, assistantId) {
 
 // src/ai/manager-factory.ts
 import * as fs8 from "fs";
-import * as path10 from "path";
+import * as path9 from "path";
 import { createHash, randomUUID as randomUUID3 } from "crypto";
 var nodeFs = {
   ensureDir(dir) {
@@ -1816,7 +2052,7 @@ var nodeFs = {
     return fs8.existsSync(filePath);
   },
   joinPath(...parts) {
-    return path10.join(...parts);
+    return path9.join(...parts);
   }
 };
 var managerCache = /* @__PURE__ */ new Map();
@@ -1826,13 +2062,13 @@ function getAssistantManager(aiDataDir) {
     cached = {
       assistant: new AssistantManager({
         fs: nodeFs,
-        assistantsDir: path10.join(aiDataDir, "assistants"),
+        assistantsDir: path9.join(aiDataDir, "assistants"),
         builtinRawConfigs: [],
         generateId: () => `custom_${randomUUID3().replace(/-/g, "").slice(0, 12)}`
       }),
       skill: new SkillManagerCore({
         fs: nodeFs,
-        skillsDir: path10.join(aiDataDir, "skills"),
+        skillsDir: path9.join(aiDataDir, "skills"),
         builtinRawSkills: [],
         contentHash: (content) => createHash("md5").update(content).digest("hex")
       })
@@ -1975,10 +2211,10 @@ async function runServerAgent(options) {
 
 // src/ai/custom-store.ts
 import * as fs9 from "fs";
-import * as path11 from "path";
+import * as path10 from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 function readProviders(aiDataDir) {
-  const storePath = path11.join(aiDataDir, "custom-providers.json");
+  const storePath = path10.join(aiDataDir, "custom-providers.json");
   if (!fs9.existsSync(storePath)) return [];
   try {
     const content = fs9.readFileSync(storePath, "utf-8");
@@ -1988,8 +2224,8 @@ function readProviders(aiDataDir) {
   }
 }
 function writeProviders(aiDataDir, providers) {
-  const storePath = path11.join(aiDataDir, "custom-providers.json");
-  const dir = path11.dirname(storePath);
+  const storePath = path10.join(aiDataDir, "custom-providers.json");
+  const dir = path10.dirname(storePath);
   if (!fs9.existsSync(dir)) fs9.mkdirSync(dir, { recursive: true });
   fs9.writeFileSync(storePath, JSON.stringify(providers, null, 2), "utf-8");
 }
@@ -2022,7 +2258,7 @@ function deleteCustomProvider(aiDataDir, id) {
   return { success: true };
 }
 function readModels(aiDataDir) {
-  const storePath = path11.join(aiDataDir, "custom-models.json");
+  const storePath = path10.join(aiDataDir, "custom-models.json");
   if (!fs9.existsSync(storePath)) return [];
   try {
     const content = fs9.readFileSync(storePath, "utf-8");
@@ -2032,8 +2268,8 @@ function readModels(aiDataDir) {
   }
 }
 function writeModels(aiDataDir, models) {
-  const storePath = path11.join(aiDataDir, "custom-models.json");
-  const dir = path11.dirname(storePath);
+  const storePath = path10.join(aiDataDir, "custom-models.json");
+  const dir = path10.dirname(storePath);
   if (!fs9.existsSync(dir)) fs9.mkdirSync(dir, { recursive: true });
   fs9.writeFileSync(storePath, JSON.stringify(models, null, 2), "utf-8");
 }
@@ -2149,7 +2385,7 @@ function registerAiRoutes(server2, dbManager2, convManager2) {
     return mgr.getBuiltinCatalog();
   });
   server2.get("/_web/ai/llm/has-config", async () => {
-    const configPath = path12.join(getAiDir(dbManager2), "llm-config.json");
+    const configPath = path11.join(getAiDir(dbManager2), "llm-config.json");
     if (!fs10.existsSync(configPath)) return false;
     try {
       const data = JSON.parse(fs10.readFileSync(configPath, "utf-8"));
@@ -2160,7 +2396,7 @@ function registerAiRoutes(server2, dbManager2, convManager2) {
     }
   });
   server2.get("/_web/ai/llm/configs", async () => {
-    const configPath = path12.join(getAiDir(dbManager2), "llm-config.json");
+    const configPath = path11.join(getAiDir(dbManager2), "llm-config.json");
     if (!fs10.existsSync(configPath)) return { configs: [], defaultAssistant: null, fastModel: null };
     try {
       const data = JSON.parse(fs10.readFileSync(configPath, "utf-8"));
@@ -2189,7 +2425,7 @@ function registerAiRoutes(server2, dbManager2, convManager2) {
     });
   });
   server2.get("/_web/ai/llm/provider-registry", async () => {
-    const customPath = path12.join(getAiDir(dbManager2), "custom-providers.json");
+    const customPath = path11.join(getAiDir(dbManager2), "custom-providers.json");
     let custom = [];
     if (fs10.existsSync(customPath)) {
       try {
@@ -2202,7 +2438,7 @@ function registerAiRoutes(server2, dbManager2, convManager2) {
     return [...BUILTIN_PROVIDERS, ...custom];
   });
   server2.get("/_web/ai/llm/model-catalog", async () => {
-    const customPath = path12.join(getAiDir(dbManager2), "custom-models.json");
+    const customPath = path11.join(getAiDir(dbManager2), "custom-models.json");
     let custom = [];
     if (fs10.existsSync(customPath)) {
       try {
@@ -2215,7 +2451,7 @@ function registerAiRoutes(server2, dbManager2, convManager2) {
     return [...BUILTIN_MODELS, ...custom];
   });
   server2.get("/_web/ai/llm/default-assistant-slot", async () => {
-    const configPath = path12.join(getAiDir(dbManager2), "llm-config.json");
+    const configPath = path11.join(getAiDir(dbManager2), "llm-config.json");
     if (!fs10.existsSync(configPath)) return null;
     try {
       const data = JSON.parse(fs10.readFileSync(configPath, "utf-8"));
@@ -2225,7 +2461,7 @@ function registerAiRoutes(server2, dbManager2, convManager2) {
     }
   });
   server2.get("/_web/ai/llm/fast-model-slot", async () => {
-    const configPath = path12.join(getAiDir(dbManager2), "llm-config.json");
+    const configPath = path11.join(getAiDir(dbManager2), "llm-config.json");
     if (!fs10.existsSync(configPath)) return null;
     try {
       const data = JSON.parse(fs10.readFileSync(configPath, "utf-8"));
@@ -2582,7 +2818,7 @@ var NOOP_LOGGER = { info: noop, warn: noop, error: noop };
 
 // ../../packages/sync/src/data-source-manager.ts
 import * as fs11 from "fs";
-import * as path13 from "path";
+import * as path12 from "path";
 import * as crypto2 from "crypto";
 var CONFIG_FILE = "data-sources.json";
 function generateId(prefix = "ds") {
@@ -2610,7 +2846,7 @@ var DataSourceManager = class {
     this.logger = logger2 ?? NOOP_LOGGER;
   }
   getConfigPath() {
-    return path13.join(this.configDir, CONFIG_FILE);
+    return path12.join(this.configDir, CONFIG_FILE);
   }
   ensureDir() {
     fs11.mkdirSync(this.configDir, { recursive: true });
@@ -2713,12 +2949,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,14 +3002,13 @@ function parseRemoteSessionsResponse(body) {
 // ../../packages/sync/src/pull-engine.ts
 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("&");
 }
@@ -2815,6 +3050,29 @@ 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 (fs12.existsSync(filePath)) fs12.unlinkSync(filePath);
@@ -2829,6 +3087,7 @@ var PullEngine = class {
   logger;
   isImporting;
   pullingSourceIds = /* @__PURE__ */ new Set();
+  progressMap = /* @__PURE__ */ new Map();
   constructor(options) {
     this.fetcher = options.fetcher;
     this.importer = options.importer;
@@ -2837,6 +3096,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) {
@@ -2850,6 +3112,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" };
@@ -2857,34 +3124,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 = fs12.statSync(tempFile);
-          this.logger.info(`[Pull] "${sess.name}" page ${pageCount}: fetched ${stat.size} bytes`);
-          if (stat.size === 0) {
+          const stat2 = fs12.statSync(tempFile);
+          this.logger.info(`[Pull] "${sess.name}" page ${pageCount}: fetched ${stat2.size} bytes`);
+          const sync0 = parseSyncFromFile(tempFile);
+          if (stat2.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 (stat2.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;
@@ -2900,6 +3247,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) {
@@ -2910,6 +3258,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) {
@@ -2917,11 +3266,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;
@@ -2938,6 +3291,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";
@@ -2948,9 +3302,17 @@ 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) {
     if (this.pullingSourceIds.has(ds.id)) {
       this.logger.info(`[Pull] Skipping pullAllSessions for "${ds.baseUrl}": pull already in progress`);
@@ -3067,17 +3429,17 @@ function reloadTimer(dsId, skipInitialPull = false) {
 // src/sync/adapters.ts
 import * as fs13 from "fs";
 import * as os4 from "os";
-import * as path14 from "path";
+import * as path13 from "path";
 import * as crypto4 from "crypto";
 function getTempFilePath(ext) {
   const id = crypto4.randomBytes(8).toString("hex");
-  return path14.join(os4.tmpdir(), `chatlab-pull-${id}${ext}`);
+  return path13.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) });
@@ -3094,7 +3456,7 @@ var NodeFetcher = class {
 };
 function resolveNativeBinding2() {
   if (process.versions.electron) return void 0;
-  const nativePath = path14.resolve(__dirname, "../../native/better_sqlite3.node");
+  const nativePath = resolveCliPath("native/better_sqlite3.node");
   if (fs13.existsSync(nativePath)) return nativePath;
   return void 0;
 }
@@ -3109,7 +3471,28 @@ var DirectImporter = class {
   }
   sessionExists(sessionId) {
     const dbPath = this.dbManager.getDbPath(sessionId);
-    return fs13.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)) {
@@ -3139,7 +3522,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 };
@@ -3177,7 +3560,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,
@@ -3219,9 +3602,15 @@ function registerAutomationRoutes(server2, ctx) {
     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(
@@ -3233,6 +3622,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" });
@@ -3276,7 +3668,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,
@@ -3295,7 +3687,7 @@ var dbManager = null;
 var convManager = null;
 function resolveNativeBinding3() {
   if (process.versions.electron) return void 0;
-  const nativePath = path15.resolve(__dirname, "../../native/better_sqlite3.node");
+  const nativePath = resolveCliPath("native/better_sqlite3.node");
   if (fs14.existsSync(nativePath)) return nativePath;
   return void 0;
 }
@@ -3320,7 +3712,7 @@ async function startHttpServer(options) {
   const pathProvider = new NodePathProvider(userDataDir);
   pathProvider.ensureAllDirs();
   if (hasPendingElectronDataWarning() || !verifyCliDataPath(pathProvider.getDatabaseDir())) {
-    throw new Error(
+    console.error(
       "\n" + "=".repeat(68) + "\n  ChatLab: Electron desktop data not found\n" + "=".repeat(68) + '\n\n  Detected that ChatLab desktop app was installed on this machine,\n  but could not locate your chat databases.\n\n  This usually means you changed the data directory in desktop settings.\n\n  To fix this, choose one of:\n\n  1. Open ChatLab desktop app \u2014 it will auto-migrate your data\n  2. Set the data directory manually:\n     export CHATLAB_DATA_DIR="/path/to/your/data"\n  3. Edit ~/.chatlab/config.toml:\n     [data]\n     user_data_dir = "/path/to/your/data"\n\n' + "=".repeat(68) + "\n"
     );
   }
@@ -3397,4 +3789,4 @@ export {
   startHttpServer,
   stopHttpServer
 };
-//# sourceMappingURL=chunk-FBTHZU55.mjs.map
+//# sourceMappingURL=chunk-AMMSVJG4.mjs.map