@remnic/core 9.66.7 → 9.66.8

package/src/access-http.test.ts

@@ -2354,7 +2354,7 @@ test("HTTP 401 www-authenticate is the bare Bearer challenge when resourceMetada
   }
 });
 
-test("HTTP /mcp returns 405 with Allow: POST for GET and DELETE (authorized requests)", async () => {
+test("HTTP /mcp serves GET SSE, DELETE 204, and 405 without SSE Accept (issue #2718)", async () => {
   const service = {} as EngramAccessService;
   const server = new EngramAccessHttpServer({
     service,
@@ -2364,23 +2364,47 @@ test("HTTP /mcp returns 405 with Allow: POST for GET and DELETE (authorized requ
   });
   const status = await server.start();
   try {
-    for (const method of ["GET", "DELETE"]) {
-      const response = await fetch(`http://127.0.0.1:${status.port}/mcp`, {
-        method,
-        headers: { authorization: "Bearer test-token" },
-      });
-      assert.equal(response.status, 405, `${method} /mcp must be 405`);
-      assert.equal(
-        response.headers.get("allow"),
-        "POST",
-        `${method} /mcp must advertise Allow: POST`,
-      );
-      const body = (await response.json()) as { code?: string };
-      assert.equal(body.code, "method_not_allowed");
-    }
-    // Unauthenticated GET /mcp still gets 401 first (auth gate beats method-conformance).
+    // Authorized GET with SSE Accept → 200 text/event-stream whose first
+    // bytes are comment-only heartbeats (never JSON-RPC). Read one bounded
+    // chunk, then cancel so the open stream cannot hang the test.
+    const controller = new AbortController();
+    const sse = await fetch(`http://127.0.0.1:${status.port}/mcp`, {
+      headers: { authorization: "Bearer test-token", accept: "text/event-stream" },
+      signal: controller.signal,
+    });
+    assert.equal(sse.status, 200, "GET /mcp with SSE Accept must be 200");
+    assert.match(
+      sse.headers.get("content-type") ?? "",
+      /^text\/event-stream/,
+      "GET /mcp SSE stream must advertise text/event-stream",
+    );
+    const reader = sse.body!.getReader();
+    const { value: firstChunk } = await reader.read();
+    const firstBytes = Buffer.from(firstChunk ?? []).toString("utf8");
+    assert.ok(
+      !firstBytes.includes("jsonrpc"),
+      `GET /mcp stream must carry no JSON-RPC payload: ${JSON.stringify(firstBytes)}`,
+    );
+    controller.abort();
+
+    // Authorized GET without the SSE Accept → 405 + full method set.
+    const rejected = await fetch(`http://127.0.0.1:${status.port}/mcp`, {
+      headers: { authorization: "Bearer test-token" },
+    });
+    assert.equal(rejected.status, 405);
+    assert.equal(rejected.headers.get("allow"), "GET, POST, DELETE");
+
+    // Authorized DELETE → 204 with empty body.
+    const deleted = await fetch(`http://127.0.0.1:${status.port}/mcp`, {
+      method: "DELETE",
+      headers: { authorization: "Bearer test-token" },
+    });
+    assert.equal(deleted.status, 204);
+    assert.equal(await deleted.text(), "");
+
+    // Unauthenticated GET /mcp still gets 401 first (auth gate beats method handling).
     const unauth = await fetch(`http://127.0.0.1:${status.port}/mcp`, {
-      method: "GET",
+      headers: { accept: "text/event-stream" },
     });
     assert.equal(unauth.status, 401);
   } finally {

package/src/access-http.ts

@@ -27,6 +27,7 @@ import { nonEmptyQueryParam, optionalNamespaceKindQueryParam, optionalQueryStrin
 import { CorrectionContractError } from "./correction/correction-contract.js";
 import { respondWearablesErrorGlue } from "./wearables/http-glue.js"; import { respondMeetingsList, respondMeetingsGet, respondMeetingsBuild } from "./meetings/http-glue.js"; import { respondLocationStatus, respondLocationCheck, respondLocationSync, respondLocationBackfill, respondLocationDay } from "./location/http-glue.js"; import { respondStandup } from "./standup/http-glue.js";
 import { EngramMcpServer, MCP_SUPPORTED_PROTOCOL_VERSIONS } from "./access-mcp.js";
+import { handleMcpGetSse } from "./access-mcp-sse.js";
 import { validateRequest, type SchemaName, type SchemaTypeFor } from "./access-schema.js";
 import {
   OFFLINE_SYNC_APPLY_MAX_BODY_BYTES,
@@ -884,17 +885,16 @@ export class EngramAccessHttpServer extends ReviewDeckAccessHttpBase {
     correlationId: string,
     abortSignal: AbortSignal,
   ): Promise<void> {
-    // Method-conformance for the streamable-HTTP MCP endpoint:
-    // GET/DELETE on /mcp must return 405 + Allow: POST instead of
-    // silently falling through to the generic 404. POST continues
-    // to the normal handler below.
-    if (pathname === "/mcp" && (req.method === "GET" || req.method === "DELETE")) {
+    // Method-conformance for the streamable-HTTP MCP endpoint (issue #2718):
+    // DELETE → 204, GET upgrades to the comment-only SSE stream in
+    // access-mcp-sse.ts when the client accepts text/event-stream, else 405
+    // with the full method set. POST continues to the handler below.
+    if (pathname === "/mcp" && req.method === "DELETE") { res.writeHead(204); res.end(); return; }
+    if (pathname === "/mcp" && req.method === "GET") {
+      if ((req.headers.accept ?? "").includes("text/event-stream"))
+        return handleMcpGetSse(req, res, this.sseCleanupFns);
       const body = JSON.stringify({ error: "method_not_allowed", code: "method_not_allowed" });
-      res.writeHead(405, {
-        "content-type": "application/json; charset=utf-8",
-        allow: "POST",
-        "x-request-id": correlationId,
-      });
+      res.writeHead(405, { "content-type": "application/json; charset=utf-8", allow: "GET, POST, DELETE", "x-request-id": correlationId });
       res.end(body);
       return;
     }

package/src/access-mcp-sse.ts

@@ -0,0 +1,50 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+
+/**
+ * GET /mcp SSE half of the MCP streamable-HTTP transport (issue #2718).
+ *
+ * Clients such as the Grok Build TUI open a GET stream after `initialize`;
+ * that stream is reserved for server-initiated messages and this server has
+ * none to push, so it carries only SSE comment heartbeats — never a
+ * JSON-RPC payload. Header/heartbeat/cleanup shape mirrors
+ * `handleGraphEventsSSE` in access-http.ts (25 s heartbeat, cleanup
+ * registered in the server's `sseCleanupFns` set so `stop()` releases the
+ * interval even if the client never disconnects), but it subscribes to no
+ * event bus, resolves no namespace, and ignores `Last-Event-ID`.
+ *
+ * Lives in a sibling module rather than access-http.ts so the handler does
+ * not push that file past its fileSizeGrandfather ceiling (issue #1995).
+ */
+export function handleMcpGetSse(
+  req: IncomingMessage,
+  res: ServerResponse,
+  sseCleanupFns: Set<() => void>,
+): void {
+  res.writeHead(200, {
+    "content-type": "text/event-stream; charset=utf-8",
+    "cache-control": "no-cache, no-store, must-revalidate",
+    "connection": "keep-alive",
+    "x-accel-buffering": "no",
+    "transfer-encoding": "chunked",
+  });
+
+  // Comment-only frames: `: ping\n\n` is a valid SSE comment that carries no
+  // data and cannot be mistaken for a JSON-RPC message. One is written
+  // immediately so clients and proxies see the stream is live without
+  // waiting for the first 25 s tick.
+  const heartbeat = (): void => {
+    try { res.write(": ping\n\n"); } catch { /* client gone; cleanup fires via "close" */ }
+  };
+  heartbeat();
+  const heartbeatInterval = setInterval(heartbeat, 25_000);
+
+  const cleanup = (): void => {
+    clearInterval(heartbeatInterval);
+    sseCleanupFns.delete(cleanup);
+    try { res.end(); } catch { /* ignore */ }
+  };
+  sseCleanupFns.add(cleanup);
+
+  req.once("close", cleanup);
+  req.once("error", cleanup);
+}