myaidev-method 0.0.1

package/src/mcp/ssh-integration.js

@@ -0,0 +1,488 @@
+import { Client } from 'ssh2';
+import fs from 'fs';
+import path from 'path';
+
+export class SSHWordPressManager {
+  constructor(config) {
+    this.host = config.host;
+    this.username = config.username;
+    this.privateKeyPath = config.privateKeyPath;
+    this.password = config.password; // Alternative to key auth
+    this.port = config.port || 22;
+    this.wordpressPath = config.wordpressPath || '/var/www/html';
+    this.connection = null;
+  }
+
+  async connect() {
+    return new Promise((resolve, reject) => {
+      this.connection = new Client();
+      
+      const authConfig = {
+        host: this.host,
+        port: this.port,
+        username: this.username
+      };
+
+      // Use private key if available, otherwise password
+      if (this.privateKeyPath && fs.existsSync(this.privateKeyPath)) {
+        authConfig.privateKey = fs.readFileSync(this.privateKeyPath);
+      } else if (this.password) {
+        authConfig.password = this.password;
+      } else {
+        reject(new Error('No valid authentication method provided'));
+        return;
+      }
+
+      this.connection.on('ready', () => {
+        resolve(true);
+      });
+
+      this.connection.on('error', (err) => {
+        reject(err);
+      });
+
+      this.connection.connect(authConfig);
+    });
+  }
+
+  async executeCommand(command, options = {}) {
+    if (!this.connection) {
+      throw new Error('SSH connection not established');
+    }
+
+    return new Promise((resolve, reject) => {
+      this.connection.exec(command, (err, stream) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+
+        let stdout = '';
+        let stderr = '';
+
+        stream.on('close', (code, signal) => {
+          resolve({
+            code,
+            signal,
+            stdout: stdout.trim(),
+            stderr: stderr.trim(),
+            success: code === 0
+          });
+        });
+
+        stream.on('data', (data) => {
+          stdout += data.toString();
+        });
+
+        stream.stderr.on('data', (data) => {
+          stderr += data.toString();
+        });
+
+        if (options.timeout) {
+          setTimeout(() => {
+            stream.close();
+            reject(new Error(`Command timeout after ${options.timeout}ms`));
+          }, options.timeout);
+        }
+      });
+    });
+  }
+
+  async disconnect() {
+    if (this.connection) {
+      this.connection.end();
+      this.connection = null;
+    }
+  }
+
+  // WordPress-specific server operations
+  async getServerInfo() {
+    try {
+      const commands = [
+        'uname -a',                           // OS info
+        'php -v',                            // PHP version
+        'mysql --version',                   // MySQL version
+        'df -h',                            // Disk usage
+        'free -m',                          // Memory usage
+        'uptime',                           // Server uptime
+        'nginx -v 2>&1 || apache2 -v',     // Web server version
+      ];
+
+      const results = {};
+      for (const cmd of commands) {
+        const result = await this.executeCommand(cmd);
+        results[cmd] = result;
+      }
+
+      return {
+        success: true,
+        server_info: this.parseServerInfo(results),
+        raw_results: results
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  async checkFilePermissions() {
+    try {
+      const commands = [
+        `find ${this.wordpressPath} -type f -perm 777`,
+        `find ${this.wordpressPath} -type d -perm 777`,
+        `ls -la ${this.wordpressPath}/wp-config.php`,
+        `ls -la ${this.wordpressPath}/wp-content/uploads/`,
+        `find ${this.wordpressPath}/wp-content/ -name "*.php" -perm +200`
+      ];
+
+      const results = {};
+      for (const cmd of commands) {
+        results[cmd] = await this.executeCommand(cmd);
+      }
+
+      return {
+        success: true,
+        permission_check: this.analyzePermissions(results),
+        recommendations: this.getPermissionRecommendations(results)
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  async scanForMalware() {
+    try {
+      const suspiciousPatterns = [
+        'eval\\(',
+        'base64_decode\\(',
+        'shell_exec\\(',
+        'system\\(',
+        'exec\\(',
+        'passthru\\(',
+        'c99shell',
+        'r57shell'
+      ];
+
+      const scanCommands = suspiciousPatterns.map(pattern => 
+        `grep -r "${pattern}" ${this.wordpressPath}/wp-content/ --include="*.php" || true`
+      );
+
+      const results = [];
+      for (const cmd of scanCommands) {
+        const result = await this.executeCommand(cmd);
+        if (result.stdout) {
+          results.push({
+            pattern: cmd.match(/"(.+?)"/)[1],
+            matches: result.stdout.split('\n').filter(line => line.trim())
+          });
+        }
+      }
+
+      return {
+        success: true,
+        malware_scan: {
+          timestamp: new Date().toISOString(),
+          suspicious_files: results,
+          total_matches: results.reduce((sum, r) => sum + r.matches.length, 0)
+        },
+        recommendations: this.getMalwareRecommendations(results)
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  async analyzeErrorLogs() {
+    try {
+      const logPaths = [
+        '/var/log/nginx/error.log',
+        '/var/log/apache2/error.log',
+        '/var/log/php_errors.log',
+        `${this.wordpressPath}/wp-content/debug.log`,
+        '/var/log/mysql/error.log'
+      ];
+
+      const results = {};
+      for (const logPath of logPaths) {
+        const cmd = `tail -n 100 ${logPath} 2>/dev/null || echo "Log file not found: ${logPath}"`;
+        results[logPath] = await this.executeCommand(cmd);
+      }
+
+      return {
+        success: true,
+        error_analysis: this.parseErrorLogs(results),
+        recommendations: this.getErrorLogRecommendations(results)
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  async optimizeDatabase() {
+    try {
+      // Get WordPress database credentials
+      const configCmd = `grep -E "DB_(NAME|USER|PASSWORD|HOST)" ${this.wordpressPath}/wp-config.php`;
+      const configResult = await this.executeCommand(configCmd);
+      
+      if (!configResult.success) {
+        throw new Error('Could not read WordPress database configuration');
+      }
+
+      const dbConfig = this.parseDbConfig(configResult.stdout);
+      
+      // Database optimization commands
+      const optimizationCommands = [
+        `mysql -h${dbConfig.host} -u${dbConfig.user} -p${dbConfig.password} ${dbConfig.name} -e "OPTIMIZE TABLE wp_posts, wp_postmeta, wp_options, wp_comments, wp_commentmeta;"`,
+        `mysql -h${dbConfig.host} -u${dbConfig.user} -p${dbConfig.password} ${dbConfig.name} -e "DELETE FROM wp_posts WHERE post_status = 'revision' AND post_date < DATE_SUB(NOW(), INTERVAL 30 DAY);"`,
+        `mysql -h${dbConfig.host} -u${dbConfig.user} -p${dbConfig.password} ${dbConfig.name} -e "DELETE FROM wp_comments WHERE comment_approved = 'spam' AND comment_date < DATE_SUB(NOW(), INTERVAL 30 DAY);"`
+      ];
+
+      const results = {};
+      for (const cmd of optimizationCommands) {
+        results[cmd] = await this.executeCommand(cmd);
+      }
+
+      return {
+        success: true,
+        database_optimization: results,
+        summary: this.summarizeDatabaseOptimization(results)
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  async createBackup() {
+    try {
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const backupDir = `/tmp/wordpress-backup-${timestamp}`;
+      
+      const commands = [
+        `mkdir -p ${backupDir}`,
+        `tar -czf ${backupDir}/wordpress-files.tar.gz -C ${path.dirname(this.wordpressPath)} ${path.basename(this.wordpressPath)}`,
+        `mysqldump --single-transaction --routines --triggers $(grep DB_NAME ${this.wordpressPath}/wp-config.php | cut -d "'" -f 4) > ${backupDir}/database.sql`
+      ];
+
+      const results = {};
+      for (const cmd of commands) {
+        results[cmd] = await this.executeCommand(cmd);
+      }
+
+      return {
+        success: true,
+        backup_location: backupDir,
+        backup_files: [`${backupDir}/wordpress-files.tar.gz`, `${backupDir}/database.sql`],
+        timestamp: timestamp,
+        commands_executed: results
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  async updateWordPressFiles() {
+    try {
+      const commands = [
+        `cd ${this.wordpressPath} && wp core update --allow-root`,
+        `cd ${this.wordpressPath} && wp plugin update --all --allow-root`,
+        `cd ${this.wordpressPath} && wp theme update --all --allow-root`
+      ];
+
+      const results = {};
+      for (const cmd of commands) {
+        results[cmd] = await this.executeCommand(cmd);
+      }
+
+      return {
+        success: true,
+        update_results: results,
+        summary: this.summarizeUpdates(results)
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  // Helper methods
+  parseServerInfo(results) {
+    return {
+      os: results['uname -a']?.stdout || 'Unknown',
+      php_version: this.extractPhpVersion(results['php -v']?.stdout),
+      mysql_version: this.extractMysqlVersion(results['mysql --version']?.stdout),
+      disk_usage: results['df -h']?.stdout,
+      memory_usage: results['free -m']?.stdout,
+      uptime: results['uptime']?.stdout,
+      web_server: results['nginx -v 2>&1 || apache2 -v']?.stdout
+    };
+  }
+
+  extractPhpVersion(phpOutput) {
+    if (!phpOutput) return 'Unknown';
+    const match = phpOutput.match(/PHP (\d+\.\d+\.\d+)/);
+    return match ? match[1] : 'Unknown';
+  }
+
+  extractMysqlVersion(mysqlOutput) {
+    if (!mysqlOutput) return 'Unknown';
+    const match = mysqlOutput.match(/(\d+\.\d+\.\d+)/);
+    return match ? match[1] : 'Unknown';
+  }
+
+  analyzePermissions(results) {
+    const issues = [];
+    
+    Object.entries(results).forEach(([cmd, result]) => {
+      if (result.stdout && result.stdout.trim()) {
+        if (cmd.includes('perm 777')) {
+          issues.push({
+            type: 'overly_permissive',
+            files: result.stdout.split('\n'),
+            severity: 'high'
+          });
+        }
+      }
+    });
+
+    return {
+      total_issues: issues.length,
+      issues: issues,
+      status: issues.length === 0 ? 'good' : 'needs_attention'
+    };
+  }
+
+  getPermissionRecommendations(results) {
+    const recommendations = [];
+    
+    // Add specific recommendations based on findings
+    recommendations.push({
+      action: 'Set proper file permissions',
+      command: `find ${this.wordpressPath} -type f -exec chmod 644 {} \\;`,
+      description: 'Set all files to 644 permissions'
+    });
+
+    recommendations.push({
+      action: 'Set proper directory permissions',
+      command: `find ${this.wordpressPath} -type d -exec chmod 755 {} \\;`,
+      description: 'Set all directories to 755 permissions'
+    });
+
+    return recommendations;
+  }
+
+  parseDbConfig(configOutput) {
+    const config = {};
+    const lines = configOutput.split('\n');
+    
+    lines.forEach(line => {
+      if (line.includes('DB_NAME')) {
+        config.name = line.match(/'([^']+)'/)[1];
+      } else if (line.includes('DB_USER')) {
+        config.user = line.match(/'([^']+)'/)[1];
+      } else if (line.includes('DB_PASSWORD')) {
+        config.password = line.match(/'([^']+)'/)[1];
+      } else if (line.includes('DB_HOST')) {
+        config.host = line.match(/'([^']+)'/)[1];
+      }
+    });
+
+    return config;
+  }
+
+  parseErrorLogs(results) {
+    const analysis = {
+      total_errors: 0,
+      error_types: {},
+      recent_errors: [],
+      recommendations: []
+    };
+
+    Object.entries(results).forEach(([logPath, result]) => {
+      if (result.stdout && !result.stdout.includes('Log file not found')) {
+        const lines = result.stdout.split('\n');
+        analysis.total_errors += lines.length;
+        
+        lines.forEach(line => {
+          if (line.trim()) {
+            analysis.recent_errors.push({
+              log: logPath,
+              message: line.trim()
+            });
+          }
+        });
+      }
+    });
+
+    return analysis;
+  }
+
+  getMalwareRecommendations(results) {
+    const recommendations = [];
+    
+    if (results.length > 0) {
+      recommendations.push({
+        priority: 'critical',
+        action: 'Quarantine suspicious files',
+        description: 'Move suspicious files to quarantine for manual review'
+      });
+      
+      recommendations.push({
+        priority: 'high',
+        action: 'Run full malware scan',
+        description: 'Use professional malware scanning tools'
+      });
+    }
+
+    return recommendations;
+  }
+
+  getErrorLogRecommendations(results) {
+    return [
+      {
+        action: 'Monitor error logs regularly',
+        description: 'Set up automated error log monitoring'
+      },
+      {
+        action: 'Configure log rotation',
+        description: 'Prevent log files from growing too large'
+      }
+    ];
+  }
+
+  summarizeDatabaseOptimization(results) {
+    return {
+      tables_optimized: 'Core WordPress tables',
+      revisions_cleaned: 'Posts older than 30 days',
+      spam_removed: 'Comments older than 30 days'
+    };
+  }
+
+  summarizeUpdates(results) {
+    return {
+      core_updated: results[Object.keys(results)[0]]?.success || false,
+      plugins_updated: results[Object.keys(results)[1]]?.success || false,
+      themes_updated: results[Object.keys(results)[2]]?.success || false
+    };
+  }
+}
+
+export default SSHWordPressManager;