chatlab-cli 0.30.2 → 0.31.1

package/dist/{chunk-D3DPCDII.mjs → chunk-SZEBCNBB.mjs}

@@ -4,31 +4,29 @@ import { fileURLToPath as __fileURLToPath } from 'url';
 const require = __createRequire(import.meta.url);
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
-import {
-  analyzeIncrementalImport,
-  analyzeNewImport,
-  incrementalImport,
-  streamImport
-} from "./chunk-KBSAVUFV.mjs";
 import {
   closeServerAiLogger,
   createCliRunAgentStream,
   getServerAiLogger,
   initServerAiLogger
-} from "./chunk-5EE2EFPE.mjs";
+} from "./chunk-VOVLPSG6.mjs";
 import {
   AGENT_TOOL_REGISTRY,
   CoreDataProvider
-} from "./chunk-TCZHG3G7.mjs";
+} from "./chunk-3VMKS7PU.mjs";
+import {
+  analyzeIncrementalImport,
+  analyzeNewImport,
+  autoImport,
+  incrementalImport,
+  streamImport
+} from "./chunk-N5AGDT7I.mjs";
 import {
   assertCliDataDirCompatible
-} from "./chunk-326OCJOT.mjs";
+} from "./chunk-ZVWUR7ET.mjs";
 import {
   getVersion
 } from "./chunk-5ADKYYNA.mjs";
