cf-memory-mcp 3.29.0 → 3.31.0

package/bin/cf-memory-mcp.js

@@ -408,6 +408,17 @@ const TOOLS_LIST = [
                 older_than_days: { type: 'number', description: 'Delete memories created more than N days ago' }
             }
         }
+    },
+    {
+        name: 'delete_session',
+        description: 'Delete a session row and any session_summary memories tied to it. Use to remove test sessions or accidental handoffs. Different from end_session — this physically removes the row. Pass the full UUID (not a prefix).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string', description: 'Full session UUID to delete.' }
+            },
+            required: ['session_id']
+        }
     }
 ];
 
@@ -3001,7 +3012,19 @@ class CFMemoryMCP {
                 cwd: process.env.CF_MEMORY_WATCH_PATH || process.cwd(),
                 response_text: text,
             };
-            fs.writeFileSync(p, JSON.stringify(entry, null, 2));
+            // Atomic write: serialize to a sibling .tmp then rename so a
+            // crash mid-write never leaves a corrupt JSON file. rename(2)
+            // is atomic on POSIX. On Windows it may fail if the target
+            // exists, so fall back to a direct write there.
+            const tmp = `${p}.tmp.${process.pid}`;
+            try {
+                fs.writeFileSync(tmp, JSON.stringify(entry, null, 2));
+                fs.renameSync(tmp, p);
+            } catch (renameErr) {
+                // Fallback: direct write. Best-effort cleanup of .tmp.
+                try { fs.unlinkSync(tmp); } catch (_) { /* ignore */ }
+                fs.writeFileSync(p, JSON.stringify(entry, null, 2));
+            }
             _mcpTrace('DISK_CACHE', `saved resume packet to ${p}`);
         } catch (err) {
             this.logDebug(`saveResumeToDisk failed: ${err && err.message}`);
@@ -3780,7 +3803,7 @@ if (process.argv.includes('--version') || process.argv.includes('-v')) {
 
 // Global --help only when no subcommand is present. With a subcommand, fall
 // through to the per-command help dispatch below.
-const SUBCOMMANDS = new Set(['resume', 'list', 'checkpoint', 'status', 'clean', 'export', 'import', 'doctor', 'completion']);
+const SUBCOMMANDS = new Set(['resume', 'list', 'checkpoint', 'status', 'clean', 'export', 'import', 'doctor', 'completion', 'delete', 'env']);
 const hasSubcommand = process.argv[2] && SUBCOMMANDS.has(process.argv[2]);
 
 if (!hasSubcommand && (process.argv.includes('--help') || process.argv.includes('-h'))) {
@@ -3799,7 +3822,9 @@ Usage:
   npx cf-memory-mcp clean --all     Delete ALL local disk caches
   npx cf-memory-mcp export <id>     Print a session's handoff as JSON bundle (backup)
   npx cf-memory-mcp import <file>   Restore a handoff bundle (cross-machine sync); use "-" for stdin
+  npx cf-memory-mcp delete <id>     Delete a session and its associated memories
   npx cf-memory-mcp doctor          Diagnose common setup issues
+  npx cf-memory-mcp env             Print all CF_MEMORY_* env vars + descriptions
   npx cf-memory-mcp completion bash Output shell completion script (bash|zsh|fish)
   npx cf-memory-mcp <cmd> --help    Show flags for a specific command
   npx cf-memory-mcp --version       Show version
@@ -4010,9 +4035,107 @@ async function runListCli() {
     }
 }
 
+async function runDeleteCli() {
+    if (!API_KEY) {
+        console.error('Error: CF_MEMORY_API_KEY environment variable is required');
+        process.exit(1);
+    }
+    const { positional, flags } = parseCliArgs(process.argv.slice(3));
+    const idArg = positional[0];
+    if (!idArg) {
+        console.error('Usage: cf-memory-mcp delete <session-id-or-prefix>');
+        process.exit(1);
+    }
+    const server = new CFMemoryMCP();
+    server.logDebug = () => {};
+    try {
+        // Resolve prefix to full id via get_context_bootstrap. The server's
+        // delete_session requires a full UUID (no implicit prefix).
+        let fullId = idArg;
+        if (idArg.length < 36) {
+            const resolveRes = await server.makeRequest({
+                jsonrpc: '2.0', id: `cli-delete-resolve-${Date.now()}`,
+                method: 'tools/call',
+                params: { name: 'get_context_bootstrap', arguments: { resume: true, session_id_hint: idArg } },
+            });
+            const resolveText = resolveRes?.result?.content?.[0]?.text;
+            const resolvePayload = JSON.parse(resolveText || '{}');
+            if (resolvePayload.resume_handoff?.session_id) {
+                fullId = resolvePayload.resume_handoff.session_id;
+            } else {
+                process.stderr.write((resolvePayload.empty_hint || `Could not resolve "${idArg}" to a full session id.`) + '\n');
+                process.exit(3);
+            }
+        }
+
+        const deleteRes = await server.makeRequest({
+            jsonrpc: '2.0', id: `cli-delete-${Date.now()}`,
+            method: 'tools/call',
+            params: { name: 'delete_session', arguments: { session_id: fullId } },
+        });
+        const deleteText = deleteRes?.result?.content?.[0]?.text;
+        const payload = JSON.parse(deleteText || '{}');
+        if (flags.json) {
+            process.stdout.write(JSON.stringify({ ...payload, session_id: fullId }, null, 2) + '\n');
+            process.exit(payload.deleted ? 0 : 3);
+        }
+        if (payload.deleted) {
+            process.stdout.write(`Deleted session ${fullId.slice(0,8)} (and ${payload.cleaned_memories || 0} associated memories).\n`);
+            process.exit(0);
+        } else {
+            process.stderr.write(`Session ${fullId} not found (or not yours).\n`);
+            process.exit(3);
+        }
+    } catch (err) {
+        console.error('delete command failed:', err.message);
+        process.exit(1);
+    }
+}
+
+function runEnvCli() {
+    const { flags } = parseCliArgs(process.argv.slice(3));
+    // Every env var the bridge reads, with default + description.
+    const vars = [
+        ['CF_MEMORY_API_KEY', 'required: your CF Memory API key'],
+        ['CF_MEMORY_BASE_URL', `default: ${BASE_URL}; override to point at a different worker`],
+        ['CF_MEMORY_WATCH_PATH', `default: cwd; use to override the repo path the bridge auto-detects`],
+        ['CF_MEMORY_AUTO_REFRESH', 'default: off; "1"/"true" auto-refreshes stale chunks before re-querying retrieve_context'],
+        ['CF_MEMORY_AUTO_CHECKPOINT', 'default: on; "off" disables the every-25-tool-calls auto-checkpoint'],
+        ['CF_MEMORY_CHECKPOINT_EVERY', 'default: 25; tool-call interval between auto-checkpoints'],
+        ['CF_MEMORY_AUTO_HANDOFF', 'default: on; "off" disables synthesis of a minimal handoff when end_session is called without one'],
+        ['CF_MEMORY_SHUTDOWN_HANDOFF', 'default: on; "off" disables the SIGINT/SIGTERM handoff flush'],
+        ['CF_MEMORY_PREWARM_RESUME', 'default: on; "off" disables the background resume prewarm at bridge startup'],
+        ['CF_MEMORY_RESUME_DIFF', 'default: on; "off" disables git-diff injection into resume responses'],
+        ['CF_MEMORY_DISK_CACHE', 'default: on; "off" disables ~/.cf-memory/handoff-*.json disk caching'],
+        ['CF_MEMORY_NO_RETRY', 'default: off; "1" disables the single retry-on-transient-failure'],
+        ['CF_MEMORY_LOG', 'default: off; "1" writes DEBUG/ERROR lines to ~/.cf-memory/bridge.log'],
+        ['CF_MEMORY_LOG_FILE', 'default: ~/.cf-memory/bridge.log; override the log file path'],
+        ['CF_MEMORY_TRACE', 'default: off; "1" emits structured MCP traces to stderr'],
+        ['CF_MEMORY_PROGRESS', 'default: off; "true" streams indexing progress events to stderr'],
+        ['CF_MEMORY_AUTO_WATCH', 'default: off; "1" starts a filesystem watcher that auto-reindexes on change'],
+        ['DEBUG', 'default: off; "1" enables debug logging on stderr'],
+        ['MCP_DEBUG', 'default: off; "1" enables MCP-protocol debug logging on stderr'],
+    ];
+    if (flags.json) {
+        const out = {};
+        for (const [name, desc] of vars) {
+            out[name] = { value: process.env[name] || null, description: desc };
+        }
+        process.stdout.write(JSON.stringify(out, null, 2) + '\n');
+        process.exit(0);
+    }
+    process.stdout.write(`cf-memory-mcp env vars (set = bold value, unset = "(unset)"):\n\n`);
+    for (const [name, desc] of vars) {
+        const val = process.env[name];
+        const display = val ? `"${name === 'CF_MEMORY_API_KEY' && val ? '(redacted)' : val}"` : '(unset)';
+        process.stdout.write(`  ${name.padEnd(30)} ${display}\n    ${desc}\n\n`);
+    }
+    process.exit(0);
+}
+
 function runCompletionCli() {
     const shell = process.argv[3] || 'bash';
-    const commands = ['resume', 'list', 'checkpoint', 'status', 'clean', 'export', 'import', 'doctor', 'completion'];
+    const commands = ['resume', 'list', 'checkpoint', 'status', 'clean', 'export', 'import', 'delete', 'doctor', 'env', 'completion'];
     const flags = ['--json', '-j', '--limit', '-n', '--md', '--all', '--force', '-f', '--version', '-v', '--help', '-h', '--diagnose'];
     if (shell === 'bash') {
         process.stdout.write(`# cf-memory-mcp bash completion
@@ -4121,6 +4244,16 @@ const PER_COMMAND_HELP = {
     --json, -j            Emit a JSON list of checks.`,
     completion: `cf-memory-mcp completion [bash|zsh|fish]
   Output shell completion script. Pipe to your shell's completion dir.`,
+    delete: `cf-memory-mcp delete <session-id-or-prefix> [--json]
+  Delete a session row and its associated session_summary memories.
+    <session-id>          Full UUID or short prefix (>=8 chars). The CLI
+                          resolves prefix to a full id via the server.
+    --json, -j            Emit a JSON status object.
+  Exit codes: 0 = deleted, 3 = not found / could not resolve.`,
+    env: `cf-memory-mcp env [--json]
+  Print all CF_MEMORY_* env vars the bridge reads, with their current
+  values + descriptions. Useful for discovering knobs.
+    --json, -j            Emit JSON for scripts.`,
 };
 
 function printPerCommandHelp(cmd) {
@@ -4693,6 +4826,16 @@ if (process.argv[2] === 'completion') {
     return;
 }
 
+if (process.argv[2] === 'delete') {
+    runDeleteCli();
+    return;
+}
+
+if (process.argv[2] === 'env') {
+    runEnvCli();
+    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.29.0",
+	"version": "3.31.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": {