memorix 1.8.2 → 1.8.3

package/CHANGELOG.md

@@ -4,6 +4,22 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [1.8.3] - 2026-08-25
+
+### Fixed
+- **Stdio MCP startup gate** -- `memorix serve` now reads and bounds
+  newline-delimited JSON-RPC input before project initialization completes.
+  Early `server/discover` requests receive the complete discovery result, while
+  initialize, notifications, responses, and versionless tool requests replay
+  through the pinned SDK transport in input order without duplicate handling.
+
+### MCP Compatibility
+- **Stable cold-start discovery** -- real stdio CLI startup now supports
+  pre-initialize discovery within the startup window and preserves legacy
+  initialize plus versionless `tools/list`/`tools/call` behavior. Tasks,
+  subscriptions, list-response caching, and modern non-discovery result
+  metadata remain unsupported or partial.
+
 ## [1.8.2] - 2026-08-25
 
 ### Fixed

package/dist/cli/index.js

@@ -3232,7 +3232,7 @@ ${import_picocolors.default.gray(m3)}  ${s4}
 
 // src/cli/version.ts
 function getCliVersion() {
-  return true ? "1.8.2" : pkg.version;
+  return true ? "1.8.3" : pkg.version;
 }
 var init_version = __esm({
   "src/cli/version.ts"() {
@@ -205764,6 +205764,259 @@ var init_tool_profile = __esm({
   }
 });
 
+// src/server/mcp-discovery.ts
+function getMcpServerInfo() {
+  return {
+    name: "memorix",
+    version: true ? "1.8.3" : "1.0.1"
+  };
+}
+function createMcpDiscoverResult(capabilities, serverInfo) {
+  return {
+    resultType: "complete",
+    supportedVersions: [
+      MCP_MODERN_PROTOCOL_VERSION,
+      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"
+  };
+}
+function createMcpStartupDiscoverResult(serverInfo) {
+  return createMcpDiscoverResult({ tools: { listChanged: true } }, serverInfo);
+}
+var MCP_MODERN_PROTOCOL_VERSION, MCP_LEGACY_PROTOCOL_VERSION, MCP_OLDEST_LEGACY_PROTOCOL_VERSION, MCP_SERVER_DISCOVER_METHOD, MCP_SERVER_INFO_META_KEY;
+var init_mcp_discovery = __esm({
+  "src/server/mcp-discovery.ts"() {
+    "use strict";
+    init_esm_shims();
+    MCP_MODERN_PROTOCOL_VERSION = "2026-07-28";
+    MCP_LEGACY_PROTOCOL_VERSION = "2025-11-25";
+    MCP_OLDEST_LEGACY_PROTOCOL_VERSION = "2024-11-05";
+    MCP_SERVER_DISCOVER_METHOD = "server/discover";
+    MCP_SERVER_INFO_META_KEY = "io.modelcontextprotocol/serverInfo";
+  }
+});
+
+// src/server/stdio-startup-gate.ts
+import { PassThrough as PassThrough3 } from "stream";
+var STDIO_STARTUP_GATE_MAX_BUFFER_SIZE, StdioStartupGate;
+var init_stdio_startup_gate = __esm({
+  "src/server/stdio-startup-gate.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_mcp_discovery();
+    STDIO_STARTUP_GATE_MAX_BUFFER_SIZE = 10 * 1024 * 1024;
+    StdioStartupGate = class {
+      input = new PassThrough3();
+      stdin;
+      stdout;
+      serverInfo;
+      maxBufferSize;
+      onError;
+      onEnd;
+      queuedMessages = [];
+      pendingInput = "";
+      queuedBytes = 0;
+      started = false;
+      ready = false;
+      stopped = false;
+      stdinEnded = false;
+      endNotified = false;
+      onData = (chunk) => {
+        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 text2 = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+        if (this.queuedBytes + Buffer.byteLength(this.pendingInput, "utf8") + Buffer.byteLength(text2, "utf8") > this.maxBufferSize) {
+          this.fail(new Error(`stdio startup input exceeded ${this.maxBufferSize} bytes before a complete JSON-RPC line`));
+          return;
+        }
+        this.pendingInput += text2;
+        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`));
+        }
+      };
+      onStdinError = (error40) => {
+        this.fail(error40);
+      };
+      onStdinEnd = () => {
+        this.stdinEnded = true;
+        if (this.ready) this.finishInput();
+      };
+      constructor(options) {
+        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() {
+        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() {
+        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() {
+        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();
+      }
+      handleLine(line) {
+        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)}
+`);
+          } catch (error40) {
+            this.fail(error40 instanceof Error ? error40 : new Error(String(error40)));
+          }
+          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;
+      }
+      parseLine(line) {
+        const trimmed = line.endsWith("\n") ? line.slice(0, -1).replace(/\r$/, "") : line;
+        if (!trimmed.trim()) return null;
+        let value;
+        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;
+        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 };
+      }
+      isDiscoveryRequest(message) {
+        if (message.method !== MCP_SERVER_DISCOVER_METHOD) return false;
+        if (!Object.prototype.hasOwnProperty.call(message, "id")) return false;
+        const params = message.params;
+        return params === void 0 || typeof params === "object" && params !== null && !Array.isArray(params);
+      }
+      isValidRequestId(id) {
+        return id === null || typeof id === "string" || typeof id === "number" && Number.isFinite(id);
+      }
+      writeJsonRpcError(id, code, message) {
+        try {
+          this.stdout.write(`${JSON.stringify({
+            jsonrpc: "2.0",
+            id,
+            error: { code, message }
+          })}
+`);
+        } catch (error40) {
+          this.fail(error40 instanceof Error ? error40 : new Error(String(error40)));
+        }
+      }
+      finishInput() {
+        if (!this.ready || this.input.destroyed || this.input.writableEnded) return;
+        this.input.end();
+        this.input.once("end", () => this.notifyEnd());
+      }
+      notifyEnd() {
+        if (this.endNotified) return;
+        this.endNotified = true;
+        this.onEnd?.();
+      }
+      fail(error40) {
+        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.destroy();
+        this.onError?.(error40);
+      }
+    };
+  }
+});
+
 // src/cli/mcp-root-path.ts
 import path37 from "path";
 function mcpFileUriToPath(uri, platform2 = process.platform) {
@@ -219212,40 +219465,22 @@ var init_request_context = __esm({
 // src/server/mcp-compat.ts
 function buildMcpDiscoverResult(server, serverInfo) {
   const getCapabilities = server.server.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);
 }
 function registerMcpDiscovery(server, serverInfo) {
   if (registeredServers.has(server)) return;
   server.server.setRequestHandler(ServerDiscoverRequestSchema, async () => buildMcpDiscoverResult(server, serverInfo));
   registeredServers.add(server);
 }
-var MCP_MODERN_PROTOCOL_VERSION, MCP_LEGACY_PROTOCOL_VERSION, MCP_OLDEST_LEGACY_PROTOCOL_VERSION, MCP_SERVER_DISCOVER_METHOD, MCP_SERVER_INFO_META_KEY, ServerDiscoverRequestSchema, registeredServers;
+var ServerDiscoverRequestSchema, registeredServers;
 var init_mcp_compat = __esm({
   "src/server/mcp-compat.ts"() {
     "use strict";
     init_esm_shims();
     init_types8();
     init_v4();
-    MCP_MODERN_PROTOCOL_VERSION = "2026-07-28";
-    MCP_LEGACY_PROTOCOL_VERSION = "2025-11-25";
-    MCP_OLDEST_LEGACY_PROTOCOL_VERSION = "2024-11-05";
-    MCP_SERVER_DISCOVER_METHOD = "server/discover";
-    MCP_SERVER_INFO_META_KEY = "io.modelcontextprotocol/serverInfo";
+    init_mcp_discovery();
+    init_mcp_discovery();
     ServerDiscoverRequestSchema = RequestSchema.extend({
       method: external_exports.literal(MCP_SERVER_DISCOVER_METHOD),
       params: external_exports.looseObject({}).optional()
@@ -261633,10 +261868,7 @@ The path should point to a directory containing a .git folder.`
       isError: true
     };
   };
-  const serverInfo = {
-    name: "memorix",
-    version: true ? "1.8.2" : "1.0.1"
-  };
+  const serverInfo = getMcpServerInfo();
   const server = existingServer ?? new McpServer(serverInfo);
   registerMcpDiscovery(server, serverInfo);
   const originalRegisterTool = server.registerTool.bind(server);
@@ -266372,6 +266604,8 @@ var init_serve = __esm({
     init_esm_shims();
     init_dist2();
     init_tool_profile();
+    init_mcp_discovery();
+    init_stdio_startup_gate();
     init_mcp_root_path();
     serve_default = defineCommand({
       meta: {
@@ -266396,15 +266630,25 @@ var init_serve = __esm({
         }
       },
       run: async ({ args }) => {
+        const startupGate = new StdioStartupGate({
+          stdin: process.stdin,
+          stdout: process.stdout,
+          serverInfo: getMcpServerInfo(),
+          onError: (error40) => {
+            console.error(`[memorix] stdio startup gate error: ${error40.message}`);
+            process.exit(1);
+          },
+          onEnd: () => {
+            console.error("[memorix] stdin closed \u2014 exiting");
+            process.exitCode = 0;
+          }
+        });
+        startupGate.start();
         const { StdioServerTransport: StdioServerTransport2 } = await Promise.resolve().then(() => (init_stdio2(), stdio_exports));
         const { createMemorixServer: createMemorixServer2 } = await Promise.resolve().then(() => (init_server4(), server_exports2));
         const { detectProject: detectProject2, findGitInSubdirs: findGitInSubdirs2, isSystemDirectory: isSystemDirectory2 } = await Promise.resolve().then(() => (init_detector(), detector_exports));
         const { homedir: homedir36 } = await import("os");
         const { resolveServeProject: resolveServeProject2 } = await Promise.resolve().then(() => (init_serve_shared(), serve_shared_exports));
-        process.stdin.on("end", () => {
-          console.error("[memorix] stdin closed \u2014 exiting");
-          process.exit(0);
-        });
         let safeCwd;
         try {
           safeCwd = process.cwd();
@@ -266439,8 +266683,9 @@ var init_serve = __esm({
         const toolProfile = resolveToolProfile({ explicit: args.mode, envValue: process.env.MEMORIX_MODE, fallback: "micro" });
         const serverOptions = detected ? { toolProfile, deferProjectRuntimeInit: true } : { allowUntrackedFallback: allowUntracked, deferProjectInitUntilBound: !allowUntracked, deferProjectRuntimeInit: true, toolProfile };
         const { server, projectId, deferredInit, switchProject } = await createMemorixServer2(projectRoot, void 0, void 0, serverOptions);
-        const transport = new StdioServerTransport2();
+        const transport = new StdioServerTransport2(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}`);
         const tryRootsSwitch = async () => {