vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1642

package/src/rui/commands/AgentCommands.js

@@ -0,0 +1,487 @@
+/**
+ * RUI Agent Commands Handler
+ * 
+ * Handles REST-based commands for agent operations.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const AgentConfigManager = require('../../agents/config/AgentConfigManager');
+const AgentCheckService = require('../../agents/AgentCheckService');
+const AgentLogger = require('../../agents/logging/AgentLogger');
+const FileManager = require('../../agents/storage/FileManager');
+
+/**
+ * RUI agent commands handler class
+ */
+class AgentCommands {
+  /**
+   * Create commands handler instance
+   * @param {Object} options - Handler options
+   * @param {AgentConfigManager} options.configManager - Configuration manager
+   * @param {AgentCheckService} options.checkService - Agent check service
+   * @param {AgentLogger} options.logger - Logger instance
+   * @param {FileManager} options.fileManager - File manager instance
+   */
+  constructor(options = {}) {
+    this.configManager = options.configManager || new AgentConfigManager();
+    this.logger = options.logger || new AgentLogger({
+      fileManager: new FileManager()
+    });
+    this.fileManager = options.fileManager || new FileManager();
+    
+    // Initialize check service with proper dependencies
+    this.checkService = new AgentCheckService({
+      configManager: this.configManager,
+      logger: this.logger,
+      fileManager: this.fileManager
+    });
+    
+    this.commandMap = {
+      // REST-style commands
+      'GET': this.handleListAgents.bind(this),
+      'LIST': this.handleListAgents.bind(this),
+      'POST': this.handleCheckAgents.bind(this),
+      'CHECK': this.handleCheckAgents.bind(this),
+      'PUT': this.handleUpdateAgent.bind(this),
+      'UPDATE': this.handleUpdateAgent.bind(this),
+      'DELETE': this.handleDeleteAgent.bind(this),
+      'REMOVE': this.handleDeleteAgent.bind(this),
+      
+      // Shortcut commands
+      'LA': this.handleListAgents.bind(this),      // List agents
+      'LI': this.handleListAgents.bind(this),      // List agents  
+      'CH': this.handleCheckAgents.bind(this),     // Check agents
+      'CA': this.handleCheckAgents.bind(this),      // Check agents
+      'EN': this.handleEnableAgent.bind(this),     // Enable agent
+      'DI': this.handleDisableAgent.bind(this),    // Disable agent
+      'GE': this.handleGetAgent.bind(this),         // Get agent
+      'UP': this.handleUpdateAgent.bind(this),     // Update agent
+      'RE': this.handleDeleteAgent.bind(this),     // Remove agent
+      'RM': this.handleDeleteAgent.bind(this)       // Remove agent
+    };
+  }
+
+  /**
+   * Parse and execute command
+   * @param {string} verb - Command verb (GET, POST, PUT, DELETE, or shortcuts)
+   * @param {string} resource - Resource (agents, agent-id)
+   * @param {Object} params - Command parameters
+   * @returns {Promise<Object>} - Command result
+   */
+  async executeCommand(verb, resource, params = {}) {
+    const commandKey = verb.toUpperCase();
+    const handler = this.commandMap[commandKey];
+    
+    if (!handler) {
+      throw new Error(`Unknown command: ${verb}`);
+    }
+
+    // Initialize config manager if not already loaded
+    if (!this.configManager.loaded) {
+      await this.configManager.load();
+    }
+
+    return await handler(resource, params);
+  }
+
+  /**
+   * Handle LIST/GET agents command
+   * @param {string} resource - Resource (should be 'agents')
+   * @param {Object} params - Command parameters
+   * @returns {Promise<Object>} - Command result
+   */
+  async handleListAgents(resource, params = {}) {
+    if (resource !== 'agents' && resource !== 'agent') {
+      throw new Error(`Invalid resource for LIST command: ${resource}`);
+    }
+
+    const { includeDisabled = false, includeStatus = true } = params;
+    
+    let agents = includeDisabled 
+      ? this.configManager.getAllAgents()
+      : this.configManager.getEnabledAgents();
+
+    // Add status information if requested
+    if (includeStatus) {
+      agents = await Promise.all(agents.map(async agent => {
+        const status = await this.configManager.getAgentStatus(agent.id);
+        return {
+          ...agent.toJSON(),
+          status: status || { status: 'NOT_INSTALLED', lastChecked: null }
+        };
+      }));
+    }
+
+    return {
+      success: true,
+      data: {
+        agents,
+        count: agents.length,
+        includeDisabled,
+        timestamp: new Date().toISOString()
+      }
+    };
+  }
+
+  /**
+   * Handle CHECK/POST agents command
+   * @param {string} resource - Resource (should be 'agents')
+   * @param {Object} params - Command parameters
+   * @returns {Promise<Object>} - Command result
+   */
+  async handleCheckAgents(resource, params = {}) {
+    if (resource !== 'agents' && resource !== 'agent') {
+      throw new Error(`Invalid resource for CHECK command: ${resource}`);
+    }
+
+    const { 
+      agentIds = null, 
+      forceReinstall = false, 
+      skipVerification = false,
+      timeout = 300000 // 5 minutes default
+    } = params;
+
+    if (this.logger) {
+      await this.logger.info('Starting agent check operation', {
+        agentIds,
+        forceReinstall,
+        skipVerification,
+        timeout
+      });
+    }
+
+    try {
+      const result = await this.checkService.checkAgents({
+        agentIds,
+        forceReinstall,
+        skipVerification,
+        timeout
+      });
+
+      return {
+        success: true,
+        data: result
+      };
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Agent check operation failed', {
+          error: error.message,
+          agentIds,
+          forceReinstall,
+          skipVerification
+        });
+      }
+
+      return {
+        success: false,
+        error: error.message,
+        data: null
+      };
+    }
+  }
+
+  /**
+   * Handle GET specific agent command
+   * @param {string} resource - Agent ID
+   * @param {Object} params - Command parameters
+   * @returns {Promise<Object>} - Command result
+   */
+  async handleGetAgent(resource, params = {}) {
+    const agentId = resource;
+    
+    if (!agentId) {
+      throw new Error('Agent ID is required for GET command');
+    }
+
+    const agent = this.configManager.getAgent(agentId);
+    if (!agent) {
+      throw new Error(`Agent not found: ${agentId}`);
+    }
+
+    const { includeStatus = true, includeLogs = false } = params;
+    
+    let result = agent.toJSON();
+
+    // Add status information if requested
+    if (includeStatus) {
+      const status = await this.configManager.getAgentStatus(agentId);
+      result.status = status || { status: 'NOT_INSTALLED', lastChecked: null };
+    }
+
+    // Add logs if requested
+    if (includeLogs && this.logger) {
+      const logs = await this.logger.getAgentLogs(agentId, { limit: 10 });
+      result.recentLogs = logs;
+    }
+
+    return {
+      success: true,
+      data: result
+    };
+  }
+
+  /**
+   * Handle UPDATE/PUT agent command
+   * @param {string} resource - Agent ID
+   * @param {Object} params - Command parameters
+   * @returns {Promise<Object>} - Command result
+   */
+  async handleUpdateAgent(resource, params = {}) {
+    const agentId = resource;
+    
+    if (!agentId) {
+      throw new Error('Agent ID is required for UPDATE command');
+    }
+
+    const agent = this.configManager.getAgent(agentId);
+    if (!agent) {
+      throw new Error(`Agent not found: ${agentId}`);
+    }
+
+    const { enabled, status, message } = params;
+    
+    try {
+      // Update agent properties
+      if (enabled !== undefined) {
+        await this.configManager[enabled ? 'enableAgent' : 'disableAgent'](agentId);
+      }
+
+      if (status) {
+        await this.configManager.updateAgentStatus(agentId, status, message);
+      }
+
+      // Return updated agent
+      const updatedAgent = this.configManager.getAgent(agentId);
+      
+      return {
+        success: true,
+        data: updatedAgent.toJSON()
+      };
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error(`Failed to update agent ${agentId}`, {
+          agentId,
+          params,
+          error: error.message
+        });
+      }
+
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Handle ENABLE agent command
+   * @param {string} resource - Agent ID
+   * @param {Object} params - Command parameters
+   * @returns {Promise<Object>} - Command result
+   */
+  async handleEnableAgent(resource, params = {}) {
+    const agentId = resource;
+    
+    if (!agentId) {
+      throw new Error('Agent ID is required for ENABLE command');
+    }
+
+    try {
+      const success = await this.configManager.enableAgent(agentId);
+      
+      if (!success) {
+        throw new Error(`Failed to enable agent: ${agentId}`);
+      }
+
+      const agent = this.configManager.getAgent(agentId);
+      
+      if (this.logger) {
+        await this.logger.info(`Agent enabled: ${agentId}`, {
+          agentId,
+          enabled: true
+        });
+      }
+
+      return {
+        success: true,
+        data: agent.toJSON()
+      };
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error(`Failed to enable agent ${agentId}`, {
+          agentId,
+          error: error.message
+        });
+      }
+
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Handle DISABLE agent command
+   * @param {string} resource - Agent ID
+   * @param {Object} params - Command parameters
+   * @returns {Promise<Object>} - Command result
+   */
+  async handleDisableAgent(resource, params = {}) {
+    const agentId = resource;
+    
+    if (!agentId) {
+      throw new Error('Agent ID is required for DISABLE command');
+    }
+
+    try {
+      const success = await this.configManager.disableAgent(agentId);
+      
+      if (!success) {
+        throw new Error(`Failed to disable agent: ${agentId}`);
+      }
+
+      const agent = this.configManager.getAgent(agentId);
+      
+      if (this.logger) {
+        await this.logger.info(`Agent disabled: ${agentId}`, {
+          agentId,
+          enabled: false
+        });
+      }
+
+      return {
+        success: true,
+        data: agent.toJSON()
+      };
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error(`Failed to disable agent ${agentId}`, {
+          agentId,
+          error: error.message
+        });
+      }
+
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Handle DELETE/REMOVE agent command
+   * @param {string} resource - Agent ID
+   * @param {Object} params - Command parameters
+   * @returns {Promise<Object>} - Command result
+   */
+  async handleDeleteAgent(resource, params = {}) {
+    const agentId = resource;
+    
+    if (!agentId) {
+      throw new Error('Agent ID is required for DELETE command');
+    }
+
+    const { confirm = false } = params;
+    
+    if (!confirm) {
+      return {
+        success: false,
+        error: 'Confirmation required. Use confirm=true to delete agent.',
+        requiresConfirmation: true
+      };
+    }
+
+    try {
+      const success = await this.configManager.removeAgent(agentId);
+      
+      if (!success) {
+        throw new Error(`Failed to remove agent: ${agentId}`);
+      }
+      
+      if (this.logger) {
+        await this.logger.info(`Agent removed: ${agentId}`, {
+          agentId
+        });
+      }
+
+      return {
+        success: true,
+        data: { message: `Agent ${agentId} removed successfully` }
+      };
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error(`Failed to remove agent ${agentId}`, {
+          agentId,
+          error: error.message
+        });
+      }
+
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Get command help
+   * @returns {Object} - Help information
+   */
+  getHelp() {
+    return {
+      availableCommands: [
+        { verb: 'GET', shortcut: 'LA', description: 'List all agents', usage: 'GET agents' },
+        { verb: 'GET', shortcut: 'GE', description: 'Get specific agent', usage: 'GET <agent-id>' },
+        { verb: 'POST', shortcut: 'CH', description: 'Check agents', usage: 'POST agents' },
+        { verb: 'PUT', shortcut: 'EN', description: 'Enable agent', usage: 'PUT <agent-id> enabled=true' },
+        { verb: 'PUT', shortcut: 'DI', description: 'Disable agent', usage: 'PUT <agent-id> enabled=false' },
+        { verb: 'DELETE', shortcut: 'RE', description: 'Remove agent', usage: 'DELETE <agent-id> confirm=true' }
+      ],
+      examples: [
+        'GET agents',
+        'GET claude-code',
+        'POST agents',
+        'PUT claude-code enabled=true',
+        'PUT claude-code enabled=false',
+        'DELETE test-agent confirm=true'
+      ]
+    };
+  }
+
+  /**
+   * Validate command parameters
+   * @param {string} verb - Command verb
+   * @param {string} resource - Resource
+   * @param {Object} params - Parameters
+   * @returns {Object} - Validation result
+   */
+  validateCommand(verb, resource, params = {}) {
+    const errors = [];
+    const warnings = [];
+
+    // Validate verb
+    const commandKey = verb.toUpperCase();
+    if (!this.commandMap[commandKey]) {
+      errors.push(`Unknown command: ${verb}`);
+    }
+
+    // Validate resource for specific commands
+    if (['GET', 'PUT', 'DELETE'].includes(commandKey) && !resource) {
+      errors.push('Agent ID is required for this command');
+    }
+
+    // Validate parameters
+    if (commandKey === 'DELETE' && !params.confirm) {
+      warnings.push('DELETE command requires confirmation (confirm=true)');
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+}
+
+module.exports = AgentCommands;