memorix 1.6.0 → 1.6.2

package/src/cli/commands/serve-http.ts

@@ -29,13 +29,19 @@ import { canManageObservation, filterReadableObservations } from '../../memory/v
 import { parseTcpPortOrReport } from '../port.js';
 import { mcpFileUriToPath } from '../mcp-root-path.js';
 
-export const DEFAULT_SESSION_TIMEOUT_MS = 30 * 60 * 1000;
+/**
+ * HTTP MCP is a shared control plane. A normal thinking break should not
+ * silently invalidate a client session. Operators can choose a shorter GC
+ * window, or set 0 to disable idle GC entirely.
+ */
+export const DEFAULT_SESSION_TIMEOUT_MS = 12 * 60 * 60 * 1000;
+export const EXPIRED_SESSION_TTL_MS = 10 * 60 * 1000;
 
 export function parseSessionTimeoutMs(raw: string | undefined): number {
   const value = raw?.trim();
   if (!value) return DEFAULT_SESSION_TIMEOUT_MS;
   const parsed = Number(value);
-  if (!Number.isFinite(parsed) || parsed <= 0) return DEFAULT_SESSION_TIMEOUT_MS;
+  if (!Number.isFinite(parsed) || parsed < 0) return DEFAULT_SESSION_TIMEOUT_MS;
   return Math.floor(parsed);
 }
 
