kynjal-cli 3.1.3 → 4.0.0

package/dist/src/services/container-worker-pool.js

@@ -15,28 +15,99 @@
  * - Volume mounting for workspace access
  * - Network isolation per worker type
  */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 import { EventEmitter } from 'events';
 import { spawn, exec } from 'child_process';
 import { promisify } from 'util';
 import { existsSync, mkdirSync } from 'fs';
 import { join } from 'path';
-const execAsync = promisify(exec);
+var execAsync = promisify(exec);
 // ============================================
 // Constants
 // ============================================
-const DEFAULT_CONFIG = {
+var DEFAULT_CONFIG = {
     maxContainers: 3,
     minContainers: 1,
-    image: 'ghcr.io/KingJune28/claude-flow-headless:latest',
+    image: 'ghcr.io/ruvnet/claude-flow-headless:latest',
     resources: {
         cpus: '2',
-        memory: '4g',
+        memory: '4g'
     },
     healthCheckIntervalMs: 30000,
-    idleTimeoutMs: 300000, // 5 minutes
+    idleTimeoutMs: 300000,
     workspacePath: '/workspace',
     statePath: '.claude-flow/container-pool',
-    defaultSandbox: 'strict',
+    defaultSandbox: 'strict'
 };
 // ============================================
 // ContainerWorkerPool Class
@@ -44,26 +115,24 @@ const DEFAULT_CONFIG = {
 /**
  * ContainerWorkerPool - Manages Docker containers for headless worker execution
  */
-export class ContainerWorkerPool extends EventEmitter {
-    config;
-    projectRoot;
-    containers = new Map();
-    taskQueue = [];
-    healthCheckTimer;
-    idleCheckTimer;
-    dockerAvailable = null;
-    initialized = false;
-    isShuttingDown = false;
-    exitHandlersRegistered = false;
-    constructor(projectRoot, config) {
-        super();
-        this.projectRoot = projectRoot;
-        this.config = { ...DEFAULT_CONFIG, ...config };
+var ContainerWorkerPool = /** @class */ (function (_super) {
+    __extends(ContainerWorkerPool, _super);
+    function ContainerWorkerPool(projectRoot, config) {
+        var _this = _super.call(this) || this;
+        _this.containers = new Map();
+        _this.taskQueue = [];
+        _this.dockerAvailable = null;
+        _this.initialized = false;
+        _this.isShuttingDown = false;
+        _this.exitHandlersRegistered = false;
+        _this.projectRoot = projectRoot;
+        _this.config = __assign(__assign({}, DEFAULT_CONFIG), config);
         // Ensure state directory exists
-        const stateDir = join(projectRoot, this.config.statePath);
+        var stateDir = join(projectRoot, _this.config.statePath);
         if (!existsSync(stateDir)) {
             mkdirSync(stateDir, { recursive: true });
         }
+        return _this;
     }
     // ============================================
     // Public API
@@ -71,382 +140,523 @@ export class ContainerWorkerPool extends EventEmitter {
     /**
      * Initialize the container pool
      */
-    async initialize() {
-        if (this.initialized) {
-            return true;
-        }
-        // Check Docker availability
-        this.dockerAvailable = await this.checkDockerAvailable();
-        if (!this.dockerAvailable) {
-            this.emit('warning', { message: 'Docker not available - container pool disabled' });
-            return false;
-        }
-        // Pull image if needed
-        await this.ensureImage();
-        // Create minimum containers
-        await this.scaleToMinimum();
-        // Start health check timer
-        this.startHealthChecks();
-        // Start idle check timer
-        this.startIdleChecks();
-        // Register exit handlers for cleanup
-        this.registerExitHandlers();
-        this.initialized = true;
-        this.emit('initialized', { containers: this.containers.size });
-        return true;
-    }
+    ContainerWorkerPool.prototype.initialize = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (this.initialized) {
+                            return [2 /*return*/, true];
+                        }
+                        // Check Docker availability
+                        _a = this;
+                        return [4 /*yield*/, this.checkDockerAvailable()];
+                    case 1:
+                        // Check Docker availability
+                        _a.dockerAvailable = _b.sent();
+                        if (!this.dockerAvailable) {
+                            this.emit('warning', { message: 'Docker not available - container pool disabled' });
+                            return [2 /*return*/, false];
+                        }
+                        // Pull image if needed
+                        return [4 /*yield*/, this.ensureImage()];
+                    case 2:
+                        // Pull image if needed
+                        _b.sent();
+                        // Create minimum containers
+                        return [4 /*yield*/, this.scaleToMinimum()];
+                    case 3:
+                        // Create minimum containers
+                        _b.sent();
+                        // Start health check timer
+                        this.startHealthChecks();
+                        // Start idle check timer
+                        this.startIdleChecks();
+                        // Register exit handlers for cleanup
+                        this.registerExitHandlers();
+                        this.initialized = true;
+                        this.emit('initialized', { containers: this.containers.size });
+                        return [2 /*return*/, true];
+                }
+            });
+        });
+    };
     /**
      * Register process exit handlers to clean up containers
      */
-    registerExitHandlers() {
+    ContainerWorkerPool.prototype.registerExitHandlers = function () {
+        var _this = this;
         if (this.exitHandlersRegistered)
             return;
-        const cleanup = async () => {
-            if (!this.isShuttingDown) {
-                await this.shutdown();
-            }
-        };
+        var cleanup = function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!!this.isShuttingDown) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.shutdown()];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        }); };
         process.once('SIGTERM', cleanup);
         process.once('SIGINT', cleanup);
         process.once('beforeExit', cleanup);
         this.exitHandlersRegistered = true;
