cf-memory-mcp 3.25.0 → 3.26.0

package/bin/cf-memory-mcp.js

@@ -3548,7 +3548,31 @@ class CFMemoryMCP {
         }
     }
 
+    /**
+     * Retry-aware wrapper. Tries once, then once more after a short
+     * backoff if the first attempt got a network error, 5xx, or timeout.
+     * Opt out with CF_MEMORY_NO_RETRY=1.
+     */
     async makeRequest(message, extraHeaders = null) {
+        const noRetry = process.env.CF_MEMORY_NO_RETRY === '1' || process.env.CF_MEMORY_NO_RETRY === 'true';
+        const first = await this.makeRequestOnce(message, extraHeaders);
+        if (noRetry) return first;
+        // Retry only on transient failures: connection error, timeout, or 5xx.
+        // We never retry application-level errors (4xx / -32602 / -32603 from
+        // server logic) since those are likely to repeat.
+        const isTransient = first?.error && (
+            /Network error|Request timeout/.test(first.error.message || '') ||
+            /HTTP 5\d\d/.test(first.error.message || '')
+        );
+        if (!isTransient) return first;
+        // Brief backoff to let an edge blip clear.
+        await new Promise(r => setTimeout(r, 250));
+        _mcpTrace('RETRY', `id=${message.id} after transient error: ${first.error.message}`);
+        const second = await this.makeRequestOnce(message, extraHeaders);
+        return second;
+    }
+
+    async makeRequestOnce(message, extraHeaders = null) {
         return new Promise((resolve) => {
             const serverUrl = this.useStreamableHttp ? this.streamableHttpUrl : this.legacyServerUrl;
             const url = new URL(serverUrl);
@@ -3588,6 +3612,18 @@ class CFMemoryMCP {
                 res.on('end', () => {
                     try {
                         const response = JSON.parse(body);
+                        // Promote 5xx HTTP status to a transient error
+                        // envelope so the retry path can catch it. The
+                        // server may have returned a valid JSON-RPC error
+                        // wrapped in 200, OR a body-less 5xx with no
+                        // error field — handle both.
+                        if (res.statusCode && res.statusCode >= 500 && !response.error) {
+                            response.error = {
+                                code: -32603,
+                                message: `HTTP ${res.statusCode}`,
+                                data: `Server returned ${res.statusCode}`,
+                            };
+                        }
                         resolve(response);
                     } catch (error) {
                         // Include HTTP status + body snippet so callers can
@@ -3596,12 +3632,16 @@ class CFMemoryMCP {
                         // "Invalid JSON" alone hides whether the worker is
                         // even reachable.
                         const bodyPreview = body.slice(0, 200).replace(/\s+/g, ' ');
+                        // 5xx with non-JSON body is transient too (Cloudflare
+                        // edge HTML pages). Tag the error message so retry catches it.
+                        const transientTag = (res.statusCode && res.statusCode >= 500)
+                            ? `HTTP ${res.statusCode}` : `HTTP ${res.statusCode || '?'}`;
                         resolve({
                             jsonrpc: '2.0',
                             id: message.id || null,
                             error: {
                                 code: -32603,
-                                message: `Invalid JSON response from server (HTTP ${res.statusCode})`,
+                                message: `Invalid JSON response from server (${transientTag})`,
                                 data: `${error.message}; body[0..200]=${bodyPreview}`
                             }
                         });
@@ -3773,7 +3813,7 @@ For more information, visit: https://github.com/johnlam90/cf-memory-mcp
 }
 
 // Parse positional + flag args for CLI subcommands. Returns
-// { positional: string[], flags: { json: boolean, limit?: number } }.
+// { positional: string[], flags: { json, limit, md_path } }.
 function parseCliArgs(rest) {
     const positional = [];
     const flags = { json: false };
@@ -3786,6 +3826,11 @@ function parseCliArgs(rest) {
         } else if (a.startsWith('--limit=')) {
             const n = parseInt(a.slice('--limit='.length), 10);
             if (Number.isFinite(n) && n > 0) flags.limit = Math.min(n, 50);
+        } else if (a === '--md') {
+            // Next arg is path; supports `--md=path` too.
+            flags.md_path = rest[++i];
+        } else if (a.startsWith('--md=')) {
+            flags.md_path = a.slice('--md='.length);
         } else positional.push(a);
     }
     return { positional, flags };
@@ -3830,6 +3875,27 @@ async function runResumeCli() {
         //   0 — handoff found and printed
         //   3 — no handoff found (lets scripts branch: `if ! cf-memory-mcp resume; then ...`)
         const found = !!payload.resume_handoff?.handoff;
+
+        // Warm the disk cache. The CLI bypasses the stdio dispatch hook
+        // that normally writes the cache on a successful resume, so do
+        // it here too. Means `cf-memory-mcp resume` ALSO populates the
+        // offline-fallback cache, not just MCP-stdio usage.
+        if (found) server.saveResumeToDisk(response);
+
+        // --md <path>: write the rendered markdown to a file instead of
+        // (or in addition to) stdout. Useful for piping to a markdown
+        // viewer or saving to the project.
+        if (found && flags.md_path && payload.resume_prompt) {
+            try {
+                fs.writeFileSync(flags.md_path, payload.resume_prompt + '\n');
+                process.stdout.write(`Wrote ${payload.resume_prompt.length} chars to ${flags.md_path}\n`);
+                process.exit(0);
+            } catch (err) {
+                console.error(`Failed to write ${flags.md_path}: ${err.message}`);
+                process.exit(1);
+            }
+        }
+
         if (flags.json) {
             process.stdout.write(JSON.stringify(payload, null, 2) + '\n');
             process.exit(found ? 0 : 3);
@@ -3889,6 +3955,8 @@ async function runListCli() {
         const payload = JSON.parse(text || '{}');
         const allList = Array.isArray(payload.recent_handoffs) ? payload.recent_handoffs : [];
         const list = flags.limit ? allList.slice(0, flags.limit) : allList;
+        // Warm the disk cache when there's a primary handoff in the payload.
+        if (payload.resume_handoff) server.saveResumeToDisk(response);
 
         if (flags.json) {
             process.stdout.write(JSON.stringify({

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cf-memory-mcp",
-	"version": "3.25.0",
+	"version": "3.26.0",
 	"description": "Cloudflare-hosted MCP server for code indexing, retrieval, and assistant memory with a direct remote MCP endpoint and local stdio bridge.",
 	"main": "bin/cf-memory-mcp.js",
 	"bin": {