cf-memory-mcp 3.26.0 → 3.27.0

package/bin/cf-memory-mcp.js

@@ -3792,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
@@ -3998,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');
@@ -4230,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.26.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": {