cf-memory-mcp 3.25.0 → 3.27.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}`
                             }
                         });
@@ -3752,6 +3792,8 @@ Usage:
   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 export <id>     Print a session's handoff as JSON bundle (backup)
+  npx cf-memory-mcp import <file>   Restore a handoff bundle (cross-machine sync); use "-" for stdin
   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
@@ -3773,7 +3815,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 +3828,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 +3877,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 +3957,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({
@@ -3930,6 +4000,153 @@ async function runListCli() {
     }
 }
 
+async function runExportCli() {
+    if (!API_KEY) {
+        console.error('Error: CF_MEMORY_API_KEY environment variable is required');
+        process.exit(1);
+    }
+    const { positional, flags } = parseCliArgs(process.argv.slice(3));
+    const sessionArg = positional[0];
+    if (!sessionArg) {
+        console.error('Usage: cf-memory-mcp export <session-id-or-prefix> [--md path]');
+        process.exit(1);
+    }
+    const server = new CFMemoryMCP();
+    server.logDebug = () => {};
+    try {
+        const args = { resume: true, session_id_hint: sessionArg };
+        const response = await server.makeRequest({
+            jsonrpc: '2.0',
+            id: `cli-export-${Date.now()}`,
+            method: 'tools/call',
+            params: { name: 'get_context_bootstrap', arguments: args },
+        });
+        const text = response?.result?.content?.[0]?.text;
+        const payload = JSON.parse(text || '{}');
+        const envelope = payload.resume_handoff;
+        if (!envelope?.handoff) {
+            process.stderr.write((payload.empty_hint || `No handoff found for "${sessionArg}".`) + '\n');
+            process.exit(3);
+        }
+        // Build an exportable bundle: enough to fully reconstruct via import.
+        const bundle = {
+            kind: 'cf-memory-handoff',
+            version: 1,
+            exported_at: new Date().toISOString(),
+            session_id: envelope.session_id,
+            started_at: envelope.started_at,
+            ended_at: envelope.ended_at,
+            handoff: envelope.handoff,
+        };
+        const output = JSON.stringify(bundle, null, 2);
+        if (flags.md_path) {
+            fs.writeFileSync(flags.md_path, output);
+            process.stdout.write(`Wrote ${output.length} bytes to ${flags.md_path}\n`);
+        } else {
+            process.stdout.write(output + '\n');
+        }
+        process.exit(0);
+    } catch (err) {
+        console.error('export command failed:', err.message);
+        process.exit(1);
+    }
+}
+
+async function runImportCli() {
+    if (!API_KEY) {
+        console.error('Error: CF_MEMORY_API_KEY environment variable is required');
+        process.exit(1);
+    }
+    const { positional, flags } = parseCliArgs(process.argv.slice(3));
+    const sourcePath = positional[0];
+    let raw;
+    try {
+        if (sourcePath === '-' || sourcePath === undefined) {
+            // Read from stdin so `cat handoff.json | cf-memory-mcp import` works.
+            raw = fs.readFileSync(0, 'utf8'); // fd 0 = stdin
+        } else {
+            raw = fs.readFileSync(sourcePath, 'utf8');
+        }
+    } catch (err) {
+        console.error('import: cannot read input:', err.message);
+        process.exit(1);
+    }
+    let bundle;
+    try { bundle = JSON.parse(raw); } catch (err) {
+        console.error('import: input is not valid JSON:', err.message);
+        process.exit(1);
+    }
+    if (bundle.kind !== 'cf-memory-handoff' || !bundle.handoff) {
+        console.error('import: input is not a cf-memory-handoff bundle (expected kind="cf-memory-handoff" + handoff field).');
+        process.exit(1);
+    }
+    const server = new CFMemoryMCP();
+    server.logDebug = () => {};
+    try {
+        // Imports always create a fresh session and write the imported
+        // handoff to it. The original session_id is preserved in
+        // handoff.notes so the link to the source isn't lost.
+        const meta = server.getRepoMetadata();
+        const startArgs = { context: 'main' };
+        if (meta.repo_path) startArgs.repo_path = meta.repo_path;
+        if (meta.branch) startArgs.branch = meta.branch;
+        const fake = { params: { name: 'retrieve_context', arguments: {} } };
+        await server.maybeFillProjectId(fake);
+        if (fake.params.arguments.project_id) startArgs.project_id = fake.params.arguments.project_id;
+
+        const startRes = await server.makeRequest({
+            jsonrpc: '2.0', id: `cli-import-start-${Date.now()}`,
+            method: 'tools/call', params: { name: 'start_session', arguments: startArgs },
+        });
+        const startText = startRes?.result?.content?.[0]?.text;
+        const startPayload = JSON.parse(startText || '{}');
+        const newSessionId = startPayload.session_id;
+        if (!newSessionId) {
+            console.error('import: failed to create new session:', startText);
+            process.exit(1);
+        }
+
+        // Build the handoff: take the imported one, append import note.
+        const importNote = `[imported from session ${bundle.session_id} on ${new Date().toISOString()}; originally started ${bundle.started_at}]`;
+        const handoff = { ...bundle.handoff };
+        handoff.notes = handoff.notes ? `${handoff.notes}\n\n${importNote}` : importNote;
+        // Fill repo metadata from current context if the imported handoff
+        // didn't specify (cross-machine sync use case).
+        if (!handoff.repo_path && meta.repo_path) handoff.repo_path = meta.repo_path;
+        if (!handoff.branch && meta.branch) handoff.branch = meta.branch;
+        if (!handoff.project_id && fake.params.arguments.project_id) handoff.project_id = fake.params.arguments.project_id;
+
+        const endRes = await server.makeRequest({
+            jsonrpc: '2.0', id: `cli-import-end-${Date.now()}`,
+            method: 'tools/call', params: { name: 'end_session', arguments: {
+                session_id: newSessionId,
+                keep_open: true,
+                handoff,
+            } },
+        });
+        const endText = endRes?.result?.content?.[0]?.text;
+        const endPayload = JSON.parse(endText || '{}');
+        if (flags.json) {
+            process.stdout.write(JSON.stringify({
+                imported_from: bundle.session_id,
+                new_session_id: newSessionId,
+                short_id: newSessionId.slice(0, 8),
+                handoff_stored: !!endPayload.handoff_stored,
+                resume_command: `npx cf-memory-mcp resume ${newSessionId.slice(0, 8)}`,
+            }, null, 2) + '\n');
+        } else {
+            process.stdout.write(`Imported handoff into session ${newSessionId.slice(0, 8)} (kept_open).\n`);
+            process.stdout.write(`Original: ${bundle.session_id}\n`);
+            process.stdout.write(`Goal: ${handoff.goal}\n`);
+            process.stdout.write(`To resume: npx cf-memory-mcp resume ${newSessionId.slice(0, 8)}\n`);
+        }
+        process.exit(endPayload.handoff_stored ? 0 : 2);
+    } catch (err) {
+        console.error('import command failed:', err.message);
+        process.exit(1);
+    }
+}
+
 async function runCleanCli() {
     const { flags, positional } = parseCliArgs(process.argv.slice(3));
     const all = positional.includes('--all') || process.argv.includes('--all');
@@ -4162,6 +4379,16 @@ if (process.argv[2] === 'clean') {
     return;
 }
 
+if (process.argv[2] === 'export') {
+    runExportCli();
+    return;
+}
+
+if (process.argv[2] === 'import') {
+    runImportCli();
+    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.25.0",
+	"version": "3.27.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": {