@@ -132,7 +138,11 @@ export default defineCommand({
     console.error(`[memorix] HTTP transport starting on ${host}:${port}`);
     console.error(`[memorix] Project root: ${projectRoot}`);
     const sessionTimeoutMs = parseSessionTimeoutMs(process.env.MEMORIX_SESSION_TIMEOUT_MS);
-    console.error(`[memorix] HTTP session idle timeout: ${Math.round(sessionTimeoutMs / 60000)}min (${sessionTimeoutMs}ms)`);
+    console.error(
+      sessionTimeoutMs === 0
+        ? '[memorix] HTTP session idle timeout: disabled'
+        : `[memorix] HTTP session idle timeout: ${Math.round(sessionTimeoutMs / 60000)}min (${sessionTimeoutMs}ms)`,
+    );
 
     // Per-project TeamStore cache (Option B) — each dataDir gets its own TeamStore instance.
     // This ensures true isolation between projects in HTTP control-plane mode.
@@ -166,6 +176,9 @@ export default defineCommand({
 
     // Session activity tracking (for GC timeout)
     const sessionLastActivity = new Map<string, number>();
+    // Keep a short-lived tombstone so an expired client gets an actionable
+    // reinitialize response instead of a generic bad request.
+    const expiredSessions = new Map<string, number>();
 
     // Probe session noise reduction: defer init logs, suppress short-lived sessions
     let suppressedProbeCount = 0;
@@ -182,6 +195,30 @@ export default defineCommand({
       }
     }
 
+    function forgetExpiredSessions(now = Date.now()): void {
+      for (const [sessionId, expiresAt] of expiredSessions) {
+        if (expiresAt <= now) expiredSessions.delete(sessionId);
+      }
+    }
+
+    function sendUnknownSession(res: ServerResponse, sessionId: string | undefined, jsonRpc = false): void {
+      const expired = Boolean(sessionId && expiredSessions.has(sessionId));
+      const message = expired
+        ? 'MCP session expired after inactivity. Initialize a new session and retry the request.'
+        : 'MCP session not found. Initialize a new session and retry the request.';
+      if (jsonRpc) {
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+          jsonrpc: '2.0',
+          error: { code: -32001, message },
+          id: null,
+        }));
+        return;
+      }
+      res.writeHead(404, { 'Content-Type': 'text/plain' });
+      res.end(message);
+    }
+
     /**
      * Parse JSON body from IncomingMessage
      */
@@ -360,6 +397,11 @@ export default defineCommand({
         return;
       }
 
+      if (sessionId) {
+        sendUnknownSession(res, sessionId, true);
+        return;
+      }
+
       if (!sessionId && isInitializeRequest(body)) {
         // New session — create transport + server
         let createdState: SessionState | null = null;
@@ -408,6 +450,10 @@ export default defineCommand({
           {
             allowUntrackedFallback: false,
             deferProjectInitUntilBound: true,
+            // Same as stdio: initialize/tools/list must not hydrate 40k+
+            // observations on the HTTP thread. /health and the LaunchAgent
+            // watchdog die if createMemorixServer blocks here.
+            deferProjectRuntimeInit: true,
             dashboardMode: 'control-plane',
             dashboardPort: port,
             toolProfile,
@@ -488,8 +534,12 @@ export default defineCommand({
     async function handleGet(req: IncomingMessage, res: ServerResponse) {
       const sessionId = req.headers['mcp-session-id'] as string | undefined;
       if (!sessionId || !sessions.has(sessionId)) {
-        res.writeHead(400, { 'Content-Type': 'text/plain' });
-        res.end('Invalid or missing session ID');
+        if (!sessionId) {
+          res.writeHead(400, { 'Content-Type': 'text/plain' });
+          res.end('Missing MCP session ID');
+          return;
+        }
+        sendUnknownSession(res, sessionId);
         return;
       }
 
@@ -502,8 +552,12 @@ export default defineCommand({
     async function handleDelete(req: IncomingMessage, res: ServerResponse) {
       const sessionId = req.headers['mcp-session-id'] as string | undefined;
       if (!sessionId || !sessions.has(sessionId)) {
-        res.writeHead(400, { 'Content-Type': 'text/plain' });
-        res.end('Invalid or missing session ID');
+        if (!sessionId) {
+          res.writeHead(400, { 'Content-Type': 'text/plain' });
+          res.end('Missing MCP session ID');
+          return;
+        }
+        sendUnknownSession(res, sessionId);
         return;
       }
 
@@ -1414,6 +1468,7 @@ export default defineCommand({
       // Lightweight health check — responds immediately, no heavy init required.
       // This is the readiness signal for background start / status.
       if (url.pathname === '/health') {
+        const { getEmbeddingRuntimeHealth } = await import('../../embedding/provider.js');
         res.writeHead(200, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({
           status: 'ok',
@@ -1421,6 +1476,7 @@ export default defineCommand({
           port,
           uptime: Math.round(process.uptime()),
           pid: process.pid,
+          embedding: getEmbeddingRuntimeHealth(),
         }));
         return;
       }
@@ -1491,6 +1547,12 @@ export default defineCommand({
       await serveDashStatic(req, res);
     });
 
+    // MCP session continuity is independent from one TCP socket. Keep Node's
+    // socket timeout above its 5s default while the session map remains the
+    // actual continuity boundary.
+    httpServer.keepAliveTimeout = 60_000;
+    httpServer.headersTimeout = 65_000;
+
     httpServer.listen(port, host, () => {
       // Write readiness file — background start polls this for out-of-band readiness detection
       try {
@@ -1521,10 +1583,13 @@ export default defineCommand({
     const gcInterval = setInterval(() => {
       maybeProbeSummary(); // Flush suppressed probe count periodically
       const now = Date.now();
+      forgetExpiredSessions(now);
+      if (SESSION_TIMEOUT_MS === 0) return;
       for (const [sid, state] of sessions) {
         const lastActive = sessionLastActivity.get(sid) ?? 0;
         if (now - lastActive > SESSION_TIMEOUT_MS) {
           console.error(`[memorix] Session ${sid.slice(0, 8)}… timed out (idle ${Math.round((now - lastActive) / 60000)}min), closing`);
+          expiredSessions.set(sid, now + EXPIRED_SESSION_TTL_MS);
           state.transport.close().catch(() => {});
           sessions.delete(sid);
           sessionLastActivity.delete(sid);

package/src/cli/heap.ts

@@ -0,0 +1,76 @@
+/**
+ * CLI heap selection for the tsup respawn banner.
+ *
+ * `memorix serve` and other long-lived commands need a large V8 heap for
+ * embeddings and the in-memory index. `memorix hook` is a per-event
+ * lifecycle process and must not reserve a 4 GB heap — copies accumulate.
+ */
+
+export const DEFAULT_CLI_HEAP_MB = 4096;
+export const DEFAULT_HOOK_HEAP_MB = 512;
+export const MIN_HEAP_MB = 64;
+export const MAX_HEAP_MB = 16_384;
+
+function parseHeapMb(raw: string | undefined, fallback: number): number {
+  if (raw === undefined || raw.trim() === '') return fallback;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed)) return fallback;
+  const mb = Math.floor(parsed);
+  if (mb < MIN_HEAP_MB || mb > MAX_HEAP_MB) return fallback;
+  return mb;
+}
+
+/**
+ * True when the CLI argv selects the short-lived `hook` command.
+ * `hooks` (install/status) is a different command and keeps the large heap.
+ */
+export function isHookCliInvocation(argv: string[]): boolean {
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (argument === '--') break;
+    if (argument.startsWith('-')) {
+      if (!argument.includes('=') && argv[index + 1] && !argv[index + 1].startsWith('-')) {
+        index += 1;
+      }
+      continue;
+    }
+    return argument === 'hook';
+  }
+  return false;
+}
+
+export function resolveCliHeapMb(
+  argv: string[],
+  env: NodeJS.ProcessEnv = process.env,
+): number {
+  if (isHookCliInvocation(argv)) {
+    return parseHeapMb(env.MEMORIX_HOOK_HEAP_MB, DEFAULT_HOOK_HEAP_MB);
+  }
+  return parseHeapMb(env.MEMORIX_HEAP_MB, DEFAULT_CLI_HEAP_MB);
+}
+
+/**
+ * Self-contained JS prepended to the bundled CLI. It runs before the bundle
+ * loads, so the selection logic is inlined rather than imported.
+ */
+export function buildCliHeapBannerPrelude(): string {
+  return [
+    '#!/usr/bin/env node',
+    'import {spawnSync as __ms} from "node:child_process";',
+    'import {fileURLToPath as __fu} from "node:url";',
+    'if(!process.env.__MEMORIX_HEAP){process.env.__MEMORIX_HEAP="1";',
+    'const __args=process.argv.slice(2);',
+    'let __cmd;',
+    'for(let __i=0;__i<__args.length;__i++){',
+    'const __a=__args[__i];',
+    'if(__a==="--")break;',
+    'if(__a.startsWith("-")){if(!__a.includes("=")&&__args[__i+1]&&!__args[__i+1].startsWith("-"))__i++;continue;}',
+    '__cmd=__a;break;}',
+    `const __fallback=__cmd==="hook"?${DEFAULT_HOOK_HEAP_MB}:${DEFAULT_CLI_HEAP_MB};`,
+    'const __raw=__cmd==="hook"?process.env.MEMORIX_HOOK_HEAP_MB:process.env.MEMORIX_HEAP_MB;',
+    'const __n=Number(__raw);',
+    `const __heap=(Number.isFinite(__n)&&__n>=${MIN_HEAP_MB}&&__n<=${MAX_HEAP_MB})?String(Math.floor(__n)):String(__fallback);`,
+    'let r=__ms(process.execPath,["--max-old-space-size="+__heap,__fu(import.meta.url),...process.argv.slice(2)],{stdio:"inherit",env:process.env,windowsHide:true});',
+    'process.exit(r.status??1);}',
+  ].join('\n');
+}

package/src/cli/invocation.ts

@@ -1,4 +1,4 @@
-import { existsSync, statSync } from 'node:fs';
+import { existsSync, realpathSync, statSync } from 'node:fs';
 import { resolve } from 'node:path';
 
 export interface CliInvocation {
@@ -88,10 +88,13 @@ export function normalizeCliInvocation(argv: string[] = process.argv): CliInvoca
   }
 
   if (invocation.projectRoot) {
-    const projectRoot = resolve(invocation.projectRoot);
-    if (!existsSync(projectRoot) || !statSync(projectRoot).isDirectory()) {
-      throw new Error(`CLI project directory does not exist: ${projectRoot}`);
+    const resolvedProjectRoot = resolve(invocation.projectRoot);
+    if (!existsSync(resolvedProjectRoot) || !statSync(resolvedProjectRoot).isDirectory()) {
+      throw new Error(`CLI project directory does not exist: ${resolvedProjectRoot}`);
     }
+    // Keep one project identity when an OS exposes the same directory through
+    // two paths (for example /var and /private/var on macOS).
+    const projectRoot = realpathSync(resolvedProjectRoot);
     process.chdir(projectRoot);
     process.env.MEMORIX_CLI_PROJECT_ROOT = projectRoot;
     invocation.projectRoot = projectRoot;