chatlab-cli 0.36.2 → 0.37.0

package/dist/{chunk-WJQOXOMR.mjs → chunk-DKIYHA3O.mjs}

@@ -11,14 +11,15 @@ import {
   getServerAiLogger,
   getSkillManagerCore,
   initServerAiLogger
-} from "./chunk-YUH3H3QW.mjs";
+} from "./chunk-MSMDLDPB.mjs";
 import {
   AGENT_TOOL_REGISTRY,
   CoreDataProvider
-} from "./chunk-HWIXK7SU.mjs";
+} from "./chunk-FM3GXNEO.mjs";
 import {
+  prepareUnixSocket,
   resolveCliLocalEmbeddingRuntimeConfig
-} from "./chunk-6E46U4H2.mjs";
+} from "./chunk-2TV7M4CC.mjs";
 import {
   analyzeIncrementalImport,
   analyzeNewImport,
@@ -26,10 +27,10 @@ import {
   autoImportBatch,
   incrementalImport,
   streamImport
-} from "./chunk-TWH422HC.mjs";
+} from "./chunk-RXMSZIYD.mjs";
 import {
   assertCliDataDirCompatible
-} from "./chunk-CH5YAZ4Q.mjs";
+} from "./chunk-SQWN4GTQ.mjs";
 import {
   getVersion
 } from "./chunk-5ADKYYNA.mjs";
