cf-memory-mcp 3.9.0 → 3.9.2

package/bin/cf-memory-mcp.js

@@ -809,25 +809,31 @@ class CFMemoryMCP {
      * a full re-index, just refresh the affected files.
      */
     async handleRefreshFiles(message) {
-        const args = (message.params && message.params.arguments) || {};
+        const payload = await this.refreshFilesCore(message.params?.arguments || {});
+        process.stdout.write(JSON.stringify({
+            jsonrpc: '2.0',
+            id: message.id,
+            result: { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] },
+        }) + '\n');
+    }
+
+    /**
+     * Core refresh-files logic: reads local files, uploads them, returns a
+     * payload. Extracted so the auto-refresh path can call it without
+     * needing to capture stdout (the previous approach of swapping
+     * process.stdout.write was racy against other concurrent messages).
+     */
+    async refreshFilesCore(args) {
         const projectIdOrName = args.project_id;
         const filePaths = Array.isArray(args.file_paths) ? args.file_paths : [];
         const projectRoot = args.project_root ? path.resolve(args.project_root)
             : (process.env.CF_MEMORY_WATCH_PATH || process.cwd());
 
-        const respond = (payload) => {
-            process.stdout.write(JSON.stringify({
-                jsonrpc: '2.0',
-                id: message.id,
-                result: { content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }] },
-            }) + '\n');
-        };
-
         if (!projectIdOrName) {
-            return respond({ error: 'project_id is required' });
+            return { error: 'project_id is required' };
         }
         if (filePaths.length === 0) {
-            return respond({ error: 'file_paths (string[]) is required' });
+            return { error: 'file_paths (string[]) is required' };
         }
 
         // Resolve to project ID via list_projects if a name was given.
@@ -872,26 +878,26 @@ class CFMemoryMCP {
         }
 
         if (files.length === 0) {
-            return respond({
+            return {
                 project_id: projectId,
                 files_refreshed: 0,
                 skipped,
                 hint: `All ${filePaths.length} file path(s) failed to read. Check that paths are relative to project_root (${projectRoot}). If the project was indexed from a different directory, pass project_root=<that directory>.`,
-            });
+            };
         }
 
         const uploadResult = await this.uploadFileBatch(projectId, files);
         const refreshed = (uploadResult && typeof uploadResult.files_indexed === 'number') ? uploadResult.files_indexed : 0;
         const chunks = (uploadResult && typeof uploadResult.chunks_created === 'number') ? uploadResult.chunks_created : 0;
 
-        return respond({
+        return {
             project_id: projectId,
             files_attempted: files.length,
             files_refreshed: refreshed,
             chunks_created: chunks,
             skipped,
             errors: uploadResult && Array.isArray(uploadResult.errors) ? uploadResult.errors : undefined,
-        });
+        };
     }
 
     /**
@@ -1656,10 +1662,15 @@ class CFMemoryMCP {
 
     /**
      * If the just-returned retrieve_context response had stale files,
-     * refresh them via refresh_files, re-run the original query, and
+     * refresh them via refreshFilesCore, re-run the original query, and
      * return the fresh response. Opt-in via CF_MEMORY_AUTO_REFRESH or
      * per-call `auto_refresh:true`. Guards against infinite loops by
      * stripping auto_refresh from the re-query.
+     *
+     * Uses refreshFilesCore (returns data directly) rather than
+     * handleRefreshFiles (writes to stdout). Avoids globally overriding
+     * process.stdout.write, which was racy against any other MCP message
+     * being handled concurrently in the same isolate.
      */
     async maybeAutoRefreshAndRequery(response, originalMessage) {
         try {
@@ -1676,33 +1687,27 @@ class CFMemoryMCP {
 
             _mcpTrace('AUTO_REFRESH', `${stalePaths.length} stale files; refreshing then re-querying`);
 
-            // Build a refresh_files message and invoke it via our own handler
-            const refreshMessage = {
-                jsonrpc: '2.0',
-                id: `auto-refresh-${Date.now()}`,
-                method: 'tools/call',
-                params: {
-                    name: 'refresh_files',
-                    arguments: {
-                        project_id: projectId,
-                        file_paths: stalePaths,
-                    },
-                },
-            };
-            // handleRefreshFiles writes to stdout itself; we need its work
-            // done but the output suppressed. Capture stdout for this call.
-            const origWrite = process.stdout.write.bind(process.stdout);
-            let captured = '';
-            process.stdout.write = (chunk) => {
-                captured += String(chunk);
-                return true;
-            };
-            try {
-                await this.handleRefreshFiles(refreshMessage);
-            } finally {
-                process.stdout.write = origWrite;
+            // Call core directly — no stdout override needed.
+            const refreshResult = await this.refreshFilesCore({
+                project_id: projectId,
+                file_paths: stalePaths,
+            });
+            _mcpTrace('AUTO_REFRESH_DONE', `refreshed=${refreshResult.files_refreshed || 0}`);
+
+            // If refresh itself errored or refreshed 0 files, return the
+            // original response with a clear note rather than re-querying
+            // and pretending the refresh succeeded.
+            if (refreshResult.error || (refreshResult.files_refreshed || 0) === 0) {
+                try {
+                    parsed.auto_refresh_failed = {
+                        attempted: stalePaths.length,
+                        error: refreshResult.error || 'refresh ran but indexed 0 files (paths may be unreadable or project_root mismatched)',
+                        skipped: refreshResult.skipped,
+                    };
+                    response.result.content[0].text = JSON.stringify(parsed);
+                } catch (_) { /* best-effort tag */ }
+                return response;
             }
-            _mcpTrace('AUTO_REFRESH_DONE', `refreshed ${stalePaths.length} files; captured=${captured.length}b`);
 
             // Re-run the original retrieve_context (without auto_refresh
             // to prevent loops). Server cache invalidates on write so the
@@ -1722,7 +1727,8 @@ class CFMemoryMCP {
                 if (freshText) {
                     const freshParsed = JSON.parse(freshText);
                     freshParsed.auto_refreshed = {
-                        files_refreshed: stalePaths.length,
+                        files_refreshed: refreshResult.files_refreshed,
+                        chunks_created: refreshResult.chunks_created || 0,
                         file_paths: stalePaths,
                     };
                     fresh.result.content[0].text = JSON.stringify(freshParsed);

package/package.json

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