cloudflare-mcp-smart-proxy 1.0.0

package/src/tools/file-operations.js

@@ -0,0 +1,211 @@
+/**
+ * Local File Operations - 本地文件操作工具
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+
+export class FileOperations {
+  /**
+   * 验证文件路径安全性
+   */
+  static validatePath(filePath, workspaceRoot) {
+    // 防止路径遍历攻击
+    if (filePath.includes('..')) {
+      throw new Error('Invalid file path: path traversal not allowed');
+    }
+    
+    // 限制在工作目录内
+    const resolvedPath = path.resolve(workspaceRoot, filePath);
+    const resolvedRoot = path.resolve(workspaceRoot);
+    
+    if (!resolvedPath.startsWith(resolvedRoot)) {
+      throw new Error('File path outside workspace root');
+    }
+    
+    return resolvedPath;
+  }
+
+  /**
+   * 读取文件
+   */
+  static async readFile(params, workspaceRoot) {
+    const { target_file, offset, limit } = params;
+    
+    if (!target_file) {
+      throw new Error('target_file parameter is required');
+    }
+    
+    const filePath = this.validatePath(target_file, workspaceRoot);
+    
+    try {
+      const content = await fs.readFile(filePath, 'utf-8');
+      const lines = content.split('\n');
+      
+      const startLine = offset || 0;
+      const endLine = limit ? startLine + limit : lines.length;
+      const selectedLines = lines.slice(startLine, endLine);
+      
+      return {
+        file: target_file,
+        content: selectedLines.join('\n'),
+        totalLines: lines.length,
+        startLine,
+        endLine: startLine + selectedLines.length
+      };
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        throw new Error(`File not found: ${target_file}`);
+      }
+      throw new Error(`Read file failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * 写入文件
+   */
+  static async writeFile(params, workspaceRoot) {
+    const { file_path, contents, overwrite = true } = params;
+    
+    if (!file_path || contents === undefined) {
+      throw new Error('file_path and contents parameters are required');
+    }
+    
+    const filePath = this.validatePath(file_path, workspaceRoot);
+    
+    try {
+      // 检查文件是否存在
+      let exists = false;
+      try {
+        await fs.access(filePath);
+        exists = true;
+      } catch {
+        exists = false;
+      }
+      
+      if (exists && !overwrite) {
+        throw new Error(`File already exists: ${file_path}. Use overwrite=true to replace.`);
+      }
+      
+      // 确保目录存在
+      const dir = path.dirname(filePath);
+      await fs.mkdir(dir, { recursive: true });
+      
+      // 写入文件
+      await fs.writeFile(filePath, contents, 'utf-8');
+      
+      return {
+        success: true,
+        file: file_path,
+        size: contents.length,
+        created: !exists,
+        overwritten: exists
+      };
+    } catch (error) {
+      if (error.message.includes('already exists')) {
+        throw error;
+      }
+      throw new Error(`Write file failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * 列出目录
+   */
+  static async listDir(params, workspaceRoot) {
+    const { target_directory, recursive = false } = params;
+    
+    if (!target_directory) {
+      throw new Error('target_directory parameter is required');
+    }
+    
+    const dirPath = this.validatePath(target_directory, workspaceRoot);
+    
+    try {
+      const files = [];
+      
+      async function scanDir(currentPath, relativePath) {
+        try {
+          const entries = await fs.readdir(currentPath, { withFileTypes: true });
+          
+          for (const entry of entries) {
+            const fullPath = path.join(currentPath, entry.name);
+            const relPath = path.join(relativePath, entry.name);
+            
+            if (entry.isDirectory()) {
+              if (recursive) {
+                await scanDir(fullPath, relPath);
+              } else {
+                files.push({
+                  name: entry.name,
+                  path: relPath,
+                  type: 'directory'
+                });
+              }
+            } else {
+              const stats = await fs.stat(fullPath);
+              files.push({
+                name: entry.name,
+                path: relPath,
+                type: 'file',
+                size: stats.size,
+                modified: stats.mtime.toISOString()
+              });
+            }
+          }
+        } catch (error) {
+          // 忽略权限错误，继续扫描其他目录
+          console.error(`Error scanning ${currentPath}:`, error.message);
+        }
+      }
+      
+      await scanDir(dirPath, target_directory);
+      
+      return {
+        directory: target_directory,
+        files,
+        total: files.length
+      };
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        throw new Error(`Directory not found: ${target_directory}`);
+      }
+      throw new Error(`List directory failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * 删除文件
+   */
+  static async deleteFile(params, workspaceRoot) {
+    const { file_path } = params;
+    
+    if (!file_path) {
+      throw new Error('file_path parameter is required');
+    }
+    
+    const filePath = this.validatePath(file_path, workspaceRoot);
+    
+    try {
+      const stats = await fs.stat(filePath);
+      
+      if (stats.isDirectory()) {
+        throw new Error('Cannot delete directory. Use a different method for directories.');
+      }
+      
+      await fs.unlink(filePath);
+      
+      return {
+        success: true,
+        file: file_path,
+        deleted: true
+      };
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        throw new Error(`File not found: ${file_path}`);
+      }
+      throw new Error(`Delete file failed: ${error.message}`);
+    }
+  }
+}
+