kynjal-cli 4.0.0 → 4.0.1

package/dist/src/services/worker-queue.js

@@ -16,88 +16,26 @@
  * - Result caching with TTL
  * - Worker heartbeat monitoring
  */
-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 };
-    }
-};
 import { EventEmitter } from 'events';
 import { randomUUID } from 'crypto';
 // ============================================
 // Constants
 // ============================================
-var DEFAULT_CONFIG = {
+const DEFAULT_CONFIG = {
     redisUrl: 'redis://localhost:6379',
     queuePrefix: 'claude-flow:queue',
-    defaultTimeoutMs: 300000,
+    defaultTimeoutMs: 300000, // 5 minutes
     maxRetries: 3,
-    resultTtlSeconds: 86400,
-    heartbeatIntervalMs: 30000,
+    resultTtlSeconds: 86400, // 24 hours
+    heartbeatIntervalMs: 30000, // 30 seconds
     deadLetterEnabled: true,
-    visibilityTimeoutMs: 60000
+    visibilityTimeoutMs: 60000, // 1 minute
 };
-var PRIORITY_SCORES = {
+const PRIORITY_SCORES = {
     critical: 4,
     high: 3,
     normal: 2,
-    low: 1
+    low: 1,
 };
 // ============================================
 // In-Memory Redis Simulation (for non-Redis environments)
@@ -106,49 +44,47 @@ var PRIORITY_SCORES = {
  * Simple in-memory queue implementation for environments without Redis
  * Production should use actual Redis connection
  */
-var InMemoryStore = /** @class */ (function () {
-    function InMemoryStore() {
-        this.tasks = new Map();
-        this.queues = new Map();
-        this.workers = new Map();
-        this.results = new Map();
-    }
+class InMemoryStore {
+    tasks = new Map();
+    queues = new Map();
+    workers = new Map();
+    results = new Map();
+    cleanupTimer;
     /**
      * Start cleanup timer (called after initialization)
      */
-    InMemoryStore.prototype.startCleanup = function () {
-        var _this = this;
+    startCleanup() {
         if (this.cleanupTimer)
             return;
-        this.cleanupTimer = setInterval(function () { return _this.cleanupExpired(); }, 60000);
+        this.cleanupTimer = setInterval(() => this.cleanupExpired(), 60000);
         this.cleanupTimer.unref();
-    };
+    }
     /**
      * Stop cleanup timer
      */
-    InMemoryStore.prototype.stopCleanup = function () {
+    stopCleanup() {
         if (this.cleanupTimer) {
             clearInterval(this.cleanupTimer);
             this.cleanupTimer = undefined;
         }
-    };
+    }
     // Task operations
-    InMemoryStore.prototype.setTask = function (id, task) {
+    setTask(id, task) {
         this.tasks.set(id, task);
-    };
-    InMemoryStore.prototype.getTask = function (id) {
+    }
+    getTask(id) {
         return this.tasks.get(id);
-    };
-    InMemoryStore.prototype.deleteTask = function (id) {
-        this.tasks["delete"](id);
-    };
+    }
+    deleteTask(id) {
+        this.tasks.delete(id);
+    }
     // Queue operations
-    InMemoryStore.prototype.pushToQueue = function (queue, taskId, priority) {
-        var queueTasks = this.queues.get(queue) || [];
+    pushToQueue(queue, taskId, priority) {
+        const queueTasks = this.queues.get(queue) || [];
         // Insert based on priority (higher priority = earlier in queue)
-        var insertIndex = queueTasks.length;
-        for (var i = 0; i < queueTasks.length; i++) {
-            var task = this.tasks.get(queueTasks[i]);
+        let insertIndex = queueTasks.length;
+        for (let i = 0; i < queueTasks.length; i++) {
+            const task = this.tasks.get(queueTasks[i]);
             if (task && PRIORITY_SCORES[task.priority] < priority) {
                 insertIndex = i;
                 break;
@@ -156,575 +92,422 @@ var InMemoryStore = /** @class */ (function () {
         }
         queueTasks.splice(insertIndex, 0, taskId);
         this.queues.set(queue, queueTasks);
-    };
-    InMemoryStore.prototype.popFromQueue = function (queue) {
-        var queueTasks = this.queues.get(queue) || [];
+    }
+    popFromQueue(queue) {
+        const queueTasks = this.queues.get(queue) || [];
         if (queueTasks.length === 0)
             return null;
         return queueTasks.shift() || null;
-    };
-    InMemoryStore.prototype.getQueueLength = function (queue) {
+    }
+    getQueueLength(queue) {
         return (this.queues.get(queue) || []).length;
-    };
+    }
     // Worker operations
-    InMemoryStore.prototype.setWorker = function (workerId, registration) {
+    setWorker(workerId, registration) {
         this.workers.set(workerId, registration);
-    };
-    InMemoryStore.prototype.getWorker = function (workerId) {
+    }
+    getWorker(workerId) {
         return this.workers.get(workerId);
-    };
-    InMemoryStore.prototype.deleteWorker = function (workerId) {
-        this.workers["delete"](workerId);
-    };
-    InMemoryStore.prototype.getAllWorkers = function () {
+    }
+    deleteWorker(workerId) {
+        this.workers.delete(workerId);
+    }
+    getAllWorkers() {
         return Array.from(this.workers.values());
-    };
+    }
     // Result operations
-    InMemoryStore.prototype.setResult = function (taskId, result, ttlSeconds) {
+    setResult(taskId, result, ttlSeconds) {
         this.results.set(taskId, {
-            result: result,
-            expiresAt: Date.now() + ttlSeconds * 1000
+            result,
+            expiresAt: Date.now() + ttlSeconds * 1000,
         });
-    };
-    InMemoryStore.prototype.getResult = function (taskId) {
-        var entry = this.results.get(taskId);
+    }
+    getResult(taskId) {
+        const entry = this.results.get(taskId);
         if (!entry)
             return undefined;
         if (Date.now() > entry.expiresAt) {
-            this.results["delete"](taskId);
+            this.results.delete(taskId);
             return undefined;
         }
         return entry.result;
-    };
+    }
     // Stats
-    InMemoryStore.prototype.getStats = function () {
+    getStats() {
         return {
             tasks: this.tasks.size,
             workers: this.workers.size,
-            results: this.results.size
+            results: this.results.size,
         };
-    };
+    }
     // Cleanup
-    InMemoryStore.prototype.cleanupExpired = function () {
-        var now = Date.now();
-        for (var _i = 0, _a = this.results; _i < _a.length; _i++) {
-            var _b = _a[_i], id = _b[0], entry = _b[1];
+    cleanupExpired() {
+        const now = Date.now();
+        for (const [id, entry] of this.results) {
             if (now > entry.expiresAt) {
-                this.results["delete"](id);
+                this.results.delete(id);
             }
         }
-    };
-    return InMemoryStore;
-}());
+    }
+}
 // ============================================
 // WorkerQueue Class
 // ============================================
 /**
  * WorkerQueue - Redis-based task queue for distributed worker execution
  */
-var WorkerQueue = /** @class */ (function (_super) {
-    __extends(WorkerQueue, _super);
-    function WorkerQueue(config) {
-        var _this = _super.call(this) || this;
-        _this.processingTasks = new Set();
-        _this.isShuttingDown = false;
-        _this.maxConcurrent = 1;
-        _this.initialized = false;
-        _this.config = __assign(__assign({}, DEFAULT_CONFIG), config);
-        _this.store = new InMemoryStore();
-        _this.workerId = "worker-" + randomUUID().slice(0, 8);
-        return _this;
+export class WorkerQueue extends EventEmitter {
+    config;
+    store;
+    workerId;
+    heartbeatTimer;
+    processingTasks = new Set();
+    isShuttingDown = false;
+    maxConcurrent = 1;
+    initialized = false;
+    constructor(config) {
+        super();
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.store = new InMemoryStore();
+        this.workerId = `worker-${randomUUID().slice(0, 8)}`;
     }
     /**
      * Initialize the queue (starts cleanup timers)
      */
-    WorkerQueue.prototype.initialize = function () {
-        return __awaiter(this, void 0, Promise, function () {
-            return __generator(this, function (_a) {
-                if (this.initialized)
-                    return [2 /*return*/];
-                this.store.startCleanup();
-                this.initialized = true;
-                this.emit('initialized', { workerId: this.workerId });
-                return [2 /*return*/];
-            });
-        });
-    };
+    async initialize() {
+        if (this.initialized)
+            return;
+        this.store.startCleanup();
+        this.initialized = true;
+        this.emit('initialized', { workerId: this.workerId });
+    }
     // ============================================
     // Public API - Task Management
     // ============================================
     /**
      * Enqueue a new task
      */
-    WorkerQueue.prototype.enqueue = function (workerType, payload, options) {
-        var _a;
-        if (payload === void 0) { payload = {}; }
-        return __awaiter(this, void 0, Promise, function () {
-            var priority, taskId, task, queueName;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!!this.initialized) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.initialize()];
-                    case 1:
-                        _b.sent();
-                        _b.label = 2;
-                    case 2:
-                        // Validate worker type
-                        if (!workerType || typeof workerType !== 'string') {
-                            throw new Error('Invalid worker type');
-                        }
-                        priority = (options === null || options === void 0 ? void 0 : options.priority) || 'normal';
-                        if (!['critical', 'high', 'normal', 'low'].includes(priority)) {
-                            throw new Error("Invalid priority: " + priority);
-                        }
-                        taskId = "task-" + Date.now() + "-" + randomUUID().slice(0, 8);
-                        task = {
-                            id: taskId,
-                            workerType: workerType,
-                            priority: priority,
-                            payload: __assign(__assign({}, payload), { timeoutMs: (options === null || options === void 0 ? void 0 : options.timeoutMs) || this.config.defaultTimeoutMs }),
-                            status: 'pending',
-                            createdAt: new Date(),
-                            retryCount: 0,
-                            maxRetries: (_a = options === null || options === void 0 ? void 0 : options.maxRetries) !== null && _a !== void 0 ? _a : this.config.maxRetries
-                        };
-                        // Store task
-                        this.store.setTask(taskId, task);
-                        queueName = this.getQueueName(workerType);
-                        this.store.pushToQueue(queueName, taskId, PRIORITY_SCORES[priority]);
-                        this.emit('taskEnqueued', { taskId: taskId, workerType: workerType, priority: priority });
-                        return [2 /*return*/, taskId];
-                }
-            });
-        });
-    };
+    async enqueue(workerType, payload = {}, options) {
+        // Initialize if needed
+        if (!this.initialized) {
+            await this.initialize();
+        }
+        // Validate worker type
+        if (!workerType || typeof workerType !== 'string') {
+            throw new Error('Invalid worker type');
+        }
+        // Validate priority
+        const priority = options?.priority || 'normal';
+        if (!['critical', 'high', 'normal', 'low'].includes(priority)) {
+            throw new Error(`Invalid priority: ${priority}`);
+        }
+        const taskId = `task-${Date.now()}-${randomUUID().slice(0, 8)}`;
+        const task = {
+            id: taskId,
+            workerType,
+            priority,
+            payload: {
+                ...payload,
+                timeoutMs: options?.timeoutMs || this.config.defaultTimeoutMs,
+            },
+            status: 'pending',
+            createdAt: new Date(),
+            retryCount: 0,
+            maxRetries: options?.maxRetries ?? this.config.maxRetries,
+        };
+        // Store task
+        this.store.setTask(taskId, task);
+        // Add to priority queue
+        const queueName = this.getQueueName(workerType);
+        this.store.pushToQueue(queueName, taskId, PRIORITY_SCORES[priority]);
+        this.emit('taskEnqueued', { taskId, workerType, priority });
+        return taskId;
+    }
     /**
      * Dequeue a task for processing
      */
-    WorkerQueue.prototype.dequeue = function (workerTypes) {
-        return __awaiter(this, void 0, Promise, function () {
-            var _i, workerTypes_1, workerType, queueName, taskId, task;
-            return __generator(this, function (_a) {
-                if (this.isShuttingDown)
-                    return [2 /*return*/, null];
-                // Check queues in priority order
-                for (_i = 0, workerTypes_1 = workerTypes; _i < workerTypes_1.length; _i++) {
-                    workerType = workerTypes_1[_i];
-                    queueName = this.getQueueName(workerType);
-                    taskId = this.store.popFromQueue(queueName);
-                    if (taskId) {
-                        task = this.store.getTask(taskId);
-                        if (task && task.status === 'pending') {
-                            task.status = 'processing';
-                            task.startedAt = new Date();
-                            task.workerId = this.workerId;
-                            this.store.setTask(taskId, task);
-                            this.processingTasks.add(taskId);
-                            this.emit('taskDequeued', { taskId: taskId, workerType: workerType });
-                            return [2 /*return*/, task];
-                        }
-                    }
+    async dequeue(workerTypes) {
+        if (this.isShuttingDown)
+            return null;
+        // Check queues in priority order
+        for (const workerType of workerTypes) {
+            const queueName = this.getQueueName(workerType);
+            const taskId = this.store.popFromQueue(queueName);
+            if (taskId) {
+                const task = this.store.getTask(taskId);
+                if (task && task.status === 'pending') {
+                    task.status = 'processing';
+                    task.startedAt = new Date();
+                    task.workerId = this.workerId;
+                    this.store.setTask(taskId, task);
+                    this.processingTasks.add(taskId);
+                    this.emit('taskDequeued', { taskId, workerType });
+                    return task;
                 }
-                return [2 /*return*/, null];
-            });
-        });
-    };
+            }
+        }
+        return null;
+    }
     /**
      * Complete a task with result
      */
-    WorkerQueue.prototype.complete = function (taskId, result) {
-        var _a;
-        return __awaiter(this, void 0, Promise, function () {
-            var task;
-            return __generator(this, function (_b) {
-                task = this.store.getTask(taskId);
-                if (!task) {
-                    this.emit('warning', { message: "Task " + taskId + " not found for completion" });
-                    return [2 /*return*/];
-                }
-                task.status = 'completed';
-                task.completedAt = new Date();
-                task.result = result;
-                this.store.setTask(taskId, task);
-                // Store result with TTL
-                this.store.setResult(taskId, result, this.config.resultTtlSeconds);
-                this.processingTasks["delete"](taskId);
-                this.emit('taskCompleted', { taskId: taskId, result: result, duration: task.completedAt.getTime() - (((_a = task.startedAt) === null || _a === void 0 ? void 0 : _a.getTime()) || 0) });
-                return [2 /*return*/];
-            });
-        });
-    };
+    async complete(taskId, result) {
+        const task = this.store.getTask(taskId);
+        if (!task) {
+            this.emit('warning', { message: `Task ${taskId} not found for completion` });
+            return;
+        }
+        task.status = 'completed';
+        task.completedAt = new Date();
+        task.result = result;
+        this.store.setTask(taskId, task);
+        // Store result with TTL
+        this.store.setResult(taskId, result, this.config.resultTtlSeconds);
+        this.processingTasks.delete(taskId);
+        this.emit('taskCompleted', { taskId, result, duration: task.completedAt.getTime() - (task.startedAt?.getTime() || 0) });
+    }
     /**
      * Fail a task with error
      */
-    WorkerQueue.prototype.fail = function (taskId, error, retryable) {
-        if (retryable === void 0) { retryable = true; }
-        return __awaiter(this, void 0, Promise, function () {
-            var task, delay, dlqName;
-            var _this = this;
-            return __generator(this, function (_a) {
-                task = this.store.getTask(taskId);
-                if (!task) {
-                    this.emit('warning', { message: "Task " + taskId + " not found for failure" });
-                    return [2 /*return*/];
-                }
-                this.processingTasks["delete"](taskId);
-                // Check if we should retry
-                if (retryable && task.retryCount < task.maxRetries) {
-                    task.retryCount++;
-                    task.status = 'pending';
-                    task.startedAt = undefined;
-                    task.workerId = undefined;
-                    task.error = error;
-                    this.store.setTask(taskId, task);
-                    delay = Math.min(30000, 1000 * Math.pow(2, task.retryCount));
-                    setTimeout(function () {
-                        var queueName = _this.getQueueName(task.workerType);
-                        _this.store.pushToQueue(queueName, taskId, PRIORITY_SCORES[task.priority]);
-                    }, delay);
-                    this.emit('taskRetrying', { taskId: taskId, retryCount: task.retryCount, delay: delay });
-                }
-                else {
-                    // Move to failed/dead letter
-                    task.status = 'failed';
-                    task.completedAt = new Date();
-                    task.error = error;
-                    this.store.setTask(taskId, task);
-                    if (this.config.deadLetterEnabled) {
-                        dlqName = this.config.queuePrefix + ":dlq";
-                        this.store.pushToQueue(dlqName, taskId, 0);
-                    }
-                    this.emit('taskFailed', { taskId: taskId, error: error, retryCount: task.retryCount });
-                }
-                return [2 /*return*/];
-            });
-        });
-    };
+    async fail(taskId, error, retryable = true) {
+        const task = this.store.getTask(taskId);
+        if (!task) {
+            this.emit('warning', { message: `Task ${taskId} not found for failure` });
+            return;
+        }
+        this.processingTasks.delete(taskId);
+        // Check if we should retry
+        if (retryable && task.retryCount < task.maxRetries) {
+            task.retryCount++;
+            task.status = 'pending';
+            task.startedAt = undefined;
+            task.workerId = undefined;
+            task.error = error;
+            this.store.setTask(taskId, task);
+            // Re-queue with delay (exponential backoff)
+            const delay = Math.min(30000, 1000 * Math.pow(2, task.retryCount));
+            setTimeout(() => {
+                const queueName = this.getQueueName(task.workerType);
+                this.store.pushToQueue(queueName, taskId, PRIORITY_SCORES[task.priority]);
+            }, delay);
+            this.emit('taskRetrying', { taskId, retryCount: task.retryCount, delay });
+        }
+        else {
+            // Move to failed/dead letter
+            task.status = 'failed';
+            task.completedAt = new Date();
+            task.error = error;
+            this.store.setTask(taskId, task);
+            if (this.config.deadLetterEnabled) {
+                const dlqName = `${this.config.queuePrefix}:dlq`;
+                this.store.pushToQueue(dlqName, taskId, 0);
+            }
+            this.emit('taskFailed', { taskId, error, retryCount: task.retryCount });
+        }
+    }
     /**
      * Get task status
      */
-    WorkerQueue.prototype.getTask = function (taskId) {
-        return __awaiter(this, void 0, Promise, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.store.getTask(taskId) || null];
-            });
-        });
-    };
+    async getTask(taskId) {
+        return this.store.getTask(taskId) || null;
+    }
     /**
      * Get task result
      */
-    WorkerQueue.prototype.getResult = function (taskId) {
-        return __awaiter(this, void 0, Promise, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.store.getResult(taskId) || null];
-            });
-        });
-    };
+    async getResult(taskId) {
+        return this.store.getResult(taskId) || null;
+    }
     /**
      * Cancel a pending task
      */