-    }
+    };
     /**
      * Execute a worker in a container
      */
-    async execute(options) {
-        if (!this.initialized) {
-            await this.initialize();
-        }
-        if (!this.dockerAvailable) {
-            return this.createErrorResult(options.workerType, 'Docker not available');
-        }
-        // Try to get a ready container
-        const container = this.getReadyContainer();
-        if (container) {
-            return this.executeInContainer(container, options);
-        }
-        // No ready containers - check if we can create more
-        if (this.containers.size < this.config.maxContainers) {
-            const newContainer = await this.createContainer();
-            if (newContainer) {
-                return this.executeInContainer(newContainer, options);
-            }
-        }
-        // Queue the task
-        return new Promise((resolve, reject) => {
-            this.taskQueue.push({
-                options,
-                resolve,
-                reject,
-                queuedAt: new Date(),
-            });
-            this.emit('taskQueued', {
-                workerType: options.workerType,
-                queuePosition: this.taskQueue.length,
+    ContainerWorkerPool.prototype.execute = function (options) {
+        return __awaiter(this, void 0, Promise, function () {
+            var container, newContainer;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!!this.initialized) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.initialize()];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        if (!this.dockerAvailable) {
+                            return [2 /*return*/, this.createErrorResult(options.workerType, 'Docker not available')];
+                        }
+                        container = this.getReadyContainer();
+                        if (container) {
+                            return [2 /*return*/, this.executeInContainer(container, options)];
+                        }
+                        if (!(this.containers.size < this.config.maxContainers)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.createContainer()];
+                    case 3:
+                        newContainer = _a.sent();
+                        if (newContainer) {
+                            return [2 /*return*/, this.executeInContainer(newContainer, options)];
+                        }
+                        _a.label = 4;
+                    case 4: 
+                    // Queue the task
+                    return [2 /*return*/, new Promise(function (resolve, reject) {
+                            _this.taskQueue.push({
+                                options: options,
+                                resolve: resolve,
+                                reject: reject,
+                                queuedAt: new Date()
+                            });
+                            _this.emit('taskQueued', {
+                                workerType: options.workerType,
+                                queuePosition: _this.taskQueue.length
+                            });
+                        })];
+                }
             });
         });
-    }
+    };
     /**
      * Scale pool for batch execution
      */
