cf-memory-mcp 3.24.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}`
                             }
                         });
@@ -3750,6 +3790,8 @@ Usage:
   npx cf-memory-mcp list            List recent handoffs for cwd
   npx cf-memory-mcp checkpoint ["<goal>"]  Snapshot current state (keep_open)
   npx cf-memory-mcp status          Show bridge state + server resume availability
+  npx cf-memory-mcp clean           Delete local disk cache for current cwd
+  npx cf-memory-mcp clean --all     Delete ALL local disk caches
   npx cf-memory-mcp --version       Show version
   npx cf-memory-mcp --help          Show this help
   npx cf-memory-mcp --diagnose      Test connectivity and report issues
@@ -3771,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 };
@@ -3784,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 };
@@ -3828,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);
@@ -3887,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({
@@ -3928,6 +3998,49 @@ async function runListCli() {
     }
 }
 
+async function runCleanCli() {
+    const { flags, positional } = parseCliArgs(process.argv.slice(3));
+    const all = positional.includes('--all') || process.argv.includes('--all');
+    const server = new CFMemoryMCP();
+    server.logDebug = () => {};
+    const removed = [];
+    try {
+        if (all) {
+            // Clear ALL disk caches in ~/.cf-memory/.
+            const dir = path.join(os.homedir(), '.cf-memory');
+            if (fs.existsSync(dir)) {
+                for (const entry of fs.readdirSync(dir)) {
+                    if (entry.startsWith('handoff-') && entry.endsWith('.json')) {
+                        const full = path.join(dir, entry);
+                        fs.unlinkSync(full);
+                        removed.push(full);
+                    }
+                }
+            }
+        } else {
+            const p = server.getDiskCachePath();
+            if (p && fs.existsSync(p)) {
+                fs.unlinkSync(p);
+                removed.push(p);
+            }
+        }
+        if (flags.json) {
+            process.stdout.write(JSON.stringify({ removed }, null, 2) + '\n');
+            process.exit(0);
+        }
+        if (removed.length === 0) {
+            process.stdout.write('(nothing to clean)\n');
+        } else {
+            process.stdout.write(`Removed ${removed.length} cache file${removed.length === 1 ? '' : 's'}:\n`);
+            for (const r of removed) process.stdout.write(`  ${r}\n`);
+        }
+        process.exit(0);
+    } catch (err) {
+        console.error('clean command failed:', err.message);
+        process.exit(1);
+    }
+}
+
 async function runStatusCli() {
     const { flags } = parseCliArgs(process.argv.slice(3));
     const server = new CFMemoryMCP();
@@ -4112,6 +4225,11 @@ if (process.argv[2] === 'status') {
     return;
 }
 
+if (process.argv[2] === 'clean') {
+    runCleanCli();
+    return;
+}
+
 if (process.argv.includes('--diagnose')) {
     (async () => {
         console.log(`CF Memory MCP v${PACKAGE_VERSION} - Diagnostics`);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cf-memory-mcp",
-	"version": "3.24.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": {