cf-memory-mcp 3.23.0 → 3.25.0

package/bin/cf-memory-mcp.js

@@ -434,13 +434,40 @@ class CFMemoryMCP {
         this.logDebug(`User Agent: ${this.userAgent}`);
     }
 
+    /**
+     * Append a line to the persistent bridge log file if configured.
+     * Honors CF_MEMORY_LOG_FILE (explicit path) or CF_MEMORY_LOG=1/true
+     * (defaults to ~/.cf-memory/bridge.log). Bounded: rotates when the
+     * file exceeds 5MB to prevent runaway disk usage.
+     */
+    appendBridgeLog(line) {
+        try {
+            const explicit = process.env.CF_MEMORY_LOG_FILE;
+            const enabled = explicit || process.env.CF_MEMORY_LOG === '1' || process.env.CF_MEMORY_LOG === 'true';
+            if (!enabled) return;
+            const target = explicit || path.join(os.homedir(), '.cf-memory', 'bridge.log');
+            const dir = path.dirname(target);
+            if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+            // Rotate if file > 5MB.
+            try {
+                const st = fs.statSync(target);
+                if (st.size > 5 * 1024 * 1024) {
+                    fs.renameSync(target, target + '.1');
+                }
+            } catch (_) { /* file doesn't exist yet */ }
+            fs.appendFileSync(target, line);
+        } catch (_) { /* logging failure is non-fatal */ }
+    }
+
     /**
      * Log debug messages to stderr (won't interfere with MCP communication)
      */
     logDebug(message) {
+        const line = `[DEBUG] ${new Date().toISOString()} ${message}\n`;
         if (process.env.DEBUG || process.env.MCP_DEBUG) {
-            process.stderr.write(`[DEBUG] ${new Date().toISOString()} ${message}\n`);
+            process.stderr.write(line);
         }
+        this.appendBridgeLog(line);
     }
 
     /**
@@ -448,9 +475,13 @@ class CFMemoryMCP {
      */
     logError(message, error = null) {
         const timestamp = new Date().toISOString();
-        process.stderr.write(`[ERROR] ${timestamp} ${message}\n`);
+        const line1 = `[ERROR] ${timestamp} ${message}\n`;
+        process.stderr.write(line1);
+        this.appendBridgeLog(line1);
         if (error && error.stack) {
-            process.stderr.write(`[ERROR] ${timestamp} ${error.stack}\n`);
+            const line2 = `[ERROR] ${timestamp} ${error.stack}\n`;
+            process.stderr.write(line2);
+            this.appendBridgeLog(line2);
         }
     }
 
@@ -3718,6 +3749,9 @@ Usage:
   npx cf-memory-mcp resume [id]     Print the prior resume handoff (markdown)
   npx cf-memory-mcp list            List recent handoffs for cwd
   npx cf-memory-mcp checkpoint ["<goal>"]  Snapshot current state (keep_open)
+  npx cf-memory-mcp status          Show bridge state + server resume availability
+  npx cf-memory-mcp clean           Delete local disk cache for current cwd
+  npx cf-memory-mcp clean --all     Delete ALL local disk caches
   npx cf-memory-mcp --version       Show version
   npx cf-memory-mcp --help          Show this help
   npx cf-memory-mcp --diagnose      Test connectivity and report issues
@@ -3896,6 +3930,141 @@ async function runListCli() {
     }
 }
 
