memorix 1.8.2 → 1.8.4

package/plugins/hermes/memorix/plugin.yaml

@@ -1,5 +1,5 @@
 name: memorix
-version: "1.8.2"
+version: "1.8.4"
 description: Shared workspace memory bridge for Hermes Agent.
 author: AVIDS2
 license: Apache-2.0

package/plugins/omp/memorix/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix-omp-package",
-  "version": "1.8.2",
+  "version": "1.8.4",
   "description": "Memorix shared workspace memory package for Oh-my-Pi.",
   "license": "Apache-2.0",
   "keywords": [

package/plugins/openclaw/memorix/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix",
-  "version": "1.8.2",
+  "version": "1.8.4",
   "description": "Shared workspace memory for OpenClaw and other AI coding agents.",
   "author": {
     "name": "AVIDS2",

package/plugins/pi/memorix/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memorix-pi-package",
-  "version": "1.8.2",
+  "version": "1.8.4",
   "description": "Memorix shared workspace memory package for Pi coding agent.",
   "license": "Apache-2.0",
   "keywords": [

package/server.json

@@ -7,7 +7,7 @@
     "url": "https://github.com/AVIDS2/memorix",
     "source": "github"
   },
-  "version": "1.8.2",
+  "version": "1.8.4",
   "websiteUrl": "https://github.com/AVIDS2/memorix#readme",
   "icons": [
     {
@@ -22,7 +22,7 @@
     {
       "registryType": "npm",
       "identifier": "memorix",
-      "version": "1.8.2",
+      "version": "1.8.4",
       "runtimeHint": "npx",
       "packageArguments": [
         {

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

@@ -413,7 +413,7 @@ export default defineCommand({
       res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
       res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Accept, Mcp-Session-Id, Mcp-Project-Handle, Mcp-Project-Root, Mcp-Stateless, Last-Event-Id');
       res.setHeader('Access-Control-Expose-Headers', 'Mcp-Session-Id, Mcp-Project-Handle, Mcp-Protocol-Version, Mcp-Method, Mcp-Name');
-      res.setHeader('Mcp-Protocol-Version', req.headers['mcp-protocol-version'] || CURRENT_MCP_PROTOCOL_VERSION);
+      res.setHeader('Mcp-Protocol-Version', MCP_SDK_COMPAT_PROTOCOL_VERSION);
       res.setHeader('Mcp-Method', req.method || 'UNKNOWN');
       res.setHeader('Mcp-Name', MCP_SERVER_NAME);
     }
@@ -433,11 +433,6 @@ export default defineCommand({
         ? req.headers['mcp-project-root']
         : undefined;
       const root = persisted?.projectRoot ?? requestedRoot ?? projectRoot;
-      if (!persisted && !isInitializeRequest(body) && !isServerDiscoverRequest(body)) {
-        res.writeHead(400, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ jsonrpc: '2.0', error: { code: -32000, message: 'Stateless MCP requests require Mcp-Project-Handle; initialize first.' }, id: null }));
-        return;
-      }
 
       const { createMemorixServer } = await import('../../server.js');
       const { createProjectBindingController } = await import('../../server/request-context.js');
@@ -465,7 +460,7 @@ export default defineCommand({
       try {
         await server.connect(transport);
         let effectiveHandle = persisted;
-        if (!effectiveHandle && projectId !== '__unresolved__') {
+        if (!effectiveHandle && projectId !== '__unresolved__' && isInitializeRequest(body)) {
           effectiveHandle = statelessBindingStore.create({
             projectId,
             projectRoot: root,

package/src/cli/commands/serve.ts

@@ -4,6 +4,8 @@
 
 import { defineCommand } from 'citty';
 import { resolveToolProfile } from '../../server/tool-profile.js';
+import { getMcpServerInfo } from '../../server/mcp-discovery.js';
+import { StdioStartupGate } from '../../server/stdio-startup-gate.js';
 import { mcpFileUriToPath } from '../mcp-root-path.js';
 
 export default defineCommand({
@@ -29,6 +31,28 @@ export default defineCommand({
     },
   },
   run: async ({ args }) => {
+    // Take ownership of stdin before project/config/runtime initialization. The
+    // gate answers handshake-free discovery and queues every other JSON-RPC line
+    // until the SDK transport is connected, so cold starts cannot lose requests.
+    const startupGate = new StdioStartupGate({
+      stdin: process.stdin,
+      stdout: process.stdout,
+      serverInfo: getMcpServerInfo(),
+      onError: (error) => {
+        console.error(`[memorix] stdio startup gate error: ${error.message}`);
+        // The stream is no longer safe to replay after an input-limit or I/O
+        // failure. Exit instead of leaving a half-connected MCP process alive.
+        process.exit(1);
+      },
+      onEnd: () => {
+        console.error('[memorix] stdin closed — exiting');
+        // The gate has already ended the transport input when ready. Set the
+        // exit code and let pending JSON-RPC stdout writes drain naturally.
+        process.exitCode = 0;
+      },
+    });
+    startupGate.start();
+
     const { StdioServerTransport } = await import(
       '@modelcontextprotocol/sdk/server/stdio.js'
     );
@@ -37,12 +61,6 @@ export default defineCommand({
     const { homedir } = await import('node:os');
     const { resolveServeProject } = await import('./serve-shared.js');
 
-    // Auto-exit when stdio pipe breaks (IDE closed) to prevent orphaned processes
-    process.stdin.on('end', () => {
-      console.error('[memorix] stdin closed — exiting');
-      process.exit(0);
-    });
-
     // Priority: explicit --cwd arg > MEMORIX_PROJECT_ROOT env > INIT_CWD (npm lifecycle) > process.cwd()
     let safeCwd: string;
     try { safeCwd = process.cwd(); } catch { safeCwd = homedir(); }
@@ -85,8 +103,9 @@ export default defineCommand({
       ? { toolProfile, deferProjectRuntimeInit: true }
       : { allowUntrackedFallback: allowUntracked, deferProjectInitUntilBound: !allowUntracked, deferProjectRuntimeInit: true, toolProfile };
     const { server, projectId, deferredInit, switchProject } = await createMemorixServer(projectRoot, undefined, undefined, serverOptions);
-    const transport = new StdioServerTransport();
+    const transport = new StdioServerTransport(startupGate.input, process.stdout);
     await server.connect(transport);
+    startupGate.markReady();
 
     console.error(`[memorix] MCP Server running on stdio (project: ${projectId})`);
     console.error(`[memorix] Project root: ${detected?.rootPath ?? projectRoot}`);

package/src/server/mcp-compat.ts

@@ -11,33 +11,29 @@ import { RequestSchema, type ServerCapabilities } from '@modelcontextprotocol/sd
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod/v4';
 
-export const MCP_MODERN_PROTOCOL_VERSION = '2026-07-28';
-export const MCP_LEGACY_PROTOCOL_VERSION = '2025-11-25';
-export const MCP_OLDEST_LEGACY_PROTOCOL_VERSION = '2024-11-05';
-export const MCP_SERVER_DISCOVER_METHOD = 'server/discover';
-export const MCP_SERVER_INFO_META_KEY = 'io.modelcontextprotocol/serverInfo';
+import {
+  createMcpDiscoverResult,
+  MCP_SERVER_DISCOVER_METHOD,
+  type McpDiscoverResult,
+  type McpServerInfo,
+} from './mcp-discovery.js';
+
+export {
+  createMcpDiscoverResult,
+  getMcpServerInfo,
+  MCP_LEGACY_PROTOCOL_VERSION,
+  MCP_MODERN_PROTOCOL_VERSION,
+  MCP_OLDEST_LEGACY_PROTOCOL_VERSION,
+  MCP_SERVER_DISCOVER_METHOD,
+  MCP_SERVER_INFO_META_KEY,
+} from './mcp-discovery.js';
+export type { McpDiscoverResult, McpServerInfo } from './mcp-discovery.js';
 
 const ServerDiscoverRequestSchema = RequestSchema.extend({
   method: z.literal(MCP_SERVER_DISCOVER_METHOD),
   params: z.looseObject({}).optional(),
 });
 
-export interface McpServerInfo {
-  name: string;
-  version: string;
-}
-
-export interface McpDiscoverResult {
-  resultType: 'complete';
-  supportedVersions: string[];
-  capabilities: ServerCapabilities;
-  _meta: {
-    [MCP_SERVER_INFO_META_KEY]: McpServerInfo;
-  };
-  ttlMs: number;
-  cacheScope: 'public' | 'private';
-}
-
 const registeredServers = new WeakSet<McpServer>();
 
 /** Build the wire result without exposing unsupported cache/task features. */
@@ -48,22 +44,7 @@ export function buildMcpDiscoverResult(server: McpServer, serverInfo: McpServerI
   const getCapabilities = (server.server as unknown as {
     getCapabilities: () => ServerCapabilities;
   }).getCapabilities.bind(server.server);
-  return {
-    resultType: 'complete',
-    supportedVersions: [
-      MCP_MODERN_PROTOCOL_VERSION,
-      MCP_LEGACY_PROTOCOL_VERSION,
-      MCP_OLDEST_LEGACY_PROTOCOL_VERSION,
-    ],
-    capabilities: getCapabilities(),
-    _meta: {
-      [MCP_SERVER_INFO_META_KEY]: { ...serverInfo },
-    },
-    // v1 has no response-cache negotiation. A zero private TTL is the
-    // conservative result and prevents clients from inventing a shared cache.
-    ttlMs: 0,
-    cacheScope: 'private',
-  };
+  return createMcpDiscoverResult(getCapabilities(), serverInfo);
 }
 
 /**

package/src/server/mcp-discovery.ts

@@ -0,0 +1,60 @@
+import type { ServerCapabilities } from '@modelcontextprotocol/sdk/types.js';
+
+export const MCP_MODERN_PROTOCOL_VERSION = '2026-07-28';
+export const MCP_LEGACY_PROTOCOL_VERSION = '2025-11-25';
+export const MCP_OLDEST_LEGACY_PROTOCOL_VERSION = '2024-11-05';
+export const MCP_SERVER_DISCOVER_METHOD = 'server/discover';
+export const MCP_SERVER_INFO_META_KEY = 'io.modelcontextprotocol/serverInfo';
+
+export interface McpServerInfo {
+  name: string;
+  version: string;
+}
+
+export interface McpDiscoverResult {
+  resultType: 'complete';
+  supportedVersions: string[];
+  capabilities: ServerCapabilities;
+  _meta: {
+    [MCP_SERVER_INFO_META_KEY]: McpServerInfo;
+  };
+  ttlMs: number;
+  cacheScope: 'public' | 'private';
+}
+
+export function getMcpServerInfo(): McpServerInfo {
+  return {
+    name: 'memorix',
+    version: typeof __MEMORIX_VERSION__ !== 'undefined' ? __MEMORIX_VERSION__ : '1.0.1',
+  };
+}
+
+/** Build the deliberately partial modern-discovery result shared by all stdio paths. */
+export function createMcpDiscoverResult(
+  capabilities: ServerCapabilities,
+  serverInfo: McpServerInfo,
+): McpDiscoverResult {
+  return {
+    resultType: 'complete',
+    supportedVersions: [
+      MCP_LEGACY_PROTOCOL_VERSION,
+      MCP_OLDEST_LEGACY_PROTOCOL_VERSION,
+    ],
+    capabilities,
+    _meta: {
+      [MCP_SERVER_INFO_META_KEY]: { ...serverInfo },
+    },
+    // v1 has no response-cache negotiation. A zero private TTL prevents clients
+    // from inventing a shared cache for an implementation that cannot invalidate it.
+    ttlMs: 0,
+    cacheScope: 'private',
+  };
+}
+
+/**
+ * The startup gate can answer discovery before McpServer exists. These are the
+ * only capabilities the production stdio profile advertises at that boundary.
+ */
+export function createMcpStartupDiscoverResult(serverInfo: McpServerInfo): McpDiscoverResult {
+  return createMcpDiscoverResult({ tools: { listChanged: true } }, serverInfo);
+}

package/src/server/stdio-startup-gate.ts

@@ -0,0 +1,263 @@
+import { PassThrough, type Readable, type Writable } from 'node:stream';
+
+import {
+  createMcpStartupDiscoverResult,
+  MCP_SERVER_DISCOVER_METHOD,
+  type McpServerInfo,
+} from './mcp-discovery.js';
+
+/** Keep the gate aligned with @modelcontextprotocol/sdk's stdio ReadBuffer limit. */
+export const STDIO_STARTUP_GATE_MAX_BUFFER_SIZE = 10 * 1024 * 1024;
+
+export interface StdioStartupGateOptions {
+  stdin: Readable;
+  stdout: Writable;
+  serverInfo: McpServerInfo;
+  maxBufferSize?: number;
+  onError?: (error: Error) => void;
+  onEnd?: () => void;
+}
+
+type JsonRpcEnvelope = Record<string, unknown>;
+type ParsedLine = { message: JsonRpcEnvelope } | { error: { code: number; message: string } } | null;
+
+/**
+ * Reads stdio before the server's expensive project setup finishes.
+ *
+ * Only the handshake-free discovery request is answered at the front door. All
+ * other complete JSON-RPC lines, including notifications and responses, stay in
+ * an ordered queue and are replayed through the SDK transport once it is ready.
+ */
+export class StdioStartupGate {
+  readonly input = new PassThrough();
+
+  private readonly stdin: Readable;
+  private readonly stdout: Writable;
+  private readonly serverInfo: McpServerInfo;
+  private readonly maxBufferSize: number;
+  private readonly onError?: (error: Error) => void;
+  private readonly onEnd?: () => void;
+  private readonly queuedMessages: string[] = [];
+  private pendingInput = '';
+  private queuedBytes = 0;
+  private started = false;
+  private ready = false;
+  private stopped = false;
+  private stdinEnded = false;
+  private endNotified = false;
+
+  private readonly onData = (chunk: Buffer | string): void => {
+    if (this.stopped) return;
+
+    if (this.ready) {
+      if (Buffer.byteLength(chunk, 'utf8') > this.maxBufferSize) {
+        this.fail(new Error(`stdio input chunk exceeded ${this.maxBufferSize} bytes`));
+        return;
+      }
+      this.input.write(chunk);
+      return;
+    }
+
+    const text = typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+    if (
+      this.queuedBytes
+      + Buffer.byteLength(this.pendingInput, 'utf8')
+      + Buffer.byteLength(text, 'utf8')
+      > this.maxBufferSize
+    ) {
+      this.fail(new Error(`stdio startup input exceeded ${this.maxBufferSize} bytes before a complete JSON-RPC line`));
+      return;
+    }
+
+    this.pendingInput += text;
+    let newline = this.pendingInput.indexOf('\n');
+    while (newline >= 0 && !this.stopped) {
+      const line = this.pendingInput.slice(0, newline + 1);
+      this.pendingInput = this.pendingInput.slice(newline + 1);
+      this.handleLine(line);
+      newline = this.pendingInput.indexOf('\n');
+    }
+
+    if (!this.stopped && Buffer.byteLength(this.pendingInput, 'utf8') > this.maxBufferSize) {
+      this.fail(new Error(`stdio startup input exceeded ${this.maxBufferSize} bytes`));
+    }
+  };
+
+  private readonly onStdinError = (error: Error): void => {
+    this.fail(error);
+  };
+
+  private readonly onStdinEnd = (): void => {
+    this.stdinEnded = true;
+    if (this.ready) this.finishInput();
+  };
+
+  constructor(options: StdioStartupGateOptions) {
+    this.stdin = options.stdin;
+    this.stdout = options.stdout;
+    this.serverInfo = { ...options.serverInfo };
+    this.maxBufferSize = options.maxBufferSize ?? STDIO_STARTUP_GATE_MAX_BUFFER_SIZE;
+    this.onError = options.onError;
+    this.onEnd = options.onEnd;
+  }
+
+  start(): void {
+    if (this.started || this.stopped) return;
+    this.started = true;
+    this.stdin.on('data', this.onData);
+    this.stdin.on('error', this.onStdinError);
+    this.stdin.on('end', this.onStdinEnd);
+  }
+
+  /** Release queued messages only after StdioServerTransport has installed its listener. */
+  markReady(): void {
+    if (this.stopped || this.ready) return;
+    this.ready = true;
+    for (const message of this.queuedMessages) this.input.write(message);
+    this.queuedMessages.length = 0;
+    this.queuedBytes = 0;
+    if (this.pendingInput) {
+      this.input.write(this.pendingInput);
+      this.pendingInput = '';
+    }
+    if (this.stdinEnded) this.finishInput();
+  }
+
+  stop(): void {
+    if (this.stopped) return;
+    this.stopped = true;
+    this.stdin.off('data', this.onData);
+    this.stdin.off('error', this.onStdinError);
+    this.stdin.off('end', this.onStdinEnd);
+    this.queuedMessages.length = 0;
+    this.pendingInput = '';
+    this.queuedBytes = 0;
+    if (!this.input.destroyed) this.input.end();
+  }
+
+  private handleLine(line: string): void {
+    const parsed = this.parseLine(line);
+    if (!parsed) return;
+    if ('error' in parsed) {
+      this.writeJsonRpcError(null, parsed.error.code, parsed.error.message);
+      return;
+    }
+
+    if (!this.ready && this.isDiscoveryRequest(parsed.message)) {
+      const response = {
+        jsonrpc: '2.0',
+        id: parsed.message.id,
+        result: createMcpStartupDiscoverResult(this.serverInfo),
+      };
+      try {
+        this.stdout.write(`${JSON.stringify(response)}\n`);
+      } catch (error) {
+        this.fail(error instanceof Error ? error : new Error(String(error)));
+      }
+      return;
+    }
+
+    if (this.ready) {
+      this.input.write(line);
+      return;
+    }
+
+    const bytes = Buffer.byteLength(line, 'utf8');
+    if (this.queuedBytes + bytes > this.maxBufferSize) {
+      this.fail(new Error(`stdio startup queue exceeded ${this.maxBufferSize} bytes`));
+      return;
+    }
+    this.queuedMessages.push(line);
+    this.queuedBytes += bytes;
+  }
+
+  private parseLine(line: string): ParsedLine {
+    const trimmed = line.endsWith('\n') ? line.slice(0, -1).replace(/\r$/, '') : line;
+    if (!trimmed.trim()) return null;
+
+    let value: unknown;
+    try {
+      value = JSON.parse(trimmed);
+    } catch {
+      return { error: { code: -32700, message: 'Parse error' } };
+    }
+
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+      return { error: { code: -32600, message: 'Invalid Request' } };
+    }
+    const message = value as JsonRpcEnvelope;
+    if (message.jsonrpc !== '2.0') {
+      return { error: { code: -32600, message: 'Invalid Request' } };
+    }
+
+    const hasId = Object.prototype.hasOwnProperty.call(message, 'id');
+    const hasMethod = typeof message.method === 'string';
+    const hasResult = Object.prototype.hasOwnProperty.call(message, 'result');
+    const hasError = Object.prototype.hasOwnProperty.call(message, 'error');
+    if (hasMethod && (hasResult || hasError)) {
+      return { error: { code: -32600, message: 'Invalid Request' } };
+    }
+    if (!hasMethod && !hasResult && !hasError) {
+      return { error: { code: -32600, message: 'Invalid Request' } };
+    }
+    if (hasId && !this.isValidRequestId(message.id)) {
+      return { error: { code: -32600, message: 'Invalid Request' } };
+    }
+    if (!hasMethod && !hasId) {
+      return { error: { code: -32600, message: 'Invalid Request' } };
+    }
+    return { message };
+  }
+
+  private isDiscoveryRequest(message: JsonRpcEnvelope): boolean {
+    if (message.method !== MCP_SERVER_DISCOVER_METHOD) return false;
+    if (!Object.prototype.hasOwnProperty.call(message, 'id')) return false;
+    const params = message.params;
+    return params === undefined || (typeof params === 'object' && params !== null && !Array.isArray(params));
+  }
+
+  private isValidRequestId(id: unknown): id is string | number | null {
+    return id === null
+      || typeof id === 'string'
+      || (typeof id === 'number' && Number.isFinite(id));
+  }
+
+  private writeJsonRpcError(id: string | number | null, code: number, message: string): void {
+    try {
+      this.stdout.write(`${JSON.stringify({
+        jsonrpc: '2.0',
+        id,
+        error: { code, message },
+      })}\n`);
+    } catch (error) {
+      this.fail(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+
+  private finishInput(): void {
+    if (!this.ready || this.input.destroyed || this.input.writableEnded) return;
+    this.input.end();
+    this.input.once('end', () => this.notifyEnd());
+  }
+
+  private notifyEnd(): void {
+    if (this.endNotified) return;
+    this.endNotified = true;
+    this.onEnd?.();
+  }
+
+  private fail(error: Error): void {
+    if (this.stopped) return;
+    this.stopped = true;
+    this.stdin.off('data', this.onData);
+    this.stdin.off('error', this.onStdinError);
+    this.stdin.off('end', this.onStdinEnd);
+    this.queuedMessages.length = 0;
+    this.pendingInput = '';
+    this.queuedBytes = 0;
+    // Destroy without an error argument so a not-yet-connected SDK transport
+    // cannot turn the gate failure into an unhandled EventEmitter error.
+    if (!this.input.destroyed) this.input.destroy();
+    this.onError?.(error);
+  }
+}

package/src/server.ts

@@ -62,7 +62,7 @@ import {
   type ProjectBindingController,
   type ProjectBindingSource,
 } from './server/request-context.js';
-import { registerMcpDiscovery } from './server/mcp-compat.js';
+import { getMcpServerInfo, registerMcpDiscovery } from './server/mcp-compat.js';
 
 // ── Timeout budgets for LLM-heavy paths ──────────────────────────
 const FORMATION_TIMEOUT_MS = parseFormationTimeoutMs(process.env.MEMORIX_FORMATION_TIMEOUT_MS); // Formation pipeline (extract+resolve+evaluate)
@@ -594,10 +594,7 @@ export async function createMemorixServer(
   };
 
   // Create MCP server (or use existing one from roots-aware flow)
-  const serverInfo = {
-    name: 'memorix',
-    version: typeof __MEMORIX_VERSION__ !== 'undefined' ? __MEMORIX_VERSION__ : '1.0.1',
-  };
+  const serverInfo = getMcpServerInfo();
   const server = existingServer ?? new McpServer(serverInfo);
   registerMcpDiscovery(server, serverInfo);