@supaku/agentfactory-cli 0.2.0 → 0.4.0

package/dist/src/worker-fleet.js

@@ -3,7 +3,7 @@
  * AgentFactory Worker Fleet Manager
  *
  * Spawns and manages multiple worker processes for parallel agent execution.
- * Each worker runs as a separate process with its own resources.
+ * Thin wrapper around the programmatic runner in ./lib/worker-fleet-runner.js.
  *
  * Usage:
  *   af-worker-fleet [options]
@@ -19,38 +19,24 @@
  *   WORKER_API_URL        Coordinator API URL (required)
  *   WORKER_API_KEY        API key for authentication (required)
  */
-import { spawn } from 'child_process';
-import os from 'os';
 import path from 'path';
-import { fileURLToPath } from 'url';
+import os from 'os';
 import { config as loadEnv } from 'dotenv';
 // Load environment variables from .env.local in CWD
 loadEnv({ path: path.resolve(process.cwd(), '.env.local') });
-// Resolve the directory of this script (for finding worker.js)
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-// ANSI colors
+import { runWorkerFleet } from './lib/worker-fleet-runner.js';
+// ANSI colors (kept for help output)
 const colors = {
     reset: '\x1b[0m',
     red: '\x1b[31m',
     green: '\x1b[32m',
     yellow: '\x1b[33m',
-    blue: '\x1b[34m',
-    magenta: '\x1b[35m',
     cyan: '\x1b[36m',
-    gray: '\x1b[90m',
 };
