chatlab-cli 0.26.3 → 0.27.1

package/dist/{chunk-QMXNJRTT.mjs → chunk-SIVERPF5.mjs}

@@ -5,18 +5,17 @@ const require = __createRequire(import.meta.url);
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 import {
-  importData,
-  parseFile
-} from "./chunk-D5MWER7N.mjs";
+  closeServerAiLogger,
+  createCliRunAgentStream,
+  initServerAiLogger
+} from "./chunk-RJ4D4QWK.mjs";
 import {
-  analyzeIncrementalImport,
-  analyzeNewImport,
-  incrementalImport,
-  streamImport
-} from "./chunk-VCN64OD6.mjs";
+  AGENT_TOOL_REGISTRY,
+  CoreDataProvider
+} from "./chunk-WQMKKUSD.mjs";
 import {
   assertCliDataDirCompatible
-} from "./chunk-742TAKEP.mjs";
+} from "./chunk-3JNVGW62.mjs";
 import {
   getVersion
 } from "./chunk-5ADKYYNA.mjs";
@@ -24,14 +23,37 @@ import {
   resolveCliPath
 } from "./chunk-FJ35V3TE.mjs";
 import {
-  closeServerAiLogger,
-  createCliRunAgentStream,
-  initServerAiLogger
-} from "./chunk-GNGZHBKM.mjs";
+  importData,
+  parseFile
+} from "./chunk-YUFYTDRH.mjs";
 import {
-  AGENT_TOOL_REGISTRY,
-  CoreDataProvider
-} from "./chunk-RMITK4IC.mjs";
+  analyzeIncrementalImport,
+  analyzeNewImport,
+  incrementalImport,
+  streamImport
+} from "./chunk-SAE2H2LN.mjs";
+import {
+  NodePathProvider,
+  PreferencesManager,
+  applyPendingNodeDataDirMigrationIfNeeded,
+  buildMergedOutput,
+  checkConflictsFromSources,
+  createJiebaNlpProvider,
+  createNodeDataDirSwitch,
+  createSemanticIndexWorkerRuntimeClient,
+  detectAllFormats,
+  detectFormat,
+  findEntryFileInDirectory,
+  getDbFileVersion,
+  getDefaultNodeUserDataDir,
+  getOrComputeAnalysisCache,
+  getPendingNodeDataDirMigration,
+  getSupportedFormats,
+  hasPendingElectronDataWarning,
+  scanMultiChatFile,
+  serializeChatLabToJsonl,
+  streamParseFileInfo
+} from "./chunk-N3G43SCQ.mjs";
 import {
   AIChatManager,
   ALL_MIGRATIONS,
@@ -46,23 +68,16 @@ import {
   LLMConfigStore,
   MergeSessionCache,
   MigrationRunner,
-  NodePathProvider,
   POS_TAG_DEFINITIONS,
-  PreferencesManager,
+  SEMANTIC_INDEX_CONFIG_FILE,
+  SemanticIndexConfigStore,
   SkillManagerCore,
   TempDbWriter,
-  applyPendingNodeDataDirMigrationIfNeeded,
-  buildMergedOutput,
   buildPiModel,
-  checkConflictsFromSources,
   computeWordFrequency,
   countMessagesTokens,
   createDatabaseManagerAdapter,
-  createJiebaNlpProvider,
-  createNodeDataDirSwitch,
   deleteDict,
-  detectAllFormats,
-  detectFormat,
   downloadDict,
   ensureDefaultDict,
   executeReadonlySql,
@@ -70,15 +85,12 @@ import {
   exportSessionToJson,
   export_service_exports,
   fetchRemoteModels,
-  findEntryFileInDirectory,
   getAvailableYears,
   getBuiltinModelsByProvider,
   getCatchphraseAnalysis,
   getCheckInAnalysis,
   getClusterGraph,
   getDailyActivity,
-  getDbFileVersion,
-  getDefaultNodeUserDataDir,
   getDefaultRulesForLocale,
   getDictList,
   getDivingAnalysis,
@@ -98,44 +110,40 @@ import {
   getMessageTypeStats,
   getMonthlyActivity,
   getNightOwlAnalysis,
-  getOrComputeAnalysisCache,
-  getPendingNodeDataDirMigration,
   getRelationshipStats,
   getRepeatAnalysis,
   getSchemaDetailed,
   getSessionInfo,
   getSessionMeta,
   getSessionOverview,
-  getSupportedFormats,
   getTextLengthPercentiles,
   getTextStats,
   getTimeRange,
   getWeekdayActivity,
   getYearlyActivity,
-  hasPendingElectronDataWarning,
   initNlpDir,
   isDictDownloaded,
   isNewerStableVersion,
+  isSemanticIndexConfigured,
   loadConfig,
   member_service_exports,
   mergeRulesForLocale,
   owner_profile_service_exports,
+  persistSemanticIndexConfig,
   queryMessages,
   resolveApiKey,
+  resolveSemanticIndexApiKeySet,
   runSimpleLlmStream,
-  scanMultiChatFile,
   segmentText,
-  serializeChatLabToJsonl,
   session_index_service_exports,
   session_service_exports,
-  streamParseFileInfo,
   stripAvatarFields,
   summary_service_exports,
   validateApiKey,
   verifyCliDataPath,
   writeAuthProfile,
   writeConfigField
-} from "./chunk-YPTJVTVJ.mjs";
+} from "./chunk-I7BHOZPX.mjs";
 
 // src/http/index.ts
 import * as fs11 from "fs";
@@ -1401,17 +1409,21 @@ function registerAiToolRoutes(server2, ctx) {
     if (!entry) {
       return reply.code(404).send({ success: false, error: `Tool not found: ${toolName}` });
     }
-    const db = ctx.dbManager.open(sessionId);
-    if (!db) {
-      return reply.code(404).send({ success: false, error: `Session not found: ${sessionId}` });
-    }
     const abortController = new AbortController();
     activeToolTests.set(testId, abortController);
     try {
+      if (ctx.executeAiTool) {
+        return await ctx.executeAiTool({ testId, toolName, params, sessionId, abortSignal: abortController.signal });
+      }
+      const db = ctx.dbManager.open(sessionId);
+      if (!db) {
+        return reply.code(404).send({ success: false, error: `Session not found: ${sessionId}` });
+      }
       const execCtx = {
         sessionId,
         db,
-        dataProvider: new CoreDataProvider(db)
+        dataProvider: new CoreDataProvider(db),
+        abortSignal: abortController.signal
       };
       const startTime = Date.now();
       const result = await entry.handler(params, execCtx);
@@ -1612,10 +1624,93 @@ function registerAiSummaryRoutes(server2, ctx) {
   });
 }
 
+// ../../packages/http-routes/src/routes/web/ai-semantic-index.ts
+import path4 from "path";
+function registerSemanticIndexRoutes(server2, ctx) {
+  const service = ctx.semanticIndexService;
+  if (!service) {
+    if (ctx.aiDataDir) {
+      const configStore = new SemanticIndexConfigStore(path4.join(ctx.aiDataDir, SEMANTIC_INDEX_CONFIG_FILE));
+      const configResponse = (config) => ({
+        config,
+        apiKeySet: resolveSemanticIndexApiKeySet(config, ctx.resolveApiKey),
+        configured: isSemanticIndexConfigured(config)
+      });
+      server2.get("/_web/ai/semantic-index/config", async () => configResponse(configStore.get()));
+      server2.put(
+        "/_web/ai/semantic-index/config",
+        async (request) => {
+          const config = persistSemanticIndexConfig(configStore, request.body.config, {
+            apiKey: request.body.apiKey,
+            writeAuthProfile: ctx.writeAuthProfile
+          });
+          return configResponse(config);
+        }
+      );
+    }
+    server2.get("/_web/ai/semantic-index/enabled", async () => ({ sessions: [] }));
+    server2.get("/_web/ai/semantic-index/status", async () => ({ status: null }));
+    server2.post("/_web/ai/semantic-index/status", async () => ({ sessions: [] }));
+    return;
+  }
+  server2.get("/_web/ai/semantic-index/config", async () => {
+    return {
+      config: await service.getConfig(),
+      apiKeySet: await service.hasApiKey(),
+      configured: await service.isConfigured()
+    };
+  });
+  server2.put(
+    "/_web/ai/semantic-index/config",
+    async (request) => {
+      const config = await service.setConfig(request.body.config, { apiKey: request.body.apiKey });
+      return { config, apiKeySet: await service.hasApiKey(), configured: await service.isConfigured() };
+    }
+  );
+  server2.get("/_web/ai/semantic-index/enabled", async () => {
+    return { sessions: await service.listEnabledStatuses() };
+  });
+  server2.get("/_web/ai/semantic-index/status", async (request) => {
+    return { status: await service.status(request.query.sessionId) };
+  });
+  server2.post("/_web/ai/semantic-index/status", async (request) => {
+    return { sessions: await service.statusForSessions(request.body.sessionIds ?? []) };
+  });
+  const sessionAction = (path13, action) => {
+    server2.post(path13, async (request, reply) => {
+      const { sessionId } = request.body;
+      if (!sessionId) return reply.code(400).send({ error: "sessionId is required" });
+      await action(sessionId);
+      return { status: await service.status(sessionId) };
+    });
+  };
+  sessionAction("/_web/ai/semantic-index/enable", (id) => service.enable(id));
+  sessionAction("/_web/ai/semantic-index/disable", (id) => service.disable(id));
+  sessionAction("/_web/ai/semantic-index/build", (id) => service.build(id));
+  sessionAction("/_web/ai/semantic-index/pause", (id) => service.pause(id));
+  sessionAction("/_web/ai/semantic-index/cancel", (id) => service.cancel(id));
+  sessionAction("/_web/ai/semantic-index/rebuild", (id) => service.rebuild(id));
+  server2.post("/_web/ai/semantic-index/build-pending", async () => {
+    await service.buildAllPending();
+    return { sessions: await service.listEnabledStatuses() };
+  });
+  server2.post("/_web/ai/semantic-index/cleanup", async () => {
+    return await service.cleanupUnused();
+  });
+  server2.post(
+    "/_web/ai/semantic-index/search",
+    async (request, reply) => {
+      const { sessionId, query, finalTopK } = request.body;
+      if (!sessionId || !query) return reply.code(400).send({ error: "sessionId and query are required" });
+      return service.search(sessionId, query, { finalTopK });
+    }
+  );
+}
+
 // ../../packages/http-routes/src/routes/web/merge.ts
 import * as fs3 from "fs";
 import * as os from "os";
-import * as path4 from "path";
+import * as path5 from "path";
 function ensureDb2(ctx, sessionId) {
   const db = ctx.dbManager.open(sessionId);
   if (!db) throw sessionNotFound(sessionId);
@@ -1632,8 +1727,8 @@ function registerMergeRoutes(server2, ctx) {
     if (contentType.includes("multipart/form-data")) {
       const data = await request.file();
       if (!data) return reply.code(400).send({ error: "No file uploaded" });
-      const tmpDir = fs3.mkdtempSync(path4.join(os.tmpdir(), "chatlab-merge-"));
-      const tmpPath = path4.join(tmpDir, data.filename || "upload");
+      const tmpDir = fs3.mkdtempSync(path5.join(os.tmpdir(), "chatlab-merge-"));
+      const tmpPath = path5.join(tmpDir, data.filename || "upload");
       const chunks = [];
       for await (const chunk of data.file) {
         chunks.push(chunk);
@@ -1651,12 +1746,12 @@ function registerMergeRoutes(server2, ctx) {
     try {
       const result = await streamParseFileInfo(filePath, {
         createTempDatabase(sourceFilePath) {
-          return mergeCache.createTempDatabase(path4.basename(sourceFilePath));
+          return mergeCache.createTempDatabase(path5.basename(sourceFilePath));
         },
         onProgress() {
         }
       });
-      const filename = path4.basename(filePath);
+      const filename = path5.basename(filePath);
       const handle = mergeCache.store(filename, result.tempDbPath);
       return {
         handle,
@@ -1725,9 +1820,9 @@ function registerMergeRoutes(server2, ctx) {
           return reply.code(501).send({ error: "Import not available on this server" });
         }
         const jsonData = JSON.stringify(merged.chatLabData);
-        const tmpDir = fs3.mkdtempSync(path4.join(os.tmpdir(), "chatlab-merged-"));
-        const safeName = path4.basename(outputName).replace(/[/\\?%*:|"<>]/g, "_") || "merged";
-        const tmpPath = path4.join(tmpDir, `${safeName}.json`);
+        const tmpDir = fs3.mkdtempSync(path5.join(os.tmpdir(), "chatlab-merged-"));
+        const safeName = path5.basename(outputName).replace(/[/\\?%*:|"<>]/g, "_") || "merged";
+        const tmpPath = path5.join(tmpDir, `${safeName}.json`);
         fs3.writeFileSync(tmpPath, jsonData, "utf-8");
         try {
           const importResult = await streamImport2(dbManager2, tmpPath);
@@ -1814,14 +1909,14 @@ function registerMergeRoutes(server2, ctx) {
 // ../../packages/http-routes/src/routes/web/cache.ts
 import * as fs4 from "fs";
 import * as fsp from "fs/promises";
-import * as path5 from "path";
+import * as path6 from "path";
 async function getDirSize(dirPath) {
   let totalSize = 0;
   try {
     if (!fs4.existsSync(dirPath)) return 0;
     const files = await fsp.readdir(dirPath, { withFileTypes: true });
     for (const file of files) {
-      const filePath = path5.join(dirPath, file.name);
+      const filePath = path6.join(dirPath, file.name);
       if (file.isDirectory()) {
         totalSize += await getDirSize(filePath);
       } else {
@@ -1839,7 +1934,7 @@ async function getFileCount(dirPath) {
     if (!fs4.existsSync(dirPath)) return 0;
     const files = await fsp.readdir(dirPath, { withFileTypes: true });
     for (const file of files) {
-      const filePath = path5.join(dirPath, file.name);
+      const filePath = path6.join(dirPath, file.name);
       if (file.isDirectory()) {
         count += await getFileCount(filePath);
       } else {
@@ -1852,8 +1947,8 @@ async function getFileCount(dirPath) {
 }
 function hasChatLabDatabases(dirPath) {
   try {
-    const markerPath = path5.join(dirPath, ".chatlab");
-    const dbDir = path5.join(dirPath, "databases");
+    const markerPath = path6.join(dirPath, ".chatlab");
+    const dbDir = path6.join(dirPath, "databases");
     if (!fs4.existsSync(markerPath) || !fs4.existsSync(dbDir)) return false;
     return fs4.readdirSync(dbDir).some((file) => file.endsWith(".db"));
   } catch {
@@ -1921,7 +2016,7 @@ function registerCacheRoutes(server2, ctx) {
     if (!fs4.existsSync(dirPath)) return { success: true };
     const files = await fsp.readdir(dirPath);
     for (const file of files) {
-      const filePath = path5.join(dirPath, file);
+      const filePath = path6.join(dirPath, file);
       const stat2 = await fsp.stat(filePath);
       if (stat2.isDirectory()) {
         await fsp.rm(filePath, { recursive: true });
@@ -1938,7 +2033,7 @@ function registerCacheRoutes(server2, ctx) {
       defaultPath: ctx.defaultUserDataDir,
       isCustom: ctx.isCustomDataDir ?? false,
       canSetDataDir: ctx.canSetDataDir ?? Boolean(ctx.setDataDir),
-      hasLegacyDataAtDefaultDir: Boolean(ctx.defaultUserDataDir) && path5.resolve(pp.getUserDataDir()) !== path5.resolve(ctx.defaultUserDataDir ?? "") && hasChatLabDatabases(ctx.defaultUserDataDir ?? ""),
+      hasLegacyDataAtDefaultDir: Boolean(ctx.defaultUserDataDir) && path6.resolve(pp.getUserDataDir()) !== path6.resolve(ctx.defaultUserDataDir ?? "") && hasChatLabDatabases(ctx.defaultUserDataDir ?? ""),
       pendingMigration: pending ? {
         from: pending.from,
         to: pending.to,
@@ -1955,7 +2050,7 @@ function registerCacheRoutes(server2, ctx) {
     return ctx.setDataDir(targetPath, migrate);
   });
   server2.get("/_web/cache/latest-import-log", async () => {
-    const importLogDir = path5.join(pp.getLogsDir(), "import");
+    const importLogDir = path6.join(pp.getLogsDir(), "import");
     if (!fs4.existsSync(importLogDir)) {
       return { success: false, error: "Log directory not found" };
     }
@@ -1966,7 +2061,7 @@ function registerCacheRoutes(server2, ctx) {
     }
     const fileStats = await Promise.all(
       logFiles.map(async (f) => {
-        const filePath = path5.join(importLogDir, f);
+        const filePath = path6.join(importLogDir, f);
         const stat2 = await fsp.stat(filePath);
         return { name: f, path: filePath, mtime: stat2.mtime.getTime() };
       })
@@ -1993,7 +2088,7 @@ function registerCacheRoutes(server2, ctx) {
     if (!fs4.existsSync(downloadsDir)) {
       fs4.mkdirSync(downloadsDir, { recursive: true });
     }
-    const filePath = path5.join(downloadsDir, filename);
+    const filePath = path6.join(downloadsDir, filename);
     fs4.writeFileSync(filePath, buffer);
     return { success: true, filePath };
   });
@@ -2068,6 +2163,7 @@ function registerSharedRoutes(server2, ctx, options) {
   registerAiToolRoutes(server2, resolvedCtx);
   registerAiChatRoutes(server2, resolvedCtx);
   registerAiSummaryRoutes(server2, resolvedCtx);
+  registerSemanticIndexRoutes(server2, resolvedCtx);
   registerMergeRoutes(server2, resolvedCtx);
   registerCacheRoutes(server2, resolvedCtx);
 }
@@ -2147,12 +2243,12 @@ function createServer() {
 
 // src/http/routes/web/index.ts
 import * as os3 from "os";
-import * as path8 from "path";
+import * as path9 from "path";
 
 // src/http/routes/web/import.ts
 import * as fs6 from "fs";
 import * as os2 from "os";
-import * as path6 from "path";
+import * as path7 from "path";
 
 // src/http/routes/web/helpers.ts
 import * as fs5 from "fs";
@@ -2185,8 +2281,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 = fs6.mkdtempSync(path6.join(os2.tmpdir(), "chatlab-detect-"));
-    const tmpPath = path6.join(tmpDir, data.filename || "upload");
+    const tmpDir = fs6.mkdtempSync(path7.join(os2.tmpdir(), "chatlab-detect-"));
+    const tmpPath = path7.join(tmpDir, data.filename || "upload");
     try {
       const chunks = [];
       for await (const chunk of data.file) {
@@ -2203,8 +2299,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 = fs6.mkdtempSync(path6.join(os2.tmpdir(), "chatlab-scan-"));
-    const tmpPath = path6.join(tmpDir, data.filename || "upload");
+    const tmpDir = fs6.mkdtempSync(path7.join(os2.tmpdir(), "chatlab-scan-"));
+    const tmpPath = path7.join(tmpDir, data.filename || "upload");
     try {
       const chunks = [];
       for await (const chunk of data.file) {
@@ -2220,8 +2316,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 = fs6.mkdtempSync(path6.join(os2.tmpdir(), "chatlab-import-"));
-    const tmpPath = path6.join(tmpDir, data.filename || "upload");
+    const tmpDir = fs6.mkdtempSync(path7.join(os2.tmpdir(), "chatlab-import-"));
+    const tmpPath = path7.join(tmpDir, data.filename || "upload");
     const chunks = [];
     for await (const chunk of data.file) {
       chunks.push(chunk);
@@ -2269,7 +2365,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 = fs6.mkdtempSync(path6.join(os2.tmpdir(), "chatlab-dir-import-"));
+    const tmpDir = fs6.mkdtempSync(path7.join(os2.tmpdir(), "chatlab-dir-import-"));
     const relativePaths = [];
     const fileBuffers = [];
     try {
@@ -2297,9 +2393,9 @@ data: ${JSON.stringify(eventData)}
         if (segments.length > 1) {
           relPath = segments.slice(1).join("/");
         }
-        const targetPath = path6.resolve(tmpDir, relPath);
-        if (!targetPath.startsWith(tmpDir + path6.sep)) continue;
-        fs6.mkdirSync(path6.dirname(targetPath), { recursive: true });
+        const targetPath = path7.resolve(tmpDir, relPath);
+        if (!targetPath.startsWith(tmpDir + path7.sep)) continue;
+        fs6.mkdirSync(path7.dirname(targetPath), { recursive: true });
         fs6.writeFileSync(targetPath, fileBuffers[i].data);
       }
       const entryPath = findEntryFileInDirectory(tmpDir);
@@ -2345,8 +2441,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 = fs6.mkdtempSync(path6.join(os2.tmpdir(), "chatlab-inc-"));
-    const tmpPath = path6.join(tmpDir, data.filename || "upload");
+    const tmpDir = fs6.mkdtempSync(path7.join(os2.tmpdir(), "chatlab-inc-"));
+    const tmpPath = path7.join(tmpDir, data.filename || "upload");
     const chunks = [];
     for await (const chunk of data.file) {
       chunks.push(chunk);
@@ -2383,8 +2479,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 = fs6.mkdtempSync(path6.join(os2.tmpdir(), "chatlab-analyze-"));
-    const tmpPath = path6.join(tmpDir, data.filename || "upload");
+    const tmpDir = fs6.mkdtempSync(path7.join(os2.tmpdir(), "chatlab-analyze-"));
+    const tmpPath = path7.join(tmpDir, data.filename || "upload");
     const chunks = [];
     for await (const chunk of data.file) {
       chunks.push(chunk);
@@ -2401,8 +2497,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 = fs6.mkdtempSync(path6.join(os2.tmpdir(), "chatlab-analyze-"));
-    const tmpPath = path6.join(tmpDir, data.filename || "upload");
+    const tmpDir = fs6.mkdtempSync(path7.join(os2.tmpdir(), "chatlab-analyze-"));
+    const tmpPath = path7.join(tmpDir, data.filename || "upload");
     const chunks = [];
     for await (const chunk of data.file) {
       chunks.push(chunk);
@@ -2437,12 +2533,12 @@ data: ${JSON.stringify(eventData)}
 
 `);
     }
-    const tmpDir = fs6.mkdtempSync(path6.join(os2.tmpdir(), "chatlab-demo-"));
+    const tmpDir = fs6.mkdtempSync(path7.join(os2.tmpdir(), "chatlab-demo-"));
     try {
       const localPaths = [];
       for (let i = 0; i < total; i++) {
         sendEvent("progress", { stage: "downloading", current: i + 1, total });
-        const localPath = path6.join(tmpDir, DEMO_FILES[i]);
+        const localPath = path7.join(tmpDir, DEMO_FILES[i]);
         const resp = await fetch(`${DEMO_BASE_URL}/${locale}/${DEMO_FILES[i]}`, {
           signal: AbortSignal.timeout(6e4)
         });
@@ -2478,7 +2574,7 @@ data: ${JSON.stringify(eventData)}
 }
 
 // src/http/routes/web/cache.ts
-import * as path7 from "path";
+import * as path8 from "path";
 import { execFile } from "child_process";
 function runExecFile(file, args, runner = execFile) {
   return new Promise((resolve4, reject) => {
@@ -2506,7 +2602,7 @@ async function showPathInFolder(filePath, platform = process.platform, runner) {
   } else if (platform === "win32") {
     await runExecFile("explorer.exe", [`/select,${filePath}`], runner);
   } else {
-    await runExecFile("xdg-open", [path7.dirname(filePath)], runner);
+    await runExecFile("xdg-open", [path8.dirname(filePath)], runner);
   }
 }
 
@@ -2529,26 +2625,28 @@ function registerWebRoutes(server2, dbManager2, options) {
   const mergeCache = options?.pathProvider ? new MergeSessionCache(options.pathProvider, { nativeBinding: options.nativeBinding }) : null;
   mergeCache?.cleanupOrphans();
   const fallbackPathProvider = {
-    getSystemDir: () => path8.join(os3.homedir(), ".chatlab"),
-    getUserDataDir: () => path8.join(os3.homedir(), ".chatlab", "data"),
-    getDatabaseDir: () => path8.join(os3.homedir(), ".chatlab", "data", "databases"),
-    getAiDataDir: () => path8.join(os3.homedir(), ".chatlab", "ai"),
-    getSettingsDir: () => path8.join(os3.homedir(), ".chatlab", "settings"),
-    getCacheDir: () => path8.join(os3.homedir(), ".chatlab", "cache"),
-    getTempDir: () => path8.join(os3.homedir(), ".chatlab", "temp"),
-    getLogsDir: () => path8.join(os3.homedir(), ".chatlab", "logs"),
-    getDownloadsDir: () => path8.join(os3.homedir(), "Downloads")
+    getSystemDir: () => path9.join(os3.homedir(), ".chatlab"),
+    getUserDataDir: () => path9.join(os3.homedir(), ".chatlab", "data"),
+    getDatabaseDir: () => path9.join(os3.homedir(), ".chatlab", "data", "databases"),
+    getVectorDir: () => path9.join(os3.homedir(), ".chatlab", "data", "vector"),
+    getAiDataDir: () => path9.join(os3.homedir(), ".chatlab", "ai"),
+    getSettingsDir: () => path9.join(os3.homedir(), ".chatlab", "settings"),
+    getCacheDir: () => path9.join(os3.homedir(), ".chatlab", "cache"),
+    getTempDir: () => path9.join(os3.homedir(), ".chatlab", "temp"),
+    getLogsDir: () => path9.join(os3.homedir(), ".chatlab", "logs"),
+    getDownloadsDir: () => path9.join(os3.homedir(), "Downloads")
   };
   const resolvedPathProvider = options?.pathProvider ?? fallbackPathProvider;
   const ai = options?.aiContext;
   const cliStreamImport = async (dm, filePath) => {
-    const { streamImport: streamImport2 } = await import("./stream-import-KZFC3XT2.mjs");
+    const { streamImport: streamImport2 } = await import("./stream-import-FQFNRQ2B.mjs");
     const result = await streamImport2(dm, filePath);
     if (!result.sessionId) throw new Error("Import succeeded but no sessionId returned");
     return { sessionId: result.sessionId };
   };
   const defaultUserDataDir = getDefaultNodeUserDataDir();
-  const isCustom = path8.resolve(resolvedPathProvider.getUserDataDir()) !== path8.resolve(defaultUserDataDir);
+  const isCustom = path9.resolve(resolvedPathProvider.getUserDataDir()) !== path9.resolve(defaultUserDataDir);
+  const semanticIndexService = options?.semanticIndexService;
   registerSharedRoutes(
     server2,
     {
@@ -2557,6 +2655,7 @@ function registerWebRoutes(server2, dbManager2, options) {
       pathProvider: resolvedPathProvider,
       getVersion,
       nativeBinding: options?.nativeBinding,
+      semanticIndexService,
       openDirectory: openDirectoryPath,
       showInFolder: showPathInFolder,
       downloadsDir: resolvedPathProvider.getDownloadsDir(),
@@ -2640,7 +2739,7 @@ function registerProxyRoutes(server2) {
 
 // src/ai/manager-factory.ts
 import * as fs7 from "fs";
-import * as path9 from "path";
+import * as path10 from "path";
 import { createHash, randomUUID } from "crypto";
 var nodeFs = {
   ensureDir(dir) {
@@ -2663,7 +2762,7 @@ var nodeFs = {
     return fs7.existsSync(filePath);
   },
   joinPath(...parts) {
-    return path9.join(...parts);
+    return path10.join(...parts);
   }
 };
 var managerCache = /* @__PURE__ */ new Map();
@@ -2673,13 +2772,13 @@ function getAssistantManager(aiDataDir) {
     cached = {
       assistant: new AssistantManager({
         fs: nodeFs,
-        assistantsDir: path9.join(aiDataDir, "assistants"),
+        assistantsDir: path10.join(aiDataDir, "assistants"),
         builtinRawConfigs: [],
         generateId: () => `custom_${randomUUID().replace(/-/g, "").slice(0, 12)}`
       }),
       skill: new SkillManagerCore({
         fs: nodeFs,
-        skillsDir: path9.join(aiDataDir, "skills"),
+        skillsDir: path10.join(aiDataDir, "skills"),
         builtinRawSkills: [],
         contentHash: (content) => createHash("md5").update(content).digest("hex")
       })
@@ -2704,7 +2803,7 @@ var NOOP_LOGGER = { info: noop, warn: noop, error: noop };
 
 // ../../packages/sync/src/data-source-manager.ts
 import * as fs8 from "fs";
-import * as path10 from "path";
+import * as path11 from "path";
 import * as crypto from "crypto";
 var CONFIG_FILE = "data-sources.json";
 function generateId(prefix = "ds") {
@@ -2732,7 +2831,7 @@ var DataSourceManager = class {
     this.logger = logger ?? NOOP_LOGGER;
   }
   getConfigPath() {
-    return path10.join(this.configDir, CONFIG_FILE);
+    return path11.join(this.configDir, CONFIG_FILE);
   }
   ensureDir() {
     fs8.mkdirSync(this.configDir, { recursive: true });
@@ -2959,6 +3058,41 @@ function fileContainsMessages(filePath) {
     return false;
   }
 }
+function getMaxMessageTimestampFromFile(filePath) {
+  try {
+    let maxTs = null;
+    const visitTimestamp = (value) => {
+      const ts = typeof value === "string" && value.trim() !== "" ? Number(value) : value;
+      if (typeof ts === "number" && Number.isFinite(ts)) {
+        maxTs = maxTs === null ? ts : Math.max(maxTs, ts);
+      }
+    };
+    if (filePath.endsWith(".jsonl")) {
+      const content = fs9.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") visitTimestamp(obj.timestamp);
+        } catch {
+          continue;
+        }
+      }
+      return maxTs;
+    }
+    const raw = fs9.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed.messages)) {
+      for (const message of parsed.messages) {
+        visitTimestamp(message?.timestamp);
+      }
+    }
+    return maxTs;
+  } catch {
+    return null;
+  }
+}
 function cleanupTempFile(filePath) {
   try {
     if (fs9.existsSync(filePath)) fs9.unlinkSync(filePath);
@@ -3012,6 +3146,8 @@ var PullEngine = class {
     this.logger.info(`[Pull] Pulling "${sess.name}" from ${ds.baseUrl}`);
     let totalNewMessages = 0;
     let since = sess.lastPullAt;
+    let offset;
+    let nextPullSince = sess.lastPullAt;
     let pageCount = 0;
     let resyncAttempted = false;
     this.progressMap.set(sess.id, { sessionId: sess.id, sessionName: sess.name, current: 0, pages: 0, done: false });
@@ -3020,6 +3156,7 @@ var PullEngine = class {
         pageCount++;
         const tempFile = await this.fetcher.fetchToTempFile(ds.baseUrl, sess.remoteSessionId, ds.token, {
           since,
+          offset,
           limit: ds.pullLimit
         });
         try {
@@ -3029,6 +3166,7 @@ var PullEngine = class {
           if (stat2.size < 1024) {
             if (!fileContainsMessages(tempFile) && sync0?.hasMore === false) {
               cleanupTempFile(tempFile);
+              if (sync0?.nextSince !== void 0) nextPullSince = Math.max(nextPullSince, sync0.nextSince);
               const retryDelays = [2e3, 3e3, 5e3];
               let retrySuccess = false;
               let retryHasMore = false;
@@ -3039,21 +3177,26 @@ var PullEngine = class {
                 await new Promise((r) => setTimeout(r, retryDelays[ri]));
                 const retryFile = await this.fetcher.fetchToTempFile(ds.baseUrl, sess.remoteSessionId, ds.token, {
                   since,
+                  offset,
                   limit: ds.pullLimit
                 });
                 const retryStat = fs9.statSync(retryFile);
                 this.logger.info(`[Pull] "${sess.name}" retry ${ri + 1}: fetched ${retryStat.size} bytes`);
                 const retrySync = parseSyncFromFile(retryFile);
                 if (retryStat.size < 1024 && !fileContainsMessages(retryFile) && retrySync?.hasMore === false) {
+                  if (retrySync.nextSince !== void 0) nextPullSince = Math.max(nextPullSince, retrySync.nextSince);
                   cleanupTempFile(retryFile);
                   continue;
                 }
+                const retryMaxTs = getMaxMessageTimestampFromFile(retryFile);
                 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;
+                  offset = void 0;
+                  nextPullSince = 0;
                   pageCount = 0;
                   sess.targetSessionId = "";
                   sess.lastPullAt = 0;
@@ -3090,6 +3233,8 @@ var PullEngine = class {
                   this.dsManager.updateSession(sourceId, sess.id, { targetSessionId: retryResult.sessionId });
                 }
                 totalNewMessages += retryResult.newMessageCount;
+                if (retryMaxTs !== null) nextPullSince = Math.max(nextPullSince, retryMaxTs);
+                if (retrySync?.nextSince !== void 0) nextPullSince = Math.max(nextPullSince, retrySync.nextSince);
                 this.progressMap.set(sess.id, {
                   sessionId: sess.id,
                   sessionName: sess.name,
@@ -3099,6 +3244,9 @@ var PullEngine = class {
                 });
                 if (retrySync?.hasMore && retrySync.nextSince !== void 0) {
                   since = retrySync.nextSince;
+                  offset = void 0;
+                } else if (retrySync?.hasMore && retrySync.nextOffset !== void 0) {
+                  offset = retrySync.nextOffset;
                 }
                 retryHasMore = !!retrySync?.hasMore;
                 retrySuccess = true;
@@ -3114,12 +3262,15 @@ var PullEngine = class {
             break;
           }
           const sync = sync0;
+          const maxMessageTs = getMaxMessageTimestampFromFile(tempFile);
           const result = await this.importTempFile(ds.baseUrl, sess, tempFile);
           cleanupTempFile(tempFile);
           if (result.needFullResync && !resyncAttempted) {
             resyncAttempted = true;
             this.logger.info(`[Pull] Resetting since=0 for "${sess.name}" full resync`);
             since = 0;
+            offset = void 0;
+            nextPullSince = 0;
             pageCount = 0;
             sess.targetSessionId = "";
             sess.lastPullAt = 0;
@@ -3154,6 +3305,7 @@ var PullEngine = class {
             this.dsManager.updateSession(sourceId, sess.id, { targetSessionId: result.sessionId });
           }
           totalNewMessages += result.newMessageCount;
+          if (maxMessageTs !== null) nextPullSince = Math.max(nextPullSince, maxMessageTs);
           this.progressMap.set(sess.id, {
             sessionId: sess.id,
             sessionName: sess.name,
@@ -3161,8 +3313,17 @@ var PullEngine = class {
             pages: pageCount,
             done: false
           });
+          if (sync?.nextSince !== void 0) nextPullSince = Math.max(nextPullSince, sync.nextSince);
           if (!sync || !sync.hasMore) break;
-          if (sync.nextSince !== void 0) since = sync.nextSince;
+          if (sync.nextSince !== void 0) {
+            since = sync.nextSince;
+            offset = void 0;
+          } else if (sync.nextOffset !== void 0) {
+            offset = sync.nextOffset;
+          } else {
+            this.logger.warn(`[Pull] "${sess.name}" returned hasMore=true without nextSince or nextOffset, stopping`);
+            break;
+          }
         } catch (importErr) {
           cleanupTempFile(tempFile);
           throw importErr;
@@ -3171,8 +3332,9 @@ var PullEngine = class {
       if (pageCount >= MAX_PAGES_PER_PULL) {
         this.logger.warn(`[Pull] "${sess.name}" reached page limit (${MAX_PAGES_PER_PULL}), data may be incomplete`);
       }
+      const savedLastPullAt = Math.max(sess.lastPullAt, Math.max(0, nextPullSince - PULL_OVERLAP_SECONDS));
       this.dsManager.updateSession(sourceId, sess.id, {
-        lastPullAt: Math.floor(Date.now() / 1e3) - PULL_OVERLAP_SECONDS,
+        lastPullAt: savedLastPullAt,
         lastStatus: "success",
         lastNewMessages: totalNewMessages,
         lastError: ""
@@ -3324,11 +3486,11 @@ function reloadTimer(dsId, skipInitialPull = false) {
 // src/sync/adapters.ts
 import * as fs10 from "fs";
 import * as os4 from "os";
-import * as path11 from "path";
+import * as path12 from "path";
 import * as crypto3 from "crypto";
 function getTempFilePath(ext) {
   const id = crypto3.randomBytes(8).toString("hex");
-  return path11.join(os4.tmpdir(), `chatlab-pull-${id}${ext}`);
+  return path12.join(os4.tmpdir(), `chatlab-pull-${id}${ext}`);
 }
 var NodeFetcher = class {
   async fetchToTempFile(baseUrl, remoteSessionId, token, params) {
@@ -3666,9 +3828,23 @@ async function startHttpServer(options) {
     limits: { fileSize: 1024 * 1024 * 1024 }
     // 1GB
   });
+  let semanticIndexService;
+  try {
+    semanticIndexService = createSemanticIndexWorkerRuntimeClient({
+      pathProvider,
+      runtime,
+      nativeBinding,
+      workerEntryUrl: import.meta.url.endsWith(".ts") ? void 0 : new URL("./semantic-index-worker.mjs", import.meta.url)
+    });
+    server.addHook("onClose", async () => semanticIndexService?.close());
+  } catch (err) {
+    console.warn("[semantic-index] worker client unavailable:", err instanceof Error ? err.message : String(err));
+    semanticIndexService = void 0;
+  }
   registerWebRoutes(server, dbManager, {
     pathProvider,
     nativeBinding,
+    semanticIndexService,
     aiContext: {
       aiDataDir,
       aiChatManager,
@@ -3677,7 +3853,7 @@ async function startHttpServer(options) {
       llmConfigStore,
       customProviderStore: new CustomProviderStore(createFileConfigStorage(aiDataDir)),
       customModelStore: new CustomModelStore(createFileConfigStorage(aiDataDir)),
-      runAgentStream: createCliRunAgentStream(dbManager, aiChatManager)
+      runAgentStream: createCliRunAgentStream(dbManager, aiChatManager, semanticIndexService)
     }
   });
   initSync(server, dbManager, pathProvider, { port, host, token });
@@ -3722,4 +3898,4 @@ export {
   startHttpServer,
   stopHttpServer
 };
-//# sourceMappingURL=chunk-QMXNJRTT.mjs.map
+//# sourceMappingURL=chunk-SIVERPF5.mjs.map