+async function runCleanCli() {
+    const { flags, positional } = parseCliArgs(process.argv.slice(3));
+    const all = positional.includes('--all') || process.argv.includes('--all');
+    const server = new CFMemoryMCP();
+    server.logDebug = () => {};
+    const removed = [];
+    try {
+        if (all) {
+            // Clear ALL disk caches in ~/.cf-memory/.
+            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 full = path.join(dir, entry);
+                        fs.unlinkSync(full);
+                        removed.push(full);
+                    }
+                }
+            }
+        } else {
+            const p = server.getDiskCachePath();
+            if (p && fs.existsSync(p)) {
+                fs.unlinkSync(p);
+                removed.push(p);
+            }
+        }
+        if (flags.json) {
+            process.stdout.write(JSON.stringify({ removed }, null, 2) + '\n');
+            process.exit(0);
+        }
+        if (removed.length === 0) {
+            process.stdout.write('(nothing to clean)\n');
+        } else {
+            process.stdout.write(`Removed ${removed.length} cache file${removed.length === 1 ? '' : 's'}:\n`);
+            for (const r of removed) process.stdout.write(`  ${r}\n`);
+        }
+        process.exit(0);
+    } catch (err) {
+        console.error('clean command failed:', err.message);
+        process.exit(1);
+    }
+}
+
+async function runStatusCli() {
+    const { flags } = parseCliArgs(process.argv.slice(3));
+    const server = new CFMemoryMCP();
+    server.logDebug = () => {};
+    server.logError = (...a) => process.stderr.write(a.join(' ') + '\n');
+    try {
+        // Local bridge state (no network call required).
+        const meta = server.getRepoMetadata();
+        const cwd = process.env.CF_MEMORY_WATCH_PATH || process.cwd();
+        const diskCachePath = server.getDiskCachePath();
+        const diskCacheExists = diskCachePath && fs.existsSync(diskCachePath);
+        let diskCacheAge = null;
+        if (diskCacheExists) {
+            try {
+                const entry = JSON.parse(fs.readFileSync(diskCachePath, 'utf8'));
+                diskCacheAge = Math.round((Date.now() - new Date(entry.cached_at).getTime()) / 60000);
+            } catch (_) { /* unreadable cache */ }
+        }
+        // Lookup the live worker count of handoffs for this cwd (best-effort).
+        let serverHandoffCount = null;
+        let resumeAvailable = false;
+        let latestGoal = null;
+        if (API_KEY) {
+            try {
+                const args = { resume: true };
+                if (meta.repo_path) args.repo_path = meta.repo_path;
+                if (meta.branch) args.branch = meta.branch;
+                const fake = { params: { name: 'retrieve_context', arguments: {} } };
+                await server.maybeFillProjectId(fake);
+                if (fake.params.arguments.project_id) args.project_id = fake.params.arguments.project_id;
+                const response = await server.makeRequest({
+                    jsonrpc: '2.0',
+                    id: `cli-status-${Date.now()}`,
+                    method: 'tools/call',
+                    params: { name: 'get_context_bootstrap', arguments: args },
+                });
+                const text = response?.result?.content?.[0]?.text;
+                const payload = JSON.parse(text || '{}');
+                serverHandoffCount = Array.isArray(payload.recent_handoffs) ? payload.recent_handoffs.length : 0;
+                resumeAvailable = !!payload.resume_handoff;
+                latestGoal = payload.resume_handoff?.handoff?.goal || null;
+            } catch (err) {
+                // Network unreachable — that's OK, we still have local info.
+            }
+        }
+
+        const status = {
+            version: PACKAGE_VERSION,
+            cwd,
+            repo_path: meta.repo_path || null,
+            branch: meta.branch || null,
+            base_url: BASE_URL,
+            api_key_set: !!API_KEY,
+            disk_cache: diskCacheExists
+                ? { path: diskCachePath, age_minutes: diskCacheAge }
+                : null,
+            server: API_KEY
+                ? { handoff_count: serverHandoffCount, resume_available: resumeAvailable, latest_goal: latestGoal }
+                : { reachable: false, reason: 'CF_MEMORY_API_KEY not set' },
+        };
+
+        if (flags.json) {
+            process.stdout.write(JSON.stringify(status, null, 2) + '\n');
+            process.exit(0);
+        }
+        process.stdout.write(`cf-memory-mcp v${PACKAGE_VERSION}\n`);
+        process.stdout.write(`  cwd:       ${cwd}\n`);
+        if (meta.repo_path) process.stdout.write(`  repo:      ${meta.repo_path}\n`);
+        if (meta.branch) process.stdout.write(`  branch:    ${meta.branch}\n`);
+        process.stdout.write(`  server:    ${BASE_URL}${API_KEY ? '' : ' (no API key set)'}\n`);
+        if (diskCacheExists) {
+            process.stdout.write(`  cache:     ${diskCachePath} (${diskCacheAge}m old)\n`);
+        } else {
+            process.stdout.write(`  cache:     (none)\n`);
+        }
+        if (API_KEY) {
+            if (resumeAvailable) {
+                process.stdout.write(`  resume:    ✓ available — "${latestGoal || '(no goal)'}"\n`);
+            } else {
+                process.stdout.write(`  resume:    (no handoff for this context)\n`);
+            }
+            if (serverHandoffCount !== null) {
+                process.stdout.write(`  threads:   ${serverHandoffCount} recent handoff${serverHandoffCount === 1 ? '' : 's'}\n`);
+            }
+        }
+        process.exit(0);
+    } catch (err) {
+        console.error('status command failed:', err.message);
+        process.exit(1);
+    }
+}
+
 async function runCheckpointCli() {
     if (!API_KEY) {
         console.error('Error: CF_MEMORY_API_KEY environment variable is required');
@@ -3983,6 +4152,16 @@ if (process.argv[2] === 'checkpoint') {
     return;
 }
 
+if (process.argv[2] === 'status') {
+    runStatusCli();
+    return;
+}
+
+if (process.argv[2] === 'clean') {
+    runCleanCli();
+    return;
+}
+
 if (process.argv.includes('--diagnose')) {
     (async () => {
         console.log(`CF Memory MCP v${PACKAGE_VERSION} - Diagnostics`);

package/package.json

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