cloudflare-mcp-smart-proxy 1.0.0

package/src/local-tools.js

@@ -0,0 +1,197 @@
+/**
+ * Local Tool Executor - 本地工具执行器
+ */
+
+import { FileOperations } from './tools/file-operations.js';
+import { EditFile } from './tools/edit-file.js';
+import { CommandExecutor } from './tools/command-executor.js';
+
+export class LocalToolExecutor {
+  constructor(workspaceRoot) {
+    this.workspaceRoot = workspaceRoot;
+  }
+
+  /**
+   * 执行本地工具
+   */
+  async execute(toolName, params) {
+    switch (toolName) {
+      case 'read_file':
+        return await FileOperations.readFile(params, this.workspaceRoot);
+      
+      case 'write_file':
+      case 'create_file':
+        return await FileOperations.writeFile(params, this.workspaceRoot);
+      
+      case 'edit_file':
+      case 'replace_lines':
+        return await EditFile.execute(params, this.workspaceRoot);
+      
+      case 'list_dir':
+      case 'list_files':
+        return await FileOperations.listDir(params, this.workspaceRoot);
+      
+      case 'delete_file':
+        return await FileOperations.deleteFile(params, this.workspaceRoot);
+      
+      case 'execute_command':
+      case 'execute_shell_command':
+        return await CommandExecutor.execute(params, this.workspaceRoot);
+      
+      default:
+        throw new Error(`Unknown local tool: ${toolName}`);
+    }
+  }
+
+  /**
+   * 列出所有本地工具
+   */
+  listTools() {
+    return [
+      {
+        name: 'read_file',
+        description: 'Read a file from local filesystem',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            target_file: {
+              type: 'string',
+              description: 'Path to the file to read (relative to workspace root)'
+            },
+            offset: {
+              type: 'number',
+              description: 'Starting line number (0-based)'
+            },
+            limit: {
+              type: 'number',
+              description: 'Maximum number of lines to read'
+            }
+          },
+          required: ['target_file']
+        }
+      },
+      {
+        name: 'write_file',
+        description: 'Write content to a file in local filesystem',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            file_path: {
+              type: 'string',
+              description: 'Path to the file to write (relative to workspace root)'
+            },
+            contents: {
+              type: 'string',
+              description: 'File contents to write'
+            },
+            overwrite: {
+              type: 'boolean',
+              description: 'Whether to overwrite existing file (default: true)'
+            }
+          },
+          required: ['file_path', 'contents']
+        }
+      },
+      {
+        name: 'edit_file',
+        description: 'Edit a file using diff-based edits. Supports multiple edits in a single operation.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            path: {
+              type: 'string',
+              description: 'Path to the file to edit (relative to workspace root)'
+            },
+            edits: {
+              type: 'array',
+              description: 'Array of edit operations',
+              items: {
+                type: 'object',
+                properties: {
+                  type: {
+                    type: 'string',
+                    enum: ['replace', 'insert', 'delete'],
+                    description: 'Type of edit operation'
+                  },
+                  startLine: {
+                    type: 'number',
+                    description: 'Start line number (1-based, inclusive)'
+                  },
+                  endLine: {
+                    type: 'number',
+                    description: 'End line number (1-based, inclusive)'
+                  },
+                  oldText: {
+                    type: 'string',
+                    description: 'Original text to replace (for validation)'
+                  },
+                  newText: {
+                    type: 'string',
+                    description: 'New text to insert'
+                  }
+                },
+                required: ['type', 'startLine', 'endLine']
+              }
+            },
+            originalContent: {
+              type: 'string',
+              description: 'Original file content (for concurrency validation)'
+            }
+          },
+          required: ['path', 'edits']
+        }
+      },
+      {
+        name: 'list_dir',
+        description: 'List directory contents in local filesystem',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            target_directory: {
+              type: 'string',
+              description: 'Path to the directory (relative to workspace root)'
+            },
+            recursive: {
+              type: 'boolean',
+              description: 'Whether to list recursively (default: false)'
+            }
+          },
+          required: ['target_directory']
+        }
+      },
+      {
+        name: 'delete_file',
+        description: 'Delete a file from local filesystem',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            file_path: {
+              type: 'string',
+              description: 'Path to the file to delete (relative to workspace root)'
+            }
+          },
+          required: ['file_path']
+        }
+      },
+      {
+        name: 'execute_command',
+        description: 'Execute a shell command locally',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            command: {
+              type: 'string',
+              description: 'Shell command to execute'
+            },
+            cwd: {
+              type: 'string',
+              description: 'Working directory (default: workspace root)'
+            }
+          },
+          required: ['command']
+        }
+      }
+    ];
+  }
+}
+

