cf-memory-mcp 3.9.4 → 3.9.6

package/README.md

@@ -25,8 +25,8 @@ The active runtime is at [src-simplified/index.ts](src-simplified/index.ts). It
 - Code indexing with `index_project` and `index_github`
 - Retrieval with `retrieve_context` (3-lane hybrid + cross-encoder rerank, returns `file_imports` + `source_kind` + `citation`)
 - Code relationship graph with `get_related_code` (calls, imports, extends, implements)
-- Project exploration with `list_files`, `list_projects`, `get_stats`, `get_file_outline`, `get_file_content`
-- **Staleness handling**: `find_stale_files`, `refresh_files`, `refresh_stale`. Results auto-tag stale chunks with a `stale_refresh_hint` showing the exact call to fix them.
+- Project exploration with `list_files`, `list_projects`, `get_stats`, `get_file_outline`, `get_file_content` (bridge reads local file byte-exact when resolvable; falls back to chunk-reconstruction with `reconstruction_warning` + `missing_line_ranges`)
+- **Staleness handling**: `find_stale_files`, `refresh_files`, `refresh_stale`. Results auto-tag stale chunks with a `stale_refresh_hint` showing the exact call to fix them. Set `CF_MEMORY_AUTO_REFRESH=true` (or pass `auto_refresh:true`) to have the bridge transparently refresh + re-query before returning.
 - Assistant memory tools (`store_memory`, `retrieve_memories`, `get_context_bootstrap`, `delete_memory`)
 - Session tracking with `start_session`, `end_session`
 - Structured entity storage with `store_entity`
@@ -64,6 +64,7 @@ Useful environment variables:
 - `CF_MEMORY_TRACE=1` — verbose request/response logging to `/tmp/cf-memory-mcp.log` (rotates at 5MB)
 - `CF_MEMORY_PROGRESS=true` — stream per-file indexing progress via SSE to stderr during `index_project`
 - `CF_MEMORY_AUTO_WATCH=true` — watch the project directory and auto-reindex on file change
+- `CF_MEMORY_AUTO_REFRESH=true` — when retrieve_context returns stale chunks, transparently refresh the changed files and re-query before returning (new in v3.9.0). Removes the find_stale → refresh → re-query loop.
 - `CF_MEMORY_WATCH_PATH=/path/to/project` — explicit project root (defaults to bridge's `cwd`)
 - `CF_MEMORY_PROJECT_NAME=my-project` — display name when auto-watch indexes the project
 

package/bin/cf-memory-mcp.js

@@ -1801,22 +1801,45 @@ class CFMemoryMCP {
                 projectRoot = process.env.CF_MEMORY_WATCH_PATH || process.cwd();
             }
 
-            // Try exact path first, then walk up substring matches under root
-            const candidates = [
-                path.resolve(projectRoot, filePath),
-                path.resolve(filePath),
-            ];
-            let resolvedFull = null;
-            for (const c of candidates) {
-                try {
-                    const stat = fs.statSync(c);
-                    if (stat.isFile()) {
-                        resolvedFull = c;
-                        break;
-                    }
-                } catch (_) { /* try next */ }
+            // Resolve the file_path against the project root and HARD-CONFINE
+            // the result to be inside the project root. Without this check the
+            // tool became a general filesystem reader — `file_path: "/etc/hosts"`
+            // or `file_path: "../../../etc/passwd"` would both serve those
+            // files because path.resolve treats absolute file_paths as-is and
+            // doesn't enforce ancestry. This is a security finding from codex
+            // review; fix before reading anything off disk.
+            //
+            // Also dereference symlinks via fs.realpathSync — without this,
+            // an attacker could create a symlink inside the project root
+            // pointing at /etc/passwd and the relative-path check would
+            // still pass (the symlink itself is in-root). realpath gives
+            // the underlying target which we then check the same way.
+            const normalizedRoot = (() => {
+                try { return fs.realpathSync(path.resolve(projectRoot)); }
+                catch (_) { return path.resolve(projectRoot); }
+            })();
+            const candidateFull = path.resolve(normalizedRoot, filePath);
+            let resolvedFull;
+            try {
+                resolvedFull = fs.realpathSync(candidateFull);
+            } catch (_) {
+                return false; // doesn't exist or unreadable
+            }
+            // Path must be strictly under the (real) project root. `relative`
+            // returns an empty string for the root itself and a `..`-prefixed
+            // string for anything outside. Use the realpath of both sides so
+            // symlinks can't smuggle the target out of the root.
+            const relative = path.relative(normalizedRoot, resolvedFull);
+            if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) {
+                _mcpTrace('GFC_LOCAL_REJECT_ESCAPE', `${filePath} -> ${resolvedFull} escapes root ${normalizedRoot}`);
+                return false;
+            }
+            try {
+                const probe = fs.statSync(resolvedFull);
+                if (!probe.isFile()) return false;
+            } catch (_) {
+                return false;
             }
-            if (!resolvedFull) return false;
 
             // Guard against blowing memory on huge files (binary blobs, big
             // SQL dumps, etc). 10MB is plenty for any source file the
@@ -1849,7 +1872,11 @@ class CFMemoryMCP {
             const language = extToLang[ext] || null;
 
             const payload = {
-                file_path: path.relative(projectRoot, resolvedFull) || path.basename(resolvedFull),
+                // Use normalizedRoot (the realpath'd root) to match resolvedFull
+                // (also realpath'd). Using the original projectRoot here gave
+                // weird relative paths on macOS where /tmp is a symlink to
+                // /private/tmp.
+                file_path: path.relative(normalizedRoot, resolvedFull) || path.basename(resolvedFull),
                 language,
                 total_lines: totalLines,
                 size_bytes: stat.size,
@@ -2274,23 +2301,30 @@ if (process.argv.includes('--diagnose')) {
     return;
 }
 
-// Check API key before starting server
-if (!API_KEY) {
-    console.error('Error: CF_MEMORY_API_KEY environment variable is required');
-    console.error('');
-    console.error('Please set your API key:');
-    console.error('  export CF_MEMORY_API_KEY="your-api-key-here"');
-    console.error('');
-    console.error('Or run with:');
-    console.error('  CF_MEMORY_API_KEY="your-api-key-here" npx cf-memory-mcp');
-    console.error('');
-    console.error(`Target server: ${BASE_URL}`);
-    process.exit(1);
+// Only run the entry-point side effects when invoked directly (not when
+// require()'d from a test or downstream tool). This guard lets the test
+// suite import CFMemoryMCP without triggering the API-key check and
+// starting the stdio listener.
+if (require.main === module) {
+    if (!API_KEY) {
+        console.error('Error: CF_MEMORY_API_KEY environment variable is required');
+        console.error('');
+        console.error('Please set your API key:');
+        console.error('  export CF_MEMORY_API_KEY="your-api-key-here"');
+        console.error('');
+        console.error('Or run with:');
+        console.error('  CF_MEMORY_API_KEY="your-api-key-here" npx cf-memory-mcp');
+        console.error('');
+        console.error(`Target server: ${BASE_URL}`);
+        process.exit(1);
+    }
+
+    const server = new CFMemoryMCP();
+    server.start().catch(error => {
+        console.error('Failed to start CF Memory MCP server:', error.message);
+        process.exit(1);
+    });
 }
 
-// Start the MCP server
-const server = new CFMemoryMCP();
-server.start().catch(error => {
-    console.error('Failed to start CF Memory MCP server:', error.message);
-    process.exit(1);
-});
+// Export for tests/downstream tools
+module.exports = { CFMemoryMCP };

package/package.json

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