cf-memory-mcp 3.60.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
@@ -4051,6 +4087,14 @@ function parseCliArgs(rest) {
             flags.raw = true;
         } else if (a === '--copy') {
             flags.copy = true;
+        } else if (a === '--watch') {
+            flags.watch = true;
+        } else if (a === '--interval') {
+            const n = parseInt(rest[++i], 10);
+            flags.interval = Number.isFinite(n) && n >= 5 ? Math.min(n, 600) : 30;
+        } else if (a.startsWith('--interval=')) {
+            const n = parseInt(a.slice('--interval='.length), 10);
+            flags.interval = Number.isFinite(n) && n >= 5 ? Math.min(n, 600) : 30;
         } else if (a === '--card') {
             flags.card = true;
         } else if (a === '--short') {
@@ -4127,6 +4171,42 @@ async function runResumeCli() {
         process.exit(1);
     }
     const { positional, flags } = parseCliArgs(process.argv.slice(3));
+
+    // --watch: re-spawn this command without --watch on an interval,
+    // clearing the screen between renders. Bounded by --interval (5-600s,
+    // default 30s). Ctrl+C exits cleanly.
+    if (flags.watch) {
+        const interval = (flags.interval || 30) * 1000;
+        const { spawnSync } = require('child_process');
+        // Strip --watch from argv for the inner call. Pass everything else.
+        const innerArgs = process.argv.slice(3).filter(a => a !== '--watch' && a !== '--interval' && !a.startsWith('--interval='))
+            .filter((_, i, arr) => {
+                // Also drop the value after --interval if it was separate.
+                const prev = arr[i - 1];
+                return prev !== '--interval';
+            });
+        let stopped = false;
+        const onSig = () => { stopped = true; process.stderr.write('\n[watch] stopped\n'); process.exit(0); };
+        process.on('SIGINT', onSig);
+        process.on('SIGTERM', onSig);
+        while (!stopped) {
+            // Clear screen (ANSI). Skip when not a TTY (just append).
+            if (process.stdout.isTTY) process.stdout.write('\x1b[2J\x1b[H');
+            process.stdout.write(`[watch] ${new Date().toISOString()} (every ${interval/1000}s, Ctrl+C to exit)\n\n`);
+            try {
+                const res = spawnSync(process.execPath, [__filename, 'resume', ...innerArgs], {
+                    stdio: ['ignore', 'inherit', 'inherit'],
+                });
+                if (res.status !== 0 && res.status !== 3) {
+                    process.stderr.write(`\n[watch] resume exited ${res.status}\n`);
+                }
+            } catch (err) {
+                process.stderr.write(`\n[watch] error: ${err.message}\n`);
+            }
+            await new Promise(r => setTimeout(r, interval));
+        }
+        process.exit(0);
+    }
     const server = new CFMemoryMCP();
     server.logDebug = () => {};
     server.logError = (...a) => process.stderr.write(a.join(' ') + '\n');
@@ -5171,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);
@@ -5210,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);
@@ -5467,6 +5559,7 @@ const PER_COMMAND_HELP = {
     --md <path>           Write the markdown to a file instead of stdout.
     --copy                Pipe the markdown to the platform clipboard (pbcopy/xclip/wl-copy/clip).
     --card                Compact 2-3 line status card (for terminal status widgets).
+    --watch [--interval N]  Re-render every N seconds (default 30, range 5-600). Ctrl+C to exit.
   Extract flags (pick one; each exits 3 if the section is empty):
     --next-only           First next_step only (for shell prompts).
     --next-steps          All next_steps, numbered.
@@ -6052,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);
@@ -6064,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.60.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": {