-    WorkerQueue.prototype.cancel = function (taskId) {
-        return __awaiter(this, void 0, Promise, function () {
-            var task;
-            return __generator(this, function (_a) {
-                task = this.store.getTask(taskId);
-                if (!task || task.status !== 'pending') {
-                    return [2 /*return*/, false];
-                }
-                task.status = 'cancelled';
-                task.completedAt = new Date();
-                this.store.setTask(taskId, task);
-                this.emit('taskCancelled', { taskId: taskId });
-                return [2 /*return*/, true];
-            });
-        });
-    };
+    async cancel(taskId) {
+        const task = this.store.getTask(taskId);
+        if (!task || task.status !== 'pending') {
+            return false;
+        }
+        task.status = 'cancelled';
+        task.completedAt = new Date();
+        this.store.setTask(taskId, task);
+        this.emit('taskCancelled', { taskId });
+        return true;
+    }
     // ============================================
     // Public API - Worker Management
     // ============================================
     /**
      * Register this instance as a worker
      */
-    WorkerQueue.prototype.registerWorker = function (workerTypes, options) {
-        return __awaiter(this, void 0, Promise, function () {
-            var registration;
-            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:
-                        // Validate worker types
-                        if (!Array.isArray(workerTypes) || workerTypes.length === 0) {
-                            throw new Error('Worker types must be a non-empty array');
-                        }
-                        this.maxConcurrent = (options === null || options === void 0 ? void 0 : options.maxConcurrent) || 1;
-                        registration = {
-                            workerId: this.workerId,
-                            workerTypes: workerTypes,
-                            maxConcurrent: this.maxConcurrent,
-                            currentTasks: 0,
-                            lastHeartbeat: new Date(),
-                            registeredAt: new Date(),
-                            hostname: options === null || options === void 0 ? void 0 : options.hostname,
-                            containerId: options === null || options === void 0 ? void 0 : options.containerId
-                        };
-                        this.store.setWorker(this.workerId, registration);
-                        // Start heartbeat
-                        this.startHeartbeat();
-                        this.emit('workerRegistered', { workerId: this.workerId, workerTypes: workerTypes });
-                        return [2 /*return*/, this.workerId];
-                }
-            });
-        });
-    };
+    async registerWorker(workerTypes, options) {
+        // Initialize if needed
+        if (!this.initialized) {
+            await this.initialize();
+        }
+        // Validate worker types
+        if (!Array.isArray(workerTypes) || workerTypes.length === 0) {
+            throw new Error('Worker types must be a non-empty array');
+        }
+        this.maxConcurrent = options?.maxConcurrent || 1;
+        const registration = {
+            workerId: this.workerId,
+            workerTypes,
+            maxConcurrent: this.maxConcurrent,
+            currentTasks: 0,
+            lastHeartbeat: new Date(),
+            registeredAt: new Date(),
+            hostname: options?.hostname,
+            containerId: options?.containerId,
+        };
+        this.store.setWorker(this.workerId, registration);
+        // Start heartbeat
+        this.startHeartbeat();
+        this.emit('workerRegistered', { workerId: this.workerId, workerTypes });
+        return this.workerId;
+    }
     /**
      * Unregister this worker
      */
