cloudflare-mcp-smart-proxy 1.5.7 → 1.5.9

package/index.js

@@ -17,6 +17,7 @@ import { sanitizeProxyError, SmartRouter } from './src/router.js';
 import { LocalToolExecutor } from './src/local-tools.js';
 import { ConnectorBridge } from './src/connector-bridge.js';
 import { LocalMemoryCoordinator } from './src/local-memory-coordinator.js';
+import { resolveClientProjectRoot } from './src/client-project-scope.js';
 import fs from 'fs';
 
 // 从环境变量读取配置
@@ -104,9 +105,37 @@ const server = new Server(
   }
 );
 
+let projectScopeRefresh = null;
+
+async function refreshProjectScope() {
+  if (!connectorBridge.isConfigured()) return connectorBridge.getBridgeStatus();
+  if (projectScopeRefresh) return projectScopeRefresh;
+  projectScopeRefresh = (async () => {
+    const clientRoot = await resolveClientProjectRoot(server, connectorBridge.workspaceRoot);
+    if (!clientRoot.workspaceRoot) {
+      connectorBridge.setProjectRootWarning(clientRoot.warning, clientRoot.roots);
+      return connectorBridge.getBridgeStatus();
+    }
+    if (
+      connectorBridge.workspaceRoot !== clientRoot.workspaceRoot
+      || !connectorBridge.state.workspaceResolution
+    ) {
+      await connectorBridge.resolveCurrentWorkspace(clientRoot.workspaceRoot);
+    }
+    localTools.workspaceRoot = clientRoot.workspaceRoot;
+    router.workspaceRoot = clientRoot.workspaceRoot;
+    memoryCoordinator.bindWorkspace(clientRoot.workspaceRoot, connectorBridge.workspaceId);
+    return connectorBridge.getBridgeStatus();
+  })().finally(() => {
+    projectScopeRefresh = null;
+  });
+  return projectScopeRefresh;
+}
+
 // 工具列表处理器
 server.setRequestHandler(ListToolsRequestSchema, async () => {
   try {
+    await refreshProjectScope();
     const tools = await router.getAllTools();
     return { tools };
   } catch (error) {
@@ -133,6 +162,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
   }
 
   try {
+    await refreshProjectScope();
     const result = await router.executeTool(name, args || {});
     
     // 格式化响应

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloudflare-mcp-smart-proxy",
-  "version": "1.5.7",
+  "version": "1.5.9",
   "description": "Smart proxy for Cloudflare MCP - routes tools to cloud or local execution",
   "repository": {
     "type": "git",

package/src/client-project-scope.js

@@ -0,0 +1,63 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+function normalizeRootUri(uri) {
+  if (typeof uri !== 'string' || !uri.trim()) return null;
+  try {
+    const parsed = new URL(uri);
+    if (parsed.protocol !== 'file:') return null;
+    return path.resolve(fileURLToPath(parsed));
+  } catch {
+    return null;
+  }
+}
+
+export async function resolveClientProjectRoot(server, fallbackRoot = process.cwd()) {
+  if (!server?.getClientCapabilities?.()?.roots || typeof server.listRoots !== 'function') {
+    return {
+      status: 'fallback',
+      workspaceRoot: path.resolve(fallbackRoot),
+      roots: []
+    };
+  }
+  let result;
+  try {
+    result = await server.listRoots();
+  } catch (error) {
+    return {
+      status: 'warning',
+      workspaceRoot: null,
+      roots: [],
+      warning: {
+        code: 'CLIENT_PROJECT_ROOT_LOOKUP_FAILED',
+        severity: 'warning',
+        scope: 'project',
+        message: '当前客户端的项目根查询失败，暂时无法解析项目空间。',
+        candidates: [],
+        detail: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+  const roots = Array.from(new Set(
+    (Array.isArray(result?.roots) ? result.roots : [])
+      .map((root) => normalizeRootUri(root?.uri))
+      .filter(Boolean)
+  ));
+  if (roots.length === 1) {
+    return { status: 'resolved', workspaceRoot: roots[0], roots };
+  }
+  return {
+    status: 'warning',
+    workspaceRoot: null,
+    roots,
+    warning: {
+      code: roots.length ? 'CLIENT_PROJECT_ROOT_AMBIGUOUS' : 'CLIENT_PROJECT_ROOT_UNAVAILABLE',
+      severity: 'warning',
+      scope: 'project',
+      message: roots.length
+        ? '当前客户端暴露了多个项目根，无法唯一解析项目空间。'
+        : '当前客户端没有暴露可用的项目根，无法解析项目空间。',
+      candidates: roots
+    }
+  };
+}

package/src/connector-bridge.js

@@ -1,4 +1,5 @@
 import os from 'os';
+import path from 'node:path';
 import { CloudClient } from './cloud-client.js';
 import { DeviceIdentity } from './device-identity.js';
 import { discoverProjectProbe } from './project-probe-discovery.js';
@@ -71,19 +72,30 @@ export class ConnectorBridge {
     };
   }
 
-  async resolveCurrentWorkspace() {
+  async resolveCurrentWorkspace(workspaceRoot = this.workspaceRoot) {
+    this.workspaceRoot = path.resolve(workspaceRoot || process.cwd());
     const projectIdentity = await discoverProjectIdentity(this.workspaceRoot);
     const response = await this.cloudClient.resolveWorkspace({ projectIdentity });
     const resolution = response?.workspaceResolution;
-    if (!resolution?.workspaceId) {
-      throw new Error('CloudMCP did not resolve a workspace for the current project');
-    }
-    this.workspaceId = resolution.workspaceId;
+    if (!resolution) throw new Error('CloudMCP returned no workspace resolution result');
+    this.workspaceId = normalizeString(resolution.workspaceId);
     this.state.projectIdentity = projectIdentity;
     this.state.workspaceResolution = resolution;
     return resolution;
   }
 
+  setProjectRootWarning(warning, roots = []) {
+    this.workspaceId = '';
+    this.state.workspaceResolution = {
+      status: 'warning',
+      resolution: 'client_project_root_unresolved',
+      workspaceId: null,
+      workspaceIds: [],
+      warnings: warning ? [warning] : [],
+      candidates: roots
+    };
+  }
+
   getBridgeStatus() {
     return {
       objectType: 'connector_bridge_status',
@@ -107,7 +119,8 @@ export class ConnectorBridge {
       return this.getBridgeStatus();
     }
 
-    await this.resolveCurrentWorkspace();
+    const workspaceResolution = await this.resolveCurrentWorkspace();
+    if (!workspaceResolution.workspaceId) return this.getBridgeStatus();
     try {
       if (typeof this.cloudClient?.registerDevice === 'function') {
         await this.ensureDeviceRegistration();

package/src/local-memory-coordinator.js

@@ -68,6 +68,12 @@ export class LocalMemoryCoordinator {
     this.connectorId = options.connectorId || '';
     this.homeDir = options.homeDir || os.homedir();
     this.cloudToolCaller = options.cloudToolCaller || null;
+    this.bindWorkspace(this.workspaceRoot, this.workspaceId);
+  }
+
+  bindWorkspace(workspaceRoot, workspaceId = '') {
+    this.workspaceRoot = path.resolve(workspaceRoot || process.cwd());
+    this.workspaceId = workspaceId || '';
     const bindingFingerprint = fingerprint([
       this.cloudUrl,
       this.clientProfileId,

package/src/router.js

@@ -136,11 +136,25 @@ export class SmartRouter {
     return 'cloud';
   }
 
+  getWorkspaceWarnings() {
+    const resolution = this.localTools?.connectorBridge?.state?.workspaceResolution;
+    if (resolution?.workspaceId) return [];
+    return Array.isArray(resolution?.warnings) ? resolution.warnings : [];
+  }
+
   /**
    * 执行工具调用
    */
   async executeTool(toolName, params) {
     const route = this.routeTool(toolName);
+    const workspaceWarnings = this.getWorkspaceWarnings();
+    if (route === 'cloud' && workspaceWarnings.length) {
+      return {
+        objectType: 'connector_workspace_warning',
+        executed: false,
+        warnings: workspaceWarnings
+      };
+    }
     
     if (route === 'local') {
       return await this.localTools.execute(toolName, params);
@@ -288,6 +302,14 @@ export class SmartRouter {
    * 获取所有工具列表（合并云端和本地）
    */
   async getAllTools() {
+    const workspaceWarnings = this.getWorkspaceWarnings();
+    if (workspaceWarnings.length) {
+      const localTools = await this.localTools.listTools();
+      const recoveryTools = new Set(['connector_bridge_status', 'connector_discover_project_probe']);
+      return localTools
+        .filter((tool) => recoveryTools.has(tool.name))
+        .map((tool) => ({ ...tool, source: 'local' }));
+    }
     const [cloudTools, localTools] = await Promise.all([
       this.getCloudTools(),
       this.localTools.listTools()