@remnic/core 9.3.725 → 9.3.727

package/dist/{chunk-C6BWLYW5.js → chunk-N3VNUM4Z.js}

@@ -1,35 +1,29 @@
 import {
   AdapterRegistry
-} from "./chunk-RKNJBZ55.js";
+} from "./chunk-JBPKEARU.js";
 import {
   WearablesInputError
 } from "./chunk-7WV3F5DQ.js";
 import {
-  ChatEngine,
   EngramMcpServer,
-  appendTranscriptEntry,
-  createChatExecutor,
-  createChatSession,
-  createProductionChatLlmAdapter,
+  cleanupExpiredChatSessions,
   loadChatSession,
-  markPendingPlan,
-  markPendingPromotion,
-  markPlanResolved,
-  markPromotionResolved,
-  sessionBelongsToPrincipal
-} from "./chunk-FN6QP7JQ.js";
+  processChatMessage,
+  sessionBelongsToPrincipal,
+  subscribeChatTranscript
+} from "./chunk-6PY5YJAV.js";
 import {
   validateRequest
 } from "./chunk-FVZ2ISIX.js";
 import {
   getOperation
-} from "./chunk-NT36GU6X.js";
+} from "./chunk-R7IYU5DZ.js";
 import {
   EngramAccessInputError
-} from "./chunk-KGZF2VO3.js";
+} from "./chunk-27QQC7ZX.js";
 import {
   CorrectionContractError
-} from "./chunk-Z3FGC3QE.js";
+} from "./chunk-AQLOP5F4.js";
 import {
   isTrustZoneName
 } from "./chunk-JGSKJHF7.js";
