myaidev-method 0.0.1

package/src/mcp/wordpress-admin-mcp.js

@@ -0,0 +1,397 @@
+import fetch from 'node-fetch';
+import { WordPressMCP } from './wordpress-integration.js';
+
+export class WordPressAdminMCP extends WordPressMCP {
+  constructor(config) {
+    super(config);
+    this.adminCapabilities = {
+      security: true,
+      performance: true,
+      health: true,
+      administration: true
+    };
+  }
+
+  // Security Operations
+  async securityScan() {
+    try {
+      const results = {
+        wordpress_version: await this.getWordPressVersion(),
+        plugins: await this.getPluginSecurityStatus(),
+        themes: await this.getThemeSecurityStatus(),
+        users: await this.getUserSecurityAudit(),
+        files: await this.getFilePermissionsScan(),
+        ssl: await this.getSSLStatus(),
+        security_headers: await this.getSecurityHeaders()
+      };
+
+      return {
+        success: true,
+        scan_type: 'comprehensive_security',
+        timestamp: new Date().toISOString(),
+        findings: this.analyzeSecurity(results),
+        recommendations: this.getSecurityRecommendations(results),
+        priority_issues: this.getPrioritySecurityIssues(results)
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        scan_type: 'security_scan_failed'
+      };
+    }
+  }
+
+  async malwareCheck() {
+    try {
+      const suspiciousPatterns = [
+        'eval\\(', 'base64_decode\\(', 'shell_exec\\(',
+        'system\\(', 'exec\\(', 'passthru\\(',
+        '\\.php\\?[a-zA-Z0-9]+=\\w+', 'c99shell',
+        'r57shell', 'wso\\.php'
+      ];
+
+      const results = await Promise.all([
+        this.scanPluginsForMalware(suspiciousPatterns),
+        this.scanThemesForMalware(suspiciousPatterns),
+        this.scanUploadsForMalware(suspiciousPatterns),
+        this.checkDatabaseForMalware()
+      ]);
+
+      return {
+        success: true,
+        scan_type: 'malware_detection',
+        timestamp: new Date().toISOString(),
+        threats_found: results.filter(r => r.threats.length > 0),
+        clean_areas: results.filter(r => r.threats.length === 0),
+        recommendations: this.getMalwareRecommendations(results)
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  async userSecurityAudit() {
+    try {
+      const users = await this.request('/users?per_page=100&context=edit');
+      
+      const audit = users.map(user => ({
+        id: user.id,
+        username: user.username,
+        email: user.email,
+        roles: user.roles,
+        capabilities: user.capabilities,
+        last_login: user.meta?.last_login || 'unknown',
+        registration_date: user.registered_date,
+        security_flags: this.analyzeUserSecurity(user)
+      }));
+
+      return {
+        success: true,
+        audit_type: 'user_security',
+        timestamp: new Date().toISOString(),
+        total_users: users.length,
+        admin_users: audit.filter(u => u.roles.includes('administrator')),
+        suspicious_users: audit.filter(u => u.security_flags.length > 0),
+        recommendations: this.getUserSecurityRecommendations(audit)
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  // Performance Operations
+  async performanceAnalysis() {
+    try {
+      const metrics = await Promise.all([
+        this.analyzePageSpeed(),
+        this.analyzeDatabasePerformance(),
+        this.analyzePluginPerformance(),
+        this.analyzeMediaOptimization(),
+        this.analyzeCachingStatus()
+      ]);
+
+      return {
+        success: true,
+        analysis_type: 'performance_comprehensive',
+        timestamp: new Date().toISOString(),
+        overall_score: this.calculatePerformanceScore(metrics),
+        metrics: metrics,
+        recommendations: this.getPerformanceRecommendations(metrics),
+        priority_actions: this.getPerformancePriorityActions(metrics)
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  async databaseOptimization() {
+    try {
+      const operations = [];
+      
+      // Get database statistics
+      const stats = await this.getDatabaseStats();
+      
+      // Cleanup operations
+      const cleanupResults = await Promise.all([
+        this.cleanupRevisions(),
+        this.cleanupSpam(),
+        this.cleanupTrash(),
+        this.cleanupExpiredTransients(),
+        this.optimizeDatabaseTables()
+      ]);
+
+      return {
+        success: true,
+        operation: 'database_optimization',
+        timestamp: new Date().toISOString(),
+        before_stats: stats.before,
+        after_stats: await this.getDatabaseStats(),
+        operations_performed: cleanupResults,
+        space_saved: this.calculateSpaceSaved(stats),
+        recommendations: this.getDatabaseRecommendations()
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  // Health Operations
+  async healthCheck() {
+    try {
+      const healthChecks = await Promise.all([
+        this.checkWordPressUpdates(),
+        this.checkPluginUpdates(),
+        this.checkThemeUpdates(),
+        this.checkFilePermissions(),
+        this.checkDiskSpace(),
+        this.checkMemoryUsage(),
+        this.checkDatabaseHealth(),
+        this.checkCronJobs(),
+        this.checkErrorLogs()
+      ]);
+
+      const overallHealth = this.calculateHealthScore(healthChecks);
+
+      return {
+        success: true,
+        check_type: 'comprehensive_health',
+        timestamp: new Date().toISOString(),
+        overall_health: overallHealth,
+        checks: healthChecks,
+        critical_issues: healthChecks.filter(c => c.status === 'critical'),
+        warnings: healthChecks.filter(c => c.status === 'warning'),
+        recommendations: this.getHealthRecommendations(healthChecks)
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  async errorLogAnalysis() {
+    try {
+      // This would require server-level access or plugin integration
+      const errorSources = [
+        'php_errors',
+        'wordpress_debug',
+        'plugin_errors',
+        'theme_errors',
+        'database_errors'
+      ];
+
+      const errorAnalysis = await Promise.all(
+        errorSources.map(source => this.analyzeErrorSource(source))
+      );
+
+      return {
+        success: true,
+        analysis_type: 'error_log',
+        timestamp: new Date().toISOString(),
+        error_summary: this.summarizeErrors(errorAnalysis),
+        critical_errors: errorAnalysis.filter(e => e.severity === 'critical'),
+        frequent_errors: this.getFrequentErrors(errorAnalysis),
+        recommendations: this.getErrorRecommendations(errorAnalysis)
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  // Admin Operations
+  async pluginManagement(operation, pluginSlug = null) {
+    try {
+      switch (operation) {
+        case 'list':
+          return await this.getInstalledPlugins();
+        
+        case 'security_check':
+          return await this.checkPluginsSecurity();
+        
+        case 'update_available':
+          return await this.getPluginUpdates();
+        
+        case 'activate':
+          return await this.activatePlugin(pluginSlug);
+        
+        case 'deactivate':
+          return await this.deactivatePlugin(pluginSlug);
+        
+        case 'delete':
+          return await this.deletePlugin(pluginSlug);
+        
+        default:
+          throw new Error(`Unknown plugin operation: ${operation}`);
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  async contentCleanup() {
+    try {
+      const cleanup = await Promise.all([
+        this.cleanupSpamComments(),
+        this.cleanupDraftPosts(),
+        this.cleanupUnusedMedia(),
+        this.cleanupOrphanedMetadata(),
+        this.cleanupExpiredTransients()
+      ]);
+
+      return {
+        success: true,
+        operation: 'content_cleanup',
+        timestamp: new Date().toISOString(),
+        cleanup_results: cleanup,
+        total_items_cleaned: cleanup.reduce((sum, result) => sum + result.items_cleaned, 0),
+        space_freed: cleanup.reduce((sum, result) => sum + result.space_freed, 0)
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  // Helper methods for analysis
+  analyzeSecurity(results) {
+    const findings = {
+      critical: [],
+      warnings: [],
+      passed: []
+    };
+
+    // Analyze WordPress version
+    if (results.wordpress_version.outdated) {
+      findings.critical.push('WordPress version is outdated');
+    }
+
+    // Analyze plugins
+    results.plugins.vulnerable.forEach(plugin => {
+      findings.critical.push(`Vulnerable plugin detected: ${plugin.name}`);
+    });
+
+    // Analyze users
+    results.users.admin_accounts.forEach(user => {
+      if (user.weak_password) {
+        findings.warnings.push(`Weak password for admin user: ${user.username}`);
+      }
+    });
+
+    return findings;
+  }
+
+  getSecurityRecommendations(results) {
+    const recommendations = [];
+
+    if (results.wordpress_version.outdated) {
+      recommendations.push({
+        priority: 'high',
+        action: 'Update WordPress to latest version',
+        impact: 'Critical security patches'
+      });
+    }
+
+    return recommendations;
+  }
+
+  calculateHealthScore(checks) {
+    const totalChecks = checks.length;
+    const passedChecks = checks.filter(c => c.status === 'passed').length;
+    const warningChecks = checks.filter(c => c.status === 'warning').length;
+    
+    // Weighted scoring: passed = 1, warning = 0.5, critical = 0
+    const score = ((passedChecks * 1) + (warningChecks * 0.5)) / totalChecks * 100;
+    
+    return {
+      score: Math.round(score),
+      grade: this.getHealthGrade(score),
+      total_checks: totalChecks,
+      passed: passedChecks,
+      warnings: warningChecks,
+      critical: checks.filter(c => c.status === 'critical').length
+    };
+  }
+
+  getHealthGrade(score) {
+    if (score >= 90) return 'A';
+    if (score >= 80) return 'B';
+    if (score >= 70) return 'C';
+    if (score >= 60) return 'D';
+    return 'F';
+  }
+
+  // Placeholder methods (would need actual implementation based on access level)
+  async getWordPressVersion() {
+    // Implementation would check WP version against latest
+    return { current: '6.3.1', latest: '6.4.0', outdated: true };
+  }
+
+  async getPluginSecurityStatus() {
+    // Implementation would check plugins against vulnerability databases
+    return { total: 15, vulnerable: [], outdated: [] };
+  }
+
+  async scanPluginsForMalware(patterns) {
+    // Implementation would scan plugin files for suspicious patterns
+    return { location: 'plugins', threats: [], files_scanned: 0 };
+  }
+
+  async checkDatabaseForMalware() {
+    // Implementation would scan database for malicious content
+    return { location: 'database', threats: [], tables_scanned: 0 };
+  }
+
+  async analyzePageSpeed() {
+    // Implementation would use external APIs like PageSpeed Insights
+    return { score: 85, metrics: {} };
+  }
+
+  async getDatabaseStats() {
+    // Implementation would query database size and optimization stats
+    return { size_mb: 125, tables: 50, optimized: false };
+  }
+}
+
+export default WordPressAdminMCP;

package/src/mcp/wordpress-integration.js

@@ -0,0 +1,218 @@
+import fetch from 'node-fetch';
+
+export class WordPressMCP {
+  constructor(config) {
+    this.baseUrl = config.endpoint.url;
+    this.apiPath = `/wp-json/${config.endpoint.api_version}`;
+    this.auth = Buffer.from(`${config.endpoint.authentication.username}:${config.endpoint.authentication.password}`).toString('base64');
+    this.defaults = config.defaults;
+  }
+
+  async request(endpoint, method = 'GET', data = null) {
+    const options = {
+      method,
+      headers: {
+        'Authorization': `Basic ${this.auth}`,
+        'Content-Type': 'application/json'
+      }
+    };
+
+    if (data && method !== 'GET') {
+      options.body = JSON.stringify(data);
+    }
+
+    const response = await fetch(`${this.baseUrl}${this.apiPath}${endpoint}`, options);
+    
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`WordPress API Error: ${response.status} - ${error}`);
+    }
+
+    return response.json();
+  }
+
+  async createPost(params) {
+    const postData = {
+      title: params.title,
+      content: params.content,
+      status: params.status || this.defaults.post_status,
+      categories: params.categories || [],
+      tags: params.tags || [],
+      format: params.format || this.defaults.format,
+      comment_status: params.comment_status || this.defaults.comment_status,
+      ping_status: params.ping_status || this.defaults.ping_status
+    };
+
+    if (params.excerpt) {
+      postData.excerpt = params.excerpt;
+    }
+
+    if (params.featured_media) {
+      postData.featured_media = params.featured_media;
+    }
+
+    if (params.meta) {
+      postData.meta = params.meta;
+    }
+
+    if (params.slug) {
+      postData.slug = params.slug;
+    }
+
+    return this.request('/posts', 'POST', postData);
+  }
+
+  async updatePost(id, params) {
+    const updateData = {};
+    
+    if (params.title) updateData.title = params.title;
+    if (params.content) updateData.content = params.content;
+    if (params.status) updateData.status = params.status;
+    if (params.categories) updateData.categories = params.categories;
+    if (params.tags) updateData.tags = params.tags;
+    if (params.excerpt) updateData.excerpt = params.excerpt;
+    if (params.featured_media) updateData.featured_media = params.featured_media;
+    if (params.slug) updateData.slug = params.slug;
+
+    return this.request(`/posts/${id}`, 'POST', updateData);
+  }
+
+  async getPost(id, context = 'view') {
+    return this.request(`/posts/${id}?context=${context}`);
+  }
+
+  async listPosts(params = {}) {
+    const queryParams = new URLSearchParams();
+    
+    if (params.per_page) queryParams.append('per_page', params.per_page);
+    if (params.page) queryParams.append('page', params.page);
+    if (params.status) queryParams.append('status', params.status);
+    if (params.search) queryParams.append('search', params.search);
+    if (params.categories) queryParams.append('categories', params.categories.join(','));
+    if (params.tags) queryParams.append('tags', params.tags.join(','));
+
+    const query = queryParams.toString();
+    return this.request(`/posts${query ? `?${query}` : ''}`);
+  }
+
+  async uploadMedia(file, metadata = {}) {
+    const formData = new FormData();
+    formData.append('file', file);
+    
+    if (metadata.title) formData.append('title', metadata.title);
+    if (metadata.alt_text) formData.append('alt_text', metadata.alt_text);
+    if (metadata.caption) formData.append('caption', metadata.caption);
+    if (metadata.description) formData.append('description', metadata.description);
+
+    const response = await fetch(`${this.baseUrl}${this.apiPath}/media`, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Basic ${this.auth}`
+      },
+      body: formData
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Media Upload Error: ${response.status} - ${error}`);
+    }
+
+    return response.json();
+  }
+
+  async createCategory(params) {
+    const categoryData = {
+      name: params.name,
+      slug: params.slug || params.name.toLowerCase().replace(/\s+/g, '-'),
+      description: params.description || ''
+    };
+
+    if (params.parent) {
+      categoryData.parent = params.parent;
+    }
+
+    return this.request('/categories', 'POST', categoryData);
+  }
+
+  async createTag(params) {
+    const tagData = {
+      name: params.name,
+      slug: params.slug || params.name.toLowerCase().replace(/\s+/g, '-'),
+      description: params.description || ''
+    };
+
+    return this.request('/tags', 'POST', tagData);
+  }
+
+  async getCategories() {
+    return this.request('/categories');
+  }
+
+  async getTags() {
+    return this.request('/tags');
+  }
+
+  // Helper method to publish content from content-writer agent
+  async publishContent(contentData) {
+    try {
+      // Create tags if they don't exist
+      const tags = [];
+      if (contentData.tags && contentData.tags.length > 0) {
+        for (const tagName of contentData.tags) {
+          try {
+            const tag = await this.createTag({ name: tagName });
+            tags.push(tag.id);
+          } catch (error) {
+            // Tag might already exist, try to find it
+            const existingTags = await this.getTags();
+            const found = existingTags.find(t => t.name.toLowerCase() === tagName.toLowerCase());
+            if (found) tags.push(found.id);
+          }
+        }
+      }
+
+      // Create category if it doesn't exist
+      let categoryId = null;
+      if (contentData.category) {
+        try {
+          const category = await this.createCategory({ name: contentData.category });
+          categoryId = category.id;
+        } catch (error) {
+          // Category might already exist
+          const existingCategories = await this.getCategories();
+          const found = existingCategories.find(c => c.name.toLowerCase() === contentData.category.toLowerCase());
+          if (found) categoryId = found.id;
+        }
+      }
+
+      // Prepare post data
+      const postParams = {
+        title: contentData.title,
+        content: contentData.content,
+        excerpt: contentData.meta_description,
+        slug: contentData.slug,
+        status: 'draft', // Always create as draft for review
+        tags: tags,
+        categories: categoryId ? [categoryId] : []
+      };
+
+      // Create the post
+      const post = await this.createPost(postParams);
+      
+      return {
+        success: true,
+        post_id: post.id,
+        post_url: post.link,
+        edit_url: `${this.baseUrl}/wp-admin/post.php?post=${post.id}&action=edit`,
+        message: `Draft post created successfully. ID: ${post.id}`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+}
+
+export default WordPressMCP;