-    async scaleForBatch(workerCount) {
-        const targetSize = Math.min(workerCount, this.config.maxContainers);
-        const currentSize = this.containers.size;
-        if (targetSize > currentSize) {
-            const toCreate = targetSize - currentSize;
-            const createPromises = [];
-            for (let i = 0; i < toCreate; i++) {
-                createPromises.push(this.createContainer());
-            }
-            await Promise.all(createPromises);
-            this.emit('scaled', { from: currentSize, to: this.containers.size });
-        }
-    }
+    ContainerWorkerPool.prototype.scaleForBatch = function (workerCount) {
+        return __awaiter(this, void 0, Promise, function () {
+            var targetSize, currentSize, toCreate, createPromises, i;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        targetSize = Math.min(workerCount, this.config.maxContainers);
+                        currentSize = this.containers.size;
+                        if (!(targetSize > currentSize)) return [3 /*break*/, 2];
+                        toCreate = targetSize - currentSize;
+                        createPromises = [];
+                        for (i = 0; i < toCreate; i++) {
+                            createPromises.push(this.createContainer());
+                        }
+                        return [4 /*yield*/, Promise.all(createPromises)];
+                    case 1:
+                        _a.sent();
+                        this.emit('scaled', { from: currentSize, to: this.containers.size });
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Get pool status
      */
-    getStatus() {
-        const containers = Array.from(this.containers.values());
+    ContainerWorkerPool.prototype.getStatus = function () {
+        var _a;
+        var containers = Array.from(this.containers.values());
         return {
             totalContainers: containers.length,
-            readyContainers: containers.filter(c => c.state === 'ready').length,
-            busyContainers: containers.filter(c => c.state === 'busy').length,
-            unhealthyContainers: containers.filter(c => c.state === 'unhealthy').length,
+            readyContainers: containers.filter(function (c) { return c.state === 'ready'; }).length,
+            busyContainers: containers.filter(function (c) { return c.state === 'busy'; }).length,
+            unhealthyContainers: containers.filter(function (c) { return c.state === 'unhealthy'; }).length,
             queuedTasks: this.taskQueue.length,
-            containers,
-            dockerAvailable: this.dockerAvailable ?? false,
-            lastHealthCheck: undefined, // Will be set by health check
+            containers: containers,
+            dockerAvailable: (_a = this.dockerAvailable) !== null && _a !== void 0 ? _a : false,
+            lastHealthCheck: undefined
         };
-    }
+    };
     /**
      * Shutdown the pool
      */
-    async shutdown() {
-        if (this.isShuttingDown)
-            return;
-        this.isShuttingDown = true;
-        // Stop timers
-        if (this.healthCheckTimer) {
-            clearInterval(this.healthCheckTimer);
-            this.healthCheckTimer = undefined;
-        }
-        if (this.idleCheckTimer) {
-            clearInterval(this.idleCheckTimer);
-            this.idleCheckTimer = undefined;
-        }
-        // Reject queued tasks
-        for (const task of this.taskQueue) {
-            task.reject(new Error('Pool shutting down'));
-        }
-        this.taskQueue = [];
-        // Terminate all containers with timeout
-        const terminatePromises = [];
-        for (const [id] of this.containers) {
-            terminatePromises.push(this.terminateContainer(id).catch(() => {
-                // Ignore errors during shutdown
-            }));
-        }
-        // Wait for all containers with 30s timeout
-        await Promise.race([
-            Promise.all(terminatePromises),
-            new Promise(resolve => setTimeout(resolve, 30000)),
-        ]);
-        this.initialized = false;
-        this.emit('shutdown', {});
-    }
+    ContainerWorkerPool.prototype.shutdown = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var _i, _a, task, terminatePromises, _b, _c, id;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        if (this.isShuttingDown)
+                            return [2 /*return*/];
+                        this.isShuttingDown = true;
+                        // Stop timers
+                        if (this.healthCheckTimer) {
+                            clearInterval(this.healthCheckTimer);
+                            this.healthCheckTimer = undefined;
+                        }
+                        if (this.idleCheckTimer) {
+                            clearInterval(this.idleCheckTimer);
+                            this.idleCheckTimer = undefined;
+                        }
+                        // Reject queued tasks
+                        for (_i = 0, _a = this.taskQueue; _i < _a.length; _i++) {
+                            task = _a[_i];
+                            task.reject(new Error('Pool shutting down'));
+                        }
+                        this.taskQueue = [];
+                        terminatePromises = [];
+                        for (_b = 0, _c = this.containers; _b < _c.length; _b++) {
+                            id = _c[_b][0];
+                            terminatePromises.push(this.terminateContainer(id)["catch"](function () {
+                                // Ignore errors during shutdown
+                            }));
+                        }
+                        // Wait for all containers with 30s timeout
+                        return [4 /*yield*/, Promise.race([
+                                Promise.all(terminatePromises),
+                                new Promise(function (resolve) { return setTimeout(resolve, 30000); }),
+                            ])];
+                    case 1:
+                        // Wait for all containers with 30s timeout
+                        _d.sent();
+                        this.initialized = false;
+                        this.emit('shutdown', {});
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     // ============================================
     // Private Methods - Container Lifecycle
     // ============================================
     /**
      * Check if Docker is available (async)
      */
-    async checkDockerAvailable() {
-        try {
-            await execAsync('docker --version', { timeout: 5000 });
-            await execAsync('docker info', { timeout: 10000 });
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
+    ContainerWorkerPool.prototype.checkDockerAvailable = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 3, , 4]);
+                        return [4 /*yield*/, execAsync('docker --version', { timeout: 5000 })];
+                    case 1:
+                        _b.sent();
+                        return [4 /*yield*/, execAsync('docker info', { timeout: 10000 })];
+                    case 2:
+                        _b.sent();
+                        return [2 /*return*/, true];
+                    case 3:
+                        _a = _b.sent();
+                        return [2 /*return*/, false];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Ensure the container image exists (async)
      */
-    async ensureImage() {
-        try {
-            await execAsync(`docker image inspect ${this.config.image}`, { timeout: 10000 });
-        }
-        catch {
-            // Image not found, try to pull
-            this.emit('imagePull', { image: this.config.image });
-            try {
-                await execAsync(`docker pull ${this.config.image}`, { timeout: 300000 });
-            }
-            catch (error) {
-                this.emit('warning', { message: `Failed to pull image: ${error}` });
-                // Continue anyway - might work with local image
-            }
-        }
-    }
+    ContainerWorkerPool.prototype.ensureImage = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var _a, error_1;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 7]);
+                        return [4 /*yield*/, execAsync("docker image inspect " + this.config.image, { timeout: 10000 })];
+                    case 1:
+                        _b.sent();
+                        return [3 /*break*/, 7];
+                    case 2:
+                        _a = _b.sent();
+                        // Image not found, try to pull
+                        this.emit('imagePull', { image: this.config.image });
+                        _b.label = 3;
+                    case 3:
+                        _b.trys.push([3, 5, , 6]);
+                        return [4 /*yield*/, execAsync("docker pull " + this.config.image, { timeout: 300000 })];
+                    case 4:
+                        _b.sent();
+                        return [3 /*break*/, 6];
+                    case 5:
+                        error_1 = _b.sent();
+                        this.emit('warning', { message: "Failed to pull image: " + error_1 });
+                        return [3 /*break*/, 6];
+                    case 6: return [3 /*break*/, 7];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Create a new container
      */
-    async createContainer() {
-        const id = `cf-worker-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-        const name = `claude-flow-worker-${id}`;
-        const containerInfo = {
-            id,
-            name,
-            state: 'creating',
-            createdAt: new Date(),
-            executionCount: 0,
-            healthCheckFailures: 0,
-        };
-        this.containers.set(id, containerInfo);
-        this.emit('containerCreating', { id, name });
-        try {
-            // Build docker run command
-            const args = [
-                'run', '-d',
-                '--name', name,
-                '--cpus', this.config.resources.cpus,
-                '--memory', this.config.resources.memory,
-                '-v', `${this.projectRoot}:${this.config.workspacePath}:ro`,
-                '-v', `${join(this.projectRoot, this.config.statePath)}:/root/.claude-flow`,
-                '-w', this.config.workspacePath,
-            ];
-            // Add environment variables
-            const env = {
-                ...this.config.env,
-                ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY || '',
-                CLAUDE_CODE_HEADLESS: 'true',
-                CLAUDE_CODE_SANDBOX_MODE: this.config.defaultSandbox,
-            };
-            for (const [key, value] of Object.entries(env)) {
-                if (value) {
-                    args.push('-e', `${key}=${value}`);
+    ContainerWorkerPool.prototype.createContainer = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var id, name, containerInfo, args, env, _i, _a, _b, key, value, stdout, containerId, error_2;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        id = "cf-worker-" + Date.now() + "-" + Math.random().toString(36).slice(2, 8);
+                        name = "claude-flow-worker-" + id;
+                        containerInfo = {
+                            id: id,
+                            name: name,
+                            state: 'creating',
+                            createdAt: new Date(),
+                            executionCount: 0,
+                            healthCheckFailures: 0
+                        };
+                        this.containers.set(id, containerInfo);
+                        this.emit('containerCreating', { id: id, name: name });
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 3, , 4]);
+                        args = [
+                            'run', '-d',
+                            '--name', name,
+                            '--cpus', this.config.resources.cpus,
+                            '--memory', this.config.resources.memory,
+                            '-v',
+                            this.projectRoot + ":" + this.config.workspacePath + ":ro",
+                            '-v',
+                            join(this.projectRoot, this.config.statePath) + ":/root/.claude-flow",
+                            '-w', this.config.workspacePath,
+                        ];
+                        env = __assign(__assign({}, this.config.env), { ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY || '', CLAUDE_CODE_HEADLESS: 'true', CLAUDE_CODE_SANDBOX_MODE: this.config.defaultSandbox });
+                        for (_i = 0, _a = Object.entries(env); _i < _a.length; _i++) {
+                            _b = _a[_i], key = _b[0], value = _b[1];
+                            if (value) {
+                                args.push('-e', key + "=" + value);
+                            }
+                        }
+                        // Add network if specified
+                        if (this.config.network) {
+                            args.push('--network', this.config.network);
+                        }
+                        // Add image and entrypoint to keep container running
+                        args.push(this.config.image, 'tail', '-f', '/dev/null');
+                        return [4 /*yield*/, execAsync("docker " + args.join(' '), { timeout: 60000 })];
+                    case 2:
+                        stdout = (_c.sent()).stdout;
+                        containerId = stdout.trim();
+                        containerInfo.state = 'ready';
+                        this.emit('containerCreated', { id: id, name: name, containerId: containerId });
+                        return [2 /*return*/, containerInfo];
+                    case 3:
+                        error_2 = _c.sent();
+                        this.containers["delete"](id);
+                        this.emit('containerError', { id: id, error: String(error_2) });
+                        return [2 /*return*/, null];
+                    case 4: return [2 /*return*/];
                 }
-            }
-            // Add network if specified
-            if (this.config.network) {
-                args.push('--network', this.config.network);
-            }
-            // Add image and entrypoint to keep container running
-            args.push(this.config.image, 'tail', '-f', '/dev/null');
-            // Create the container (async)
-            const { stdout } = await execAsync(`docker ${args.join(' ')}`, { timeout: 60000 });
-            const containerId = stdout.trim();
-            containerInfo.state = 'ready';
-            this.emit('containerCreated', { id, name, containerId });
-            return containerInfo;
-        }
-        catch (error) {
-            this.containers.delete(id);
-            this.emit('containerError', { id, error: String(error) });
-            return null;
-        }
-    }
+            });
+        });
+    };
     /**
      * Terminate a container (async)
      */
-    async terminateContainer(id) {
-        const container = this.containers.get(id);
-        if (!container)
-            return;
-        container.state = 'terminated';
-        try {
-            await execAsync(`docker rm -f ${container.name}`, { timeout: 30000 });
-        }
-        catch {
-            // Ignore removal errors
-        }
-        this.containers.delete(id);
-        this.emit('containerTerminated', { id, name: container.name });
-    }
+    ContainerWorkerPool.prototype.terminateContainer = function (id) {
+        return __awaiter(this, void 0, Promise, function () {
+            var container, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        container = this.containers.get(id);
+                        if (!container)
+                            return [2 /*return*/];
+                        container.state = 'terminated';
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, execAsync("docker rm -f " + container.name, { timeout: 30000 })];
+                    case 2:
+                        _b.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        _a = _b.sent();
+                        return [3 /*break*/, 4];
+                    case 4:
+                        this.containers["delete"](id);
+                        this.emit('containerTerminated', { id: id, name: container.name });
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Get a ready container
      */
-    getReadyContainer() {
-        for (const container of this.containers.values()) {
+    ContainerWorkerPool.prototype.getReadyContainer = function () {
+        for (var _i = 0, _a = this.containers.values(); _i < _a.length; _i++) {
+            var container = _a[_i];
             if (container.state === 'ready') {
                 return container;
             }
         }
         return null;
-    }
+    };
     /**
      * Scale to minimum containers
      */
-    async scaleToMinimum() {
-        const current = this.containers.size;
-        const needed = this.config.minContainers - current;
-        if (needed > 0) {
-            const createPromises = [];
-            for (let i = 0; i < needed; i++) {
-                createPromises.push(this.createContainer());
-            }
-            await Promise.all(createPromises);
-        }
-    }
+    ContainerWorkerPool.prototype.scaleToMinimum = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var current, needed, createPromises, i;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        current = this.containers.size;
+                        needed = this.config.minContainers - current;
+                        if (!(needed > 0)) return [3 /*break*/, 2];
+                        createPromises = [];
+                        for (i = 0; i < needed; i++) {
+                            createPromises.push(this.createContainer());
+                        }
+                        return [4 /*yield*/, Promise.all(createPromises)];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        });
+    };
     // ============================================
     // Private Methods - Execution
     // ============================================
     /**
      * Execute worker in a specific container
      */
-    async executeInContainer(container, options) {
-        const startTime = Date.now();
-        const executionId = `${options.workerType}_${startTime}_${Math.random().toString(36).slice(2, 8)}`;
-        container.state = 'busy';
-        container.workerType = options.workerType;
-        container.lastUsedAt = new Date();
-        this.emit('executionStart', { executionId, containerId: container.id, workerType: options.workerType });
-        try {
-            // Build the command to run inside container
-            const command = this.buildWorkerCommand(options);
-            // Execute in container with timeout
-            const timeoutMs = options.timeoutMs || 300000;
-            const output = await this.execInContainer(container.name, command, timeoutMs);
-            container.state = 'ready';
-            container.executionCount++;
-            const result = {
-                success: true,
-                output: output,
-                parsedOutput: this.tryParseJson(output),
-                durationMs: Date.now() - startTime,
-                model: options.model || 'sonnet',
-                sandboxMode: options.sandbox || this.config.defaultSandbox,
-                workerType: options.workerType,
-                timestamp: new Date(),
-                executionId,
-            };
-            this.emit('executionComplete', result);
-            // Process queue
-            this.processQueue();
-            return result;
-        }
-        catch (error) {
-            container.state = 'ready';
-            const result = this.createErrorResult(options.workerType, error instanceof Error ? error.message : String(error));
-            result.executionId = executionId;
-            result.durationMs = Date.now() - startTime;
-            this.emit('executionError', result);
-            // Process queue
-            this.processQueue();
-            return result;
-        }
-    }
+    ContainerWorkerPool.prototype.executeInContainer = function (container, options) {
+        return __awaiter(this, void 0, Promise, function () {
+            var startTime, executionId, command, timeoutMs, output, result, error_3, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        startTime = Date.now();
+                        executionId = options.workerType + "_" + startTime + "_" + Math.random().toString(36).slice(2, 8);
+                        container.state = 'busy';
+                        container.workerType = options.workerType;
+                        container.lastUsedAt = new Date();
+                        this.emit('executionStart', { executionId: executionId, containerId: container.id, workerType: options.workerType });
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        command = this.buildWorkerCommand(options);
+                        timeoutMs = options.timeoutMs || 300000;
+                        return [4 /*yield*/, this.execInContainer(container.name, command, timeoutMs)];
+                    case 2:
+                        output = _a.sent();
+                        container.state = 'ready';
+                        container.executionCount++;
+                        result = {
+                            success: true,
+                            output: output,
+                            parsedOutput: this.tryParseJson(output),
+                            durationMs: Date.now() - startTime,
+                            model: options.model || 'sonnet',
+                            sandboxMode: options.sandbox || this.config.defaultSandbox,
+                            workerType: options.workerType,
+                            timestamp: new Date(),
+                            executionId: executionId
+                        };
+                        this.emit('executionComplete', result);
+                        // Process queue
+                        this.processQueue();
+                        return [2 /*return*/, result];
+                    case 3:
+                        error_3 = _a.sent();
+                        container.state = 'ready';
+                        result = this.createErrorResult(options.workerType, error_3 instanceof Error ? error_3.message : String(error_3));
+                        result.executionId = executionId;
+                        result.durationMs = Date.now() - startTime;
+                        this.emit('executionError', result);
+                        // Process queue
+                        this.processQueue();
+                        return [2 /*return*/, result];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Execute command in container
      */
-    async execInContainer(containerName, command, timeoutMs) {
-        return new Promise((resolve, reject) => {
-            const args = ['exec', containerName, ...command];
-            const child = spawn('docker', args, {
-                stdio: ['pipe', 'pipe', 'pipe'],
-            });
-            let stdout = '';
-            let stderr = '';
-            let timedOut = false;
-            const timeout = setTimeout(() => {
-                timedOut = true;
-                child.kill('SIGTERM');
-                setTimeout(() => {
-                    if (!child.killed) {
-                        child.kill('SIGKILL');
-                    }
-                }, 5000);
-            }, timeoutMs);
-            child.stdout?.on('data', (data) => {
-                stdout += data.toString();
-            });
-            child.stderr?.on('data', (data) => {
-                stderr += data.toString();
-            });
-            child.on('close', (code) => {
-                clearTimeout(timeout);
-                if (timedOut) {
-                    reject(new Error(`Execution timed out after ${timeoutMs}ms`));
-                    return;
-                }
-                if (code !== 0) {
-                    reject(new Error(stderr || `Process exited with code ${code}`));
-                    return;
-                }
-                resolve(stdout);
-            });
-            child.on('error', (error) => {
-                clearTimeout(timeout);
-                reject(error);
+    ContainerWorkerPool.prototype.execInContainer = function (containerName, command, timeoutMs) {
+        return __awaiter(this, void 0, Promise, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        var _a, _b;
+                        var args = __spreadArray(['exec', containerName], command, true);
+                        var child = spawn('docker', args, {
+                            stdio: ['pipe', 'pipe', 'pipe']
+                        });
+                        var stdout = '';
+                        var stderr = '';
+                        var timedOut = false;
+                        var timeout = setTimeout(function () {
+                            timedOut = true;
+                            child.kill('SIGTERM');
+                            setTimeout(function () {
+                                if (!child.killed) {
+                                    child.kill('SIGKILL');
+                                }
+                            }, 5000);
+                        }, timeoutMs);
+                        (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', function (data) {
+                            stdout += data.toString();
+                        });
+                        (_b = child.stderr) === null || _b === void 0 ? void 0 : _b.on('data', function (data) {
+                            stderr += data.toString();
+                        });
+                        child.on('close', function (code) {
+                            clearTimeout(timeout);
+                            if (timedOut) {
+                                reject(new Error("Execution timed out after " + timeoutMs + "ms"));
+                                return;
+                            }
+                            if (code !== 0) {
+                                reject(new Error(stderr || "Process exited with code " + code));
+                                return;
+                            }
+                            resolve(stdout);
+                        });
+                        child.on('error', function (error) {
+                            clearTimeout(timeout);
+                            reject(error);
+                        });
+                    })];
             });
         });
-    }
+    };
     /**
      * Build worker command for container execution
      */
-    buildWorkerCommand(options) {
+    ContainerWorkerPool.prototype.buildWorkerCommand = function (options) {
         // Use npx to run claude-flow daemon trigger
         return [
             'npx', 'claude-flow@v3alpha',
@@ -454,128 +664,188 @@ export class ContainerWorkerPool extends EventEmitter {
             '-w', options.workerType,
             '--headless',
         ];
-    }
+    };
     /**
      * Process queued tasks
      */
-    processQueue() {
+    ContainerWorkerPool.prototype.processQueue = function () {
         while (this.taskQueue.length > 0) {
-            const container = this.getReadyContainer();
+            var container = this.getReadyContainer();
             if (!container)
                 break;
-            const task = this.taskQueue.shift();
+            var task = this.taskQueue.shift();
             if (task) {
                 this.executeInContainer(container, task.options)
-                    .then(task.resolve)
-                    .catch(task.reject);
+                    .then(task.resolve)["catch"](task.reject);
             }
         }
-    }
+    };
     // ============================================
     // Private Methods - Health & Maintenance
     // ============================================
     /**
      * Start health check timer
      */
-    startHealthChecks() {
-        this.healthCheckTimer = setInterval(async () => {
-            await this.runHealthChecks();
-        }, this.config.healthCheckIntervalMs);
-    }
+    ContainerWorkerPool.prototype.startHealthChecks = function () {
+        var _this = this;
+        this.healthCheckTimer = setInterval(function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.runHealthChecks()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); }, this.config.healthCheckIntervalMs);
+        this.healthCheckTimer.unref();
+    };
     /**
      * Run health checks on all containers
      */
-    async runHealthChecks() {
-        for (const [id, container] of this.containers) {
-            if (container.state === 'terminated')
-                continue;
-            try {
-                // Check if container is running (async)
-                const { stdout } = await execAsync(`docker inspect -f '{{.State.Running}}' ${container.name}`, { timeout: 10000 });
-                const output = stdout.trim();
-                if (output !== 'true') {
-                    container.healthCheckFailures++;
-                    if (container.healthCheckFailures >= 3) {
+    ContainerWorkerPool.prototype.runHealthChecks = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var _i, _a, _b, id, container, stdout, output, _c;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _i = 0, _a = this.containers;
+                        _d.label = 1;
+                    case 1:
+                        if (!(_i < _a.length)) return [3 /*break*/, 11];
+                        _b = _a[_i], id = _b[0], container = _b[1];
+                        if (container.state === 'terminated')
+                            return [3 /*break*/, 10];
+                        _d.label = 2;
+                    case 2:
+                        _d.trys.push([2, 9, , 10]);
+                        return [4 /*yield*/, execAsync("docker inspect -f '{{.State.Running}}' " + container.name, { timeout: 10000 })];
+                    case 3:
+                        stdout = (_d.sent()).stdout;
+                        output = stdout.trim();
+                        if (!(output !== 'true')) return [3 /*break*/, 7];
+                        container.healthCheckFailures++;
+                        if (!(container.healthCheckFailures >= 3)) return [3 /*break*/, 6];
                         container.state = 'unhealthy';
-                        this.emit('containerUnhealthy', { id, name: container.name });
+                        this.emit('containerUnhealthy', { id: id, name: container.name });
                         // Remove and replace
-                        await this.terminateContainer(id);
-                        if (this.containers.size < this.config.minContainers) {
-                            await this.createContainer();
-                        }
-                    }
-                }
-                else {
-                    container.healthCheckFailures = 0;
+                        return [4 /*yield*/, this.terminateContainer(id)];
+                    case 4:
+                        // Remove and replace
+                        _d.sent();
+                        if (!(this.containers.size < this.config.minContainers)) return [3 /*break*/, 6];
+                        return [4 /*yield*/, this.createContainer()];
+                    case 5:
+                        _d.sent();
+                        _d.label = 6;
+                    case 6: return [3 /*break*/, 8];
+                    case 7:
+                        container.healthCheckFailures = 0;
+                        _d.label = 8;
+                    case 8: return [3 /*break*/, 10];
+                    case 9:
+                        _c = _d.sent();
+                        container.healthCheckFailures++;
+                        return [3 /*break*/, 10];
+                    case 10:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 11:
+                        this.emit('healthCheckComplete', { containers: this.containers.size });
+                        return [2 /*return*/];
                 }
-            }
-            catch {
-                container.healthCheckFailures++;
-            }
-        }
-        this.emit('healthCheckComplete', { containers: this.containers.size });
-    }
+            });
+        });
+    };
     /**
      * Start idle check timer
      */
-    startIdleChecks() {
-        this.idleCheckTimer = setInterval(async () => {
-            await this.runIdleChecks();
-        }, 60000); // Check every minute
-    }
+    ContainerWorkerPool.prototype.startIdleChecks = function () {
+        var _this = this;
+        this.idleCheckTimer = setInterval(function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.runIdleChecks()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); }, 60000); // Check every minute
+        this.idleCheckTimer.unref();
+    };
     /**
      * Terminate idle containers above minimum
      */
-    async runIdleChecks() {
-        const now = Date.now();
-        const readyContainers = Array.from(this.containers.values())
-            .filter(c => c.state === 'ready')
-            .sort((a, b) => (a.lastUsedAt?.getTime() || 0) - (b.lastUsedAt?.getTime() || 0));
-        // Keep minimum containers
-        const toTerminate = readyContainers.slice(this.config.minContainers);
-        for (const container of toTerminate) {
-            const lastUsed = container.lastUsedAt?.getTime() || container.createdAt.getTime();
-            if (now - lastUsed > this.config.idleTimeoutMs) {
-                await this.terminateContainer(container.id);
-                this.emit('containerIdleTerminated', { id: container.id, name: container.name });
-            }
-        }
-    }
+    ContainerWorkerPool.prototype.runIdleChecks = function () {
+        var _a;
+        return __awaiter(this, void 0, Promise, function () {
+            var now, readyContainers, toTerminate, _i, toTerminate_1, container, lastUsed;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        now = Date.now();
+                        readyContainers = Array.from(this.containers.values())
+                            .filter(function (c) { return c.state === 'ready'; })
+                            .sort(function (a, b) { var _a, _b; return (((_a = a.lastUsedAt) === null || _a === void 0 ? void 0 : _a.getTime()) || 0) - (((_b = b.lastUsedAt) === null || _b === void 0 ? void 0 : _b.getTime()) || 0); });
+                        toTerminate = readyContainers.slice(this.config.minContainers);
+                        _i = 0, toTerminate_1 = toTerminate;
+                        _b.label = 1;
+                    case 1:
+                        if (!(_i < toTerminate_1.length)) return [3 /*break*/, 4];
+                        container = toTerminate_1[_i];
+                        lastUsed = ((_a = container.lastUsedAt) === null || _a === void 0 ? void 0 : _a.getTime()) || container.createdAt.getTime();
+                        if (!(now - lastUsed > this.config.idleTimeoutMs)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.terminateContainer(container.id)];
+                    case 2:
+                        _b.sent();
+                        this.emit('containerIdleTerminated', { id: container.id, name: container.name });
+                        _b.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
     // ============================================
     // Private Methods - Utilities
     // ============================================
     /**
      * Try to parse JSON from output
      */
-    tryParseJson(output) {
+    ContainerWorkerPool.prototype.tryParseJson = function (output) {
         try {
-            const jsonMatch = output.match(/\{[\s\S]*\}/);
+            var jsonMatch = output.match(/\{[\s\S]*\}/);
             if (jsonMatch) {
                 return JSON.parse(jsonMatch[0]);
             }
             return JSON.parse(output.trim());
         }
-        catch {
+        catch (_a) {
             return undefined;
         }
-    }
+    };
     /**
      * Create an error result
      */
-    createErrorResult(workerType, error) {
+    ContainerWorkerPool.prototype.createErrorResult = function (workerType, error) {
         return {
             success: false,
             output: '',
             durationMs: 0,
             model: 'unknown',
             sandboxMode: this.config.defaultSandbox,
-            workerType,
+            workerType: workerType,
             timestamp: new Date(),
-            executionId: `error_${Date.now()}`,
-            error,
+            executionId: "error_" + Date.now(),
+            error: error
         };
-    }
-}
+    };
+    return ContainerWorkerPool;
+}(EventEmitter));
+export { ContainerWorkerPool };
 // Export default
 export default ContainerWorkerPool;
 //# sourceMappingURL=container-worker-pool.js.map