@@ -41,7 +35,7 @@ import {
 } from "./chunk-DEUNUKTD.js";
 import {
   isRecallDisclosure
-} from "./chunk-7AG54AF3.js";
+} from "./chunk-PUR2CKX2.js";
 import {
   OFFLINE_SYNC_APPLY_MAX_BODY_BYTES,
   OFFLINE_SYNC_FILE_CONTENT_MAX_CHUNK_BYTES,
@@ -65,6 +59,28 @@ import { fileURLToPath, URL } from "url";
 import { gunzipSync } from "zlib";
 
 // src/chat/chat-http.ts
+import { createHash } from "crypto";
+var chatInFlight = /* @__PURE__ */ new Map();
+function principalFingerprintComponent(principal) {
+  return principal === void 0 ? "\0absent" : `
${principal}`;
+}
+function chatDedupFingerprint(memoryDir, chatSessionId, principal, message) {
+  const messageHash = createHash("sha256").update(message, "utf8").digest("hex").slice(0, 32);
+  return `${memoryDir}:${chatSessionId}:${principalFingerprintComponent(principal)}:${messageHash}`;
+}
+function processChatMessageDedup(opts) {
+  if (!opts.chatSessionId) {
+    return processChatMessage(opts);
+  }
+  const fp = chatDedupFingerprint(opts.memoryDir, opts.chatSessionId, opts.principal, opts.message);
+  const existing = chatInFlight.get(fp);
+  if (existing) return existing;
+  const pending = processChatMessage(opts).finally(() => {
+    chatInFlight.delete(fp);
+  });
+  chatInFlight.set(fp, pending);
+  return pending;
+}
 async function handleChatMessage(req, res, body, opts, principal) {
   if (!opts.config?.enabled) {
     respondJson(res, 404, { error: "chat_disabled", code: "chat_disabled" });
@@ -75,63 +91,43 @@ async function handleChatMessage(req, res, body, opts, principal) {
     respondJson(res, 400, { error: "message is required", code: "input_error" });
     return;
   }
-  const llm = opts.service.fallbackLlmRef ?? opts.service.localLlmRef;
-  if (!llm) {
+  if (!opts.service.fallbackLlmRef && !opts.service.localLlmRef) {
     respondJson(res, 503, {
       error: "No LLM model is available. Configure a local or cloud model.",
       code: "no_llm"
     });
     return;
   }
-  const adapter = createProductionChatLlmAdapter(llm);
-  const requestedSessionId = typeof body.chatSessionId === "string" ? body.chatSessionId : void 0;
-  let session;
-  if (requestedSessionId) {
-    session = await loadChatSession(opts.memoryDir, requestedSessionId);
-    if (!session) {
+  const chatSessionId = typeof body.chatSessionId === "string" ? body.chatSessionId : void 0;
+  let result;
+  try {
+    result = await processChatMessageDedup({
+      service: opts.service,
+      config: opts.config,
+      memoryDir: opts.memoryDir,
+      message,
+      ...chatSessionId ? { chatSessionId } : {},
+      ...principal ? { principal } : {}
+    });
+  } catch (err) {
+    const code = err instanceof Error ? err.message : String(err);
+    if (code === "chat_session_not_found") {
       respondJson(res, 404, { error: "chat_session_not_found", code: "chat_session_not_found" });
-      return;
-    }
-    if (!sessionBelongsToPrincipal(session, principal)) {
+    } else if (code === "access_denied") {
       respondJson(res, 403, { error: "access_denied", code: "access_denied" });
-      return;
+    } else if (code === "chat_session_expired") {
+      respondJson(res, 410, { error: "chat_session_expired", code: "chat_session_expired" });
+    } else if (code === "chat_disabled") {
+      respondJson(res, 404, { error: "chat_disabled", code: "chat_disabled" });
+    } else if (code === "no_llm_available" || code === "engine_unavailable") {
+      respondJson(res, 503, {
+        error: "No LLM model is available. Configure a local or cloud model.",
+        code: "no_llm"
+      });
+    } else {
+      respondJson(res, 500, { error: "internal_error", code: "internal_error" });
     }
-  } else {
-    session = await createChatSession(opts.memoryDir, { principal });
-  }
-  const executor = createChatExecutor({
-    service: opts.service,
-    principal,
-    ...session.namespace ? { namespace: session.namespace } : {},
-    ...session.sessionKey ? { sessionKey: session.sessionKey } : {}
-  });
-  const engine = new ChatEngine({
-    llm: adapter,
-    executor,
-    maxToolCallsPerTurn: opts.config.maxToolCallsPerTurn,
-    ...opts.config.model ? { model: opts.config.model } : {},
-    correctionAvailable: false,
-    scopeInspectAvailable: false
-  });
-  await appendTranscriptEntry(opts.memoryDir, session.id, {
-    role: "user",
-    content: message
-  });
-  const priorPendingPlanId = session.pendingPlanId;
-  const priorPendingPromotionId = session.pendingPromotionId;
-  const result = await engine.processMessage(message, session);
-  await appendTranscriptEntry(opts.memoryDir, session.id, {
-    role: "assistant",
-    content: result.reply
-  });
-  if (result.pendingPlan?.planId) {
-    await markPendingPlan(opts.memoryDir, session.id, result.pendingPlan.planId);
-  } else if (session.pendingPromotionId && !priorPendingPromotionId) {
-    await markPendingPromotion(opts.memoryDir, session.id, session.pendingPromotionId);
-  } else if (priorPendingPlanId && !session.pendingPlanId && !result.error) {
-    await markPlanResolved(opts.memoryDir, session.id, priorPendingPlanId);
-  } else if (priorPendingPromotionId && !session.pendingPromotionId && !result.error) {
-    await markPromotionResolved(opts.memoryDir, session.id, priorPendingPromotionId);
+    return;
   }
   const wireResult = result.error ? { reply: result.reply, chatSessionId: result.chatSessionId, ...result.pendingPlan ? { pendingPlan: result.pendingPlan } : {} } : result;
   respondJson(res, 200, wireResult);
@@ -141,12 +137,55 @@ async function handleChatEventsSSE(req, res, chatSessionId, opts, principal) {
     respondJson(res, 404, { error: "chat_disabled", code: "chat_disabled" });
     return;
   }
+  let heartbeat;
+  let closed = false;
+  const writeSse = (chunk) => {
+    if (closed) return false;
+    try {
+      res.write(chunk);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const pending = [];
+  let bursting = true;
+  const unsubscribe = subscribeChatTranscript(opts.memoryDir, chatSessionId, (entry) => {
+    if (closed) return;
+    if (bursting) {
+      pending.push(entry);
+      return;
+    }
+    writeSse(`data: ${JSON.stringify(entry)}
+
+`);
+  });
+  const doCleanup = () => {
+    closed = true;
+    clearInterval(heartbeat);
+    unsubscribe();
+    try {
+      res.end();
+    } catch {
+    }
+  };
+  const unregisterServerCleanup = opts.registerSseCleanup?.(doCleanup) ?? (() => {
+  });
+  req.on("close", () => {
+    doCleanup();
+    unregisterServerCleanup();
+  });
   const session = await loadChatSession(opts.memoryDir, chatSessionId);
+  if (closed) return;
   if (!session) {
+    unsubscribe();
+    unregisterServerCleanup();
     respondJson(res, 404, { error: "chat_session_not_found", code: "chat_session_not_found" });
     return;
   }
   if (!sessionBelongsToPrincipal(session, principal)) {
+    unsubscribe();
+    unregisterServerCleanup();
     respondJson(res, 403, { error: "access_denied", code: "access_denied" });
     return;
   }
@@ -155,27 +194,29 @@ async function handleChatEventsSSE(req, res, chatSessionId, opts, principal) {
     "cache-control": "no-cache",
     connection: "keep-alive"
   });
+  writeSse("retry: 5000\n\n");
+  const deliveredSeqs = /* @__PURE__ */ new Set();
   for (const entry of session.transcript) {
-    res.write(`data: ${JSON.stringify(entry)}
+    writeSse(`data: ${JSON.stringify(entry)}
 
 `);
+    deliveredSeqs.add(entry.seq);
   }
-  const heartbeat = setInterval(() => {
-    try {
-      res.write(`data: ${JSON.stringify({ type: "heartbeat" })}
+  bursting = false;
+  for (const entry of pending) {
+    if (!deliveredSeqs.has(entry.seq)) {
+      writeSse(`data: ${JSON.stringify(entry)}
 
 `);
-    } catch {
     }
+  }
+  if (closed) return;
+  heartbeat = setInterval(() => {
+    writeSse(`data: ${JSON.stringify({ type: "heartbeat" })}
+
+`);
   }, 25e3);
-  heartbeat.unref();
-  req.on("close", () => {
-    clearInterval(heartbeat);
-    try {
-      res.end();
-    } catch {
-    }
-  });
+  heartbeat.unref?.();
 }
 function respondJson(res, status, body) {
   const json = JSON.stringify(body);
@@ -324,6 +365,12 @@ var EngramAccessHttpServer = class {
    * (Cursor review thread `access-http.ts:232`).
    */
   sseCleanupFns = /* @__PURE__ */ new Set();
+  /**
+   * Periodic chat-session TTL sweep handle (issue #1685 item 1 /
+   * #1687 Thread 21).  unref'd so it never blocks process exit
+   * (rule 47); cleared in `stop()`.
+   */
+  chatTtlTimer = null;
   constructor(options) {
     this.service = options.service;
     this.host = options.host?.trim() || "127.0.0.1";
@@ -409,10 +456,15 @@ var EngramAccessHttpServer = class {
     this.server = server;
     const address = server.address();
     this.boundPort = typeof address === "object" && address ? address.port : this.requestedPort;
+    this.scheduleChatSessionTtlSweep();
     return this.status();
   }
   async stop() {
     if (!this.server) return;
+    if (this.chatTtlTimer) {
+      clearInterval(this.chatTtlTimer);
+      this.chatTtlTimer = null;
+    }
     const server = this.server;
     this.server = null;
     this.boundPort = 0;
@@ -439,6 +491,31 @@ var EngramAccessHttpServer = class {
       server.close((err) => err ? reject(err) : resolve());
     });
   }
+  /**
+   * Schedule the chat-session TTL sweep: one immediate pass plus a
+   * recurring hourly pass (issue #1685 item 1 / #1687 Thread 21).  Both
+   * are skipped when chat is disabled.  The recurring timer is unref'd
+   * so it never keeps the event loop alive on its own (rule 47).  The
+   * sweep itself is best-effort — cleanup failures are swallowed inside
+   * `cleanupExpiredChatSessions`.
+   */
+  scheduleChatSessionTtlSweep() {
+    if (this.chatTtlTimer) {
+      clearInterval(this.chatTtlTimer);
+      this.chatTtlTimer = null;
+    }
+    const chat = this.service.configRef?.chat;
+    if (!chat?.enabled) return;
+    const ttlHours = typeof chat.sessionTtlHours === "number" && chat.sessionTtlHours > 0 ? chat.sessionTtlHours : 72;
+    void cleanupExpiredChatSessions(this.service.memoryDir, ttlHours).catch(() => {
+    });
+    const SWEEP_INTERVAL_MS = 60 * 60 * 1e3;
+    this.chatTtlTimer = setInterval(() => {
+      void cleanupExpiredChatSessions(this.service.memoryDir, ttlHours).catch(() => {
+      });
+    }, SWEEP_INTERVAL_MS);
+    this.chatTtlTimer.unref?.();
+  }
   status() {
     return {
       running: this.server !== null,
@@ -1731,7 +1808,22 @@ var EngramAccessHttpServer = class {
         req,
         res,
         chatEventsMatch[1] ?? "",
-        { service: this.service, config: this.service.configRef?.chat, memoryDir: this.service.memoryDir },
+        {
+          service: this.service,
+          config: this.service.configRef?.chat,
+          memoryDir: this.service.memoryDir,
+          // Register the chat-SSE disconnect cleanup with this server's
+          // stop() set so an HTTP shutdown forcibly releases the heartbeat
+          // and transcript subscription even when a lingering client never
+          // emits 'close' (cursor Medium review; mirrors handleGraphEventsSSE
+          // which registers in sseCleanupFns at access-http.ts:2604).
+          registerSseCleanup: (cleanup) => {
+            this.sseCleanupFns.add(cleanup);
+            return () => {
+              this.sseCleanupFns.delete(cleanup);
+            };
+          }
+        },
         this.resolveRequestPrincipal(req)
       );
       return;
@@ -2537,4 +2629,4 @@ function positiveIntQueryParam(value, label) {
 export {
   EngramAccessHttpServer
 };
-//# sourceMappingURL=chunk-C6BWLYW5.js.map
+//# sourceMappingURL=chunk-N3VNUM4Z.js.map