@cachly-dev/mcp-server 0.10.47 → 0.10.48

package/dist/index.js

@@ -241,8 +241,19 @@ async function getConnection(instance_id) {
             '• Pass instance_id explicitly to the tool, or\n' +
             '• Run `list_instances` to see your available instances.');
     }
-    if (pool.has(instance_id))
-        return pool.get(instance_id);
+    if (pool.has(instance_id)) {
+        const cached = pool.get(instance_id);
+        // Verify the pooled connection is still alive before reusing it.
+        // ioredis 'error' eviction is async — a connection can be in the pool
+        // but already internally broken (status 'reconnecting' or 'end').
+        const status = cached.status;
+        if (status === 'ready' || status === 'connect') {
+            return cached;
+        }
+        // Stale — evict and fall through to reconnect.
+        pool.delete(instance_id);
+        cached.disconnect();
+    }
     // Fetch instance, waiting up to 25 s if it is still provisioning.
     // This covers the zero-friction path: device-flow auth → auto-provision → first tool call
     // all happen in quick succession and the instance isn't running yet.
@@ -319,12 +330,42 @@ async function getConnection(instance_id) {
     const evict = () => pool.delete(instance_id);
     client.on('error', evict);
     client.on('end', evict);
-    try {
-        await client.connect();
+    // Retry up to 3 times with 2s backoff. Covers the window between K8s PodReady
+    // and Valkey actually accepting connections (RDB/AOF load, ~1-3s on cold start).
+    let connectErr;
+    for (let attempt = 0; attempt < 3; attempt++) {
+        try {
+            if (attempt > 0) {
+                await new Promise(r => setTimeout(r, 2000 * attempt));
+                // Fresh client on retry — ioredis doesn't allow reconnect after explicit disconnect.
+                client.disconnect();
+                const retryClient = new Redis({
+                    host: inst.host,
+                    port: inst.port,
+                    password: password || undefined,
+                    ...(tlsEnabled ? { tls: {} } : {}),
+                    lazyConnect: true,
+                    enableReadyCheck: true,
+                    connectTimeout: 8000,
+                    retryStrategy: () => null,
+                });
+                retryClient.on('error', () => pool.delete(instance_id));
+                retryClient.on('end', () => pool.delete(instance_id));
+                await retryClient.connect();
+                pool.set(instance_id, retryClient);
+                return retryClient;
+            }
+            await client.connect();
+            connectErr = undefined;
+            break;
+        }
+        catch (err) {
+            connectErr = err;
+        }
     }
-    catch (err) {
+    if (connectErr) {
         client.disconnect();
-        const msg = err instanceof Error ? err.message : String(err);
+        const msg = connectErr instanceof Error ? connectErr.message : String(connectErr);
         void fetch(`${API_URL}/api/v1/telemetry/mcp`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json', ...(getJWT() ? { Authorization: `Bearer ${getJWT()}` } : {}) },
@@ -2603,6 +2644,27 @@ if (!process.env.CACHLY_NO_UPDATE_CHECK) {
     })();
 }
 const httpPort = process.env.PORT ? parseInt(process.env.PORT, 10) : undefined;
+// ── Per-request MCP Server factory (HTTP / Smithery stateless mode) ──────────
+// SDK ≥1.9 forbids reusing a stateless transport across requests.
+// Solution: create a fresh Server+Transport per /mcp request.
+// The module-level `server` below is used for stdio mode only.
+function createHttpMcpServer() {
+    const srv = new Server({ name: 'cachly-mcp', version: CURRENT_VERSION }, { capabilities: { tools: {} } });
+    srv.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+    srv.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        try {
+            const text = await handleTool(name, (args ?? {}));
+            return { content: [{ type: 'text', text }] };
+        }
+        catch (err) {
+            if (err instanceof McpError)
+                throw err;
+            throw new McpError(ErrorCode.InternalError, err.message);
+        }
+    });
+    return srv;
+}
 if (httpPort) {
     // ── HTTP mode (Streamable HTTP transport) ───────────────────────────────
     // Used for Smithery URL deployment: PORT=3000 node dist/index.js
@@ -2611,14 +2673,19 @@ if (httpPort) {
     //   2. Smithery config: ?config=base64url({CACHLY_JWT, CACHLY_BRAIN_INSTANCE_ID, ...})
     // Falls back to module-level env-derived values when neither is provided.
     const { createServer } = await import('node:http');
-    const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
-    await server.connect(transport);
     function extractReqCtx(req, url) {
         let jwtVal = '';
         let instId = '';
         const auth = req.headers['authorization'];
-        if (typeof auth === 'string' && auth.toLowerCase().startsWith('bearer ')) {
-            jwtVal = auth.slice(7).trim();
+        if (typeof auth === 'string' && auth.trim()) {
+            const a = auth.trim();
+            jwtVal = a.toLowerCase().startsWith('bearer ') ? a.slice(7).trim() : a;
+        }
+        // Fallback: raw JWT in custom header (Smithery "header" transport without Bearer prefix)
+        if (!jwtVal) {
+            const rawJwt = req.headers['cachly_jwt'] ?? req.headers['cachly-jwt'] ?? req.headers['x-cachly-jwt'] ?? req.headers['x-api-key'];
+            if (typeof rawJwt === 'string')
+                jwtVal = rawJwt.trim();
         }
         const hdrInst = req.headers['x-cachly-instance-id'];
         if (typeof hdrInst === 'string')
@@ -2637,6 +2704,17 @@ if (httpPort) {
             }
             catch { /* malformed config — ignore, fall back to globals */ }
         }
+        // Direct query params (Smithery "query" transport, manual clients, etc.)
+        if (!jwtVal) {
+            const q = url.searchParams.get('CACHLY_JWT') ?? url.searchParams.get('cachly_jwt') ?? url.searchParams.get('api_key');
+            if (q)
+                jwtVal = q.trim();
+        }
+        if (!instId) {
+            const q = url.searchParams.get('CACHLY_BRAIN_INSTANCE_ID') ?? url.searchParams.get('cachly_brain_instance_id') ?? url.searchParams.get('instance_id');
+            if (q)
+                instId = q.trim();
+        }
         return { jwt: jwtVal, instanceId: instId };
     }
     const httpServer = createServer((req, res) => {
@@ -2655,16 +2733,51 @@ if (httpPort) {
             }));
             return;
         }
+        // Static server card — lets Smithery skip live scanning (avoids auth complexity).
+        if (url.pathname === '/.well-known/mcp/server-card.json') {
+            const card = {
+                name: 'cachly AI Brain',
+                version: CURRENT_VERSION,
+                description: 'Persistent AI memory for Claude Code, Cursor, Copilot, Windsurf & friends. Remembers every lesson, fix, and architecture decision forever.',
+                transport: { type: 'streamable-http', url: 'https://mcp.cachly.dev/mcp' },
+                capabilities: { tools: {} },
+            };
+            res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+            res.end(JSON.stringify(card));
+            return;
+        }
         if (url.pathname === '/mcp' || url.pathname === '/') {
+            // Handle CORS preflight
+            if (req.method === 'OPTIONS') {
+                res.writeHead(204, {
+                    'Access-Control-Allow-Origin': '*',
+                    'Access-Control-Allow-Methods': 'GET, POST, DELETE, OPTIONS',
+                    'Access-Control-Allow-Headers': 'Authorization, Content-Type, Mcp-Session-Id, X-Cachly-Instance-Id, cachly_jwt, cachly-jwt, x-cachly-jwt, x-api-key',
+                });
+                res.end();
+                return;
+            }
             const ctx = extractReqCtx(req, url);
-            reqCtx.run(ctx, () => {
-                transport.handleRequest(req, res).catch((err) => {
-                    process.stderr.write(`cachly-mcp HTTP handler error: ${err.message}\n`);
-                    if (!res.headersSent) {
-                        res.writeHead(500, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ error: 'internal_error' }));
-                    }
+            // Create a fresh Server+Transport for each request (stateless multi-tenant mode).
+            // SDK ≥1.9 throws if a stateless transport is reused across requests.
+            const reqServer = createHttpMcpServer();
+            const reqTransport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+            reqServer.connect(reqTransport).then(() => {
+                reqCtx.run(ctx, () => {
+                    reqTransport.handleRequest(req, res).catch((err) => {
+                        process.stderr.write(`cachly-mcp HTTP handler error: ${err.message}\n`);
+                        if (!res.headersSent) {
+                            res.writeHead(500, { 'Content-Type': 'application/json' });
+                            res.end(JSON.stringify({ error: 'internal_error' }));
+                        }
+                    });
                 });
+            }).catch((err) => {
+                process.stderr.write(`cachly-mcp connect error: ${err.message}\n`);
+                if (!res.headersSent) {
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'internal_error' }));
+                }
             });
             return;
         }