grove-mcp 1.0.4 → 1.0.7

package/index.js

@@ -17,6 +17,10 @@
 
 const https = require('https');
 const readline = require('readline');
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
 
 const HOSTNAME = 'mcp.lyra.tg';
 const SSE_PATH = '/sse';
@@ -29,100 +33,189 @@ 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;
+
 // Per-user session isolation: scopes Redis session keys so multiple users
 // on the shared 3-pod cluster never overwrite each other's auth tokens.
-// Generate your key once with: grove_auth_start(email=...) and copy the
-// returned session_key into your claude_desktop_config.json env block.
-if (process.env.GROVE_SESSION_KEY)
-  TOKEN_HEADERS['X-Grove-Session-Key'] = process.env.GROVE_SESSION_KEY;
+// If GROVE_SESSION_KEY is set in the environment and is not the placeholder
+// value, use it directly.  Otherwise auto-generate a stable random key the
+// first time and persist it to ~/.grove-mcp/session-key so that it survives
+// restarts without any manual configuration.
+(function resolveSessionKey() {
+  const PLACEHOLDER = '<your-session-key-here>';
+  const envKey = process.env.GROVE_SESSION_KEY;
+
+  if (envKey && envKey !== PLACEHOLDER) {
+    TOKEN_HEADERS['X-Grove-Session-Key'] = envKey;
+    return;
+  }
+
+  const keyFile = path.join(os.homedir(), '.grove-mcp', 'session-key');
+  try {
+    const stored = fs.readFileSync(keyFile, 'utf8').trim();
+    if (stored) {
+      TOKEN_HEADERS['X-Grove-Session-Key'] = stored;
+      return;
+    }
+  } catch (_) {
+    // File doesn't exist yet — generate below.
+  }
+
+  const generated = crypto.randomBytes(16).toString('hex');
+  try {
+    fs.mkdirSync(path.dirname(keyFile), { recursive: true });
+    fs.writeFileSync(keyFile, generated, { mode: 0o600 });
+  } catch (err) {
+    process.stderr.write(
+      `grove-mcp-bridge: warning: could not persist session key to ${keyFile}: ${err.message}\n`
+    );
+  }
+  TOKEN_HEADERS['X-Grove-Session-Key'] = generated;
+})();
+
+// Strip MCP spec fields that older Claude Desktop clients don't handle.
+// FastMCP 3.x auto-generates outputSchema from Python return type annotations;
+// Claude Desktop silently drops ALL tools when it sees this field (claude-code#25081).
+function stripMcpCompat(raw) {
+  try {
+    const msg = JSON.parse(raw);
+    if (msg.result && Array.isArray(msg.result.tools)) {
+      msg.result.tools = msg.result.tools.map(function (t) {
+        // eslint-disable-next-line no-unused-vars
+        var outputSchema = t.outputSchema, rest = Object.assign({}, t);
+        delete rest.outputSchema;
+        return rest;
+      });
+    }
+    return JSON.stringify(msg);
+  } catch (_) {
+    return raw;
+  }
+}
 
 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;
+              }
+              // 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');
             }
-            // 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) {
-            // raw is already a serialised JSON-RPC object — write directly
-            process.stdout.write(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('end', () => {
+        process.stderr.write(`grove-mcp-bridge: SSE stream ended, reconnecting in ${reconnectDelay}ms\n`);
+        scheduleReconnect();
+      });
 
-    res.on('error', (err) => {
-      process.stderr.write(`grove-mcp-bridge: SSE error: ${err.message}\n`);
-      process.exit(1);
-    });
-  }
-);
-
-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;
+  setTimeout(() => {
+    connect();
+  }, reconnectDelay);
+  reconnectDelay = Math.min(reconnectDelay * 2, 30000);
+}
+
+connect();
 
 // ── stdin → POST ────────────────────────────────────────────────────────────
 

package/package.json

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