cf-memory-mcp 3.11.0 → 3.13.0

package/bin/cf-memory-mcp.js

@@ -826,9 +826,30 @@ class CFMemoryMCP {
                 }
             }
 
+            // After end_session without keep_open, drop the implicit-session
+            // cache so a subsequent end_session creates a fresh session.
+            if (message.method === 'tools/call' && message.params?.name === 'end_session') {
+                this.clearImplicitSessionIfFinalized(message, response);
+            }
+
+            // After explicit start_session, cache the returned session_id as
+            // the implicit session for this cwd. Lets a subsequent
+            // end_session({handoff:{...}}) without session_id resolve to
+            // the just-created one.
+            if (message.method === 'tools/call' && message.params?.name === 'start_session') {
+                this.cacheImplicitSessionFromResponse(response);
+            }
+
             // Send response to stdout
             process.stdout.write(JSON.stringify(response) + '\n');
 
+            // Safety net: every N tool calls, if there's an active implicit
+            // session AND tracked activity, fire a background auto-checkpoint
+            // with a synthesized handoff. Catches agents that forget to call
+            // end_session before a crash or timeout. Fire-and-forget so it
+            // doesn't slow down the real response.
+            this.maybeAutoCheckpoint();
+
         } catch (error) {
             this.logError('Error handling message:', error);
             _mcpTrace('ERROR', `${error.message} elapsed=${Date.now()-_t0}ms`);
@@ -2119,22 +2140,35 @@ class CFMemoryMCP {
                 return;
             }
 
-            if (toolName === 'end_session' && args.handoff && typeof args.handoff === 'object') {
-                const meta = this.getRepoMetadata();
-                if (!args.handoff.repo_path && meta.repo_path) args.handoff.repo_path = meta.repo_path;
-                if (!args.handoff.branch && meta.branch) args.handoff.branch = meta.branch;
-                if (!args.handoff.project_id) {
-                    const fake = { params: { name: 'retrieve_context', arguments: {} } };
-                    await this.maybeFillProjectId(fake);
-                    if (fake.params.arguments.project_id) {
-                        args.handoff.project_id = fake.params.arguments.project_id;
+            if (toolName === 'end_session') {
+                // session_id auto-fill: if the caller didn't pass one, use
+                // the implicit session for this cwd. Lets agents call
+                // end_session({handoff:{...}}) without threading session_id
+                // through every checkpoint.
+                if (!args.session_id) {
+                    const implicit = await this.getOrCreateImplicitSession();
+                    if (implicit) {
+                        args.session_id = implicit;
+                        _mcpTrace('IMPLICIT_SESSION', `end_session using implicit session=${implicit}`);
+                    }
+                }
+                if (args.handoff && typeof args.handoff === 'object') {
+                    const meta = this.getRepoMetadata();
+                    if (!args.handoff.repo_path && meta.repo_path) args.handoff.repo_path = meta.repo_path;
+                    if (!args.handoff.branch && meta.branch) args.handoff.branch = meta.branch;
+                    if (!args.handoff.project_id) {
+                        const fake = { params: { name: 'retrieve_context', arguments: {} } };
+                        await this.maybeFillProjectId(fake);
+                        if (fake.params.arguments.project_id) {
+                            args.handoff.project_id = fake.params.arguments.project_id;
+                        }
                     }
+                    // Auto-fill files_read from observed retrieve_context /
+                    // get_file_content / get_file_outline calls during this
+                    // bridge session, if the agent didn't supply them. The
+                    // agent's hand-written files_touched stays authoritative.
+                    this.autoFillHandoffFilesRead(args.handoff);
                 }
-                // Auto-fill files_read from observed retrieve_context /
-                // get_file_content / get_file_outline calls during this
-                // bridge session, if the agent didn't supply them. The
-                // agent's hand-written files_touched stays authoritative.
-                this.autoFillHandoffFilesRead(args.handoff);
                 return;
             }
         } catch (err) {
@@ -2142,6 +2176,107 @@ class CFMemoryMCP {
         }
     }
 
+    /**
+     * Return the implicit session_id for the current cwd, creating one via
+     * start_session when no session is active. Lets agents skip explicit
+     * session management — they can go straight to end_session({handoff})
+     * for checkpoint or finalization.
+     *
+     * 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.
+     */
+    async getOrCreateImplicitSession() {
+        try {
+            const cwd = process.env.CF_MEMORY_WATCH_PATH || process.cwd();
+            if (!this._implicitSessionByCwd) this._implicitSessionByCwd = new Map();
+            const cached = this._implicitSessionByCwd.get(cwd);
+            if (cached) return cached;
+
+            // Lazily start a session, tagged with the same repo metadata as
+            // start_session would auto-attach if called explicitly.
+            const meta = this.getRepoMetadata();
+            const startArgs = { context: 'main' };
+            if (meta.repo_path) startArgs.repo_path = meta.repo_path;
+            if (meta.branch) startArgs.branch = meta.branch;
+            const fake = { params: { name: 'retrieve_context', arguments: {} } };
+            await this.maybeFillProjectId(fake);
+            if (fake.params.arguments.project_id) startArgs.project_id = fake.params.arguments.project_id;
+
+            const response = await this.makeRequest({
+                jsonrpc: '2.0',
+                id: `auto-session-${Date.now()}`,
+                method: 'tools/call',
+                params: { name: 'start_session', arguments: startArgs },
+            });
+            let sessionId = null;
+            try {
+                const payload = JSON.parse(response.result.content[0].text);
+                sessionId = payload.session_id;
+            } catch (_) { /* malformed response */ }
+            if (sessionId) {
+                this._implicitSessionByCwd.set(cwd, sessionId);
+                _mcpTrace('IMPLICIT_SESSION', `created implicit session=${sessionId} for cwd=${cwd}`);
+            }
+            return sessionId;
+        } catch (err) {
+            this.logDebug(`getOrCreateImplicitSession failed: ${err && err.message}`);
+            return null;
+        }
+    }
+
+    /**
+     * After an explicit start_session response, cache the returned session_id
+     * as the implicit session for the current cwd. This way the next
+     * end_session call without a session_id picks up the right one
+     * automatically.
+     */
+    cacheImplicitSessionFromResponse(response) {
+        try {
+            const text = response?.result?.content?.[0]?.text;
+            if (!text) return;
+            let parsed;
+            try { parsed = JSON.parse(text); } catch (_) { return; }
+            const sessionId = parsed?.session_id;
+            if (!sessionId) return;
+            const cwd = process.env.CF_MEMORY_WATCH_PATH || process.cwd();
+            if (!this._implicitSessionByCwd) this._implicitSessionByCwd = new Map();
+            this._implicitSessionByCwd.set(cwd, sessionId);
+            _mcpTrace('IMPLICIT_SESSION', `cached implicit session=${sessionId} for cwd=${cwd}`);
+        } catch (err) {
+            this.logDebug(`cacheImplicitSessionFromResponse failed: ${err && err.message}`);
+        }
+    }
+
+    /**
+     * Clear the implicit session for the current cwd after a non-keep_open
+     * end_session call. Lets a subsequent checkpoint create a fresh
+     * session instead of reusing a finalized one.
+     */
+    clearImplicitSessionIfFinalized(originalMessage, response) {
+        try {
+            if (originalMessage?.params?.name !== 'end_session') return;
+            const args = originalMessage.params.arguments || {};
+            if (args.keep_open) return; // checkpoint — keep cache
+            // Parse the response to confirm the session was actually ended
+            // (vs. an error). Don't clear if the server errored.
+            const text = response?.result?.content?.[0]?.text;
+            if (!text) return;
+            try {
+                const parsed = JSON.parse(text);
+                if (parsed?.error || parsed?.kept_open) return;
+            } catch (_) { return; }
+
+            const cwd = process.env.CF_MEMORY_WATCH_PATH || process.cwd();
+            if (this._implicitSessionByCwd?.has(cwd)) {
+                this._implicitSessionByCwd.delete(cwd);
+                _mcpTrace('IMPLICIT_SESSION', `cleared implicit session for cwd=${cwd}`);
+            }
+        } catch (err) {
+            this.logDebug(`clearImplicitSessionIfFinalized failed: ${err && err.message}`);
+        }
+    }
+
     /**
      * Record file paths the agent touched via retrieve_context, get_file_content,
      * get_file_outline, and refresh_files. Used to seed end_session.handoff.files_read
@@ -2174,11 +2309,85 @@ class CFMemoryMCP {
             } else if (toolName === 'refresh_files' && Array.isArray(args.file_paths)) {
                 for (const p of args.file_paths) noteFile(p, 'refresh_files');
             }
+
+            // Remember the most recent retrieve_context query so auto-checkpoints
+            // have something concrete to put in the synthesized handoff.goal.
+            if (toolName === 'retrieve_context' && typeof args.query === 'string' && args.query.trim()) {
+                this._lastRetrieveQuery = args.query.trim();
+            }
+
+            // Tool-call counter for auto-checkpoint safety net. Counts all
+            // tool/call messages; auto-checkpoint fires every N calls.
+            this._toolCallCount = (this._toolCallCount || 0) + 1;
         } catch (err) {
             this.logDebug(`trackToolActivity failed: ${err && err.message}`);
         }
     }
 
+    /**
+     * Fire-and-forget auto-checkpoint. Every N tool calls, if there's an
+     * active implicit session AND there's been meaningful activity, send a
+     * background end_session({keep_open:true}) with a synthesized handoff.
+     * This is the safety net for agents that forget (or crash) before
+     * calling end_session manually.
+     *
+     * Behavior:
+     *   - Only fires when an implicit session exists (no surprise creation)
+     *   - Synthesizes handoff.goal from the last retrieve_context query
+     *   - Pulls files_read from activity tracker
+     *   - keep_open=true so the user can still finalize properly
+     *   - Failures are silent — never blocks the real tool call
+     */
+    async maybeAutoCheckpoint() {
+        try {
+            const intervalEnv = parseInt(process.env.CF_MEMORY_CHECKPOINT_EVERY || '25', 10);
+            const interval = Number.isFinite(intervalEnv) && intervalEnv > 0 ? intervalEnv : 25;
+            const opt = process.env.CF_MEMORY_AUTO_CHECKPOINT;
+            // Opt-out by env. Default is on. Set to 0/false/off to disable.
+            const enabled = !(opt === '0' || opt === 'false' || opt === 'off');
+            if (!enabled) return;
+            const count = this._toolCallCount || 0;
+            if (count === 0 || count % interval !== 0) return;
+            const cwd = process.env.CF_MEMORY_WATCH_PATH || process.cwd();
+            const sessionId = this._implicitSessionByCwd?.get(cwd);
+            if (!sessionId) return; // no implicit session, nothing to checkpoint
+            // Require at least one tracked file so we don't spam empty handoffs.
+            if (!this._activityFiles || this._activityFiles.size === 0) return;
+
+            // Synthesize handoff.
+            const meta = this.getRepoMetadata();
+            const fake = { params: { name: 'retrieve_context', arguments: {} } };
+            await this.maybeFillProjectId(fake);
+            const handoff = {
+                goal: this._lastRetrieveQuery
+                    ? `Working on: ${this._lastRetrieveQuery.slice(0, 120)}`
+                    : `Auto-checkpoint at ${count} tool calls`,
+                status: 'in_progress',
+            };
+            if (meta.repo_path) handoff.repo_path = meta.repo_path;
+            if (meta.branch) handoff.branch = meta.branch;
+            if (fake.params.arguments.project_id) handoff.project_id = fake.params.arguments.project_id;
+            this.autoFillHandoffFilesRead(handoff);
+
+            // Fire-and-forget — don't block the real response on this.
+            // Awaiting would serialise auto-checkpoint behind the main
+            // request path. Failures are logged at debug only.
+            this.makeRequest({
+                jsonrpc: '2.0',
+                id: `auto-checkpoint-${Date.now()}`,
+                method: 'tools/call',
+                params: { name: 'end_session', arguments: {
+                    session_id: sessionId,
+                    keep_open: true,
+                    handoff,
+                } },
+            }).catch(err => this.logDebug(`auto-checkpoint failed: ${err && err.message}`));
+            _mcpTrace('AUTO_CHECKPOINT', `session=${sessionId} after ${count} calls files=${this._activityFiles.size}`);
+        } catch (err) {
+            this.logDebug(`maybeAutoCheckpoint failed: ${err && err.message}`);
+        }
+    }
+
     /**
      * Record file paths from a retrieve_context response. Called after the
      * server responds so we capture what was actually returned (not just

package/package.json

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