cloudflare-mcp-smart-proxy 1.2.0 → 1.3.0

package/src/local-tools.js

@@ -10,8 +10,9 @@ import { SymbolTools } from './tools/symbol-tools.js';
 import { Diagnostics } from './tools/diagnostics.js';
 
 export class LocalToolExecutor {
-  constructor(workspaceRoot) {
+  constructor(workspaceRoot, connectorBridge = null) {
     this.workspaceRoot = workspaceRoot;
+    this.connectorBridge = connectorBridge;
   }
 
   /**
@@ -55,6 +56,26 @@ export class LocalToolExecutor {
       
       case 'get_diagnostics':
         return await Diagnostics.getDiagnostics(params, this.workspaceRoot);
+
+      case 'connector_bridge_status':
+        if (!this.connectorBridge) throw new Error('Connector bridge is not configured');
+        return this.connectorBridge.getBridgeStatus();
+
+      case 'connector_sync_profile':
+        if (!this.connectorBridge) throw new Error('Connector bridge is not configured');
+        return await this.connectorBridge.syncProfile();
+
+      case 'connector_report_status':
+        if (!this.connectorBridge) throw new Error('Connector bridge is not configured');
+        return await this.connectorBridge.reportStatus(params || {});
+
+      case 'connector_discover_project_probe':
+        if (!this.connectorBridge) throw new Error('Connector bridge is not configured');
+        return await this.connectorBridge.discoverProjectProbe();
+
+      case 'connector_report_project_probe':
+        if (!this.connectorBridge) throw new Error('Connector bridge is not configured');
+        return await this.connectorBridge.reportProjectProbe(params || {});
       
       default:
         throw new Error(`Unknown local tool: ${toolName}`);
@@ -314,8 +335,69 @@ export class LocalToolExecutor {
           },
           required: ['file_path']
         }
+      },
+      {
+        name: 'connector_bridge_status',
+        description: 'Get current connector bridge state, sync metadata, and workspace binding status',
+        inputSchema: {
+          type: 'object',
+          properties: {}
+        }
+      },
+      {
+        name: 'connector_sync_profile',
+        description: 'Pull the latest install plan and recent status reports for the configured client profile',
+        inputSchema: {
+          type: 'object',
+          properties: {}
+        }
+      },
+      {
+        name: 'connector_report_status',
+        description: 'Report local connector apply status back to CloudMCP',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            status: {
+              type: 'string',
+              description: 'Overall status, for example succeeded, degraded, or failed'
+            },
+            summary: {
+              type: 'object',
+              description: 'High level summary of local apply results'
+            },
+            operationResults: {
+              type: 'array',
+              description: 'Per-operation execution results'
+            },
+            issues: {
+              type: 'array',
+              description: 'Reported install or runtime issues'
+            }
+          }
+        }
+      },
+      {
+        name: 'connector_discover_project_probe',
+        description: 'Discover the local workspace skeleton and build a project_probe candidate payload',
+        inputSchema: {
+          type: 'object',
+          properties: {}
+        }
+      },
+      {
+        name: 'connector_report_project_probe',
+        description: 'Report the local workspace project probe to CloudMCP and optionally auto-generate a draft context pack',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            autoGenerateContextPack: {
+              type: 'boolean',
+              description: 'Whether CloudMCP should auto-generate a draft context pack from this probe'
+            }
+          }
+        }
       }
     ];
   }
 }
-

package/src/project-probe-discovery.js

@@ -0,0 +1,137 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+async function pathExists(target) {
+  try {
+    await fs.access(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function safeReadDir(target) {
+  try {
+    return await fs.readdir(target, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+
+function inferLanguages(fileNames = []) {
+  const set = new Set();
+  if (fileNames.some((name) => name.endsWith('.js') || name.endsWith('.mjs') || name.endsWith('.cjs'))) set.add('javascript');
+  if (fileNames.some((name) => name.endsWith('.ts') || name.endsWith('.tsx'))) set.add('typescript');
+  if (fileNames.some((name) => name.endsWith('.py'))) set.add('python');
+  if (fileNames.some((name) => name.endsWith('.go'))) set.add('go');
+  if (fileNames.some((name) => name.endsWith('.rs'))) set.add('rust');
+  if (fileNames.some((name) => name.endsWith('.java'))) set.add('java');
+  if (fileNames.some((name) => name.endsWith('.html'))) set.add('html');
+  if (fileNames.some((name) => name.endsWith('.css'))) set.add('css');
+  return Array.from(set);
+}
+
+function inferFrameworkHints(fileNames = [], dirs = []) {
+  const set = new Set();
+  if (fileNames.includes('wrangler.toml')) set.add('cloudflare_workers');
+  if (fileNames.includes('package.json')) set.add('node_workspace');
+  if (fileNames.includes('pnpm-workspace.yaml') || dirs.includes('packages') || dirs.includes('apps')) set.add('monorepo');
+  if (fileNames.includes('next.config.js') || fileNames.includes('next.config.mjs')) set.add('nextjs');
+  if (fileNames.includes('vite.config.js') || fileNames.includes('vite.config.ts')) set.add('vite');
+  if (fileNames.includes('go.mod')) set.add('go_module');
+  if (fileNames.includes('pyproject.toml')) set.add('python_project');
+  return Array.from(set);
+}
+
+function inferPackageManager(fileNames = []) {
+  if (fileNames.includes('pnpm-lock.yaml')) return 'pnpm';
+  if (fileNames.includes('yarn.lock')) return 'yarn';
+  if (fileNames.includes('package-lock.json')) return 'npm';
+  if (fileNames.includes('bun.lockb') || fileNames.includes('bun.lock')) return 'bun';
+  return '';
+}
+
+function buildWorkspaceLayout(dirs = []) {
+  const preferred = ['apps', 'packages', 'src', 'tests', 'docs', 'scripts'];
+  const found = preferred.filter((name) => dirs.includes(name));
+  return found.join(' + ');
+}
+
+export async function discoverProjectProbe({
+  workspaceRoot,
+  workspaceId,
+  clientProfileId = null,
+  connectorId = null,
+  connectorType = null,
+  generatedBy = 'connector_scan'
+}) {
+  const repoRoot = path.resolve(workspaceRoot || process.cwd());
+  const repoName = path.basename(repoRoot);
+  const topLevel = await safeReadDir(repoRoot);
+  const dirNames = topLevel.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  const fileNames = topLevel.filter((entry) => entry.isFile()).map((entry) => entry.name);
+
+  const keyFiles = [
+    'wrangler.toml',
+    'package.json',
+    'pnpm-workspace.yaml',
+    'README.md',
+    'src/worker.js',
+    'src/admin-page.html',
+    'docs/CLOUDMCP_CURRENT_DESIGN_FRAMEWORK_AND_DATAFLOW_2026-05-07.md'
+  ];
+  const docCandidates = [
+    'README.md',
+    'docs/CLOUDMCP_CURRENT_DESIGN_FRAMEWORK_AND_DATAFLOW_2026-05-07.md',
+    'docs/CLOUDMCP_INTERNAL_CAPABILITY_BRIDGE_STANDARD_2026-05-06.md',
+    'docs/CLOUDMCP_EXTERNAL_TOOL_SURFACE_STANDARD_2026-05-06.md'
+  ];
+
+  const resolvedKeyFiles = [];
+  for (const relativePath of keyFiles) {
+    if (await pathExists(path.join(repoRoot, relativePath))) {
+      resolvedKeyFiles.push(relativePath);
+    }
+  }
+
+  const resolvedDocCandidates = [];
+  for (const relativePath of docCandidates) {
+    if (await pathExists(path.join(repoRoot, relativePath))) {
+      resolvedDocCandidates.push(relativePath);
+    }
+  }
+
+  const languages = inferLanguages(fileNames.concat(resolvedKeyFiles));
+  const frameworkHints = inferFrameworkHints(fileNames, dirNames);
+  const packageManager = inferPackageManager(fileNames);
+  const workspaceLayout = buildWorkspaceLayout(dirNames);
+  const commandHints = [];
+  if (packageManager) {
+    commandHints.push(`${packageManager} test`);
+    commandHints.push(`${packageManager} run gen-admin`);
+  }
+
+  return {
+    id: `project_probe.${repoName}.${(workspaceId || 'default').replace(/[^a-zA-Z0-9_.-]/g, '_')}`,
+    clientProfileId,
+    connectorId,
+    connectorType,
+    projectId: repoName.toLowerCase(),
+    workspaceId: workspaceId || null,
+    repoName,
+    repoRoot,
+    gitRemote: null,
+    defaultBranch: 'main',
+    languages,
+    frameworkHints,
+    packageManager: packageManager || null,
+    workspaceLayout: workspaceLayout || null,
+    keyFiles: resolvedKeyFiles,
+    docCandidates: resolvedDocCandidates,
+    commandHints,
+    summary: `${repoName} 项目骨架自动探测结果`,
+    notes: '由本地 connector bridge 自动生成，后续应由 CloudMCP 生成候选上下文包并进入确认流程。',
+    generatedBy,
+    status: 'ready_for_context'
+  };
+}

package/src/reference-connectors.js

@@ -0,0 +1,315 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+const DEFAULT_SERVER_NAME = 'cloudmcp';
+const DEFAULT_PACKAGE_NAME = 'cloudflare-mcp-smart-proxy';
+const DEFAULT_PACKAGE_BIN = 'cloudflare-mcp-proxy';
+const MANAGED_BLOCK_PREFIX = '# BEGIN CLOUDMCP MANAGED MCP SERVER';
+const MANAGED_BLOCK_SUFFIX = '# END CLOUDMCP MANAGED MCP SERVER';
+
+function normalizeString(value, fallback = '') {
+  const normalized = typeof value === 'string' ? value.trim() : '';
+  return normalized || fallback;
+}
+
+function normalizeEnvValue(value) {
+  if (value == null) return '';
+  return String(value);
+}
+
+function sanitizeServerName(value) {
+  const candidate = normalizeString(value, DEFAULT_SERVER_NAME)
+    .replace(/[^a-zA-Z0-9_-]/g, '_');
+  return candidate || DEFAULT_SERVER_NAME;
+}
+
+function resolveHomeDir(homeDir = null) {
+  return homeDir || os.homedir();
+}
+
+function buildWorkspaceId(workspaceRoot) {
+  return `workspace.${path.basename(workspaceRoot || process.cwd()).replace(/[^a-zA-Z0-9_.-]/g, '_')}`;
+}
+
+function buildConnectorId(ecosystem, workspaceRoot) {
+  return `connector.${sanitizeServerName(ecosystem)}.${path.basename(workspaceRoot || process.cwd()).replace(/[^a-zA-Z0-9_.-]/g, '_')}`;
+}
+
+function ensureDir(targetPath) {
+  const dirPath = path.dirname(targetPath);
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+function readJson(filePath, fallback) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function escapeTomlString(value) {
+  return String(value)
+    .replace(/\\/g, '\\\\')
+    .replace(/"/g, '\\"');
+}
+
+function formatTomlArray(values) {
+  return `[${values.map((value) => `"${escapeTomlString(value)}"`).join(', ')}]`;
+}
+
+function toManagedEnv({
+  cloudUrl,
+  cloudApiKey,
+  workspaceRoot,
+  clientProfileId,
+  connectorId,
+  connectorType,
+  workspaceId
+}) {
+  const env = {
+    CLOUDFLARE_MCP_URL: normalizeEnvValue(cloudUrl),
+    CLOUDFLARE_MCP_API_KEY: normalizeEnvValue(cloudApiKey),
+    WORKSPACE_ROOT: normalizeEnvValue(workspaceRoot),
+    CLOUDMCP_CLIENT_PROFILE_ID: normalizeEnvValue(clientProfileId),
+    CLOUDMCP_CONNECTOR_ID: normalizeEnvValue(connectorId),
+    CLOUDMCP_CONNECTOR_TYPE: normalizeEnvValue(connectorType),
+    CLOUDMCP_WORKSPACE_ID: normalizeEnvValue(workspaceId)
+  };
+
+  return Object.fromEntries(
+    Object.entries(env).filter(([, value]) => value !== '')
+  );
+}
+
+export function resolveReferenceConnectorCommand({
+  packageRoot = null,
+  runtime = 'npm'
+} = {}) {
+  if (runtime === 'npm') {
+    if (process.platform === 'win32') {
+      return {
+        command: 'cmd',
+        args: ['/c', 'npx', '-y', '-p', DEFAULT_PACKAGE_NAME, DEFAULT_PACKAGE_BIN]
+      };
+    }
+    return {
+      command: 'npx',
+      args: ['-y', '-p', DEFAULT_PACKAGE_NAME, DEFAULT_PACKAGE_BIN]
+    };
+  }
+
+  const resolvedPackageRoot = path.resolve(packageRoot || path.join(process.cwd(), 'local-proxy'));
+  return {
+    command: process.execPath,
+    args: [path.join(resolvedPackageRoot, 'index.js')]
+  };
+}
+
+export function buildReferenceConnectorServer({
+  ecosystem,
+  cloudUrl,
+  cloudApiKey,
+  workspaceRoot = process.cwd(),
+  clientProfileId,
+  connectorId = '',
+  connectorType = '',
+  workspaceId = '',
+  packageRoot = null,
+  runtime = 'npm'
+}) {
+  const normalizedEcosystem = normalizeString(ecosystem).toLowerCase();
+  const resolvedWorkspaceRoot = path.resolve(workspaceRoot || process.cwd());
+  const resolvedConnectorType = normalizeString(connectorType, normalizedEcosystem || 'reference_connector');
+  const resolvedWorkspaceId = normalizeString(workspaceId, buildWorkspaceId(resolvedWorkspaceRoot));
+  const resolvedConnectorId = normalizeString(connectorId, buildConnectorId(normalizedEcosystem, resolvedWorkspaceRoot));
+  const commandDescriptor = resolveReferenceConnectorCommand({ packageRoot, runtime });
+
+  return {
+    type: 'stdio',
+    command: commandDescriptor.command,
+    args: commandDescriptor.args,
+    env: toManagedEnv({
+      cloudUrl,
+      cloudApiKey,
+      workspaceRoot: resolvedWorkspaceRoot,
+      clientProfileId,
+      connectorId: resolvedConnectorId,
+      connectorType: resolvedConnectorType,
+      workspaceId: resolvedWorkspaceId
+    }),
+    enabled: true,
+    connectorId: resolvedConnectorId,
+    connectorType: resolvedConnectorType,
+    workspaceId: resolvedWorkspaceId
+  };
+}
+
+export function getReferenceConnectorTarget({
+  ecosystem,
+  workspaceRoot = process.cwd(),
+  scope = 'user',
+  homeDir = null
+}) {
+  const normalizedEcosystem = normalizeString(ecosystem).toLowerCase();
+  const normalizedScope = normalizeString(scope, 'user').toLowerCase();
+  const resolvedWorkspaceRoot = path.resolve(workspaceRoot || process.cwd());
+  const resolvedHomeDir = resolveHomeDir(homeDir);
+
+  if (normalizedEcosystem === 'codex') {
+    return {
+      ecosystem: normalizedEcosystem,
+      scope: 'user',
+      format: 'toml',
+      targetFile: path.join(resolvedHomeDir, '.codex', 'config.toml')
+    };
+  }
+
+  if (normalizedEcosystem === 'claude_code') {
+    if (normalizedScope === 'project') {
+      return {
+        ecosystem: normalizedEcosystem,
+        scope: 'project',
+        format: 'json',
+        targetFile: path.join(resolvedWorkspaceRoot, '.mcp.json')
+      };
+    }
+    return {
+      ecosystem: normalizedEcosystem,
+      scope: 'user',
+      format: 'json',
+      targetFile: path.join(resolvedHomeDir, '.claude.json')
+    };
+  }
+
+  throw new Error(`Unsupported reference connector ecosystem "${ecosystem}"`);
+}
+
+export function buildCodexManagedBlock(serverName, serverDefinition) {
+  const lines = [
+    `${MANAGED_BLOCK_PREFIX} ${serverName}`,
+    `[mcp_servers.${serverName}]`,
+    `command = "${escapeTomlString(serverDefinition.command)}"`,
+    `args = ${formatTomlArray(serverDefinition.args || [])}`,
+    `enabled = ${serverDefinition.enabled === false ? 'false' : 'true'}`
+  ];
+
+  const envEntries = Object.entries(serverDefinition.env || {});
+  if (envEntries.length > 0) {
+    lines.push('', `[mcp_servers.${serverName}.env]`);
+    for (const [key, value] of envEntries) {
+      lines.push(`${key} = "${escapeTomlString(value)}"`);
+    }
+  }
+
+  lines.push(MANAGED_BLOCK_SUFFIX);
+  return `${lines.join('\n')}\n`;
+}
+
+function replaceManagedBlock(existingContent, serverName, nextBlock) {
+  const startMarker = `${MANAGED_BLOCK_PREFIX} ${serverName}`;
+  const endMarker = MANAGED_BLOCK_SUFFIX;
+  const pattern = new RegExp(
+    `${startMarker.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}[\\s\\S]*?${endMarker.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\n?`,
+    'g'
+  );
+  const withoutPrevious = String(existingContent || '').replace(pattern, '').trimEnd();
+  if (!withoutPrevious) {
+    return nextBlock;
+  }
+  return `${withoutPrevious}\n\n${nextBlock}`;
+}
+
+export function mergeCodexConfig(existingContent, serverName, serverDefinition) {
+  return replaceManagedBlock(existingContent, serverName, buildCodexManagedBlock(serverName, serverDefinition));
+}
+
+export function mergeClaudeCodeConfig(existingConfig, serverName, serverDefinition) {
+  const nextConfig = existingConfig && typeof existingConfig === 'object' ? { ...existingConfig } : {};
+  nextConfig.mcpServers = nextConfig.mcpServers && typeof nextConfig.mcpServers === 'object'
+    ? { ...nextConfig.mcpServers }
+    : {};
+  nextConfig.mcpServers[serverName] = {
+    command: serverDefinition.command,
+    args: [...(serverDefinition.args || [])],
+    env: { ...(serverDefinition.env || {}) }
+  };
+  return nextConfig;
+}
+
+export function installReferenceConnector({
+  ecosystem,
+  cloudUrl,
+  cloudApiKey,
+  workspaceRoot = process.cwd(),
+  clientProfileId,
+  connectorId = '',
+  connectorType = '',
+  workspaceId = '',
+  packageRoot = null,
+  runtime = 'npm',
+  scope = 'user',
+  serverName = DEFAULT_SERVER_NAME,
+  homeDir = null,
+  dryRun = false
+}) {
+  const normalizedServerName = sanitizeServerName(serverName);
+  const target = getReferenceConnectorTarget({
+    ecosystem,
+    workspaceRoot,
+    scope,
+    homeDir
+  });
+  const serverDefinition = buildReferenceConnectorServer({
+    ecosystem,
+    cloudUrl,
+    cloudApiKey,
+    workspaceRoot,
+    clientProfileId,
+    connectorId,
+    connectorType,
+    workspaceId,
+    packageRoot,
+    runtime
+  });
+
+  let renderedContent = '';
+  if (target.format === 'toml') {
+    const existingContent = fs.existsSync(target.targetFile)
+      ? fs.readFileSync(target.targetFile, 'utf8')
+      : '';
+    renderedContent = mergeCodexConfig(existingContent, normalizedServerName, serverDefinition);
+  } else {
+    const existingConfig = readJson(target.targetFile, {});
+    renderedContent = JSON.stringify(
+      mergeClaudeCodeConfig(existingConfig, normalizedServerName, serverDefinition),
+      null,
+      2
+    );
+  }
+
+  if (!dryRun) {
+    ensureDir(target.targetFile);
+    fs.writeFileSync(target.targetFile, renderedContent, 'utf8');
+  }
+
+  return {
+    ecosystem: target.ecosystem,
+    scope: target.scope,
+    targetFile: target.targetFile,
+    serverName: normalizedServerName,
+    serverDefinition,
+    renderedContent,
+    written: !dryRun
+  };
+}
+
+export function printReferenceConnectorConfig(options) {
+  return installReferenceConnector({
+    ...options,
+    dryRun: true
+  });
+}

package/src/router.js

@@ -3,11 +3,12 @@
  */
 
 export class SmartRouter {
-  constructor(cloudUrl, cloudApiKey, localTools, workspaceRoot = null) {
+  constructor(cloudUrl, cloudApiKey, localTools, workspaceRoot = null, deviceIdentity = null) {
     this.cloudUrl = cloudUrl.replace(/\/$/, ''); // 移除尾部斜杠
     this.cloudApiKey = cloudApiKey;
     this.localTools = localTools;
     this.workspaceRoot = workspaceRoot || process.cwd();
+    this.deviceIdentity = deviceIdentity;
     
     // 工具路由规则
     this.routingRules = {
@@ -27,7 +28,12 @@ export class SmartRouter {
         'get_document_symbols',
         'replace_lines',
         'execute_command',
-        'execute_shell_command'
+        'execute_shell_command',
+        'connector_bridge_status',
+        'connector_sync_profile',
+        'connector_report_status',
+        'connector_discover_project_probe',
+        'connector_report_project_probe'
       ],
       
       // 云端工具（需要网络或云端资源）
@@ -151,21 +157,26 @@ export class SmartRouter {
     }
     
     try {
+      const body = JSON.stringify({
+        jsonrpc: '2.0',
+        id: Date.now(),
+        method: 'tools/call',
+        params: {
+          name: toolName,
+          arguments: params
+        }
+      });
+      const signedHeaders = this.deviceIdentity
+        ? await this.deviceIdentity.buildSignedHeaders({ method: 'POST', pathname: '/mcp', body })
+        : {};
       const response = await fetch(`${this.cloudUrl}/mcp`, {
         method: 'POST',
         headers: {
           'Authorization': `Bearer ${this.cloudApiKey}`,
-          'Content-Type': 'application/json'
+          'Content-Type': 'application/json',
+          ...signedHeaders
         },
-        body: JSON.stringify({
-          jsonrpc: '2.0',
-          id: Date.now(),
-          method: 'tools/call',
-          params: {
-            name: toolName,
-            arguments: params
-          }
-        })
+        body
       });
 
       if (!response.ok) {
@@ -263,18 +274,23 @@ export class SmartRouter {
    */
   async getCloudTools() {
     try {
+      const body = JSON.stringify({
+        jsonrpc: '2.0',
+        id: Date.now(),
+        method: 'tools/list',
+        params: {}
+      });
+      const signedHeaders = this.deviceIdentity
+        ? await this.deviceIdentity.buildSignedHeaders({ method: 'POST', pathname: '/mcp', body })
+        : {};
       const response = await fetch(`${this.cloudUrl}/mcp`, {
         method: 'POST',
         headers: {
           'Authorization': `Bearer ${this.cloudApiKey}`,
-          'Content-Type': 'application/json'
+          'Content-Type': 'application/json',
+          ...signedHeaders
         },
-        body: JSON.stringify({
-          jsonrpc: '2.0',
-          id: Date.now(),
-          method: 'tools/list',
-          params: {}
-        })
+        body
       });
 
       if (!response.ok) {
@@ -294,4 +310,3 @@ export class SmartRouter {
     }
   }
 }
-

package/package-personal.json

@@ -1,28 +0,0 @@
-{
-  "name": "cloudflare-mcp-smart-proxy",
-  "version": "1.1.1",
-  "description": "Smart proxy for Cloudflare MCP - routes tools to cloud or local execution",
-  "type": "module",
-  "main": "index.js",
-  "bin": {
-    "cloudflare-mcp-proxy": "./index.js"
-  },
-  "scripts": {
-    "start": "node index.js"
-  },
-  "keywords": [
-    "mcp",
-    "cloudflare",
-    "proxy",
-    "local",
-    "filesystem"
-  ],
-  "author": "",
-  "license": "MIT",
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0"
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  }
-}