cloudflare-mcp-smart-proxy 1.5.6 → 1.5.7

package/connector-cli.js

@@ -9,6 +9,7 @@ import { reloadCodexMcpServer } from './src/codex-app-server.js';
 import { installReferenceConnector, printReferenceConnectorConfig } from './src/reference-connectors.js';
 import { DeviceIdentity } from './src/device-identity.js';
 import { writeFileAtomically } from './src/reference-connectors.js';
+import { discoverProjectIdentity } from './src/project-identity.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -202,6 +203,7 @@ async function runActivation(options) {
   };
 
   const createApprovalRequest = async ({ replacesRequestId = '' } = {}) => {
+    const projectIdentity = await discoverProjectIdentity(paths.workspaceRoot);
     const requested = await activationFetch(`${paths.cloudUrl}/connectors/activation-requests`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
@@ -211,6 +213,7 @@ async function runActivation(options) {
         publicKeyJwk: device.publicKeyJwk,
         deviceLabel: options['device-label'] || os.hostname(),
         workspaceLabel: path.basename(paths.workspaceRoot),
+        projectIdentity,
         connectorId: options['connector-id'] || defaultConnectorId(options.ecosystem, paths.workspaceRoot)
       })
     });

package/index.js

@@ -38,11 +38,14 @@ function readManagedCredential() {
 const MANAGED_CREDENTIAL = readManagedCredential();
 const CLOUD_URL = MANAGED_CREDENTIAL?.cloudUrl || process.env.CLOUDFLARE_MCP_URL || process.env.MCP_URL;
 const CLOUD_API_KEY = MANAGED_CREDENTIAL?.apiKey || process.env.CLOUDFLARE_MCP_API_KEY || process.env.MCP_API_KEY;
-const WORKSPACE_ROOT = process.env.WORKSPACE_ROOT || process.cwd();
+const FIXED_PROJECT_CONTEXT = process.env.CLOUDMCP_FIXED_PROJECT_CONTEXT === 'true';
+const WORKSPACE_ROOT = FIXED_PROJECT_CONTEXT ? (process.env.WORKSPACE_ROOT || process.cwd()) : process.cwd();
 const CLIENT_PROFILE_ID = MANAGED_CREDENTIAL?.clientProfileId || process.env.CLOUDMCP_CLIENT_PROFILE_ID || process.env.CLIENT_PROFILE_ID || '';
 const CONNECTOR_ID = MANAGED_CREDENTIAL?.connectorId || process.env.CLOUDMCP_CONNECTOR_ID || process.env.CONNECTOR_ID || '';
 const CONNECTOR_TYPE = MANAGED_CREDENTIAL?.connectorType || process.env.CLOUDMCP_CONNECTOR_TYPE || process.env.CONNECTOR_TYPE || 'smart_proxy';
-const WORKSPACE_ID = MANAGED_CREDENTIAL?.workspaceId || process.env.CLOUDMCP_WORKSPACE_ID || process.env.WORKSPACE_ID || '';
+const WORKSPACE_ID = FIXED_PROJECT_CONTEXT
+  ? (process.env.CLOUDMCP_WORKSPACE_ID || process.env.WORKSPACE_ID || '')
+  : '';
 const DEVICE_IDENTITY_PATH = process.env.CLOUDMCP_DEVICE_IDENTITY_PATH || '';
 const AUTO_SYNC_PROFILE = (process.env.CLOUDMCP_AUTO_SYNC_PROFILE || 'true') !== 'false';
 const AUTO_APPLY_BRAIN = (process.env.CLOUDMCP_AUTO_APPLY_BRAIN || 'true') !== 'false';
@@ -77,7 +80,14 @@ const memoryCoordinator = new LocalMemoryCoordinator({
   connectorId: CONNECTOR_ID
 });
 const localTools = new LocalToolExecutor(WORKSPACE_ROOT, connectorBridge, memoryCoordinator);
-const router = new SmartRouter(CLOUD_URL, CLOUD_API_KEY, localTools, WORKSPACE_ROOT, connectorBridge.deviceIdentity);
+const router = new SmartRouter(
+  CLOUD_URL,
+  CLOUD_API_KEY,
+  localTools,
+  WORKSPACE_ROOT,
+  connectorBridge.deviceIdentity,
+  () => connectorBridge.getScopeHeaders()
+);
 localTools.setCloudToolCaller((tool, params) => router.callCloudTool(tool, params));
 
 // 创建 MCP 服务器
@@ -163,7 +173,8 @@ server.setRequestHandler(ListPromptsRequestSchema, async () => {
       method: 'POST',
       headers: {
         'Authorization': `Bearer ${CLOUD_API_KEY}`,
-        'Content-Type': 'application/json'
+        'Content-Type': 'application/json',
+        ...connectorBridge.getScopeHeaders()
       },
       body: JSON.stringify({
         jsonrpc: '2.0',
@@ -199,7 +210,8 @@ server.setRequestHandler(GetPromptRequestSchema, async (request) => {
       method: 'POST',
       headers: {
         'Authorization': `Bearer ${CLOUD_API_KEY}`,
-        'Content-Type': 'application/json'
+        'Content-Type': 'application/json',
+        ...connectorBridge.getScopeHeaders()
       },
       body: JSON.stringify({
         jsonrpc: '2.0',
@@ -240,18 +252,22 @@ server.setRequestHandler(GetPromptRequestSchema, async (request) => {
 // 启动服务器
 async function main() {
   try {
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    console.error('Cloudflare MCP Smart Proxy started');
-    console.error(`Workspace root: ${WORKSPACE_ROOT}`);
-    console.error(`Cloud URL: ${CLOUD_URL}`);
+    let bridgeStatus = null;
     if (connectorBridge.isConfigured()) {
-      const bridgeStatus = await connectorBridge.initialize({
+      bridgeStatus = await connectorBridge.initialize({
         autoApplyBrain: AUTO_APPLY_BRAIN,
         autoSyncProfile: AUTO_SYNC_PROFILE,
         autoReportProjectProbe: AUTO_REPORT_PROJECT_PROBE,
         autoGenerateContextPack: AUTO_GENERATE_CONTEXT_PACK
       });
+      memoryCoordinator.workspaceId = connectorBridge.workspaceId;
+    }
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('Cloudflare MCP Smart Proxy started');
+    console.error(`Workspace root: ${WORKSPACE_ROOT}`);
+    console.error(`Cloud URL: ${CLOUD_URL}`);
+    if (bridgeStatus) {
       console.error(`Connector bridge profile: ${bridgeStatus.clientProfileId}`);
       console.error(`Connector bridge workspace: ${bridgeStatus.workspaceId}`);
       const applyResult = bridgeStatus.state?.lastBrainApplyResult;

package/package.json

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

package/src/cloud-client.js

@@ -1,10 +1,11 @@
 const CONNECTOR_CONTRACT_VERSION = 'a2.v1';
 
 export class CloudClient {
-  constructor({ cloudUrl, cloudApiKey, deviceIdentity = null }) {
+  constructor({ cloudUrl, cloudApiKey, deviceIdentity = null, getScopeHeaders = null }) {
     this.cloudUrl = String(cloudUrl || '').replace(/\/$/, '');
     this.cloudApiKey = cloudApiKey || '';
     this.deviceIdentity = deviceIdentity;
+    this.getScopeHeaders = typeof getScopeHeaders === 'function' ? getScopeHeaders : () => ({});
     if (!this.cloudUrl) {
       throw new Error('cloudUrl is required');
     }
@@ -42,6 +43,7 @@ export class CloudClient {
         'Authorization': `Bearer ${this.cloudApiKey}`,
         'Content-Type': 'application/json',
         'X-CloudMCP-Connector-Contract-Version': CONNECTOR_CONTRACT_VERSION,
+        ...this.getScopeHeaders(),
         ...signedHeaders,
         ...(idempotencyKey ? { 'X-Idempotency-Key': idempotencyKey } : {})
       },
@@ -73,6 +75,13 @@ export class CloudClient {
     });
   }
 
+  async resolveWorkspace({ projectIdentity }) {
+    return this.request('/connectors/workspace-resolution', {
+      method: 'POST',
+      body: { projectIdentity }
+    });
+  }
+
   async listConnectorStatusReports({ clientProfileId, workspaceId, connectorId, limit = 5 }) {
     return this.request('/connectors/status-reports', {
       query: { clientProfileId, workspaceId, connectorId, limit }

package/src/connector-bridge.js

@@ -1,9 +1,9 @@
 import os from 'os';
-import path from 'path';
 import { CloudClient } from './cloud-client.js';
 import { DeviceIdentity } from './device-identity.js';
 import { discoverProjectProbe } from './project-probe-discovery.js';
 import { detectIde, applyBrainSnapshot } from './ide-configurator.js';
+import { discoverProjectIdentity } from './project-identity.js';
 
 function normalizeString(value, fallback = '') {
   const normalized = typeof value === 'string' ? value.trim() : '';
@@ -14,10 +14,6 @@ function defaultConnectorId() {
   return `connector.${os.hostname().replace(/[^a-zA-Z0-9_.-]/g, '_')}.local`;
 }
 
-function defaultWorkspaceId(workspaceRoot) {
-  return `workspace.${path.basename(workspaceRoot || process.cwd()).replace(/[^a-zA-Z0-9_.-]/g, '_')}`;
-}
-
 function buildIdempotencyKey(...parts) {
   return parts
     .map((entry) => normalizeString(entry))
@@ -42,12 +38,13 @@ export class ConnectorBridge {
     this.clientProfileId = normalizeString(clientProfileId);
     this.connectorId = normalizeString(connectorId, defaultConnectorId());
     this.connectorType = normalizeString(connectorType, 'smart_proxy');
-    this.workspaceId = normalizeString(workspaceId, defaultWorkspaceId(this.workspaceRoot));
+    this.workspaceId = normalizeString(workspaceId);
     this.deviceIdentity = deviceIdentity || new DeviceIdentity({ identityPath: deviceIdentityPath });
     this.cloudClient = cloudClient || new CloudClient({
       cloudUrl,
       cloudApiKey,
-      deviceIdentity: this.deviceIdentity
+      deviceIdentity: this.deviceIdentity,
+      getScopeHeaders: () => this.getScopeHeaders()
     });
     this.state = {
       initializedAt: Date.now(),
@@ -66,6 +63,27 @@ export class ConnectorBridge {
     return Boolean(this.clientProfileId);
   }
 
+  getScopeHeaders() {
+    return {
+      ...(this.workspaceId ? { 'X-CloudMCP-Workspace-ID': this.workspaceId } : {}),
+      ...(this.clientProfileId ? { 'X-CloudMCP-Client-Profile-ID': this.clientProfileId } : {}),
+      ...(this.connectorId ? { 'X-CloudMCP-Connector-ID': this.connectorId } : {})
+    };
+  }
+
+  async resolveCurrentWorkspace() {
+    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;
+    this.state.projectIdentity = projectIdentity;
+    this.state.workspaceResolution = resolution;
+    return resolution;
+  }
+
   getBridgeStatus() {
     return {
       objectType: 'connector_bridge_status',
@@ -89,6 +107,7 @@ export class ConnectorBridge {
       return this.getBridgeStatus();
     }
 
+    await this.resolveCurrentWorkspace();
     try {
       if (typeof this.cloudClient?.registerDevice === 'function') {
         await this.ensureDeviceRegistration();

package/src/project-identity.js

@@ -0,0 +1,75 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+function normalizeString(value, fallback = '') {
+  const normalized = typeof value === 'string' ? value.trim() : '';
+  return normalized || fallback;
+}
+
+function normalizeAlias(value) {
+  return normalizeString(value)
+    .toLowerCase()
+    .replace(/\.git$/i, '')
+    .replace(/\/+$/, '');
+}
+
+function normalizeGitRemote(value) {
+  const remote = normalizeString(value);
+  if (!remote) return '';
+  const scpMatch = remote.match(/^(?:[^@]+@)?([^:]+):(.+)$/);
+  if (scpMatch && !remote.includes('://')) {
+    return normalizeAlias(`${scpMatch[1]}/${scpMatch[2]}`);
+  }
+  try {
+    const parsed = new URL(remote);
+    return normalizeAlias(`${parsed.hostname}${parsed.pathname}`);
+  } catch {
+    return normalizeAlias(remote);
+  }
+}
+
+async function readText(filePath) {
+  try {
+    return await fs.readFile(filePath, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+async function readPackageName(repoRoot) {
+  try {
+    const payload = JSON.parse(await fs.readFile(path.join(repoRoot, 'package.json'), 'utf8'));
+    return normalizeAlias(payload?.name);
+  } catch {
+    return '';
+  }
+}
+
+async function readGitRemote(repoRoot) {
+  const gitConfig = await readText(path.join(repoRoot, '.git', 'config'));
+  const originSection = gitConfig.match(/\[remote\s+"origin"\]([\s\S]*?)(?=\n\[|$)/i)?.[1] || '';
+  const originUrl = originSection.match(/^\s*url\s*=\s*(.+)$/mi)?.[1] || '';
+  return normalizeGitRemote(originUrl);
+}
+
+export async function discoverProjectIdentity(workspaceRoot = process.cwd()) {
+  const repoRoot = path.resolve(workspaceRoot || process.cwd());
+  const repoName = path.basename(repoRoot);
+  const [gitRemote, packageName] = await Promise.all([
+    readGitRemote(repoRoot),
+    readPackageName(repoRoot)
+  ]);
+  const aliases = Array.from(new Set([
+    gitRemote ? `git:${gitRemote}` : '',
+    packageName ? `package:${packageName}` : '',
+    `repo:${normalizeAlias(repoName)}`
+  ].filter(Boolean)));
+
+  return {
+    canonicalId: aliases[0],
+    aliases,
+    repoName,
+    gitRemote: gitRemote || null,
+    packageName: packageName || null
+  };
+}

package/src/reference-connectors.js

@@ -100,7 +100,8 @@ function toManagedEnv({
   connectorType,
   workspaceId,
   deviceIdentityPath,
-  codexConfigPath
+  codexConfigPath,
+  fixedProjectContext = false
 }) {
   const env = {
     CLOUDFLARE_MCP_URL: normalizeEnvValue(cloudUrl),
@@ -112,7 +113,8 @@ function toManagedEnv({
     CLOUDMCP_CONNECTOR_TYPE: normalizeEnvValue(connectorType),
     CLOUDMCP_WORKSPACE_ID: normalizeEnvValue(workspaceId),
     CLOUDMCP_DEVICE_IDENTITY_PATH: normalizeEnvValue(deviceIdentityPath),
-    CODEX_SHARED_CONFIG_PATH: normalizeEnvValue(codexConfigPath)
+    CODEX_SHARED_CONFIG_PATH: normalizeEnvValue(codexConfigPath),
+    CLOUDMCP_FIXED_PROJECT_CONTEXT: fixedProjectContext ? 'true' : ''
   };
 
   return Object.fromEntries(
@@ -156,6 +158,7 @@ export function buildReferenceConnectorServer({
   workspaceId = '',
   deviceIdentityPath = '',
   codexConfigPath = '',
+  fixedProjectContext = true,
   packageRoot = null,
   runtime = 'npm'
 }) {
@@ -174,13 +177,14 @@ export function buildReferenceConnectorServer({
       cloudUrl,
       cloudApiKey,
       credentialPath,
-      workspaceRoot: resolvedWorkspaceRoot,
+      workspaceRoot: fixedProjectContext ? resolvedWorkspaceRoot : '',
       clientProfileId,
       connectorId: resolvedConnectorId,
       connectorType: resolvedConnectorType,
-      workspaceId: resolvedWorkspaceId,
+      workspaceId: fixedProjectContext ? resolvedWorkspaceId : '',
       deviceIdentityPath,
-      codexConfigPath: normalizedEcosystem === 'codex' ? codexConfigPath : ''
+      codexConfigPath: normalizedEcosystem === 'codex' ? codexConfigPath : '',
+      fixedProjectContext
     }),
     enabled: true,
     startupTimeoutSec: normalizedEcosystem === 'codex' ? DEFAULT_CODEX_STARTUP_TIMEOUT_SEC : null,
@@ -358,6 +362,7 @@ export function installReferenceConnector({
     workspaceId,
     deviceIdentityPath,
     codexConfigPath: target.ecosystem === 'codex' ? target.targetFile : '',
+    fixedProjectContext: target.scope === 'project',
     packageRoot,
     runtime
   });

package/src/router.js

@@ -38,12 +38,13 @@ export function sanitizeProxyError(error, params = {}) {
 }
 
 export class SmartRouter {
-  constructor(cloudUrl, cloudApiKey, localTools, workspaceRoot = null, deviceIdentity = null) {
+  constructor(cloudUrl, cloudApiKey, localTools, workspaceRoot = null, deviceIdentity = null, getScopeHeaders = null) {
     this.cloudUrl = cloudUrl.replace(/\/$/, ''); // 移除尾部斜杠
     this.cloudApiKey = cloudApiKey;
     this.localTools = localTools;
     this.workspaceRoot = workspaceRoot || process.cwd();
     this.deviceIdentity = deviceIdentity;
+    this.getScopeHeaders = typeof getScopeHeaders === 'function' ? getScopeHeaders : () => ({});
     
     // 工具路由规则
     this.routingRules = {
@@ -215,6 +216,7 @@ export class SmartRouter {
         headers: {
           'Authorization': `Bearer ${this.cloudApiKey}`,
           'Content-Type': 'application/json',
+          ...this.getScopeHeaders(),
           ...signedHeaders
         },
         body
@@ -325,6 +327,7 @@ export class SmartRouter {
         headers: {
           'Authorization': `Bearer ${this.cloudApiKey}`,
           'Content-Type': 'application/json',
+          ...this.getScopeHeaders(),
           ...signedHeaders
         },
         body