grove-mcp 1.0.7 → 1.0.8

package/index.js

@@ -13,6 +13,16 @@
  *   2. Server sends: event: endpoint  data: /messages/?session_id=<uuid>
  *   3. stdin lines → POST to session endpoint (with affinity cookie if set)
  *   4. SSE message events → stdout lines
+ *
+ * Reconnect behaviour:
+ *   On SSE disconnect the bridge reconnects automatically with exponential
+ *   back-off.  Each reconnect creates a new server-side MCP session that
+ *   must be re-initialized before tool calls can proceed.  The bridge stores
+ *   the original `initialize` request and `notifications/initialized`
+ *   notification from Claude Desktop and silently replays them on every
+ *   reconnect so the server session is fully initialized before any queued
+ *   tool calls are flushed.  The replay response is intercepted and NOT
+ *   forwarded to Claude Desktop, which already considers itself initialized.
  */
 
 const https = require('https');
@@ -33,6 +43,8 @@ if (process.env.GROVE_OUTLINE_TOKEN)
   TOKEN_HEADERS['Grove-Outline-Token'] = process.env.GROVE_OUTLINE_TOKEN;
 if (process.env.GROVE_MATTERMOST_TOKEN)
   TOKEN_HEADERS['Grove-Mattermost-Token'] = process.env.GROVE_MATTERMOST_TOKEN;
+if (process.env.GROVE_NOCODB_TOKEN)
+  TOKEN_HEADERS['Grove-Nocodb-Token'] = process.env.GROVE_NOCODB_TOKEN;
 
 // Per-user session isolation: scopes Redis session keys so multiple users
 // on the shared 3-pod cluster never overwrite each other's auth tokens.
@@ -92,6 +104,24 @@ function stripMcpCompat(raw) {
   }
 }
 
+// ── MCP initialization replay state ─────────────────────────────────────────
+//
+// The MCP session lives on the server; each SSE reconnect creates a new one.
+// Claude Desktop does NOT re-send `initialize` on reconnect — it assumes the
+// session is continuous.  We fix this by storing the original handshake and
+// replaying it silently on every reconnect before flushing queued messages.
+
+// Raw JSON lines captured from stdin on first connection.
+let storedInitRequest = null;        // {"method":"initialize", ...}
+let storedInitNotification = null;   // {"method":"notifications/initialized"}
+
+// Bridge-internal init replay tracking.
+let bridgeInitId = null;     // ID we assign to the replayed initialize request
+let awaitingBridgeInit = false; // true while waiting for the server's init response
+let heldPending = [];        // messages queued while awaiting bridge init response
+
+// ── Transport state ──────────────────────────────────────────────────────────
+
 let sessionPath = null;
 let affinityCookie = null; // sticky-session cookie from SSE response headers
 const pending = [];
@@ -157,13 +187,57 @@ function connect() {
                 // Fallback: server sent a plain path instead of JSON
                 sessionPath = raw;
               }
-              // Flush any stdin lines that arrived before the endpoint was ready
-              for (const msg of pending) sendToServer(msg);
-              pending.length = 0;
+
+              if (storedInitRequest !== null) {
+                // ── Reconnect path ─────────────────────────────────────────
+                // New server session — must replay the initialize handshake
+                // before any tool calls can proceed.  Use a bridge-internal
+                // ID so we can intercept the response without forwarding it
+                // to Claude Desktop (which already considers itself initialized).
+                process.stderr.write('grove-mcp-bridge: reconnected — replaying MCP init\n');
+                bridgeInitId = '__bridge_init_' + Date.now();
+                awaitingBridgeInit = true;
+                // Move all pending messages to held; they'll be flushed after
+                // the server acknowledges initialization.
+                heldPending = pending.splice(0);
+                try {
+                  const initMsg = JSON.parse(storedInitRequest);
+                  sendToServer(JSON.stringify(Object.assign({}, initMsg, { id: bridgeInitId })));
+                } catch (_) {
+                  // Malformed stored request — fall back to plain flush
+                  awaitingBridgeInit = false;
+                  bridgeInitId = null;
+                  for (const msg of heldPending) sendToServer(msg);
+                  heldPending = [];
+                }
+              } else {
+                // ── First connection path ──────────────────────────────────
+                // Claude Desktop's real initialize request is in pending.
+                // Flush everything; the server will process them in order.
+                for (const msg of pending) sendToServer(msg);
+                pending.length = 0;
+              }
             } else if (eventType === 'message' && raw) {
-              // Strip modern MCP spec fields that cause Claude Desktop to silently
-              // drop all tools (anthropics/claude-code#25081): FastMCP 3.x emits
-              // outputSchema in tools/list which Claude Desktop doesn't understand.
+              if (awaitingBridgeInit) {
+                // Check whether this is the response to our replayed initialize.
+                try {
+                  const msg = JSON.parse(raw);
+                  if (msg.id === bridgeInitId) {
+                    // Server acknowledged init — complete the handshake and
+                    // flush held messages.  Do NOT forward to Claude Desktop.
+                    awaitingBridgeInit = false;
+                    bridgeInitId = null;
+                    if (storedInitNotification) sendToServer(storedInitNotification);
+                    for (const msg of heldPending) sendToServer(msg);
+                    heldPending = [];
+                    process.stderr.write('grove-mcp-bridge: MCP init replay complete\n');
+                    eventType = '';
+                    continue; // skip stdout.write
+                  }
+                } catch (_) {}
+              }
+
+              // Normal message — strip compat fields and forward to Claude Desktop.
               process.stdout.write(stripMcpCompat(raw) + '\n');
             }
 
@@ -209,6 +283,14 @@ function scheduleReconnect() {
   // fired at a dead endpoint during the reconnect delay window.
   sessionPath = null;
   affinityCookie = null;
+  // Reset bridge-init state so a clean replay happens on the next connect().
+  awaitingBridgeInit = false;
+  bridgeInitId = null;
+  // Move any messages held mid-replay back to pending so they aren't lost.
+  if (heldPending.length > 0) {
+    pending.unshift(...heldPending);
+    heldPending = [];
+  }
   setTimeout(() => {
     connect();
   }, reconnectDelay);
@@ -256,9 +338,21 @@ const rl = readline.createInterface({
 rl.on('line', (line) => {
   if (!line.trim()) return;
 
-  if (sessionPath === null) {
-    // Session not yet established — queue the message
-    pending.push(line);
+  // Capture the initialize handshake for reconnect replay.
+  try {
+    const msg = JSON.parse(line);
+    if (msg.method === 'initialize') storedInitRequest = line;
+    if (msg.method === 'notifications/initialized') storedInitNotification = line;
+  } catch (_) {}
+
+  if (sessionPath === null || awaitingBridgeInit) {
+    // Either: session not yet established, or we're mid-replay.
+    // In both cases queue the message — it'll be flushed once ready.
+    if (awaitingBridgeInit) {
+      heldPending.push(line);
+    } else {
+      pending.push(line);
+    }
   } else {
     sendToServer(line);
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "grove-mcp",
-  "version": "1.0.7",
-  "description": "Claude Desktop bridge for the Grove MCP Server (Mattermost + Outline)",
+  "version": "1.0.8",
+  "description": "Claude Desktop bridge for the Grove MCP Server (Mattermost + Outline + NocoDB)",
   "main": "index.js",
   "bin": {
     "grove-mcp": "index.js"