ssh-mcp-devops 2.0.0

package/security-checker.js

@@ -0,0 +1,43 @@
+export class SecurityChecker {
+  constructor() {
+    // 危险命令模式
+    this.dangerousPatterns = [
+      { pattern: /rm\s+-rf\s+\//, reason: '删除根目录', level: 'critical' },
+      { pattern: /rm\s+-rf/, reason: '强制递归删除', level: 'high' },
+      { pattern: /dd\s+if=.*of=\/dev/, reason: '磁盘写入操作', level: 'critical' },
+      { pattern: /mkfs/, reason: '格式化文件系统', level: 'critical' },
+      { pattern: /:\(\)\{.*\}/, reason: 'Fork炸弹', level: 'critical' },
+      { pattern: /chmod\s+777/, reason: '设置最大权限', level: 'medium' },
+      { pattern: /shutdown|reboot|halt/, reason: '系统关机/重启', level: 'high' },
+      { pattern: /iptables.*-F/, reason: '清空防火墙规则', level: 'high' },
+      { pattern: /userdel|deluser/, reason: '删除用户', level: 'medium' },
+      { pattern: />.*\/dev\/sda/, reason: '直接写入磁盘', level: 'critical' },
+    ];
+  }
+
+  checkCommand(command) {
+    for (const { pattern, reason, level } of this.dangerousPatterns) {
+      if (pattern.test(command)) {
+        return {
+          isDangerous: true,
+          level,
+          reason,
+          command,
+        };
+      }
+    }
+
+    return {
+      isDangerous: false,
+      level: 'safe',
+      reason: '命令安全',
+      command,
+    };
+  }
+
+  // 检查路径是否安全
+  isPathSafe(path) {
+    const dangerousPaths = ['/', '/etc', '/boot', '/sys', '/proc'];
+    return !dangerousPaths.some(dp => path === dp || path.startsWith(dp + '/'));
+  }
+}

package/ssh-manager-v2.js

@@ -0,0 +1,299 @@
+import { Client } from 'ssh2';
+import fs from 'fs/promises';
+import path from 'path';
+
+export class SSHManager {
+  constructor() {
+    this.client = null;
+    this.connected = false;
+    this.config = null;
+    this.reconnectAttempts = 0;
+    this.maxReconnectAttempts = 3;
+    this.commandTimeout = 300000; // 5分钟超时
+  }
+
+  async autoConnect(config) {
+    this.config = config;
+    if (config.privateKeyPath) {
+      try {
+        config.privateKey = await fs.readFile(config.privateKeyPath, 'utf-8');
+      } catch (error) {
+        throw new Error(`无法读取私钥文件: ${error.message}`);
+      }
+    }
+    return this.connect(config);
+  }
+
+  async connect(config) {
+    return new Promise((resolve, reject) => {
+      // 如果已连接，先断开
+      if (this.client) {
+        this.client.end();
+      }
+
+      this.client = new Client();
+      
+      const connectionConfig = {
+        host: config.host,
+        port: config.port || 22,
+        username: config.username,
+        readyTimeout: 30000, // 30秒连接超时
+        keepaliveInterval: 10000, // 10秒心跳
+      };
+
+      if (config.password) {
+        connectionConfig.password = config.password;
+      } else if (config.privateKey) {
+        connectionConfig.privateKey = config.privateKey;
+      } else {
+        return reject(new Error('必须提供密码或私钥'));
+      }
+
+      const timeout = setTimeout(() => {
+        this.client.end();
+        reject(new Error('连接超时'));
+      }, 30000);
+
+      this.client
+        .on('ready', () => {
+          clearTimeout(timeout);
+          this.connected = true;
+          this.reconnectAttempts = 0;
+          resolve(`✅ 成功连接到 ${config.username}@${config.host}:${config.port || 22}`);
+        })
+        .on('error', (err) => {
+          clearTimeout(timeout);
+          this.connected = false;
+          reject(new Error(`SSH连接失败: ${err.message}`));
+        })
+        .on('close', () => {
+          this.connected = false;
+          console.error('SSH连接已关闭');
+        })
+        .connect(connectionConfig);
+    });
+  }
+
+  async ensureConnected() {
+    if (!this.connected && this.config && this.reconnectAttempts < this.maxReconnectAttempts) {
+      console.error('连接已断开，尝试重新连接...');
+      this.reconnectAttempts++;
+      try {
+        await this.connect(this.config);
+      } catch (error) {
+        throw new Error(`重连失败 (${this.reconnectAttempts}/${this.maxReconnectAttempts}): ${error.message}`);
+      }
+    }
+    
+    if (!this.connected) {
+      throw new Error('未连接到SSH服务器，请先使用 ssh_connect');
+    }
+  }
+
+  async execCommand(command, options = {}) {
+    await this.ensureConnected();
+
+    const timeout = options.timeout || this.commandTimeout;
+
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(new Error(`命令执行超时 (${timeout}ms): ${command}`));
+      }, timeout);
+
+      this.client.exec(command, (err, stream) => {
+        if (err) {
+          clearTimeout(timer);
+          return reject(err);
+        }
+
+        let stdout = '';
+        let stderr = '';
+
+        stream
+          .on('close', (code) => {
+            clearTimeout(timer);
+            if (code !== 0 && stderr) {
+              reject(new Error(`命令执行失败 (退出码: ${code})\n${stderr}`));
+            } else {
+              const output = stdout || stderr || `命令执行完成 (退出码: ${code})`;
+              resolve(output);
+            }
+          })
+          .on('data', (data) => {
+            stdout += data.toString();
+          })
+          .stderr.on('data', (data) => {
+            stderr += data.toString();
+          });
+      });
+    });
+  }
+
+  async uploadFile(localPath, remotePath, options = {}) {
+    await this.ensureConnected();
+
+    // 检查本地文件是否存在
+    try {
+      await fs.access(localPath);
+    } catch (error) {
+      throw new Error(`本地文件不存在: ${localPath}`);
+    }
+
+    return new Promise((resolve, reject) => {
+      this.client.sftp((err, sftp) => {
+        if (err) return reject(err);
+
+        const transferOptions = {
+          concurrency: 64,
+          chunkSize: 32768,
+          step: options.onProgress || undefined,
+        };
+
+        sftp.fastPut(localPath, remotePath, transferOptions, (err) => {
+          sftp.end();
+          if (err) return reject(new Error(`上传失败: ${err.message}`));
+          resolve(`✅ 文件上传成功: ${localPath} -> ${remotePath}`);
+        });
+      });
+    });
+  }
+
+  async downloadFile(remotePath, localPath, options = {}) {
+    await this.ensureConnected();
+
+    // 确保本地目录存在
+    const localDir = path.dirname(localPath);
+    await fs.mkdir(localDir, { recursive: true });
+
+    return new Promise((resolve, reject) => {
+      this.client.sftp((err, sftp) => {
+        if (err) return reject(err);
+
+        const transferOptions = {
+          concurrency: 64,
+          chunkSize: 32768,
+          step: options.onProgress || undefined,
+        };
+
+        sftp.fastGet(remotePath, localPath, transferOptions, (err) => {
+          sftp.end();
+          if (err) return reject(new Error(`下载失败: ${err.message}`));
+          resolve(`✅ 文件下载成功: ${remotePath} -> ${localPath}`);
+        });
+      });
+    });
+  }
+
+  async uploadDirectory(localDir, remoteDir) {
+    await this.ensureConnected();
+
+    return new Promise((resolve, reject) => {
+      this.client.sftp(async (err, sftp) => {
+        if (err) return reject(err);
+
+        try {
+          // 创建远程目录
+          await this.execCommand(`mkdir -p ${remoteDir}`);
+
+          const files = await fs.readdir(localDir, { withFileTypes: true });
+          
+          for (const file of files) {
+            const localPath = path.join(localDir, file.name);
+            const remotePath = `${remoteDir}/${file.name}`;
+
+            if (file.isDirectory()) {
+              await this.uploadDirectory(localPath, remotePath);
+            } else {
+              await new Promise((res, rej) => {
+                sftp.fastPut(localPath, remotePath, (err) => {
+                  if (err) rej(err);
+                  else res();
+                });
+              });
+            }
+          }
+
+          sftp.end();
+          resolve(`✅ 目录上传成功: ${localDir} -> ${remoteDir}`);
+        } catch (error) {
+          sftp.end();
+          reject(error);
+        }
+      });
+    });
+  }
+
+  async deployProject(projectPath, remotePath, deployScript) {
+    const steps = [];
+    
+    try {
+      // 1. 在远程创建临时目录
+      steps.push('📦 准备部署环境...');
+      const timestamp = Date.now();
+      const tempDir = `/tmp/deploy-${timestamp}`;
+      await this.execCommand(`mkdir -p ${tempDir}`);
+      
+      // 2. 上传项目文件
+      steps.push('⬆️  上传项目文件...');
+      await this.uploadDirectory(projectPath, tempDir);
+      
+      // 3. 备份现有部署（如果存在）
+      steps.push('💾 备份现有部署...');
+      const backupPath = `${remotePath}.backup.${timestamp}`;
+      await this.execCommand(`if [ -d "${remotePath}" ]; then cp -r ${remotePath} ${backupPath}; fi`);
+      
+      // 4. 移动到目标目录
+      steps.push('📂 部署到目标目录...');
+      await this.execCommand(`mkdir -p ${remotePath} && cp -r ${tempDir}/* ${remotePath}/`);
+      
+      // 5. 执行部署脚本
+      steps.push('🚀 执行部署脚本...');
+      const result = await this.execCommand(`cd ${remotePath} && ${deployScript}`, { timeout: 600000 });
+      
+      // 6. 清理临时文件
+      steps.push('🧹 清理临时文件...');
+      await this.execCommand(`rm -rf ${tempDir}`);
+      
+      steps.push('✅ 部署完成！');
+      steps.push(`\n备份位置: ${backupPath}`);
+      
+      return steps.join('\n') + '\n\n部署输出:\n' + result;
+    } catch (error) {
+      steps.push(`❌ 部署失败: ${error.message}`);
+      throw new Error(steps.join('\n'));
+    }
+  }
+
+  async getSystemInfo() {
+    await this.ensureConnected();
+
+    const commands = {
+      hostname: 'hostname',
+      os: 'cat /etc/os-release | grep PRETTY_NAME | cut -d= -f2 | tr -d \'"\'',
+      kernel: 'uname -r',
+      uptime: 'uptime -p',
+      cpu: 'lscpu | grep "Model name" | cut -d: -f2 | xargs',
+      memory: 'free -h | grep Mem | awk \'{print $2}\'',
+      disk: 'df -h / | tail -1 | awk \'{print $2}\'',
+    };
+
+    const info = {};
+    for (const [key, cmd] of Object.entries(commands)) {
+      try {
+        info[key] = (await this.execCommand(cmd)).trim();
+      } catch (error) {
+        info[key] = 'N/A';
+      }
+    }
+
+    return info;
+  }
+
+  disconnect() {
+    if (this.client) {
+      this.client.end();
+      this.connected = false;
+      this.client = null;
+    }
+  }
+}

