cf-memory-mcp 3.11.0 → 3.12.0

package/bin/cf-memory-mcp.js

@@ -826,6 +826,20 @@ 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');
 
@@ -2119,22 +2133,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 +2169,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

package/package.json

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