-    WorkerQueue.prototype.unregisterWorker = function () {
-        return __awaiter(this, void 0, Promise, function () {
-            return __generator(this, function (_a) {
-                this.stopHeartbeat();
-                this.store.deleteWorker(this.workerId);
-                this.emit('workerUnregistered', { workerId: this.workerId });
-                return [2 /*return*/];
-            });
-        });
-    };
+    async unregisterWorker() {
+        this.stopHeartbeat();
+        this.store.deleteWorker(this.workerId);
+        this.emit('workerUnregistered', { workerId: this.workerId });
+    }
     /**
      * Get all registered workers
      */
-    WorkerQueue.prototype.getWorkers = function () {
-        return __awaiter(this, void 0, Promise, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.store.getAllWorkers()];
-            });
-        });
-    };
+    async getWorkers() {
+        return this.store.getAllWorkers();
+    }
     // ============================================
     // Public API - Statistics
     // ============================================
     /**
      * Get queue statistics
      */
-    WorkerQueue.prototype.getStats = function () {
-        return __awaiter(this, void 0, Promise, function () {
-            var storeStats, stats;
-            return __generator(this, function (_a) {
-                storeStats = this.store.getStats();
-                stats = {
-                    pending: 0,
-                    processing: this.processingTasks.size,
-                    completed: 0,
-                    failed: 0,
-                    deadLetter: 0,
-                    byPriority: { critical: 0, high: 0, normal: 0, low: 0 },
-                    byWorkerType: {},
-                    averageWaitTimeMs: 0,
-                    averageProcessingTimeMs: 0
-                };
-                return [2 /*return*/, stats];
-            });
-        });
-    };
+    async getStats() {
+        const storeStats = this.store.getStats();
+        // This is a simplified implementation
+        // Full implementation would aggregate across all queues
+        const stats = {
+            pending: 0,
+            processing: this.processingTasks.size,
+            completed: 0,
+            failed: 0,
+            deadLetter: 0,
+            byPriority: { critical: 0, high: 0, normal: 0, low: 0 },
+            byWorkerType: {},
+            averageWaitTimeMs: 0,
+            averageProcessingTimeMs: 0,
+        };
+        return stats;
+    }
     // ============================================
     // Public API - Lifecycle
     // ============================================
     /**
      * Start processing tasks
      */