@@ -58,11 +59,10 @@ import {
   getPendingNodeDataDirMigration,
   hasPendingElectronDataWarning,
   importDemoSessions,
-  initNlpDir,
   isDictDownloaded,
   segmentText,
   serializeChatLabToJsonl
-} from "./chunk-TJ3NOBVI.mjs";
+} from "./chunk-5YOHLJFB.mjs";
 import {
   ArchiveImportError,
   ArchiveImportSourceManager,
@@ -77,6 +77,7 @@ import {
   TempDbWriter,
   createChatLabTempDir,
   createContactsService,
+  createCrossChatAnalysisService,
   createGlobalInsightService,
   createNavigationLayoutService,
   createPeopleRelationshipsService,
@@ -102,9 +103,10 @@ import {
   session_service_exports,
   streamParseFileInfo,
   summary_service_exports
-} from "./chunk-VREVDZ4Q.mjs";
+} from "./chunk-DQR2YS3I.mjs";
 import {
   AIChatManager,
+  AIMemoryService,
   ALL_MIGRATIONS,
   ANNUAL_SUMMARY_PLUGIN_ID,
   BUILTIN_MODELS,
@@ -169,16 +171,20 @@ import {
   getWeekdayActivity,
   getYearlyActivity,
   initAppLogger,
+  initNlpDir,
   isNewerStableVersion,
+  linkAIMemorySources,
+  listAIMemoriesWithSourceStatus,
   loadConfig,
   mergeRulesForLocale,
   queryMessages,
+  resolveAIMemorySourceStatus,
   runSimpleLlmStream,
   stripAvatarFields,
   validateApiKey,
   verifyCliDataPath,
   writeConfigField
-} from "./chunk-TRGR3KKJ.mjs";
+} from "./chunk-4J4MA3RC.mjs";
 
 // src/http/index.ts
 import * as fs11 from "fs";
@@ -810,14 +816,16 @@ function registerNodePlugins(server2, context, plugins) {
 }
 
 // ../../packages/http-routes/src/routes/web/ai-agent-stream.ts
+import { randomUUID } from "crypto";
 var activeAgentAborts = /* @__PURE__ */ new Map();
-function registerAiAgentStreamRoutes(server2, ctx) {
+function registerAiAgentStreamRoutes(server2, ctx, memoryProvenanceCoordinator) {
   if (!ctx.runAgentStream) return;
   const runAgentStream = ctx.runAgentStream;
   server2.post("/_web/ai/agent/stream", async (request, reply) => {
-    const requestId = `req_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const requestId = `req_${randomUUID()}`;
     const abortController = new AbortController();
     activeAgentAborts.set(requestId, abortController);
+    memoryProvenanceCoordinator?.begin(requestId, request.body.aiChatId);
     reply.raw.writeHead(200, {
       "Content-Type": "text/event-stream",
       "Cache-Control": "no-cache",
@@ -849,6 +857,11 @@ data: ${JSON.stringify(data)}
         request.body,
         (chunk) => {
           if (chunk.type === "done") emittedDone = true;
+          if (chunk.type === "memory_change" && chunk.memoryId) {
+            memoryProvenanceCoordinator?.record(requestId, chunk.memoryId);
+            safeSendSSE(chunk.type, { ...chunk, provenanceToken: requestId });
+            return;
+          }
           safeSendSSE(chunk.type, chunk);
         },
         abortController.signal
@@ -857,6 +870,8 @@ data: ${JSON.stringify(data)}
       const msg = error instanceof Error ? error.message : String(error);
       safeSendSSE("error", { type: "error", error: { name: "ServerError", message: msg } });
     } finally {
+      const expectedParentMessageId = ctx.aiChatManager?.getAIChat(request.body.aiChatId)?.activeMessageId ?? null;
+      memoryProvenanceCoordinator?.complete(requestId, expectedParentMessageId);
       releaseInteractiveWork();
       if (!emittedDone) safeSendSSE("done", { type: "done", isFinished: true });
       activeAgentAborts.delete(requestId);
@@ -947,6 +962,13 @@ function registerAiChatRoutes(server2, ctx) {
     if (!sessionId) return [];
     return cm.getAIChats(sessionId);
   });
+  server2.post("/_web/ai/global-chats", async (request) => {
+    const { title, assistantId } = request.body;
+    return cm.createGlobalAIChat(title, assistantId);
+  });
+  server2.get("/_web/ai/global-chats", async () => {
+    return cm.getGlobalAIChats();
+  });
   server2.get("/_web/ai/chats/:id", async (request, reply) => {
     const conv = cm.getAIChat(request.params.id);
     if (!conv) return reply.code(404).send({ error: "AI chat not found" });
@@ -958,8 +980,14 @@ function registerAiChatRoutes(server2, ctx) {
   server2.delete("/_web/ai/chats/:id", async (request) => {
     return cm.deleteAIChat(request.params.id);
   });
+  server2.post("/_web/ai/chats/:id/message-pair", async (request) => {
+    return cm.addMessagePair(request.params.id, request.body.userMessage, request.body.assistantMessage);
+  });
+  server2.post("/_web/ai/chats/:id/replace-latest-message-round", async (request) => {
+    return cm.replaceLatestMessageRound(request.params.id, request.body);
+  });
   server2.post("/_web/ai/chats/:id/messages", async (request) => {
-    const { role, content, dataKeywords, dataMessageCount, contentBlocks, tokenUsage } = request.body;
+    const { role, content, dataKeywords, dataMessageCount, contentBlocks, tokenUsage, entityRefs } = request.body;
     return cm.addMessage(
       request.params.id,
       role,
@@ -967,7 +995,8 @@ function registerAiChatRoutes(server2, ctx) {
       dataKeywords,
       dataMessageCount,
       contentBlocks,
-      tokenUsage
+      tokenUsage,
+      entityRefs
     );
   });
   server2.get("/_web/ai/chats/:id/messages", async (request) => {
@@ -989,11 +1018,11 @@ function registerAiChatRoutes(server2, ctx) {
     return cm.forkAIChat(request.params.id, upToMessageId, title);
   });
   server2.put("/_web/ai/messages/:messageId/content", async (request, reply) => {
-    const { content } = request.body;
+    const { content, entityRefs } = request.body;
     if (!content || typeof content !== "string") {
       return reply.code(400).send({ error: "content is required" });
     }
-    cm.updateMessageContent(request.params.messageId, content);
+    cm.updateMessageContent(request.params.messageId, content, entityRefs);
     return { success: true };
   });
   server2.post("/_web/ai/chats/:id/messages/:messageId/delete-relink", async (request, reply) => {
@@ -1005,11 +1034,19 @@ function registerAiChatRoutes(server2, ctx) {
     return { success: true };
   });
   server2.post("/_web/ai/chats/:id/messages/insert-after", async (request, reply) => {
-    const { afterMessageId, role, content, contentBlocks, tokenUsage } = request.body;
+    const { afterMessageId, role, content, contentBlocks, tokenUsage, entityRefs } = request.body;
     if (!afterMessageId || typeof afterMessageId !== "string") {
       return reply.code(400).send({ error: "afterMessageId is required" });
     }
-    return cm.insertMessageAfter(request.params.id, afterMessageId, role, content, contentBlocks, tokenUsage);
+    return cm.insertMessageAfter(
+      request.params.id,
+      afterMessageId,
+      role,
+      content,
+      contentBlocks,
+      tokenUsage,
+      entityRefs
+    );
   });
   server2.get("/_web/ai/chats/:id/token-usage", async (request) => {
     return cm.getAIChatTokenUsage(request.params.id);
@@ -1336,6 +1373,127 @@ function registerAiLogRoutes(server2, ctx) {
   });
 }
 
+// ../../packages/http-routes/src/routes/web/ai-memories.ts
+function parseScope(input) {
+  const scopeType = input.scopeType;
+  if (scopeType !== "global" && scopeType !== "self" && scopeType !== "contact" && scopeType !== "group") {
+    throw new Error("scopeType must be global, self, contact, or group");
+  }
+  return {
+    scopeType,
+    scopeId: typeof input.scopeId === "string" ? input.scopeId : null
+  };
+}
+function sendBadRequest(reply, error) {
+  return reply.code(400).send({ error: error instanceof Error ? error.message : String(error) });
+}
+function registerAiMemoryRoutes(server2, ctx, memoryProvenanceCoordinator) {
+  const memoryService = ctx.aiMemoryService;
+  if (!memoryService) return;
+  const aiChatManager2 = ctx.aiChatManager;
+  const withSourceStatus = (entry) => ({
+    ...entry,
+    sourceStatus: aiChatManager2 ? resolveAIMemorySourceStatus(entry, aiChatManager2) : entry.sourceAIChatId ? "unavailable" : "none"
+  });
+  server2.get("/_web/ai/memories", async (request, reply) => {
+    try {
+      const { scopeType, scopeId } = request.query;
+      if (!scopeType) {
+        if (scopeId != null) throw new Error("scopeType is required when scopeId is provided");
+        return aiChatManager2 ? listAIMemoriesWithSourceStatus(memoryService, aiChatManager2) : memoryService.list().map((entry) => ({
+          ...entry,
+          sourceStatus: entry.sourceAIChatId ? "unavailable" : "none"
+        }));
+      }
+      const scope = parseScope({ scopeType, scopeId });
+      return aiChatManager2 ? listAIMemoriesWithSourceStatus(memoryService, aiChatManager2, scope) : memoryService.list(scope).map((entry) => ({
+        ...entry,
+        sourceStatus: entry.sourceAIChatId ? "unavailable" : "none"
+      }));
+    } catch (error) {
+      return sendBadRequest(reply, error);
+    }
+  });
+  server2.post("/_web/ai/memories/link-sources", async (request, reply) => {
+    if (!aiChatManager2) {
+      return reply.code(503).send({ error: "AI conversation storage is unavailable" });
+    }
+    try {
+      const body = request.body ?? {};
+      const input = {
+        provenanceToken: body.provenanceToken ?? "",
+        aiChatId: body.aiChatId ?? "",
+        userMessageId: body.userMessageId ?? "",
+        assistantMessageId: body.assistantMessageId ?? "",
+        memoryIds: body.memoryIds ?? []
+      };
+      if (!memoryProvenanceCoordinator) throw new Error("Memory provenance coordination is unavailable");
+      const provenance = memoryProvenanceCoordinator.validate(input.provenanceToken, input.aiChatId, input.memoryIds);
+      const result = linkAIMemorySources(memoryService, aiChatManager2, input, provenance);
+      memoryProvenanceCoordinator.consume(input.provenanceToken);
+      return result;
+    } catch (error) {
+      return sendBadRequest(reply, error);
+    }
+  });
+  server2.post("/_web/ai/memories", async (request, reply) => {
+    try {
+      const scope = parseScope(request.body ?? {});
+      return withSourceStatus(
+        memoryService.create({
+          ...scope,
+          content: request.body?.content ?? "",
+          sourceType: "user",
+          sourceAIChatId: null,
+          sourceMessageId: null
+        })
+      );
+    } catch (error) {
+      return sendBadRequest(reply, error);
+    }
+  });
+  server2.put("/_web/ai/memories/:id", async (request, reply) => {
+    if (!memoryService.get(request.params.id)) {
+      return reply.code(404).send({ error: "AI memory not found" });
+    }
+    try {
+      return withSourceStatus(
+        memoryService.update(request.params.id, {
+          content: request.body?.content ?? "",
+          sourceType: "user",
+          sourceAIChatId: null,
+          sourceMessageId: null
+        })
+      );
+    } catch (error) {
+      return sendBadRequest(reply, error);
+    }
+  });
+  server2.delete("/_web/ai/memories/:id", async (request, reply) => {
+    if (!memoryService.forget(request.params.id)) {
+      return reply.code(404).send({ error: "AI memory not found" });
+    }
+    return { success: true };
+  });
+  server2.post("/_web/ai/memories/clear", async (request, reply) => {
+    const { all, scopeType, scopeId } = request.body ?? {};
+    if (all === true) {
+      if (scopeType || scopeId != null) {
+        return reply.code(400).send({ error: "all cannot be combined with a scope" });
+      }
+      return { success: true, cleared: memoryService.clear() };
+    }
+    if (!scopeType) {
+      return reply.code(400).send({ error: "A scope or all: true is required" });
+    }
+    try {
+      return { success: true, cleared: memoryService.clear(parseScope({ scopeType, scopeId })) };
+    } catch (error) {
+      return sendBadRequest(reply, error);
+    }
+  });
+}
+
 // ../../packages/http-routes/src/routes/web/ai-semantic-index.ts
 import path2 from "path";
 function registerSemanticIndexRoutes(server2, ctx) {
@@ -1627,10 +1785,53 @@ function registerAiToolRoutes(server2, ctx) {
   });
 }
 
+// ../../packages/http-routes/src/routes/web/memory-provenance-coordinator.ts
+var MemoryProvenanceCoordinator = class {
+  pending = /* @__PURE__ */ new Map();
+  begin(token, aiChatId) {
+    this.pending.set(token, {
+      aiChatId,
+      expectedParentMessageId: null,
+      memoryIds: /* @__PURE__ */ new Set(),
+      completed: false
+    });
+  }
+  record(token, memoryId) {
+    const changeSet = this.pending.get(token);
+    if (!changeSet || changeSet.completed) return;
+    changeSet.memoryIds.add(memoryId);
+  }
+  complete(token, expectedParentMessageId) {
+    const changeSet = this.pending.get(token);
+    if (!changeSet) return;
+    if (changeSet.memoryIds.size === 0) {
+      this.pending.delete(token);
+      return;
+    }
+    changeSet.expectedParentMessageId = expectedParentMessageId;
+    changeSet.completed = true;
+  }
+  validate(token, aiChatId, memoryIds) {
+    const changeSet = this.pending.get(token);
+    if (!changeSet || !changeSet.completed || changeSet.aiChatId !== aiChatId) {
+      throw new Error("Memory provenance token is invalid");
+    }
+    const requestedIds = new Set(memoryIds);
+    if (requestedIds.size !== changeSet.memoryIds.size || [...requestedIds].some((memoryId) => !changeSet.memoryIds.has(memoryId))) {
+      throw new Error("Memory IDs do not match the agent turn change set");
+    }
+    return { expectedParentMessageId: changeSet.expectedParentMessageId };
+  }
+  consume(token) {
+    this.pending.delete(token);
+  }
+};
+
 // ../../packages/http-routes/src/routes/web/register-ai.ts
 var REQUIRED_AI_DEPENDENCIES = [
   "aiDataDir",
   "aiChatManager",
+  "aiMemoryService",
   "assistantManager",
   "skillManagerCore",
   "llmConfigStore",
@@ -1646,13 +1847,15 @@ function assertRequiredAiContext(ctx) {
 }
 function registerAiRoutes(server2, ctx, options) {
   if (options?.requireAi) assertRequiredAiContext(ctx);
+  const memoryProvenanceCoordinator = new MemoryProvenanceCoordinator();
   registerAiAssistantRoutes(server2, ctx);
   registerAiSkillRoutes(server2, ctx);
   registerAiLlmRoutes(server2, ctx);
   registerAiLlmStreamRoutes(server2, ctx);
-  registerAiAgentStreamRoutes(server2, ctx);
+  registerAiAgentStreamRoutes(server2, ctx, memoryProvenanceCoordinator);
   registerAiToolRoutes(server2, ctx);
   registerAiChatRoutes(server2, ctx);
+  registerAiMemoryRoutes(server2, ctx, memoryProvenanceCoordinator);
   registerAiChatTopicRoutes(server2, ctx);
   registerAiSummaryRoutes(server2, ctx);
   registerAiLogRoutes(server2, ctx);
@@ -3142,7 +3345,8 @@ function registerAutomationRoutes(server2, ctx) {
       enabled: true,
       port: automation.serverInfo.port,
       token: automation.serverInfo.token,
-      host: automation.serverInfo.host
+      host: automation.serverInfo.host,
+      socket: automation.serverInfo.socket
     };
   });
   server2.get("/_web/automation/data-sources", async (_request, reply) => {
@@ -3237,7 +3441,7 @@ function registerAutomationRoutes(server2, ctx) {
 // src/http/routes/web/import.ts
 import * as fs7 from "fs";
 import * as path8 from "path";
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 import { pipeline } from "stream/promises";
 
 // src/http/routes/web/helpers.ts
@@ -3292,7 +3496,7 @@ function registerImportRoutes2(server2, dbManager2, options = {}) {
       limits: { fileSize: ARCHIVE_UPLOAD_LIMIT }
     });
     if (!data) return reply.code(400).send({ success: false, error: "error.no_file_selected" });
-    const uploadPath = path8.join(getChatLabTempScopeDir("imports"), `archive-${randomUUID()}.zip`);
+    const uploadPath = path8.join(getChatLabTempScopeDir("imports"), `archive-${randomUUID2()}.zip`);
     try {
       await pipeline(data.file, fs7.createWriteStream(uploadPath, { flags: "wx" }));
       if (data.file.truncated) {
@@ -3442,7 +3646,7 @@ data: ${JSON.stringify(eventData)}
     const parts = request.parts();
     if (!parts) return reply.code(400).send({ error: "No files uploaded" });
     const requestedBatchId = request.headers["x-chatlab-import-batch-id"];
-    const batchId = typeof requestedBatchId === "string" && requestedBatchId ? requestedBatchId : randomUUID();
+    const batchId = typeof requestedBatchId === "string" && requestedBatchId ? requestedBatchId : randomUUID2();
     if (activeBatchControllers.has(batchId)) {
       return reply.code(409).send({ error: "Batch import id is already active" });
     }
@@ -3763,10 +3967,10 @@ function registerWebRoutes2(server2, dbManager2, options) {
   const resolvedPathProvider = options?.pathProvider ?? fallbackPathProvider;
   const ai = options?.aiContext;
   const cliStreamImport = async (dm, filePath) => {
-    const { streamImport: streamImport2 } = await import("./stream-import-RXNSOOYH.mjs");
+    const { streamImport: streamImport2 } = await import("./stream-import-YYQVZDGQ.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-AYMALWU5.mjs");
+      const { IMPORT_IN_PROGRESS_ERROR_KEY: IMPORT_IN_PROGRESS_ERROR_KEY2, ImportInProgressError: ImportInProgressError2 } = await import("./src-WE5HNN2O.mjs");
       if (result.error === IMPORT_IN_PROGRESS_ERROR_KEY2) throw new ImportInProgressError2();
       throw new Error(result.error || "Import failed");
     }
@@ -3791,6 +3995,9 @@ function registerWebRoutes2(server2, dbManager2, options) {
       getVersion,
       nativeBinding: options?.nativeBinding,
       semanticIndexService,
+      contactsService: options?.contactsService,
+      globalInsightService: options?.globalInsightService,
+      preferencesManager: options?.preferencesManager,
       analyticsService,
       getCurrentAiLogPath: () => getServerAiLogger()?.getExistingLogPath() ?? null,
       openDirectory: openDirectoryPath,
@@ -3824,6 +4031,7 @@ function registerWebRoutes2(server2, dbManager2, options) {
       ...ai && {
         aiDataDir: ai.aiDataDir,
         aiChatManager: ai.aiChatManager,
+        aiMemoryService: ai.aiMemoryService,
         assistantManager: ai.assistantManager,
         skillManagerCore: ai.skillManagerCore,
         llmConfigStore: ai.llmConfigStore,
@@ -4797,6 +5005,7 @@ function cleanupSync() {
 var server = null;
 var dbManager = null;
 var aiChatManager = null;
+var aiMemoryService = null;
 function resolveNativeBinding2() {
   if (process.versions.electron) return void 0;
   const nativePath = resolveCliPath("native/better_sqlite3.node");
@@ -4819,7 +5028,9 @@ async function startHttpServer(options) {
   let config = loadConfig();
   const port = options?.port ?? config.api.port;
   const host = options?.host ?? config.api.host;
+  const socket = options?.socket;
   const token = options?.token ?? ensureToken(config);
+  if (socket) await prepareUnixSocket(socket);
   const pendingMigration = applyPendingNodeDataDirMigrationIfNeeded();
   if (!pendingMigration.skipped) {
     if (pendingMigration.success) {
@@ -4850,8 +5061,30 @@ async function startHttpServer(options) {
   await migrationRunner.run();
   const nativeBinding = resolveNativeBinding2();
   dbManager = new DatabaseManager(pathProvider, { nativeBinding, runtime });
+  const sessionAdapter = createDatabaseManagerAdapter(dbManager);
+  const contactsService = createContactsService({
+    adapter: sessionAdapter,
+    pathProvider,
+    runtimeIdentity: runtime,
+    nativeBinding
+  });
+  const preferencesManager = new PreferencesManager(pathProvider.getSystemDir());
+  const globalInsightService = createGlobalInsightService({
+    adapter: sessionAdapter,
+    pathProvider,
+    runtimeIdentity: runtime,
+    nativeBinding,
+    getExcludedSessionIds: () => preferencesManager.load().ownerExcludedSessionIds
+  });
+  const crossChatAnalysisService = createCrossChatAnalysisService({
+    adapter: sessionAdapter,
+    contactsService,
+    globalInsightService,
+    getExcludedSessionIds: () => preferencesManager.load().ownerExcludedSessionIds
+  });
   const aiDataDir = pathProvider.getAiDataDir();
   aiChatManager = new AIChatManager(aiDataDir, { nativeBinding });
+  aiMemoryService = new AIMemoryService(aiDataDir, { nativeBinding });
   const assistantManager = getAssistantManager(aiDataDir);
   const skillManagerCore = getSkillManagerCore(aiDataDir);
   const llmRuntimeStores = createLlmRuntimeStores(aiDataDir);
@@ -4860,7 +5093,10 @@ async function startHttpServer(options) {
   initServerAiLogger(pathProvider.getLogsDir());
   appLogger.info("ai-config", "Shared LLM configuration store initialized", { aiDataDir });
   appLogger.info("temp-workspace", "Temporary workspace initialized", { root: pathProvider.getTempDir() });
-  appLogger.info("server", `HTTP server starting on ${host}:${port}`);
+  appLogger.info(
+    "server",
+    socket ? `HTTP server starting on Unix socket ${socket}` : `HTTP server starting on ${host}:${port}`
+  );
   logNativeParserStatus();
   setAuthToken(token);
   setRequireAuth(!!(options?.requireAuth ?? config.api.require_auth));
@@ -4888,10 +5124,14 @@ async function startHttpServer(options) {
     pathProvider,
     nativeBinding,
     runtimeIdentity: runtime,
+    contactsService,
+    globalInsightService,
+    preferencesManager,
     semanticIndexService,
     aiContext: {
       aiDataDir,
       aiChatManager,
+      aiMemoryService,
       assistantManager,
       skillManagerCore,
       llmConfigStore,
@@ -4899,11 +5139,14 @@ async function startHttpServer(options) {
       customModelStore,
       runAgentStream: createCliRunAgentStream(dbManager, aiChatManager, {
         llmConfigStore,
-        semanticIndexService
+        semanticIndexService,
+        crossChatAnalysisService,
+        sessionAdapter,
+        memoryService: aiMemoryService
       })
     }
   });
-  initSync(server, dbManager, pathProvider, { port, host, token });
+  initSync(server, dbManager, pathProvider, { port, host, socket, token });
   if (options?.webRoot && fs11.existsSync(options.webRoot)) {
     registerProxyRoutes(server);
     const fastifyStatic = await import("@fastify/static");
@@ -4916,8 +5159,12 @@ async function startHttpServer(options) {
       return reply.sendFile("index.html");
     });
   }
-  await server.listen({ port, host });
-  return { port, host, token };
+  if (socket) {
+    await server.listen({ path: socket });
+  } else {
+    await server.listen({ port, host });
+  }
+  return socket ? { socket, token } : { port, host, token };
 }
 async function stopHttpServer() {
   if (!server) return;
@@ -4929,6 +5176,10 @@ async function stopHttpServer() {
       aiChatManager.close();
       aiChatManager = null;
     }
+    if (aiMemoryService) {
+      aiMemoryService.close();
+      aiMemoryService = null;
+    }
     if (dbManager) {
       dbManager.closeAll();
       dbManager = null;
@@ -4945,4 +5196,4 @@ export {
   startHttpServer,
   stopHttpServer
 };
-//# sourceMappingURL=chunk-WJQOXOMR.mjs.map
+//# sourceMappingURL=chunk-DKIYHA3O.mjs.map