cf-memory-mcp 3.47.0 → 3.48.0

package/bin/cf-memory-mcp.js

@@ -2612,6 +2612,66 @@ class CFMemoryMCP {
         }
     }
 
+    /**
+     * Path for the on-disk implicit-session cache (keyed by cwd hash).
+     * Lets the bridge survive restarts without losing the implicit
+     * session — otherwise a fresh process would create a duplicate
+     * session for the same cwd.
+     */
+    getImplicitSessionDiskPath() {
+        try {
+            const cwd = process.env.CF_MEMORY_WATCH_PATH || process.cwd();
+            const crypto = require('crypto');
+            const hash = crypto.createHash('sha256').update(cwd).digest('hex').slice(0, 16);
+            return path.join(os.homedir(), '.cf-memory', `implicit-${hash}.json`);
+        } catch (_) { return null; }
+    }
+
+    /**
+     * Load the disk-persisted implicit session for the current cwd, if any.
+     * Stale entries (>1 day old) are ignored — sessions that haven't been
+     * touched in a day are probably not "implicitly active" anymore.
+     */
+    loadImplicitSessionFromDisk() {
+        try {
+            const p = this.getImplicitSessionDiskPath();
+            if (!p || !fs.existsSync(p)) return null;
+            const entry = JSON.parse(fs.readFileSync(p, 'utf8'));
+            const ageMs = Date.now() - new Date(entry.cached_at).getTime();
+            if (ageMs > 24 * 60 * 60 * 1000) return null; // stale
+            return entry.session_id || null;
+        } catch (_) { return null; }
+    }
+
+    /**
+     * Persist the current implicit session id to disk. Called from
+     * getOrCreateImplicitSession and cacheImplicitSessionFromResponse.
+     * Atomic via .tmp + rename, same as the resume cache.
+     */
+    saveImplicitSessionToDisk(sessionId) {
+        try {
+            const p = this.getImplicitSessionDiskPath();
+            if (!p) return;
+            const dir = path.dirname(p);
+            if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+            const entry = {
+                cached_at: new Date().toISOString(),
+                cwd: process.env.CF_MEMORY_WATCH_PATH || process.cwd(),
+                session_id: sessionId,
+            };
+            const tmp = `${p}.tmp.${process.pid}`;
+            try {
+                fs.writeFileSync(tmp, JSON.stringify(entry, null, 2));
+                fs.renameSync(tmp, p);
+            } catch (renameErr) {
+                try { fs.unlinkSync(tmp); } catch (_) { /* ignore */ }
+                fs.writeFileSync(p, JSON.stringify(entry, null, 2));
+            }
+        } catch (err) {
+            this.logDebug(`saveImplicitSessionToDisk failed: ${err && err.message}`);
+        }
+    }
+
     /**
      * Return the implicit session_id for the current cwd, creating one via
      * start_session when no session is active. Lets agents skip explicit
@@ -2621,6 +2681,7 @@ class CFMemoryMCP {
      * The cache is keyed by cwd so multiple bridge processes for different
      * repos don't share state. Sessions finalized via end_session WITHOUT
      * keep_open clear the implicit cache so the next call starts fresh.
+     * Persists to disk so bridge restarts don't churn new sessions.
      */
     async getOrCreateImplicitSession() {
         try {
@@ -2628,6 +2689,13 @@ class CFMemoryMCP {
             if (!this._implicitSessionByCwd) this._implicitSessionByCwd = new Map();
             const cached = this._implicitSessionByCwd.get(cwd);
             if (cached) return cached;
+            // Try disk cache (survives bridge restarts).
+            const fromDisk = this.loadImplicitSessionFromDisk();
+            if (fromDisk) {
+                this._implicitSessionByCwd.set(cwd, fromDisk);
+                _mcpTrace('IMPLICIT_SESSION', `restored implicit session=${fromDisk} from disk for cwd=${cwd}`);
+                return fromDisk;
+            }
 
             // Lazily start a session, tagged with the same repo metadata as
             // start_session would auto-attach if called explicitly.
@@ -2652,6 +2720,7 @@ class CFMemoryMCP {
             } catch (_) { /* malformed response */ }
             if (sessionId) {
                 this._implicitSessionByCwd.set(cwd, sessionId);
+                this.saveImplicitSessionToDisk(sessionId);
                 _mcpTrace('IMPLICIT_SESSION', `created implicit session=${sessionId} for cwd=${cwd}`);
             }
             return sessionId;
@@ -2678,6 +2747,7 @@ class CFMemoryMCP {
             const cwd = process.env.CF_MEMORY_WATCH_PATH || process.cwd();
             if (!this._implicitSessionByCwd) this._implicitSessionByCwd = new Map();
             this._implicitSessionByCwd.set(cwd, sessionId);
+            this.saveImplicitSessionToDisk(sessionId);
             _mcpTrace('IMPLICIT_SESSION', `cached implicit session=${sessionId} for cwd=${cwd}`);
         } catch (err) {
             this.logDebug(`cacheImplicitSessionFromResponse failed: ${err && err.message}`);
@@ -2708,6 +2778,12 @@ class CFMemoryMCP {
                 this._implicitSessionByCwd.delete(cwd);
                 _mcpTrace('IMPLICIT_SESSION', `cleared implicit session for cwd=${cwd}`);
             }
+            // Also drop the on-disk persistent cache so a future restart
+            // doesn't pick the just-finalized session back up.
+            try {
+                const p = this.getImplicitSessionDiskPath();
+                if (p && fs.existsSync(p)) fs.unlinkSync(p);
+            } catch (_) { /* ignore */ }
         } catch (err) {
             this.logDebug(`clearImplicitSessionIfFinalized failed: ${err && err.message}`);
         }
@@ -3981,6 +4057,10 @@ function parseCliArgs(rest) {
             flags.branch_only = true;
         } else if (a === '--repo-only') {
             flags.repo_only = true;
+        } else if (a === '--fields') {
+            flags.fields = rest[++i];
+        } else if (a.startsWith('--fields=')) {
+            flags.fields = a.slice('--fields='.length);
         } else if (a === '--older-than') {
             // Accept "7d" / "30d" / "12h" / raw number (days).
             const raw = rest[++i] || '';
@@ -4175,6 +4255,43 @@ async function runResumeCli() {
             process.exit(0);
         }
 
+        // --fields a,b,c: multi-field extract. Print each field on its
+        // own line (or as `name=value` for shell scripting). Supports
+        // any top-level handoff field plus envelope metadata.
+        if (flags.fields) {
+            const envelope = payload.resume_handoff;
+            if (!envelope) process.exit(3);
+            const handoff = envelope.handoff || {};
+            const fieldLookup = (name) => {
+                switch (name) {
+                    case 'session_id': return envelope.session_id;
+                    case 'age_minutes': return envelope.handoff_age_minutes;
+                    case 'quality_score': return envelope.quality_score;
+                    case 'match_confidence': return envelope.match_confidence;
+                    case 'match_reason': return envelope.match_reason;
+                    case 'stale': return envelope.stale ? 'true' : 'false';
+                    default: return handoff[name];
+                }
+            };
+            const wantNames = flags.fields.split(',').map(s => s.trim()).filter(Boolean);
+            if (wantNames.length === 0) process.exit(3);
+            const lines = [];
+            for (const name of wantNames) {
+                const v = fieldLookup(name);
+                if (v === undefined || v === null) continue;
+                if (Array.isArray(v)) {
+                    lines.push(`${name}=${v.length} item${v.length === 1 ? '' : 's'}`);
+                } else if (typeof v === 'object') {
+                    lines.push(`${name}=${JSON.stringify(v)}`);
+                } else {
+                    lines.push(`${name}=${v}`);
+                }
+            }
+            if (lines.length === 0) process.exit(3);
+            process.stdout.write(lines.join('\n') + '\n');
+            process.exit(0);
+        }
+
         // --age: print just handoff_age_minutes (single integer).
         if (flags.age) {
             const ageMin = payload.resume_handoff?.handoff_age_minutes;
@@ -4989,6 +5106,9 @@ const PER_COMMAND_HELP = {
     --status-only         Print just the status string.
     --branch-only         Print just the branch.
     --repo-only           Print just the repo_path.
+    --fields <list>       Print specified fields as "name=value", comma-sep.
+                          Supports any handoff field plus session_id, age_minutes,
+                          quality_score, match_confidence, match_reason, stale.
     --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]

package/package.json

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