cf-memory-mcp 3.61.0 → 3.62.0

package/bin/cf-memory-mcp.js

@@ -2672,6 +2672,42 @@ class CFMemoryMCP {
         }
     }
 
+    /**
+     * Drop the implicit-session disk cache iff the cached session id is
+     * in `deletedSessionIds`. Called from the delete CLI so a subsequent
+     * end_session against the implicit cache won't write to a session
+     * that no longer exists on the server. Also clears the in-memory map
+     * for the matching cwd. Returns true when something was dropped.
+     */
+    invalidateImplicitSessionIfMatches(deletedSessionIds) {
+        if (!deletedSessionIds || !deletedSessionIds.length) return false;
+        const matchSet = new Set(deletedSessionIds);
+        let dropped = false;
+        try {
+            const implicitPath = this.getImplicitSessionDiskPath();
+            if (implicitPath && fs.existsSync(implicitPath)) {
+                const entry = JSON.parse(fs.readFileSync(implicitPath, 'utf8'));
+                if (matchSet.has(entry.session_id)) {
+                    fs.unlinkSync(implicitPath);
+                    dropped = true;
+                }
+            }
+        } catch (_) { /* non-fatal */ }
+        // Also evict in-memory entries so a long-lived bridge stops
+        // auto-filling the deleted id.
+        try {
+            if (this._implicitSessionByCwd && this._implicitSessionByCwd.size) {
+                for (const [cwd, sid] of this._implicitSessionByCwd.entries()) {
+                    if (matchSet.has(sid)) {
+                        this._implicitSessionByCwd.delete(cwd);
+                        dropped = true;
+                    }
+                }
+            }
+        } catch (_) { /* non-fatal */ }
+        return dropped;
+    }
+
     /**
      * Return the implicit session_id for the current cwd, creating one via
      * start_session when no session is active. Lets agents skip explicit
@@ -5215,6 +5251,12 @@ async function runDeleteCli() {
             });
             const deleteText = deleteRes?.result?.content?.[0]?.text;
             const payload = JSON.parse(deleteText || '{}');
+            // Implicit-cache invalidation: if any deleted id matches the
+            // current cwd's implicit session, drop the cache so the next
+            // end_session creates a fresh one.
+            if (payload.deleted) {
+                server.invalidateImplicitSessionIfMatches(payload.deleted_session_ids || []);
+            }
             if (flags.json) {
                 process.stdout.write(JSON.stringify(payload, null, 2) + '\n');
                 process.exit(payload.deleted ? 0 : 3);
@@ -5254,6 +5296,12 @@ async function runDeleteCli() {
         });
         const deleteText = deleteRes?.result?.content?.[0]?.text;
         const payload = JSON.parse(deleteText || '{}');
+        // Drop the implicit-session disk cache if the deleted id matches
+        // it. Otherwise a subsequent end_session would try to write to a
+        // session that no longer exists.
+        if (payload.deleted) {
+            server.invalidateImplicitSessionIfMatches([fullId]);
+        }
         if (flags.json) {
             process.stdout.write(JSON.stringify({ ...payload, session_id: fullId }, null, 2) + '\n');
             process.exit(payload.deleted ? 0 : 3);
@@ -6097,11 +6145,15 @@ async function runCleanCli() {
     const removed = [];
     try {
         if (all) {
-            // Clear ALL disk caches in ~/.cf-memory/.
+            // Clear ALL disk caches in ~/.cf-memory/: handoff-*.json
+            // (offline resume cache) AND implicit-*.json (persistent
+            // implicit session id per cwd).
             const dir = path.join(os.homedir(), '.cf-memory');
             if (fs.existsSync(dir)) {
                 for (const entry of fs.readdirSync(dir)) {
-                    if (entry.startsWith('handoff-') && entry.endsWith('.json')) {
+                    const isHandoff = entry.startsWith('handoff-') && entry.endsWith('.json');
+                    const isImplicit = entry.startsWith('implicit-') && entry.endsWith('.json');
+                    if (isHandoff || isImplicit) {
                         const full = path.join(dir, entry);
                         fs.unlinkSync(full);
                         removed.push(full);
@@ -6109,10 +6161,17 @@ async function runCleanCli() {
                 }
             }
         } else {
-            const p = server.getDiskCachePath();
-            if (p && fs.existsSync(p)) {
-                fs.unlinkSync(p);
-                removed.push(p);
+            // cwd-only mode: drop both the handoff cache AND the
+            // implicit session cache for this cwd.
+            const handoffPath = server.getDiskCachePath();
+            if (handoffPath && fs.existsSync(handoffPath)) {
+                fs.unlinkSync(handoffPath);
+                removed.push(handoffPath);
+            }
+            const implicitPath = server.getImplicitSessionDiskPath();
+            if (implicitPath && fs.existsSync(implicitPath)) {
+                fs.unlinkSync(implicitPath);
+                removed.push(implicitPath);
             }
         }
         if (flags.json) {

package/package.json

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