package/src/router.js

@@ -0,0 +1,209 @@
+/**
+ * Smart Router - 智能路由工具请求到云端或本地
+ */
+
+export class SmartRouter {
+  constructor(cloudUrl, cloudApiKey, localTools) {
+    this.cloudUrl = cloudUrl.replace(/\/$/, ''); // 移除尾部斜杠
+    this.cloudApiKey = cloudApiKey;
+    this.localTools = localTools;
+    
+    // 工具路由规则
+    this.routingRules = {
+      // 本地工具（需要文件系统访问）
+      local: [
+        'read_file',
+        'write_file',
+        'edit_file',
+        'list_dir',
+        'list_files',
+        'create_file',
+        'delete_file',
+        'search_files',
+        'get_diagnostics',
+        'search_symbols',
+        'get_symbol_definition',
+        'get_document_symbols',
+        'replace_lines',
+        'execute_command',
+        'execute_shell_command'
+      ],
+      
+      // 云端工具（需要网络或云端资源）
+      cloud: [
+        'web_search',
+        'fetch_content',
+        'github_search_repos',
+        'github_get_repo',
+        'github_get_file',
+        'github_list_files',
+        'github_create_issue',
+        'github_list_issues',
+        'github_create_pr',
+        'github_get_commits',
+        'resolve_library_id',
+        'get_library_docs',
+        'create_entities',
+        'create_relations',
+        'add_observations',
+        'delete_entities',
+        'delete_observations',
+        'delete_relations',
+        'search_nodes',
+        'open_nodes',
+        'read_graph',
+        'get_datetime',
+        'sequentialthinking',
+        'get_config',
+        'set_config',
+        'codebase_search' // R2 存储的代码库搜索
+      ]
+    };
+  }
+
+  /**
+   * 判断工具应该路由到哪里
+   */
+  routeTool(toolName) {
+    // 检查是否是本地工具（精确匹配或前缀匹配）
+    for (const pattern of this.routingRules.local) {
+      if (toolName === pattern || toolName.startsWith(pattern + '_')) {
+        return 'local';
+      }
+    }
+    
+    // 检查是否是云端工具
+    for (const pattern of this.routingRules.cloud) {
+      if (toolName === pattern || toolName.startsWith(pattern + '_')) {
+        return 'cloud';
+      }
+    }
+    
+    // 默认路由到云端（安全策略）
+    return 'cloud';
+  }
+
+  /**
+   * 执行工具调用
+   */
+  async executeTool(toolName, params) {
+    const route = this.routeTool(toolName);
+    
+    if (route === 'local') {
+      return await this.localTools.execute(toolName, params);
+    } else {
+      return await this.callCloudTool(toolName, params);
+    }
+  }
+
+  /**
+   * 调用云端工具
+   */
+  async callCloudTool(toolName, params) {
+    try {
+      const response = await fetch(`${this.cloudUrl}/mcp`, {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${this.cloudApiKey}`,
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+          jsonrpc: '2.0',
+          id: Date.now(),
+          method: 'tools/call',
+          params: {
+            name: toolName,
+            arguments: params
+          }
+        })
+      });
+
+      if (!response.ok) {
+        throw new Error(`Cloud request failed: ${response.status} ${response.statusText}`);
+      }
+
+      const result = await response.json();
+      
+      if (result.error) {
+        throw new Error(result.error.message || 'Cloud tool execution failed');
+      }
+      
+      // 提取结果内容
+      if (result.result && result.result.content) {
+        // MCP 标准格式
+        const content = result.result.content;
+        if (Array.isArray(content) && content.length > 0) {
+          return content[0].text;
+        }
+        return content;
+      } else if (result.result) {
+        return result.result;
+      } else {
+        return result;
+      }
+    } catch (error) {
+      throw new Error(`Cloud tool call failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * 获取所有工具列表（合并云端和本地）
+   */
+  async getAllTools() {
+    try {
+      const [cloudTools, localTools] = await Promise.all([
+        this.getCloudTools(),
+        this.localTools.listTools()
+      ]);
+
+      // 合并工具列表，添加 source 标识
+      const allTools = [
+        ...cloudTools.map(t => ({ ...t, source: 'cloud' })),
+        ...localTools.map(t => ({ ...t, source: 'local' }))
+      ];
+
+      return allTools;
+    } catch (error) {
+      console.error('Error getting all tools:', error);
+      // 如果云端获取失败，至少返回本地工具
+      return this.localTools.listTools().map(t => ({ ...t, source: 'local' }));
+    }
+  }
+
+  /**
+   * 获取云端工具列表
+   */
+  async getCloudTools() {
+    try {
+      const response = await fetch(`${this.cloudUrl}/mcp`, {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${this.cloudApiKey}`,
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+          jsonrpc: '2.0',
+          id: Date.now(),
+          method: 'tools/list',
+          params: {}
+        })
+      });
+
+      if (!response.ok) {
+        throw new Error(`Failed to fetch cloud tools: ${response.status}`);
+      }
+
+      const result = await response.json();
+      
+      if (result.error) {
+        throw new Error(result.error.message || 'Failed to fetch cloud tools');
+      }
+      
+      return result.result?.tools || [];
+    } catch (error) {
+      console.error('Error fetching cloud tools:', error);
+      return [];
+    }
+  }
+}
+

package/src/tools/command-executor.js

@@ -0,0 +1,82 @@
+/**
+ * Command Executor - 本地命令执行工具
+ */
+
+import { spawn } from 'child_process';
+import path from 'path';
+
+export class CommandExecutor {
+  /**
+   * 执行命令
+   */
+  static async execute(params, workspaceRoot) {
+    const { command, cwd } = params;
+    
+    if (!command) {
+      throw new Error('command parameter is required');
+    }
+    
+    const workingDir = cwd ? path.resolve(workspaceRoot, cwd) : workspaceRoot;
+    
+    return new Promise((resolve, reject) => {
+      // 解析命令和参数
+      const parts = command.trim().split(/\s+/);
+      const cmd = parts[0];
+      const args = parts.slice(1);
+      
+      // 安全限制：禁止某些危险命令
+      const dangerousCommands = ['rm', 'del', 'format', 'shutdown', 'reboot'];
+      if (dangerousCommands.some(danger => cmd.includes(danger))) {
+        reject(new Error(`Command "${cmd}" is not allowed for security reasons`));
+        return;
+      }
+      
+      const startTime = Date.now();
+      let stdout = '';
+      let stderr = '';
+      
+      // 执行命令
+      const proc = spawn(cmd, args, {
+        cwd: workingDir,
+        shell: true,
+        stdio: ['ignore', 'pipe', 'pipe']
+      });
+      
+      // 收集输出
+      proc.stdout.on('data', (data) => {
+        stdout += data.toString();
+      });
+      
+      proc.stderr.on('data', (data) => {
+        stderr += data.toString();
+      });
+      
+      // 处理完成
+      proc.on('close', (code) => {
+        const duration = Date.now() - startTime;
+        
+        resolve({
+          success: code === 0,
+          exitCode: code,
+          stdout: stdout.trim(),
+          stderr: stderr.trim(),
+          duration: duration,
+          command: command,
+          cwd: workingDir
+        });
+      });
+      
+      // 处理错误
+      proc.on('error', (error) => {
+        reject(new Error(`Command execution failed: ${error.message}`));
+      });
+      
+      // 超时保护（30秒）
+      setTimeout(() => {
+        proc.kill();
+        reject(new Error('Command execution timeout (30s)'));
+      }, 30000);
+    });
+  }
+}
+

package/src/tools/edit-file.js

@@ -0,0 +1,204 @@
+/**
+ * Edit File - 差异文件编辑工具
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { FileOperations } from './file-operations.js';
+
+export class EditFile {
+  /**
+   * 执行差异编辑
+   */
+  static async execute(params, workspaceRoot) {
+    const { path: filePath, edits, originalContent } = params;
+    
+    if (!filePath || !edits || !Array.isArray(edits) || edits.length === 0) {
+      throw new Error('path and edits (array) parameters are required');
+    }
+    
+    // 读取当前文件
+    let currentContent;
+    try {
+      currentContent = await FileOperations.readFile({ 
+        target_file: filePath 
+      }, workspaceRoot);
+    } catch (error) {
+      throw new Error(`Failed to read file: ${error.message}`);
+    }
+    
+    const fullContent = currentContent.content;
+    
+    // 验证原始内容（防止并发修改）
+    if (originalContent && fullContent !== originalContent) {
+      throw new Error('File has been modified. Please refresh and try again.');
+    }
+    
+    // 应用所有编辑操作
+    let lines = fullContent.split('\n');
+    const appliedEdits = [];
+    
+    // 按行号排序编辑（从后往前，避免行号偏移问题）
+    const sortedEdits = [...edits].sort((a, b) => b.startLine - a.startLine);
+    
+    for (const edit of sortedEdits) {
+      try {
+        const result = this.applyEdit(lines, edit);
+        lines = result.newLines;
+        appliedEdits.push({
+          ...result,
+          edit: edit
+        });
+      } catch (error) {
+        throw new Error(`Edit failed at lines ${edit.startLine}-${edit.endLine}: ${error.message}`);
+      }
+    }
+    
+    // 写回文件
+    const newContent = lines.join('\n');
+    await FileOperations.writeFile({
+      file_path: filePath,
+      contents: newContent,
+      overwrite: true
+    }, workspaceRoot);
+    
+    // 生成 diff
+    const diff = this.generateDiff(fullContent, newContent);
+    
+    return {
+      success: true,
+      file: filePath,
+      editsApplied: appliedEdits.length,
+      diff: diff,
+      preview: this.generatePreview(lines, appliedEdits)
+    };
+  }
+
+  /**
+   * 应用单个编辑操作
+   */
+  static applyEdit(lines, edit) {
+    const { type, startLine, endLine, oldText, newText } = edit;
+    
+    // 验证行号（1-based to 0-based）
+    const start = startLine - 1;
+    const end = endLine - 1;
+    
+    if (start < 0 || end >= lines.length || start > end) {
+      throw new Error(`Invalid line range: ${startLine}-${endLine} (file has ${lines.length} lines)`);
+    }
+    
+    // 提取原始文本（用于验证）
+    const actualOldText = lines.slice(start, end + 1).join('\n');
+    
+    // 验证原始文本（如果提供了 oldText）
+    if (oldText !== undefined && actualOldText !== oldText) {
+      throw new Error(`Content mismatch at lines ${startLine}-${endLine}. Expected:\n${oldText}\nGot:\n${actualOldText}`);
+    }
+    
+    // 执行替换
+    const newLines = newText !== undefined ? newText.split('\n') : [];
+    
+    const result = {
+      startLine: start,
+      endLine: end,
+      newLines: [
+        ...lines.slice(0, start),
+        ...newLines,
+        ...lines.slice(end + 1)
+      ]
+    };
+    
+    return result;
+  }
+
+  /**
+   * 生成简单的行级 diff
+   */
+  static generateDiff(oldContent, newContent) {
+    const oldLines = oldContent.split('\n');
+    const newLines = newContent.split('\n');
+    const diff = [];
+    
+    let i = 0, j = 0;
+    while (i < oldLines.length || j < newLines.length) {
+      if (i >= oldLines.length) {
+        // 新文件有额外行
+        diff.push(`+${newLines[j]}`);
+        j++;
+      } else if (j >= newLines.length) {
+        // 旧文件有删除行
+        diff.push(`-${oldLines[i]}`);
+        i++;
+      } else if (oldLines[i] === newLines[j]) {
+        // 相同行
+        diff.push(` ${oldLines[i]}`);
+        i++;
+        j++;
+      } else {
+        // 查找下一个匹配
+        const nextMatch = this.findNextMatch(oldLines, newLines, i, j);
+        if (nextMatch.oldIndex === i && nextMatch.newIndex === j) {
+          // 没有匹配，都是修改
+          diff.push(`-${oldLines[i]}`);
+          diff.push(`+${newLines[j]}`);
+          i++;
+          j++;
+        } else {
+          // 处理中间的差异
+          while (i < nextMatch.oldIndex) {
+            diff.push(`-${oldLines[i]}`);
+            i++;
+          }
+          while (j < nextMatch.newIndex) {
+            diff.push(`+${newLines[j]}`);
+            j++;
+          }
+        }
+      }
+    }
+    
+    return diff.join('\n');
+  }
+
+  /**
+   * 查找下一个匹配的行
+   */
+  static findNextMatch(oldLines, newLines, oldStart, newStart) {
+    // 简单的贪心匹配：查找最近的匹配行
+    for (let i = oldStart + 1; i < oldLines.length && i < oldStart + 10; i++) {
+      for (let j = newStart + 1; j < newLines.length && j < newStart + 10; j++) {
+        if (oldLines[i] === newLines[j]) {
+          return { oldIndex: i, newIndex: j };
+        }
+      }
+    }
+    return { oldIndex: oldStart, newIndex: newStart };
+  }
+
+  /**
+   * 生成编辑预览
+   */
+  static generatePreview(lines, appliedEdits) {
+    const previews = [];
+    
+    for (const applied of appliedEdits) {
+      const edit = applied.edit;
+      const startLine = applied.startLine;
+      const endLine = applied.endLine;
+      const newLinesCount = applied.newLines.length - (endLine - startLine + 1);
+      
+      const contextStart = Math.max(0, startLine - 2);
+      const contextEnd = Math.min(lines.length, startLine + newLinesCount + 2);
+      
+      previews.push({
+        range: `${edit.startLine}-${edit.endLine}`,
+        context: lines.slice(contextStart, contextEnd).join('\n'),
+        changes: applied.newLines.slice(startLine, startLine + newLinesCount).join('\n')
+      });
+    }
+    
+    return previews;
+  }
+}
+