-    WorkerQueue.prototype.start = function (workerTypes, handler, options) {
-        return __awaiter(this, void 0, Promise, function () {
-            var processLoop;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.registerWorker(workerTypes, { maxConcurrent: options === null || options === void 0 ? void 0 : options.maxConcurrent })];
-                    case 1:
-                        _a.sent();
-                        processLoop = function () { return __awaiter(_this, void 0, void 0, function () {
-                            var _loop_1, this_1;
-                            var _this = this;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0:
-                                        _loop_1 = function () {
-                                            var task_1, error_1;
-                                            return __generator(this, function (_b) {
-                                                switch (_b.label) {
-                                                    case 0:
-                                                        _b.trys.push([0, 7, , 9]);
-                                                        if (!(this_1.processingTasks.size >= this_1.maxConcurrent)) return [3 /*break*/, 2];
-                                                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 100); })];
-                                                    case 1:
-                                                        _b.sent();
-                                                        return [2 /*return*/, "continue"];
-                                                    case 2: return [4 /*yield*/, this_1.dequeue(workerTypes)];
-                                                    case 3:
-                                                        task_1 = _b.sent();
-                                                        if (!task_1) return [3 /*break*/, 4];
-                                                        // Process task without blocking the loop (allows concurrency)
-                                                        this_1.processTask(task_1, handler)["catch"](function (error) {
-                                                            _this.emit('error', { taskId: task_1.id, error: String(error) });
-                                                        });
-                                                        return [3 /*break*/, 6];
-                                                    case 4: 
-                                                    // No task available, wait before polling again
-                                                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 1000); })];
-                                                    case 5:
-                                                        // No task available, wait before polling again
-                                                        _b.sent();
-                                                        _b.label = 6;
-                                                    case 6: return [3 /*break*/, 9];
-                                                    case 7:
-                                                        error_1 = _b.sent();
-                                                        this_1.emit('error', { error: error_1 instanceof Error ? error_1.message : String(error_1) });
-                                                        // Wait before retrying to avoid tight error loop
-                                                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 5000); })];
-                                                    case 8:
-                                                        // Wait before retrying to avoid tight error loop
-                                                        _b.sent();
-                                                        return [3 /*break*/, 9];
-                                                    case 9: return [2 /*return*/];
-                                                }
-                                            });
-                                        };
-                                        this_1 = this;
-                                        _a.label = 1;
-                                    case 1:
-                                        if (!!this.isShuttingDown) return [3 /*break*/, 3];
-                                        return [5 /*yield**/, _loop_1()];
-                                    case 2:
-                                        _a.sent();
-                                        return [3 /*break*/, 1];
-                                    case 3: return [2 /*return*/];
-                                }
-                            });
-                        }); };
-                        // Start processing
-                        processLoop()["catch"](function (error) {
-                            _this.emit('error', { error: error instanceof Error ? error.message : String(error) });
+    async start(workerTypes, handler, options) {
+        await this.registerWorker(workerTypes, { maxConcurrent: options?.maxConcurrent });
+        const processLoop = async () => {
+            while (!this.isShuttingDown) {
+                try {
+                    // Respect concurrency limit
+                    if (this.processingTasks.size >= this.maxConcurrent) {
+                        await new Promise(resolve => setTimeout(resolve, 100));
+                        continue;
+                    }
+                    const task = await this.dequeue(workerTypes);
+                    if (task) {
+                        // Process task without blocking the loop (allows concurrency)
+                        this.processTask(task, handler).catch(error => {
+                            this.emit('error', { taskId: task.id, error: String(error) });
                         });
-                        return [2 /*return*/];
+                    }
+                    else {
+                        // No task available, wait before polling again
+                        await new Promise(resolve => setTimeout(resolve, 1000));
+                    }
                 }
-            });
+                catch (error) {
+                    this.emit('error', { error: error instanceof Error ? error.message : String(error) });
+                    // Wait before retrying to avoid tight error loop
+                    await new Promise(resolve => setTimeout(resolve, 5000));
+                }
+            }
+        };
+        // Start processing
+        processLoop().catch(error => {
+            this.emit('error', { error: error instanceof Error ? error.message : String(error) });
         });
-    };
+    }
     /**
      * Process a single task
      */