package/ssh-manager.js

@@ -0,0 +1,144 @@
+import { Client } from 'ssh2';
+import fs from 'fs/promises';
+import path from 'path';
+
+export class SSHManager {
+  constructor() {
+    this.client = null;
+    this.connected = false;
+    this.config = null;
+  }
+
+  async autoConnect(config) {
+    this.config = config;
+    if (config.privateKeyPath) {
+      const fs = await import('fs/promises');
+      config.privateKey = await fs.readFile(config.privateKeyPath, 'utf-8');
+    }
+    return this.connect(config);
+  }
+
+  async connect(config) {
+    return new Promise((resolve, reject) => {
+      this.client = new Client();
+      
+      const connectionConfig = {
+        host: config.host,
+        port: config.port || 22,
+        username: config.username,
+      };
+
+      if (config.password) {
+        connectionConfig.password = config.password;
+      } else if (config.privateKey) {
+        connectionConfig.privateKey = config.privateKey;
+      }
+
+      this.client
+        .on('ready', () => {
+          this.connected = true;
+          resolve(`✅ 成功连接到 ${config.username}@${config.host}:${config.port || 22}`);
+        })
+        .on('error', (err) => {
+          this.connected = false;
+          reject(new Error(`SSH连接失败: ${err.message}`));
+        })
+        .connect(connectionConfig);
+    });
+  }
+
+  async execCommand(command) {
+    if (!this.connected) {
+      throw new Error('未连接到SSH服务器，请先使用 ssh_connect');
+    }
+
+    return new Promise((resolve, reject) => {
+      this.client.exec(command, (err, stream) => {
+        if (err) return reject(err);
+
+        let stdout = '';
+        let stderr = '';
+
+        stream
+          .on('close', (code) => {
+            const output = stdout || stderr || `命令执行完成 (退出码: ${code})`;
+            resolve(output);
+          })
+          .on('data', (data) => {
+            stdout += data.toString();
+          })
+          .stderr.on('data', (data) => {
+            stderr += data.toString();
+          });
+      });
+    });
+  }
+
+  async uploadFile(localPath, remotePath) {
+    if (!this.connected) {
+      throw new Error('未连接到SSH服务器');
+    }
+
+    return new Promise((resolve, reject) => {
+      this.client.sftp((err, sftp) => {
+        if (err) return reject(err);
+
+        sftp.fastPut(localPath, remotePath, (err) => {
+          if (err) return reject(new Error(`上传失败: ${err.message}`));
+          resolve(`✅ 文件上传成功: ${localPath} -> ${remotePath}`);
+        });
+      });
+    });
+  }
+
+  async downloadFile(remotePath, localPath) {
+    if (!this.connected) {
+      throw new Error('未连接到SSH服务器');
+    }
+
+    return new Promise((resolve, reject) => {
+      this.client.sftp((err, sftp) => {
+        if (err) return reject(err);
+
+        sftp.fastGet(remotePath, localPath, (err) => {
+          if (err) return reject(new Error(`下载失败: ${err.message}`));
+          resolve(`✅ 文件下载成功: ${remotePath} -> ${localPath}`);
+        });
+      });
+    });
+  }
+
+  async deployProject(projectPath, remotePath, deployScript) {
+    const steps = [];
+    
+    // 1. 压缩项目
+    steps.push('📦 压缩项目文件...');
+    const archiveName = `deploy-${Date.now()}.tar.gz`;
+    await this.execCommand(`cd ${projectPath} && tar -czf /tmp/${archiveName} .`);
+    
+    // 2. 上传压缩包
+    steps.push('⬆️  上传到远程服务器...');
+    await this.uploadFile(`/tmp/${archiveName}`, `/tmp/${archiveName}`);
+    
+    // 3. 解压到目标目录
+    steps.push('📂 解压文件...');
+    await this.execCommand(`mkdir -p ${remotePath} && tar -xzf /tmp/${archiveName} -C ${remotePath}`);
+    
+    // 4. 执行部署脚本
+    steps.push('🚀 执行部署脚本...');
+    const result = await this.execCommand(`cd ${remotePath} && ${deployScript}`);
+    
+    // 5. 清理临时文件
+    await this.execCommand(`rm /tmp/${archiveName}`);
+    
+    steps.push('✅ 部署完成！');
+    return steps.join('\n') + '\n\n' + result;
+  }
+
+  disconnect() {
+    if (this.client) {
+      this.client.end();
+      this.connected = false;
+    }
+  }
+}

