grove-mcp 1.0.6 → 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,95 +104,200 @@ 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 = [];
 
-// ── SSE connection ──────────────────────────────────────────────────────────
-
-const sseReq = https.request(
-  {
-    hostname: HOSTNAME,
-    path: SSE_PATH,
-    method: 'GET',
-    headers: { Accept: 'text/event-stream' },
-  },
-  (res) => {
-    if (res.statusCode !== 200) {
-      process.stderr.write(
-        `grove-mcp-bridge: SSE connect failed (HTTP ${res.statusCode})\n`
-      );
-      process.exit(1);
-    }
+// ── SSE connection with reconnect ───────────────────────────────────────────
 
-    // Capture nginx sticky-session cookie so POSTs reach the same pod
-    const setCookie = res.headers['set-cookie'];
-    if (setCookie) {
-      const cookies = Array.isArray(setCookie) ? setCookie : [setCookie];
-      const parts = cookies.map((c) => c.split(';')[0].trim());
-      affinityCookie = parts.join('; ');
-    }
+let reconnectDelay = 1000; // ms; doubles on each failure, capped at 30s
 
-    let buf = '';
-    let eventType = '';
+function connect() {
+  // Reset session state so stdin messages are queued until the new endpoint arrives
+  sessionPath = null;
+  affinityCookie = null;
 
-    res.on('data', (chunk) => {
-      buf += chunk.toString('utf8');
+  const sseReq = https.request(
+    {
+      hostname: HOSTNAME,
+      path: SSE_PATH,
+      method: 'GET',
+      headers: { Accept: 'text/event-stream' },
+    },
+    (res) => {
+      if (res.statusCode !== 200) {
+        process.stderr.write(
+          `grove-mcp-bridge: SSE connect failed (HTTP ${res.statusCode}), retrying in ${reconnectDelay}ms\n`
+        );
+        res.on('error', () => {}); // prevent unhandled-error crash while draining
+        res.resume();
+        scheduleReconnect();
+        return;
+      }
 
-      let nl;
-      while ((nl = buf.indexOf('\n')) !== -1) {
-        const line = buf.slice(0, nl).replace(/\r$/, '');
-        buf = buf.slice(nl + 1);
+      // Successful connection — reset backoff
+      reconnectDelay = 1000;
 
-        if (line.startsWith('event:')) {
-          eventType = line.slice(6).trim();
-        } else if (line.startsWith('data:')) {
-          const raw = line.slice(5).trim();
+      // Capture nginx sticky-session cookie so POSTs reach the same pod
+      const setCookie = res.headers['set-cookie'];
+      if (setCookie) {
+        const cookies = Array.isArray(setCookie) ? setCookie : [setCookie];
+        const parts = cookies.map((c) => c.split(';')[0].trim());
+        affinityCookie = parts.join('; ');
+      }
 
-          if (eventType === 'endpoint') {
-            try {
-              sessionPath = JSON.parse(raw).uri;
-            } catch (_) {
-              // Fallback: server sent a plain path instead of JSON
-              sessionPath = raw;
+      let buf = '';
+      let eventType = '';
+
+      res.on('data', (chunk) => {
+        buf += chunk.toString('utf8');
+
+        let nl;
+        while ((nl = buf.indexOf('\n')) !== -1) {
+          const line = buf.slice(0, nl).replace(/\r$/, '');
+          buf = buf.slice(nl + 1);
+
+          if (line.startsWith('event:')) {
+            eventType = line.slice(6).trim();
+          } else if (line.startsWith('data:')) {
+            const raw = line.slice(5).trim();
+
+            if (eventType === 'endpoint') {
+              try {
+                sessionPath = JSON.parse(raw).uri;
+              } catch (_) {
+                // Fallback: server sent a plain path instead of JSON
+                sessionPath = raw;
+              }
+
+              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) {
+              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');
             }
-            // Flush any stdin lines that arrived before the endpoint was ready
-            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.
-            process.stdout.write(stripMcpCompat(raw) + '\n');
-          }
 
-          eventType = '';
-        } else if (line === '') {
-          eventType = '';
+            eventType = '';
+          } else if (line === '') {
+            eventType = '';
+          }
         }
-      }
-    });
-
-    res.on('end', () => {
-      process.stderr.write('grove-mcp-bridge: SSE stream ended\n');
-      process.exit(0);
-    });
+      });
 
-    res.on('error', (err) => {
-      process.stderr.write(`grove-mcp-bridge: SSE error: ${err.message}\n`);
-      process.exit(1);
-    });
-  }
-);
+      res.on('end', () => {
+        process.stderr.write(`grove-mcp-bridge: SSE stream ended, reconnecting in ${reconnectDelay}ms\n`);
+        scheduleReconnect();
+      });
 
-sseReq.on('error', (err) => {
-  process.stderr.write(
-    `grove-mcp-bridge: cannot reach ${HOSTNAME}: ${err.message}\n`
+      res.on('error', (err) => {
+        process.stderr.write(`grove-mcp-bridge: SSE error: ${err.message}, reconnecting in ${reconnectDelay}ms\n`);
+        scheduleReconnect();
+      });
+    }
   );
-  process.exit(1);
-});
 
-sseReq.end();
+  sseReq.on('error', (err) => {
+    process.stderr.write(
+      `grove-mcp-bridge: cannot reach ${HOSTNAME}: ${err.message}, retrying in ${reconnectDelay}ms\n`
+    );
+    scheduleReconnect();
+  });
+
+  // Server sends keepalive pings every 30s. If nothing arrives in 75s the
+  // connection is stale (server crash, network partition) — destroy and reconnect.
+  sseReq.setTimeout(75000);
+  sseReq.on('timeout', () => {
+    process.stderr.write(`grove-mcp-bridge: SSE idle timeout, reconnecting in ${reconnectDelay}ms\n`);
+    sseReq.destroy(); // triggers sseReq.on('error') or res.on('error') → scheduleReconnect()
+  });
+
+  sseReq.end();
+}
+
+function scheduleReconnect() {
+  // Null the session immediately so stdin messages are queued rather than
+  // 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);
+  reconnectDelay = Math.min(reconnectDelay * 2, 30000);
+}
+
+connect();
 
 // ── stdin → POST ────────────────────────────────────────────────────────────
 
@@ -221,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.6",
-  "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"