cf-memory-mcp 3.44.0 → 3.46.0

package/bin/cf-memory-mcp.js

@@ -3969,6 +3969,14 @@ function parseCliArgs(rest) {
             flags.card = true;
         } else if (a === '--short') {
             flags.short = true;
+        } else if (a === '--age') {
+            flags.age = true;
+        } else if (a === '--quality') {
+            flags.quality = true;
+        } else if (a === '--goal-only') {
+            flags.goal_only = true;
+        } else if (a === '--status-only') {
+            flags.status_only = true;
         } else if (a === '--older-than') {
             // Accept "7d" / "30d" / "12h" / raw number (days).
             const raw = rest[++i] || '';
@@ -4131,6 +4139,38 @@ async function runResumeCli() {
             process.exit(0);
         }
 
+        // --goal-only: print just the goal (single line).
+        if (flags.goal_only) {
+            const goal = payload.resume_handoff?.handoff?.goal;
+            if (!goal) process.exit(3);
+            process.stdout.write(goal + '\n');
+            process.exit(0);
+        }
+
+        // --status-only: print just the status string.
+        if (flags.status_only) {
+            const status = payload.resume_handoff?.handoff?.status;
+            if (!status) process.exit(3);
+            process.stdout.write(status + '\n');
+            process.exit(0);
+        }
+
+        // --age: print just handoff_age_minutes (single integer).
+        if (flags.age) {
+            const ageMin = payload.resume_handoff?.handoff_age_minutes;
+            if (typeof ageMin !== 'number') process.exit(3);
+            process.stdout.write(String(ageMin) + '\n');
+            process.exit(0);
+        }
+
+        // --quality: print just quality_score (single float).
+        if (flags.quality) {
+            const q = payload.resume_handoff?.quality_score;
+            if (typeof q !== 'number') process.exit(3);
+            process.stdout.write(String(q) + '\n');
+            process.exit(0);
+        }
+
         // --short: single line for tmux/status bars. "goal · status"
         // truncated to terminal-friendly length.
         if (flags.short) {
@@ -4923,6 +4963,10 @@ const PER_COMMAND_HELP = {
     --chain               Walk parent_session_id back; show the thread history.
     --validate            Check that files_touched + code_anchors still exist locally.
     --raw                 Print just the raw handoff JSON (no envelope metadata).
+    --age                 Print handoff_age_minutes (single integer).
+    --quality             Print quality_score (single float, 0-1).
+    --goal-only           Print just the goal text (single line).
+    --status-only         Print just the status string.
     --json, -j            Full bootstrap payload as JSON.
   Exit codes: 0 = found, 3 = no handoff / no data, 4 = --validate found missing files.`,
     list: `cf-memory-mcp list [--status S] [--since ISO] [--repo PATH] [--limit N] [--json]
@@ -4950,14 +4994,18 @@ const PER_COMMAND_HELP = {
     --all                 Delete ALL cf-memory disk caches.
     --json, -j            Emit a JSON list of removed paths.`,
     export: `cf-memory-mcp export <session-id-or-prefix> [--md path]
+  cf-memory-mcp export --all
   Print a handoff as a JSON bundle to stdout (or write to file). For
-  backup or cross-machine sync.
+  backup or cross-machine sync. With --all, streams ALL handoffs as
+  NDJSON (one bundle per line) suitable for piping to a file.
     <session-id>          Full UUID or short prefix (>=8 chars).
-    --md <path>           Write the JSON to a file.`,
-    import: `cf-memory-mcp import [<file>|-] [--json]
+    --md <path>           Write the JSON to a file (single-handoff mode).
+    --all                 Stream all handoffs as NDJSON.`,
+    import: `cf-memory-mcp import [<file>|-] [--all] [--json]
   Restore a handoff bundle into a NEW session (keep_open). Cross-machine
   sync. Use "-" to read from stdin.
     <file>                Bundle file path; "-" for stdin.
+    --all                 Input is NDJSON (one bundle per line). Imports each.
     --json, -j            Emit a JSON status object.`,
     doctor: `cf-memory-mcp doctor [--json]
   Diagnose common setup issues. Checks API key, git repo/branch, disk-
@@ -5131,12 +5179,91 @@ async function runExportCli() {
     }
     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]');
+    const exportAll = process.argv.includes('--all');
+    if (!sessionArg && !exportAll) {
+        console.error('Usage:');
+        console.error('  cf-memory-mcp export <session-id-or-prefix>  # single handoff bundle');
+        console.error('  cf-memory-mcp export --all                   # all handoffs as NDJSON');
         process.exit(1);
     }
     const server = new CFMemoryMCP();
     server.logDebug = () => {};
+
+    // --all: stream every handoff as NDJSON (one bundle per line).
+    if (exportAll) {
+        // EPIPE handler: when piping to `head` etc., downstream closes
+        // stdout while we're still writing. Exit cleanly instead of
+        // dumping a Node stack trace.
+        process.stdout.on('error', (err) => {
+            if (err.code === 'EPIPE') process.exit(0);
+            throw err;
+        });
+        try {
+            // Page through all the user's handoffs via get_context_bootstrap
+            // with recent_handoff_limit=50, sorted by recency. Use `since`
+            // to walk back in time without dupes — query for entries before
+            // the oldest one in the previous batch.
+            const seen = new Set();
+            let cursor = null; // ISO timestamp; entries with ended_at|started_at >= cursor are returned
+            let totalEmitted = 0;
+            for (let page = 0; page < 100; page++) {
+                const args = { resume: true, recent_handoff_limit: 50 };
+                const meta = server.getRepoMetadata();
+                if (meta.repo_path) args.repo_path = meta.repo_path;
+                if (cursor) args.since = cursor;
+                const res = await server.makeRequest({
+                    jsonrpc: '2.0', id: `cli-export-all-${page}-${Date.now()}`,
+                    method: 'tools/call',
+                    params: { name: 'get_context_bootstrap', arguments: args },
+                });
+                const text = res?.result?.content?.[0]?.text;
+                const payload = JSON.parse(text || '{}');
+                const handoffs = payload.recent_handoffs || [];
+                if (handoffs.length === 0) break;
+                let newCount = 0;
+                let oldestSeen = null;
+                for (const h of handoffs) {
+                    if (seen.has(h.session_id)) continue;
+                    seen.add(h.session_id);
+                    // Fetch the full handoff (not just the summary).
+                    const fullRes = await server.makeRequest({
+                        jsonrpc: '2.0', id: `cli-export-all-detail-${Date.now()}`,
+                        method: 'tools/call',
+                        params: { name: 'get_context_bootstrap', arguments: { resume: true, session_id_hint: h.session_id } },
+                    });
+                    const fullText = fullRes?.result?.content?.[0]?.text;
+                    const fullPayload = JSON.parse(fullText || '{}');
+                    const envelope = fullPayload.resume_handoff;
+                    if (!envelope) continue;
+                    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,
+                    };
+                    process.stdout.write(JSON.stringify(bundle) + '\n');
+                    totalEmitted++;
+                    newCount++;
+                    const t = envelope.ended_at || envelope.started_at;
+                    if (!oldestSeen || t > oldestSeen) oldestSeen = t;
+                }
+                // No new entries → we've exhausted the timeline.
+                if (newCount === 0) break;
+                // Step the cursor forward (next page returns entries from
+                // after the oldest we saw).
+                cursor = oldestSeen;
+            }
+            process.stderr.write(`Exported ${totalEmitted} handoffs.\n`);
+            process.exit(totalEmitted === 0 ? 3 : 0);
+        } catch (err) {
+            console.error('export --all failed:', err.message);
+            process.exit(1);
+        }
+        return;
+    }
     try {
         const args = { resume: true, session_id_hint: sessionArg };
         const response = await server.makeRequest({
@@ -5182,6 +5309,7 @@ async function runImportCli() {
         process.exit(1);
     }
     const { positional, flags } = parseCliArgs(process.argv.slice(3));
+    const bulk = process.argv.includes('--all');
     const sourcePath = positional[0];
     let raw;
     try {
@@ -5195,6 +5323,64 @@ async function runImportCli() {
         console.error('import: cannot read input:', err.message);
         process.exit(1);
     }
+
+    // Bulk: parse NDJSON (one bundle per line) and import each.
+    if (bulk) {
+        const lines = raw.split('\n').filter(l => l.trim());
+        const server = new CFMemoryMCP();
+        server.logDebug = () => {};
+        const results = { imported: 0, failed: 0, errors: [] };
+        const meta = server.getRepoMetadata();
+        for (const line of lines) {
+            let bundle;
+            try { bundle = JSON.parse(line); } catch (err) {
+                results.failed++;
+                results.errors.push(`line skip: not valid JSON`);
+                continue;
+            }
+            if (bundle.kind !== 'cf-memory-handoff' || !bundle.handoff) {
+                results.failed++;
+                results.errors.push(`line skip: not a cf-memory-handoff bundle`);
+                continue;
+            }
+            try {
+                const startArgs = { context: 'main' };
+                if (meta.repo_path) startArgs.repo_path = meta.repo_path;
+                if (meta.branch) startArgs.branch = meta.branch;
+                const startRes = await server.makeRequest({
+                    jsonrpc: '2.0', id: `cli-import-all-start-${Date.now()}`,
+                    method: 'tools/call', params: { name: 'start_session', arguments: startArgs },
+                });
+                const sp = JSON.parse(startRes?.result?.content?.[0]?.text || '{}');
+                const newId = sp.session_id;
+                if (!newId) { results.failed++; continue; }
+                const handoff = {
+                    ...bundle.handoff,
+                    parent_session_id: bundle.session_id,
+                    notes: (bundle.handoff.notes || '') + `\n\n[bulk-imported from ${bundle.session_id}]`,
+                };
+                await server.makeRequest({
+                    jsonrpc: '2.0', id: `cli-import-all-end-${Date.now()}`,
+                    method: 'tools/call', params: { name: 'end_session', arguments: {
+                        session_id: newId, keep_open: true, handoff,
+                    } },
+                });
+                results.imported++;
+            } catch (err) {
+                results.failed++;
+                results.errors.push(`${bundle.session_id}: ${err.message}`);
+            }
+        }
+        if (flags.json) {
+            process.stdout.write(JSON.stringify(results, null, 2) + '\n');
+        } else {
+            process.stderr.write(`Imported ${results.imported} handoffs.`);
+            if (results.failed > 0) process.stderr.write(` Failed: ${results.failed}.`);
+            process.stderr.write('\n');
+        }
+        process.exit(results.imported > 0 ? 0 : 3);
+    }
+
     let bundle;
     try { bundle = JSON.parse(raw); } catch (err) {
         console.error('import: input is not valid JSON:', err.message);

package/package.json

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