cf-memory-mcp 3.45.0 → 3.47.0

package/bin/cf-memory-mcp.js

@@ -3973,6 +3973,14 @@ function parseCliArgs(rest) {
             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 === '--branch-only') {
+            flags.branch_only = true;
+        } else if (a === '--repo-only') {
+            flags.repo_only = true;
         } else if (a === '--older-than') {
             // Accept "7d" / "30d" / "12h" / raw number (days).
             const raw = rest[++i] || '';
@@ -4135,6 +4143,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);
+        }
+
+        // --branch-only: print just the branch.
+        if (flags.branch_only) {
+            const branch = payload.resume_handoff?.handoff?.branch;
+            if (!branch) process.exit(3);
+            process.stdout.write(branch + '\n');
+            process.exit(0);
+        }
+
+        // --repo-only: print just the repo_path.
+        if (flags.repo_only) {
+            const repo = payload.resume_handoff?.handoff?.repo_path;
+            if (!repo) process.exit(3);
+            process.stdout.write(repo + '\n');
+            process.exit(0);
+        }
+
         // --age: print just handoff_age_minutes (single integer).
         if (flags.age) {
             const ageMin = payload.resume_handoff?.handoff_age_minutes;
@@ -4945,6 +4985,10 @@ const PER_COMMAND_HELP = {
     --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.
+    --branch-only         Print just the branch.
+    --repo-only           Print just the repo_path.
     --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]
@@ -4979,10 +5023,11 @@ const PER_COMMAND_HELP = {
     <session-id>          Full UUID or short prefix (>=8 chars).
     --md <path>           Write the JSON to a file (single-handoff mode).
     --all                 Stream all handoffs as NDJSON.`,
-    import: `cf-memory-mcp import [<file>|-] [--json]
+    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-
@@ -5286,6 +5331,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 {
@@ -5299,6 +5345,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.45.0",
+	"version": "3.47.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": {