-import {
-  resolveCliPath
-} from "./chunk-FJ35V3TE.mjs";
 import {
   AnalyticsService,
   NodePathProvider,
@@ -43,7 +41,7 @@ import {
   getPendingNodeDataDirMigration,
   hasPendingElectronDataWarning,
   serializeChatLabToJsonl
-} from "./chunk-ULNRUS55.mjs";
+} from "./chunk-E6W2RURS.mjs";
 import {
   AIChatManager,
   ArchiveImportError,
@@ -51,6 +49,9 @@ import {
   AssistantManager,
   CustomModelStore,
   CustomProviderStore,
+  IMPORT_IN_PROGRESS_ERROR_KEY,
+  ImportIdempotencyCache,
+  ImportInProgressError,
   LLMConfigStore,
   MergeSessionCache,
   SEMANTIC_INDEX_CONFIG_FILE,
@@ -61,6 +62,7 @@ import {
   computeWordFrequency,
   countMessagesTokens,
   createContactsService,
+  createGlobalInsightService,
   createPeopleRelationshipsService,
   deleteDict,
   detectAllFormats,
@@ -74,6 +76,7 @@ import {
   getDefaultRulesForLocale,
   getDictList,
   getSupportedFormats,
+  hashImportBody,
   isDictDownloaded,
   isSemanticIndexConfigured,
   logNativeParserStatus,
@@ -91,7 +94,10 @@ import {
   streamParseFileInfo,
   summary_service_exports,
   validateApiKey
-} from "./chunk-36JGKW6K.mjs";
+} from "./chunk-KCPGEILH.mjs";
+import {
+  resolveCliPath
+} from "./chunk-FJ35V3TE.mjs";
 import {
   ALL_MIGRATIONS,
   BUILTIN_MODELS,
@@ -154,7 +160,7 @@ import {
   verifyCliDataPath,
   writeAuthProfile,
   writeConfigField
-} from "./chunk-LVEJHB3X.mjs";
+} from "./chunk-DQ45LDKZ.mjs";
 
 // src/http/index.ts
 import * as fs12 from "fs";
@@ -174,6 +180,8 @@ var HTTP_STATUS = {
   ["EXPORT_TOO_LARGE" /* EXPORT_TOO_LARGE */]: 400,
   ["BODY_TOO_LARGE" /* BODY_TOO_LARGE */]: 413,
   ["IMPORT_IN_PROGRESS" /* IMPORT_IN_PROGRESS */]: 409,
+  ["IDEMPOTENCY_CONFLICT" /* IDEMPOTENCY_CONFLICT */]: 409,
+  ["IDEMPOTENCY_PENDING" /* IDEMPOTENCY_PENDING */]: 409,
   ["IMPORT_FAILED" /* IMPORT_FAILED */]: 500,
   ["DATA_DIR_INCOMPATIBLE" /* DATA_DIR_INCOMPATIBLE */]: 409,
   ["SERVER_ERROR" /* SERVER_ERROR */]: 500
@@ -212,6 +220,15 @@ function serverError(message = "Internal server error") {
 function importInProgress() {
   return new ApiError("IMPORT_IN_PROGRESS" /* IMPORT_IN_PROGRESS */, "Another import is already in progress");
 }
+function idempotencyConflict() {
+  return new ApiError("IDEMPOTENCY_CONFLICT" /* IDEMPOTENCY_CONFLICT */, "Same Idempotency-Key with different request body hash");
+}
+function idempotencyPending() {
+  return new ApiError(
+    "IDEMPOTENCY_PENDING" /* IDEMPOTENCY_PENDING */,
+    "A request with this Idempotency-Key is still in progress. Please retry later."
+  );
+}
 function importFailed(message) {
   return new ApiError("IMPORT_FAILED" /* IMPORT_FAILED */, message);
 }
@@ -220,6 +237,7 @@ function dataDirIncompatible(message) {
 }
 function apiErrorFromUnknown(error) {
   if (error instanceof ApiError) return error;
+  if (error instanceof ImportInProgressError) return importInProgress();
   if (error instanceof DataDirCompatibilityError) return dataDirIncompatible(error.message);
   return null;
 }
@@ -488,6 +506,7 @@ function registerRestSessionRoutes(server2, ctx) {
 
 // ../../packages/http-routes/src/routes/imports.ts
 function registerImportRoutes(server2, ctx) {
+  const idempotencyCache = new ImportIdempotencyCache();
   server2.post(
     "/api/v1/imports/:sessionId",
     async (request, reply) => {
@@ -501,20 +520,42 @@ function registerImportRoutes(server2, ctx) {
         const err = invalidPayload("X-Dry-Run is not yet supported");
         return reply.code(err.statusCode).send(errorResponse(err));
       }
-      const outcome = await pushImport(ctx.dbManager, sessionId, request.body ?? {});
-      if (!outcome.ok) {
-        if (outcome.reason === "import_in_progress") {
-          const err2 = importInProgress();
-          return reply.code(err2.statusCode).send(errorResponse(err2));
+      const idempotencyKey = request.headers["idempotency-key"];
+      const cacheKey = typeof idempotencyKey === "string" && idempotencyKey ? `${idempotencyKey}:${sessionId}` : null;
+      if (cacheKey) {
+        const start = idempotencyCache.start(cacheKey, hashImportBody(request.body));
+        if (start.status === "conflict") {
+          const err = idempotencyConflict();
+          return reply.code(err.statusCode).send(errorResponse(err));
         }
-        if (outcome.reason === "invalid_payload") {
-          const err2 = invalidPayload(outcome.message);
-          return reply.code(err2.statusCode).send(errorResponse(err2));
+        if (start.status === "pending") {
+          const err = idempotencyPending();
+          return reply.code(err.statusCode).send(errorResponse(err));
         }
-        const err = importFailed(outcome.message);
-        return reply.code(err.statusCode).send(errorResponse(err));
+        if (start.status === "success") return start.response;
+      }
+      try {
+        const outcome = await pushImport(ctx.dbManager, sessionId, request.body ?? {});
+        if (!outcome.ok) {
+          if (cacheKey) idempotencyCache.fail(cacheKey);
+          if (outcome.reason === "import_in_progress") {
+            const err2 = importInProgress();
+            return reply.code(err2.statusCode).send(errorResponse(err2));
+          }
+          if (outcome.reason === "invalid_payload") {
+            const err2 = invalidPayload(outcome.message);
+            return reply.code(err2.statusCode).send(errorResponse(err2));
+          }
+          const err = importFailed(outcome.message);
+          return reply.code(err.statusCode).send(errorResponse(err));
+        }
+        const response = successResponse(outcome.result);
+        if (cacheKey) idempotencyCache.success(cacheKey, response);
+        return response;
+      } catch (error) {
+        if (cacheKey) idempotencyCache.fail(cacheKey);
+        throw error;
       }
-      return successResponse(outcome.result);
     }
   );
 }
@@ -748,6 +789,43 @@ function parsePeopleRelationshipsGraphScope(value) {
   return value === "close" || value === "friends" ? value : "panorama";
 }
 
+// ../../packages/http-routes/src/routes/web/global-insight.ts
+function registerGlobalInsightRoutes(server2, ctx) {
+  const service = ctx.globalInsightService ?? createGlobalInsightService({
+    adapter: ctx.sessionAdapter,
+    pathProvider: ctx.pathProvider,
+    runtimeIdentity: ctx.runtimeIdentity,
+    nativeBinding: ctx.nativeBinding
+  });
+  server2.addHook("onClose", async () => service.close());
+  server2.get("/_web/global-insight/annual-summary", async (request) => {
+    return service.getAnnualSummary({
+      ...parseRange(request.query),
+      acceptStale: isTruthy3(request.query.acceptStale)
+    });
+  });
+  server2.post(
+    "/_web/global-insight/annual-summary/recompute",
+    async (request) => service.startRecompute(parseRange(request.query))
+  );
+}
+function parseRange(query) {
+  const mode = query.mode === "recent" ? "recent" : "year";
+  return {
+    mode,
+    year: parseInteger(query.year),
+    days: query.days === "365" ? 365 : void 0
+  };
+}
+function parseInteger(value) {
+  if (!value) return void 0;
+  const parsed = Number(value);
+  return Number.isInteger(parsed) ? parsed : void 0;
+}
+function isTruthy3(value) {
+  return value === "1" || value === "true" || value === "yes";
+}
+
 // ../../packages/http-routes/src/routes/web/preferences.ts
 function registerPreferencesRoutes(server2, ctx) {
   const prefManager = ctx.preferencesManager ?? new PreferencesManager(ctx.pathProvider.getSystemDir());
@@ -1570,8 +1648,55 @@ data: ${JSON.stringify(data)}
   });
 }
 
-// ../../packages/http-routes/src/routes/web/ai-tools.ts
+// ../../packages/http-routes/src/ai/tool-executor.ts
 var MAX_RESULT_CHARS = 5e5;
+async function executeRegistryTool(params, deps) {
+  const { toolName, params: toolParams, abortSignal } = params;
+  const entry = AGENT_TOOL_REGISTRY.find((tool) => tool.name === toolName);
+  if (!entry) {
+    return { success: false, error: `Tool not found: ${toolName}` };
+  }
+  try {
+    if (abortSignal.aborted) return { success: false, error: "cancelled" };
+    const execCtx = {
+      sessionId: params.sessionId,
+      abortSignal,
+      db: deps.db,
+      dataProvider: deps.dataProvider,
+      semanticIndexService: deps.semanticIndexService,
+      segmentText: deps.segmentText,
+      translateTemplate: deps.translateTemplate
+    };
+    const startTime = Date.now();
+    const result = await entry.handler(toolParams, execCtx);
+    const elapsed = Date.now() - startTime;
+    if (abortSignal.aborted) return { success: false, error: "cancelled" };
+    let details = result.data ?? void 0;
+    let truncated = false;
+    if (details) {
+      stripAvatarFields(details);
+      const raw = JSON.stringify(details);
+      if (raw.length > MAX_RESULT_CHARS) {
+        truncated = true;
+        details = { _truncated: true, _originalSize: raw.length, _preview: raw.slice(0, MAX_RESULT_CHARS) };
+      }
+    }
+    return {
+      success: true,
+      elapsed,
+      content: [{ type: "text", text: result.content }],
+      details,
+      truncated
+    };
+  } catch (error) {
+    if (abortSignal.aborted) {
+      return { success: false, error: "cancelled" };
+    }
+    return { success: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+// ../../packages/http-routes/src/routes/web/ai-tools.ts
 var activeToolTests = /* @__PURE__ */ new Map();
 function registerAiToolRoutes(server2, ctx) {
   server2.get("/_web/ai/tools/full-catalog", async () => {
@@ -1598,40 +1723,22 @@ function registerAiToolRoutes(server2, ctx) {
       if (!db) {
         return reply.code(404).send({ success: false, error: `Session not found: ${sessionId}` });
       }
-      const execCtx = {
-        sessionId,
-        db,
-        dataProvider: new CoreDataProvider(db),
-        abortSignal: abortController.signal
-      };
-      const startTime = Date.now();
-      const result = await entry.handler(params, execCtx);
-      const elapsed = Date.now() - startTime;
-      if (abortController.signal.aborted) {
-        return { success: false, error: "cancelled" };
-      }
-      let details = result.data ?? void 0;
-      let truncated = false;
-      if (details) {
-        stripAvatarFields(details);
-        const raw = JSON.stringify(details);
-        if (raw.length > MAX_RESULT_CHARS) {
-          truncated = true;
-          details = { _truncated: true, _originalSize: raw.length, _preview: raw.slice(0, MAX_RESULT_CHARS) };
+      const result = await executeRegistryTool(
+        { testId, toolName, params, sessionId, abortSignal: abortController.signal },
+        {
+          db,
+          dataProvider: new CoreDataProvider(db)
         }
+      );
+      if (!result.success && result.error !== "cancelled") {
+        appLogger.error("ai-tools", `Failed to execute tool ${toolName}`, { error: result.error });
       }
-      return {
-        success: true,
-        elapsed,
-        content: [{ type: "text", text: result.content }],
-        details,
-        truncated
-      };
+      return result;
     } catch (error) {
       if (abortController.signal.aborted) {
         return { success: false, error: "cancelled" };
       }
-      console.error(`Failed to execute tool ${toolName}:`, error);
+      appLogger.error("ai-tools", `Failed to execute tool ${toolName}`, error);
       return { success: false, error: String(error) };
     } finally {
       activeToolTests.delete(testId);
@@ -2416,6 +2523,7 @@ function registerSharedRoutes(server2, ctx, options) {
   registerMemberRoutes(server2, resolvedCtx);
   registerContactsRoutes(server2, resolvedCtx);
   registerPeopleRelationshipsRoutes(server2, resolvedCtx);
+  registerGlobalInsightRoutes(server2, resolvedCtx);
   registerPreferencesRoutes(server2, resolvedCtx);
   registerAnalyticsRoutes(server2, resolvedCtx);
   registerSqlRoutes(server2, resolvedCtx);
@@ -2710,19 +2818,14 @@ function registerImportRoutes2(server2, dbManager2, options = {}) {
   const sourceManager = options.sourceManager ?? new ArchiveImportSourceManager({
     tempRoot: fs7.mkdtempSync(path8.join(os2.tmpdir(), "chatlab-import-sources-"))
   });
+  const runAutoImport = options.runAutoImport ?? autoImport.bind(null, dbManager2);
   const runPreparedImport = options.runPreparedImport ?? (async (manifestPath, onProgress) => {
-    const result = await streamImport(dbManager2, manifestPath, {
+    const result = await runAutoImport(manifestPath, {
       formatId: "google-chat-takeout",
       nativeBinding: resolveNativeBinding(),
       onProgress
     });
-    return {
-      success: result.success,
-      sessionId: result.sessionId,
-      error: result.error,
-      messageCount: result.diagnostics?.messagesWritten ?? 0,
-      memberCount: 0
-    };
+    return result;
   });
   server2.addHook("onClose", async () => {
     await sourceManager.close();
@@ -2857,19 +2960,14 @@ data: ${JSON.stringify(eventData)}
     }
     try {
       const nativeBinding = resolveNativeBinding();
-      const result = await streamImport(dbManager2, tmpPath, {
+      const result = await runAutoImport(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
-        });
+        sendEvent("done", result);
       } else {
         sendEvent("error", { success: false, error: result.error });
       }
@@ -2926,17 +3024,12 @@ data: ${JSON.stringify(eventData)}
         Connection: "keep-alive"
       });
       const nativeBinding = resolveNativeBinding();
-      const result = await streamImport(dbManager2, entryPath, {
+      const result = await runAutoImport(entryPath, {
         nativeBinding,
         onProgress: (p) => sendEvent2("progress", p)
       });
       if (result.success) {
-        sendEvent2("done", {
-          success: true,
-          sessionId: result.sessionId,
-          messageCount: result.diagnostics?.messagesWritten ?? 0,
-          memberCount: 0
-        });
+        sendEvent2("done", result);
       } else {
         sendEvent2("error", { success: false, error: result.error });
       }
@@ -3157,8 +3250,13 @@ function registerWebRoutes(server2, dbManager2, options) {
   const resolvedPathProvider = options?.pathProvider ?? fallbackPathProvider;
   const ai = options?.aiContext;
   const cliStreamImport = async (dm, filePath) => {
-    const { streamImport: streamImport2 } = await import("./stream-import-HIE7PNL4.mjs");
+    const { streamImport: streamImport2 } = await import("./stream-import-AWEHGQJY.mjs");
     const result = await streamImport2(dm, filePath);
+    if (!result.success) {
+      const { IMPORT_IN_PROGRESS_ERROR_KEY: IMPORT_IN_PROGRESS_ERROR_KEY2, ImportInProgressError: ImportInProgressError2 } = await import("./src-7OD6RD5V.mjs");
+      if (result.error === IMPORT_IN_PROGRESS_ERROR_KEY2) throw new ImportInProgressError2();
+      throw new Error(result.error || "Import failed");
+    }
     if (!result.sessionId) throw new Error("Import succeeded but no sessionId returned");
     return { sessionId: result.sessionId };
   };
@@ -3652,6 +3750,12 @@ var PullEngine = class {
     const externalId = deriveLocalSessionId(baseUrl, sess.remoteSessionId);
     return this.importer.importFile(tempFile, targetId || void 0, externalId);
   }
+  deferRetryableImport(sess, error) {
+    const errMsg = error || "Import deferred";
+    this.logger.info(`[Pull] Deferring "${sess.name}": ${errMsg}`);
+    this.markProgressDone(sess.id);
+    return { success: false, newMessageCount: 0, error: errMsg };
+  }
   async executePullSession(sourceId, ds, sess) {
     const currentDs = this.dsManager.get(sourceId);
     if (!currentDs || !currentDs.sessions.some((s) => s.id === sess.id)) {
@@ -3737,6 +3841,7 @@ var PullEngine = class {
                   return { success: false, newMessageCount: 0, error: errMsg };
                 }
                 if (!retryResult.success) {
+                  if (retryResult.retryable) return this.deferRetryableImport(sess, retryResult.error);
                   const errMsg = retryResult.error || "Import failed";
                   this.dsManager.updateSession(sourceId, sess.id, {
                     lastPullAt: Math.floor(Date.now() / 1e3),
@@ -3809,6 +3914,7 @@ var PullEngine = class {
             return { success: false, newMessageCount: 0, error: errMsg };
           }
           if (!result.success) {
+            if (result.retryable) return this.deferRetryableImport(sess, result.error);
             const errMsg = result.error || "Import failed";
             this.dsManager.updateSession(sourceId, sess.id, {
               lastPullAt: Math.floor(Date.now() / 1e3),
@@ -4132,6 +4238,10 @@ var DirectImporter = class {
       if (result.error === "error.session_not_found" || result.error?.includes("no such table")) {
         return { success: false, newMessageCount: 0, sessionId, needFullResync: true };
       }
+      if (result.error === IMPORT_IN_PROGRESS_ERROR_KEY) {
+        this.logger.info(`[DirectImporter] Incremental import deferred: another import is in progress`);
+        return { success: false, newMessageCount: 0, sessionId, error: result.error, retryable: true };
+      }
       return { success: false, newMessageCount: 0, sessionId, error: result.error };
     } catch (err) {
       this.logger.error(`[DirectImporter] Incremental import failed`, err);
@@ -4146,6 +4256,10 @@ var DirectImporter = class {
         this.logger.info(`[DirectImporter] Full import OK: +${newMessageCount} messages`);
         return { success: true, newMessageCount, sessionId: result.sessionId ?? externalId };
       }
+      if (result.error === IMPORT_IN_PROGRESS_ERROR_KEY) {
+        this.logger.info(`[DirectImporter] Full import deferred: another import is in progress`);
+        return { success: false, newMessageCount: 0, error: result.error, retryable: true };
+      }
       return { success: false, newMessageCount: 0, error: result.error };
     } catch (err) {
       this.logger.error(`[DirectImporter] Full import failed`, err);
@@ -4383,4 +4497,4 @@ export {
   startHttpServer,
   stopHttpServer
 };
-//# sourceMappingURL=chunk-D3DPCDII.mjs.map
+//# sourceMappingURL=chunk-SZEBCNBB.mjs.map