-// Worker color cycling
-const workerColors = [
-    colors.cyan,
-    colors.magenta,
-    colors.yellow,
-    colors.green,
-    colors.blue,
-];
 function parseArgs() {
     const args = process.argv.slice(2);
-    let workers = parseInt(process.env.WORKER_FLEET_SIZE ?? '0', 10) || Math.max(1, Math.floor(os.cpus().length / 2));
+    let workers = parseInt(process.env.WORKER_FLEET_SIZE ?? '0', 10) ||
+        Math.max(1, Math.floor(os.cpus().length / 2));
     let capacity = parseInt(process.env.WORKER_CAPACITY ?? '3', 10);
     let dryRun = false;
     for (let i = 0; i < args.length; i++) {
@@ -101,146 +87,8 @@ ${colors.yellow}System Info:${colors.reset}
   Free RAM:  ${Math.round(os.freemem() / 1024 / 1024 / 1024)} GB
 `);
 }
-function timestamp() {
-    return new Date().toLocaleTimeString('en-US', { hour12: false });
-}
-function fleetLog(workerId, color, level, message) {
-    const prefix = workerId !== null ? `[W${workerId.toString().padStart(2, '0')}]` : '[FLEET]';
-    const levelColor = level === 'ERR' ? colors.red : level === 'WRN' ? colors.yellow : colors.gray;
-    console.log(`${colors.gray}${timestamp()}${colors.reset} ${color}${prefix}${colors.reset} ${levelColor}${level}${colors.reset} ${message}`);
-}
-class WorkerFleet {
-    workers = new Map();
-    fleetConfig;
-    shuttingDown = false;
-    workerScript;
-    constructor(fleetConfig) {
-        this.fleetConfig = fleetConfig;
-        // Use the compiled worker.js in the same directory
-        this.workerScript = path.resolve(__dirname, 'worker.js');
-    }
-    async start() {
-        const { workers, capacity, dryRun } = this.fleetConfig;
-        const totalCapacity = workers * capacity;
-        console.log(`
-${colors.cyan}================================================================${colors.reset}
-${colors.cyan}  AgentFactory Worker Fleet Manager${colors.reset}
-${colors.cyan}================================================================${colors.reset}
-  Workers:         ${colors.green}${workers}${colors.reset}
-  Capacity/Worker: ${colors.green}${capacity}${colors.reset}
-  Total Capacity:  ${colors.green}${totalCapacity}${colors.reset} concurrent agents
-
-  System:
-    CPU Cores:    ${os.cpus().length}
-    Total RAM:    ${Math.round(os.totalmem() / 1024 / 1024 / 1024)} GB
-    Free RAM:     ${Math.round(os.freemem() / 1024 / 1024 / 1024)} GB
-${colors.cyan}================================================================${colors.reset}
-`);
-        if (dryRun) {
-            console.log(`${colors.yellow}Dry run mode - not starting workers${colors.reset}`);
-            return;
-        }
-        // Set up shutdown handlers
-        process.on('SIGINT', () => this.shutdown('SIGINT'));
-        process.on('SIGTERM', () => this.shutdown('SIGTERM'));
-        // Spawn workers with staggered start to avoid thundering herd
-        for (let i = 0; i < workers; i++) {
-            await this.spawnWorker(i);
-            if (i < workers - 1) {
-                await new Promise(resolve => setTimeout(resolve, 1000));
-            }
-        }
-        fleetLog(null, colors.green, 'INF', `All ${workers} workers started`);
-        // Keep the fleet manager running
-        await new Promise(() => { });
-    }
-    async spawnWorker(id) {
-        const color = workerColors[id % workerColors.length];
-        const existingWorker = this.workers.get(id);
-        const restartCount = existingWorker?.restartCount ?? 0;
-        fleetLog(id, color, 'INF', `Starting worker (capacity: ${this.fleetConfig.capacity})${restartCount > 0 ? ` [restart #${restartCount}]` : ''}`);
-        const workerProcess = spawn('node', [this.workerScript, '--capacity', String(this.fleetConfig.capacity)], {
-            stdio: ['ignore', 'pipe', 'pipe'],
-            env: {
-                ...process.env,
-                WORKER_FLEET_ID: String(id),
-            },
-            cwd: process.cwd(),
-        });
-        const workerInfo = {
-            id,
-            process: workerProcess,
-            color,
-            startedAt: new Date(),
-            restartCount,
-        };
-        this.workers.set(id, workerInfo);
-        // Handle stdout - prefix with worker ID
-        workerProcess.stdout?.on('data', (data) => {
-            const lines = data.toString().trim().split('\n');
-            for (const line of lines) {
-                if (line.trim()) {
-                    console.log(`${color}[W${id.toString().padStart(2, '0')}]${colors.reset} ${line}`);
-                }
-            }
-        });
-        // Handle stderr
-        workerProcess.stderr?.on('data', (data) => {
-            const lines = data.toString().trim().split('\n');
-            for (const line of lines) {
-                if (line.trim()) {
-                    console.log(`${color}[W${id.toString().padStart(2, '0')}]${colors.reset} ${colors.red}${line}${colors.reset}`);
-                }
-            }
-        });
-        // Handle worker exit
-        workerProcess.on('exit', (code, signal) => {
-            if (this.shuttingDown) {
-                fleetLog(id, color, 'INF', `Worker stopped (code: ${code}, signal: ${signal})`);
-                return;
-            }
-            fleetLog(id, color, 'WRN', `Worker exited unexpectedly (code: ${code}, signal: ${signal}) - restarting in 5s`);
-            const worker = this.workers.get(id);
-            if (worker) {
-                worker.restartCount++;
-            }
-            setTimeout(() => {
-                if (!this.shuttingDown) {
-                    this.spawnWorker(id);
-                }
-            }, 5000);
-        });
-        workerProcess.on('error', (err) => {
-            fleetLog(id, color, 'ERR', `Worker error: ${err.message}`);
-        });
-    }
-    async shutdown(signal) {
-        if (this.shuttingDown)
-            return;
-        this.shuttingDown = true;
-        console.log(`\n${colors.yellow}Received ${signal} - shutting down fleet...${colors.reset}`);
-        for (const [id, worker] of this.workers) {
-            fleetLog(id, worker.color, 'INF', 'Stopping worker...');
-            worker.process.kill('SIGTERM');
-        }
-        // Wait for workers to exit (max 30 seconds)
-        const timeout = setTimeout(() => {
-            console.log(`${colors.red}Timeout waiting for workers - force killing${colors.reset}`);
-            for (const worker of this.workers.values()) {
-                worker.process.kill('SIGKILL');
-            }
-            process.exit(1);
-        }, 30000);
-        await Promise.all(Array.from(this.workers.values()).map((worker) => new Promise((resolve) => {
-            worker.process.on('exit', () => resolve());
-        })));
-        clearTimeout(timeout);
-        console.log(`${colors.green}All workers stopped${colors.reset}`);
-        process.exit(0);
-    }
-}
-// Main
-const fleetConfig = parseArgs();
+// --- Main ---
+const fleetArgs = parseArgs();
 if (!process.env.WORKER_API_URL) {
     console.error(`${colors.red}Error: WORKER_API_URL environment variable is required${colors.reset}`);
     process.exit(1);
@@ -249,8 +97,21 @@ if (!process.env.WORKER_API_KEY) {
     console.error(`${colors.red}Error: WORKER_API_KEY environment variable is required${colors.reset}`);
     process.exit(1);
 }
-const fleet = new WorkerFleet(fleetConfig);
-fleet.start().catch((err) => {
+// Create AbortController for graceful shutdown
+const controller = new AbortController();
+process.on('SIGINT', () => controller.abort());
+process.on('SIGTERM', () => controller.abort());
+runWorkerFleet({
+    workers: fleetArgs.workers,
+    capacity: fleetArgs.capacity,
+    dryRun: fleetArgs.dryRun,
+    apiUrl: process.env.WORKER_API_URL,
+    apiKey: process.env.WORKER_API_KEY,
+}, controller.signal)
+    .then(() => {
+    process.exit(0);
+})
+    .catch((err) => {
     console.error(`${colors.red}Fleet error: ${err instanceof Error ? err.message : String(err)}${colors.reset}`);
     process.exit(1);
 });

package/dist/src/worker.d.ts

@@ -3,6 +3,7 @@
  * AgentFactory Worker CLI
  *
  * Local worker that polls the coordinator for work and executes agents.
+ * Thin wrapper around the programmatic runner in ./lib/worker-runner.js.
  *
  * Usage:
  *   af-worker [options]

package/dist/src/worker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../../src/worker.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;GAmBG"}
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../../src/worker.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;;GAoBG"}