package/system-monitor.js

@@ -0,0 +1,136 @@
+export class SystemMonitor {
+  constructor(sshManager) {
+    this.ssh = sshManager;
+  }
+
+  async getCPUUsage() {
+    const output = await this.ssh.execCommand("top -bn1 | grep 'Cpu(s)' | awk '{print $2}' | cut -d'%' -f1");
+    return parseFloat(output.trim());
+  }
+
+  async getMemoryUsage() {
+    const output = await this.ssh.execCommand("free | grep Mem | awk '{printf \"%.2f\", $3/$2 * 100.0}'");
+    return parseFloat(output.trim());
+  }
+
+  async getDiskUsage(path = '/') {
+    const output = await this.ssh.execCommand(`df -h ${path} | tail -1 | awk '{print $5}' | cut -d'%' -f1`);
+    return parseFloat(output.trim());
+  }
+
+  async getLoadAverage() {
+    const output = await this.ssh.execCommand("uptime | awk -F'load average:' '{print $2}' | xargs");
+    const [load1, load5, load15] = output.trim().split(',').map(s => parseFloat(s.trim()));
+    return { load1, load5, load15 };
+  }
+
+  async getNetworkStats() {
+    const output = await this.ssh.execCommand("cat /proc/net/dev | grep -E 'eth0|ens|enp' | head -1 | awk '{print $2,$10}'");
+    const [received, transmitted] = output.trim().split(' ').map(Number);
+    
+    return {
+      received: this.formatBytes(received),
+      transmitted: this.formatBytes(transmitted),
+    };
+  }
+
+  async getProcessList(limit = 10) {
+    const output = await this.ssh.execCommand(`ps aux --sort=-%mem | head -${limit + 1}`);
+    const lines = output.trim().split('\n');
+    
+    const processes = lines.slice(1).map(line => {
+      const parts = line.trim().split(/\s+/);
+      return {
+        user: parts[0],
+        pid: parts[1],
+        cpu: parts[2],
+        memory: parts[3],
+        command: parts.slice(10).join(' '),
+      };
+    });
+
+    return processes;
+  }
+
+  async getServiceStatus(serviceName) {
+    try {
+      const output = await this.ssh.execCommand(`systemctl is-active ${serviceName}`);
+      return output.trim() === 'active';
+    } catch (error) {
+      return false;
+    }
+  }
+
+  async restartService(serviceName) {
+    const output = await this.ssh.execCommand(`sudo systemctl restart ${serviceName}`);
+    return `✅ 服务已重启: ${serviceName}\n${output}`;
+  }
+
+  async getSystemLogs(lines = 50) {
+    const output = await this.ssh.execCommand(`journalctl -n ${lines} --no-pager`);
+    return output;
+  }
+
+  async getFileContent(filePath, lines = 50) {
+    const output = await this.ssh.execCommand(`tail -n ${lines} ${filePath}`);
+    return output;
+  }
+
+  async searchInLogs(pattern, logFile = '/var/log/syslog', lines = 20) {
+    const output = await this.ssh.execCommand(`grep -i "${pattern}" ${logFile} | tail -n ${lines}`);
+    return output;
+  }
+
+  async getOpenPorts() {
+    const output = await this.ssh.execCommand("ss -tuln | grep LISTEN");
+    const lines = output.trim().split('\n');
+    
+    const ports = lines.map(line => {
+      const parts = line.trim().split(/\s+/);
+      const address = parts[4];
+      const [ip, port] = address.split(':');
+      return { protocol: parts[0], port, ip: ip || '*' };
+    });
+
+    return ports;
+  }
+
+  async checkDiskIO() {
+    const output = await this.ssh.execCommand("iostat -x 1 2 | tail -n +4 | grep -E 'sda|vda|nvme' | tail -1");
+    const parts = output.trim().split(/\s+/);
+    
+    return {
+      device: parts[0],
+      readKBps: parts[5],
+      writeKBps: parts[6],
+      utilization: parts[13],
+    };
+  }
+
+  async getSystemHealth() {
+    const [cpu, memory, disk, load] = await Promise.all([
+      this.getCPUUsage(),
+      this.getMemoryUsage(),
+      this.getDiskUsage(),
+      this.getLoadAverage(),
+    ]);
+
+    const health = {
+      cpu: { usage: cpu, status: cpu > 80 ? 'warning' : 'ok' },
+      memory: { usage: memory, status: memory > 80 ? 'warning' : 'ok' },
+      disk: { usage: disk, status: disk > 80 ? 'warning' : 'ok' },
+      load: { ...load, status: load.load1 > 4 ? 'warning' : 'ok' },
+    };
+
+    const overallStatus = Object.values(health).some(h => h.status === 'warning') ? 'warning' : 'healthy';
+
+    return { ...health, overall: overallStatus };
+  }
+
+  formatBytes(bytes) {
+    const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+    if (bytes === 0) return '0 B';
+    const i = Math.floor(Math.log(bytes) / Math.log(1024));
+    return `${(bytes / Math.pow(1024, i)).toFixed(2)} ${sizes[i]}`;
+  }
+}