@fleettools/server 0.1.0 → 0.1.1

package/src/coordination/agent-lifecycle.ts

@@ -1,13 +0,0 @@
-/**
- * Agent Lifecycle Management Methods
- *
- * NOTE: This file previously contained a partially-copied implementation with
- * broken syntax that prevented `tsc` from building the monorepo.
- *
- * For now we keep only a minimal, compilable helper class. The real lifecycle
- * behavior should live alongside AgentSpawner with proper unit/integration tests.
- */
-
-export class AgentLifecycleManager {
-  // Placeholder to preserve import surface, if any.
-}

package/src/coordination/agent-runner.ts

@@ -1,479 +0,0 @@
-#!/usr/bin/env bun
-/**
- * FleetTools Agent Runner
- *
- * Bootstrap script for spawning and managing individual agents
- * Handles agent lifecycle, communication, and coordination
- */
-
-import { randomUUID } from 'node:crypto';
-import path from 'node:path';
-
-interface AgentConfig {
-  agentId: string;
-  agentType: string;
-  mailboxId: string;
-  task?: string;
-  timeout?: number;
-}
-
-class AgentRunner {
-  private config: AgentConfig;
-  private isRunning = false;
-  private heartbeatInterval?: ReturnType<typeof setInterval>;
-  private taskProgress = 0;
-  private startTime = Date.now();
-
-  constructor(config: AgentConfig) {
-    this.config = config;
-  }
-
-  /**
-   * Start the agent runner
-   */
-  async start(): Promise<void> {
-    console.log(`🚀 Starting agent runner for ${this.config.agentId} (${this.config.agentType})`);
-    
-    this.isRunning = true;
-    this.startTime = Date.now();
-
-    try {
-      // Start heartbeat mechanism
-      this.startHeartbeat();
-      
-      // Initialize agent based on type
-      await this.initializeAgent();
-      
-      // Execute task if provided
-      if (this.config.task) {
-        await this.executeTask(this.config.task);
-      } else {
-        await this.runDefaultBehavior();
-      }
-      
-      console.log(`✅ Agent ${this.config.agentId} completed successfully`);
-      process.exit(0);
-    } catch (error: any) {
-      console.error(`❌ Agent ${this.config.agentId} failed:`, error.message);
-      process.exit(1);
-    }
-  }
-
-  /**
-   * Initialize agent based on type
-   */
-  private async initializeAgent(): Promise<void> {
-    console.log(`🔧 Initializing ${this.config.agentType} agent...`);
-    
-    switch (this.config.agentType) {
-      case 'frontend':
-        await this.initializeFrontendAgent();
-        break;
-      case 'backend':
-        await this.initializeBackendAgent();
-        break;
-      case 'testing':
-        await this.initializeTestingAgent();
-        break;
-      case 'documentation':
-        await this.initializeDocumentationAgent();
-        break;
-      case 'security':
-        await this.initializeSecurityAgent();
-        break;
-      case 'performance':
-        await this.initializePerformanceAgent();
-        break;
-      default:
-        throw new Error(`Unknown agent type: ${this.config.agentType}`);
-    }
-    
-    console.log(`✅ ${this.config.agentType} agent initialized`);
-  }
-
-  /**
-   * Execute a specific task
-   */
-  private async executeTask(task: string): Promise<void> {
-    console.log(`📋 Executing task: ${task}`);
-    
-    // Simulate task execution with progress updates
-    const steps = this.getTaskSteps(task);
-    
-    for (let i = 0; i < steps.length; i++) {
-      if (!this.isRunning) break;
-      
-      const step = steps[i];
-      this.taskProgress = Math.round(((i + 1) / steps.length) * 100);
-      
-      console.log(`⚡ [${this.taskProgress}%] ${step}`);
-      
-      // Simulate work
-      await this.simulateWork(2000, 5000);
-      
-      // Send progress update
-      await this.sendProgressUpdate(step, this.taskProgress);
-    }
-  }
-
-  /**
-   * Run default behavior when no specific task is provided
-   */
-  private async runDefaultBehavior(): Promise<void> {
-    console.log(`🔄 Running default behavior for ${this.config.agentType} agent`);
-    
-    while (this.isRunning) {
-      await this.simulateWork(5000, 10000);
-      
-      // Simulate some activity
-      const activities = this.getDefaultActivities();
-      const activity = activities[Math.floor(Math.random() * activities.length)];
-      
-      console.log(`💼 ${activity}`);
-      await this.sendProgressUpdate(activity, this.taskProgress);
-    }
-  }
-
-  /**
-   * Start heartbeat mechanism
-   */
-  private startHeartbeat(): void {
-    this.heartbeatInterval = setInterval(async () => {
-      if (!this.isRunning) return;
-      
-      try {
-        await this.sendHeartbeat();
-      } catch (error) {
-        console.warn(`Failed to send heartbeat:`, error);
-      }
-    }, 15000); // Send heartbeat every 15 seconds
-    
-    console.log(`💓 Heartbeat started for agent ${this.config.agentId}`);
-  }
-
-  /**
-   * Send heartbeat to coordinator
-   */
-  private async sendHeartbeat(): Promise<void> {
-    const uptime = Date.now() - this.startTime;
-    const resourceUsage = this.getResourceUsage();
-    
-    const heartbeat = {
-      timestamp: new Date().toISOString(),
-      uptime: Math.floor(uptime / 1000),
-      resourceUsage,
-      status: 'running'
-    };
-
-    // Send to coordinator API
-    try {
-      const response = await fetch(`http://localhost:3001/api/v1/agents/${this.config.agentId}/heartbeat`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(heartbeat)
-      });
-      
-      if (!response.ok) {
-        console.warn(`Heartbeat failed: ${response.status}`);
-      }
-    } catch (error) {
-      console.warn(`Heartbeat network error:`, error);
-    }
-  }
-
-  /**
-   * Send progress update
-   */
-  private async sendProgressUpdate(message: string, progress: number): Promise<void> {
-    try {
-      const response = await fetch(`http://localhost:3001/api/v1/agents/${this.config.agentId}/progress`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          status: 'busy',
-          progress,
-          message
-        })
-      });
-      
-      if (!response.ok) {
-        console.warn(`Progress update failed: ${response.status}`);
-      }
-    } catch (error) {
-      console.warn(`Progress update network error:`, error);
-    }
-  }
-
-  /**
-   * Get mock resource usage
-   */
-  private getResourceUsage(): { memory: number; cpu: number } {
-    return {
-      memory: Math.floor(Math.random() * 150) + 50,
-      cpu: Math.floor(Math.random() * 40) + 10
-    };
-  }
-
-  /**
-   * Simulate work with random delay
-   */
-  private async simulateWork(minMs: number, maxMs: number): Promise<void> {
-    const delay = Math.floor(Math.random() * (maxMs - minMs)) + minMs;
-    await new Promise(resolve => setTimeout(resolve, delay));
-  }
-
-  /**
-   * Get task steps based on task description
-   */
-  private getTaskSteps(task: string): string[] {
-    const taskLower = task.toLowerCase();
-    
-    if (taskLower.includes('implement') || taskLower.includes('build')) {
-      return [
-        'Analyzing requirements',
-        'Designing solution',
-        'Implementing core functionality',
-        'Adding tests',
-        'Documentation',
-        'Code review',
-        'Deployment preparation'
-      ];
-    }
-    
-    if (taskLower.includes('test') || taskLower.includes('testing')) {
-      return [
-        'Setting up test environment',
-        'Writing unit tests',
-        'Writing integration tests',
-        'Running test suite',
-        'Analyzing coverage',
-        'Reporting results'
-      ];
-    }
-    
-    if (taskLower.includes('document') || taskLower.includes('docs')) {
-      return [
-        'Analyzing codebase',
-        'Generating documentation',
-        'Creating examples',
-        'Reviewing documentation',
-        'Publishing docs'
-      ];
-    }
-    
-    if (taskLower.includes('security') || taskLower.includes('audit')) {
-      return [
-        'Scanning dependencies',
-        'Analyzing code for vulnerabilities',
-        'Checking configurations',
-        'Generating security report',
-        'Providing remediation steps'
-      ];
-    }
-    
-    if (taskLower.includes('performance') || taskLower.includes('optimize')) {
-      return [
-        'Profiling application',
-        'Identifying bottlenecks',
-        'Implementing optimizations',
-        'Measuring improvements',
-        'Creating performance report'
-      ];
-    }
-    
-    // Default steps
-    return [
-      'Understanding task',
-      'Planning approach',
-      'Executing task',
-      'Validating results',
-      'Completing task'
-    ];
-  }
-
-  /**
-   * Get default activities for agent type
-   */
-  private getDefaultActivities(): string[] {
-    switch (this.config.agentType) {
-      case 'frontend':
-        return [
-          'Reviewing UI components',
-          'Optimizing user experience',
-          'Updating styles',
-          'Testing responsive design'
-        ];
-      case 'backend':
-        return [
-          'Monitoring API performance',
-          'Optimizing database queries',
-          'Reviewing server logs',
-          'Validating data integrity'
-        ];
-      case 'testing':
-        return [
-          'Running automated tests',
-          'Updating test cases',
-          'Analyzing test results',
-          'Improving test coverage'
-        ];
-      case 'documentation':
-        return [
-          'Updating API documentation',
-          'Creating user guides',
-          'Reviewing documentation',
-          'Publishing updates'
-        ];
-      case 'security':
-        return [
-          'Scanning for vulnerabilities',
-          'Reviewing security policies',
-          'Analyzing access logs',
-          'Updating security measures'
-        ];
-      case 'performance':
-        return [
-          'Monitoring system metrics',
-          'Analyzing performance data',
-          'Optimizing resource usage',
-          'Generating reports'
-        ];
-      default:
-        return ['Processing requests', 'Maintaining systems', 'Performing routine checks'];
-    }
-  }
-
-  /**
-   * Agent type-specific initializers
-   */
-  private async initializeFrontendAgent(): Promise<void> {
-    console.log('🎨 Initializing frontend development environment');
-    // Simulate frontend-specific setup
-    await this.simulateWork(1000, 3000);
-  }
-
-  private async initializeBackendAgent(): Promise<void> {
-    console.log('⚙️ Initializing backend development environment');
-    // Simulate backend-specific setup
-    await this.simulateWork(1000, 3000);
-  }
-
-  private async initializeTestingAgent(): Promise<void> {
-    console.log('🧪 Initializing testing environment');
-    // Simulate testing-specific setup
-    await this.simulateWork(1000, 3000);
-  }
-
-  private async initializeDocumentationAgent(): Promise<void> {
-    console.log('📚 Initializing documentation environment');
-    // Simulate documentation-specific setup
-    await this.simulateWork(1000, 3000);
-  }
-
-  private async initializeSecurityAgent(): Promise<void> {
-    console.log('🔒 Initializing security environment');
-    // Simulate security-specific setup
-    await this.simulateWork(1000, 3000);
-  }
-
-  private async initializePerformanceAgent(): Promise<void> {
-    console.log('📊 Initializing performance monitoring');
-    // Simulate performance-specific setup
-    await this.simulateWork(1000, 3000);
-  }
-
-  /**
-   * Cleanup on shutdown
-   */
-  cleanup(): void {
-    this.isRunning = false;
-    
-    if (this.heartbeatInterval) {
-      clearInterval(this.heartbeatInterval);
-    }
-    
-    console.log(`🧹 Agent runner ${this.config.agentId} cleaned up`);
-  }
-}
-
-/**
- * Parse command line arguments
- */
-function parseArgs(): AgentConfig {
-  const args = process.argv.slice(2);
-  
-  const config: Partial<AgentConfig> = {};
-  
-  for (let i = 0; i < args.length; i += 2) {
-    const flag = args[i];
-    const value = args[i + 1];
-    
-    switch (flag) {
-      case '--agent-id':
-        config.agentId = value;
-        break;
-      case '--agent-type':
-        config.agentType = value;
-        break;
-      case '--mailbox-id':
-        config.mailboxId = value;
-        break;
-      case '--task':
-        config.task = value;
-        break;
-      case '--timeout':
-        config.timeout = parseInt(value);
-        break;
-    }
-  }
-  
-  if (!config.agentId || !config.agentType || !config.mailboxId) {
-    console.error('Missing required arguments');
-    console.log('Usage: bun agent-runner.js --agent-id <id> --agent-type <type> --mailbox-id <id> [--task <task>] [--timeout <ms>]');
-    process.exit(1);
-  }
-  
-  return config as AgentConfig;
-}
-
-/**
- * Main execution
- */
-async function main(): Promise<void> {
-  const config = parseArgs();
-  const runner = new AgentRunner(config);
-  
-  // Handle graceful shutdown
-  process.on('SIGINT', () => {
-    console.log('\n🛑 Received SIGINT, shutting down gracefully...');
-    runner.cleanup();
-    process.exit(0);
-  });
-  
-  process.on('SIGTERM', () => {
-    console.log('\n🛑 Received SIGTERM, shutting down gracefully...');
-    runner.cleanup();
-    process.exit(0);
-  });
-  
-  // Handle timeout
-  if (config.timeout) {
-    setTimeout(() => {
-      console.log(`⏰ Agent timeout reached (${config.timeout}ms)`);
-      runner.cleanup();
-      process.exit(1);
-    }, config.timeout);
-  }
-  
-  try {
-    await runner.start();
-  } catch (error: any) {
-    console.error('Agent runner failed:', error.message);
-    process.exit(1);
-  }
-}
-
-// Run the agent
-if (import.meta.main) {
-  main();
-}