-    WorkerQueue.prototype.processTask = function (task, handler) {
-        return __awaiter(this, void 0, Promise, function () {
-            var result, error_2;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 3, , 5]);
-                        return [4 /*yield*/, handler(task)];
-                    case 1:
-                        result = _a.sent();
-                        return [4 /*yield*/, this.complete(task.id, result)];
-                    case 2:
-                        _a.sent();
-                        return [3 /*break*/, 5];
-                    case 3:
-                        error_2 = _a.sent();
-                        return [4 /*yield*/, this.fail(task.id, error_2 instanceof Error ? error_2.message : String(error_2))];
-                    case 4:
-                        _a.sent();
-                        return [3 /*break*/, 5];
-                    case 5: return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async processTask(task, handler) {
+        try {
+            const result = await handler(task);
+            await this.complete(task.id, result);
+        }
+        catch (error) {
+            await this.fail(task.id, error instanceof Error ? error.message : String(error));
+        }
+    }
     /**
      * Shutdown the queue gracefully
      */
-    WorkerQueue.prototype.shutdown = function () {
-        return __awaiter(this, void 0, Promise, function () {
-            var timeout, start, _i, _a, taskId;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (this.isShuttingDown)
-                            return [2 /*return*/];
-                        this.isShuttingDown = true;
-                        timeout = 30000;
-                        start = Date.now();
-                        _b.label = 1;
-                    case 1:
-                        if (!(this.processingTasks.size > 0 && Date.now() - start < timeout)) return [3 /*break*/, 3];
-                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 1000); })];
-                    case 2:
-                        _b.sent();
-                        return [3 /*break*/, 1];
-                    case 3:
-                        _i = 0, _a = this.processingTasks;
-                        _b.label = 4;
-                    case 4:
-                        if (!(_i < _a.length)) return [3 /*break*/, 7];
-                        taskId = _a[_i];
-                        return [4 /*yield*/, this.fail(taskId, 'Worker shutdown', false)];
-                    case 5:
-                        _b.sent();
-                        _b.label = 6;
-                    case 6:
-                        _i++;
-                        return [3 /*break*/, 4];
-                    case 7:
-                        // Stop store cleanup
-                        this.store.stopCleanup();
-                        return [4 /*yield*/, this.unregisterWorker()];
-                    case 8:
-                        _b.sent();
-                        this.initialized = false;
-                        this.emit('shutdown', {});
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async shutdown() {
+        if (this.isShuttingDown)
+            return;
+        this.isShuttingDown = true;
+        // Wait for processing tasks to complete (with timeout)
+        const timeout = 30000;
+        const start = Date.now();
+        while (this.processingTasks.size > 0 && Date.now() - start < timeout) {
+            await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+        // Force fail remaining tasks
+        for (const taskId of this.processingTasks) {
+            await this.fail(taskId, 'Worker shutdown', false);
+        }
+        // Stop store cleanup
+        this.store.stopCleanup();
+        await this.unregisterWorker();
+        this.initialized = false;
+        this.emit('shutdown', {});
+    }
     // ============================================
     // Private Methods
     // ============================================
     /**
      * Get queue name for worker type
      */
-    WorkerQueue.prototype.getQueueName = function (workerType) {
-        return this.config.queuePrefix + ":" + workerType;
-    };
+    getQueueName(workerType) {
+        return `${this.config.queuePrefix}:${workerType}`;
+    }
     /**
      * Start heartbeat timer
      */
-    WorkerQueue.prototype.startHeartbeat = function () {
-        var _this = this;
-        this.heartbeatTimer = setInterval(function () {
-            var registration = _this.store.getWorker(_this.workerId);
+    startHeartbeat() {
+        this.heartbeatTimer = setInterval(() => {
+            const registration = this.store.getWorker(this.workerId);
             if (registration) {
                 registration.lastHeartbeat = new Date();
-                registration.currentTasks = _this.processingTasks.size;
-                _this.store.setWorker(_this.workerId, registration);
+                registration.currentTasks = this.processingTasks.size;
+                this.store.setWorker(this.workerId, registration);
             }
         }, this.config.heartbeatIntervalMs);
         this.heartbeatTimer.unref();
-    };
+    }
     /**
      * Stop heartbeat timer
      */
-    WorkerQueue.prototype.stopHeartbeat = function () {
+    stopHeartbeat() {
         if (this.heartbeatTimer) {
             clearInterval(this.heartbeatTimer);
             this.heartbeatTimer = undefined;
         }
-    };
-    return WorkerQueue;
-}(EventEmitter));
-export { WorkerQueue };
+    }
+}
 // Export default
 export default WorkerQueue;
 //# sourceMappingURL=worker-queue.js.map