swarm-orchestrator 7.0.0-alpha.0

package/dist/src/demo-mode.js

@@ -0,0 +1,180 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DemoMode = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Pre-configured demo scenarios for showcasing swarm orchestrator
+ */
+class DemoMode {
+    scenariosDir;
+    constructor(scenariosDir) {
+        this.scenariosDir = scenariosDir || path.join(process.cwd(), 'demos');
+    }
+    /**
+     * Get all available demo scenarios
+     */
+    getAvailableScenarios() {
+        return [
+            this.getDemoFastScenario(),
+            this.getApiQuickScenario()
+        ];
+    }
+    /**
+     * Demo Fast - "hello world" swarm
+     * Two agents, one wave, minimal work.
+     * Both steps are truly independent - no shared files.
+     */
+    getDemoFastScenario() {
+        return {
+            name: 'demo-fast',
+            description: 'Two independent utility files, one wave',
+            goal: 'Two independent micro-tasks: each agent adds one small TypeScript utility file.',
+            expectedDuration: '20-30 seconds',
+            steps: [
+                {
+                    stepNumber: 1,
+                    agentName: 'backend_master',
+                    task: 'Create a tiny TypeScript utility module at src/string-utils.ts that exports a function greet(name: string): string which returns "Hello, <name>!". Keep it boring. No new deps. Add a short top-of-file comment. Commit your work.',
+                    dependencies: [],
+                    expectedOutputs: [
+                        'src/string-utils.ts with exported greet() function'
+                    ]
+                },
+                {
+                    stepNumber: 2,
+                    agentName: 'frontend_expert',
+                    task: 'Create a tiny TypeScript utility module at src/number-utils.ts that exports a function double(n: number): number which returns n * 2. Keep it boring. No new deps. Add a short top-of-file comment. Commit your work.',
+                    dependencies: [],
+                    expectedOutputs: [
+                        'src/number-utils.ts with exported double() function'
+                    ]
+                }
+            ]
+        };
+    }
+    /**
+     * API Quick: 3-step REST API build showing wave dependencies.
+     * Step 1: Worker builds the endpoints.
+     * Step 2: Worker adds tests (depends on step 1).
+     * Step 3: Worker adds a Dockerfile (depends on step 1).
+     */
+    getApiQuickScenario() {
+        return {
+            name: 'api-quick',
+            description: 'REST API with tests and Dockerfile, dependency-chained across two waves',
+            goal: 'Build a minimal REST API with health and items CRUD, add tests, and containerize with Docker',
+            expectedDuration: '4-6 minutes',
+            steps: [
+                {
+                    stepNumber: 1,
+                    agentName: 'backend_master',
+                    task: 'Create a Node.js REST API with Express. Endpoints: GET /health returning { status: "ok" }, GET /api/items returning an in-memory array, POST /api/items accepting { name } and returning the created item with a generated id. Add input validation (reject empty name). Export the app for testing. Add a start script to package.json. Commit your work.',
+                    dependencies: [],
+                    expectedOutputs: [
+                        'server.js with /health, GET /api/items, POST /api/items',
+                        'package.json with start script',
+                        'Input validation for name field'
+                    ]
+                },
+                {
+                    stepNumber: 2,
+                    agentName: 'tester_elite',
+                    task: 'Add tests for the REST API created in step 1. Use the Node.js built-in test runner (node:test and node:assert/strict). Test: GET /health returns 200 and { status: "ok" }, GET /api/items returns empty array initially, POST /api/items with valid name returns 201, POST /api/items with empty name returns 400, GET /api/items after POST includes the new item. Import the app from server.js and start/stop it in before/after hooks. Add a test script to package.json. Commit your work.',
+                    dependencies: [1],
+                    expectedOutputs: [
+                        'test/api.test.js with 5+ test cases',
+                        'Tests use node:test and node:assert/strict',
+                        'package.json test script'
+                    ]
+                },
+                {
+                    stepNumber: 3,
+                    agentName: 'devops_pro',
+                    task: 'Add a Dockerfile for the Node.js REST API. Use node:20-alpine base image, copy package.json first for layer caching, run npm ci --omit=dev, copy source files, expose port 3000, set NODE_ENV=production, and use CMD ["node", "server.js"]. Add a .dockerignore excluding node_modules, .git, and test/. Commit your work.',
+                    dependencies: [1],
+                    expectedOutputs: [
+                        'Dockerfile with multi-layer caching',
+                        '.dockerignore'
+                    ]
+                }
+            ]
+        };
+    }
+    /**
+     * Get scenario by name
+     */
+    getScenario(name) {
+        const scenarios = this.getAvailableScenarios();
+        return scenarios.find(s => s.name === name);
+    }
+    /**
+     * Save scenario to file
+     */
+    saveScenario(scenario) {
+        if (!fs.existsSync(this.scenariosDir)) {
+            fs.mkdirSync(this.scenariosDir, { recursive: true });
+        }
+        const filePath = path.join(this.scenariosDir, `${scenario.name}.json`);
+        fs.writeFileSync(filePath, JSON.stringify(scenario, null, 2), 'utf8');
+    }
+    /**
+     * Load scenario from file
+     */
+    loadScenarioFromFile(name) {
+        const filePath = path.join(this.scenariosDir, `${name}.json`);
+        if (!fs.existsSync(filePath)) {
+            return undefined;
+        }
+        const content = fs.readFileSync(filePath, 'utf8');
+        return JSON.parse(content);
+    }
+    /**
+     * Convert scenario to ExecutionPlan
+     */
+    scenarioToPlan(scenario) {
+        return {
+            goal: scenario.goal,
+            createdAt: new Date().toISOString(),
+            steps: scenario.steps,
+            metadata: {
+                totalSteps: scenario.steps.length,
+                estimatedDuration: scenario.expectedDuration
+            }
+        };
+    }
+}
+exports.DemoMode = DemoMode;

package/dist/src/deployment-handler.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeOptionalDeployment = executeOptionalDeployment;
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("./logger");
+const deployment_manager_1 = require("./deployment-manager");
+const external_tool_manager_1 = require("./external-tool-manager");
+const logger = (0, logger_1.getLogger)('deployment');
+async function executeOptionalDeployment(workingDir, step, agent, context, options) {
+    logger.info(`  🚀 Deploying preview (--confirm-deploy)...`);
+    const toolManager = new external_tool_manager_1.ExternalToolManager({
+        enableExternal: options.enableExternal || true,
+        dryRun: options.dryRun || false,
+        logFile: path_1.default.join(context.runDir, 'deployment-commands.log')
+    });
+    const deploymentManager = new deployment_manager_1.DeploymentManager(toolManager, workingDir);
+    try {
+        const branchName = context.results.find(r => r.stepNumber === step.stepNumber)?.branchName || 'unknown';
+        // tag HEAD before deploy for rollback safety
+        let preDeployTag;
+        try {
+            preDeployTag = deploymentManager.tagPreDeploy(context.executionId);
+            logger.info(`  🏷️  Tagged: ${preDeployTag}`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.info(`  [deploy] Could not tag pre-deploy (non-fatal): ${msg}`);
+        }
+        const deployResult = await deploymentManager.deployPreview(branchName);
+        if (deployResult.success && deployResult.previewUrl) {
+            logger.info(`  ✅ Preview deployed: ${deployResult.previewUrl}`);
+            // health check the preview URL
+            const healthy = await deploymentManager.runHealthCheck(deployResult.previewUrl);
+            if (!healthy && preDeployTag) {
+                logger.warn(`  ⚠️  Health check failed, rolling back...`);
+                try {
+                    deploymentManager.rollbackToTag(preDeployTag);
+                }
+                catch (rollbackErr) {
+                    const msg = rollbackErr instanceof Error ? rollbackErr.message : String(rollbackErr);
+                    logger.warn(`  ⚠️  Rollback failed: ${msg}`);
+                }
+                return;
+            }
+            else if (healthy) {
+                logger.info(`  ✅ Health check passed`);
+            }
+            // store deployment metadata
+            const metadata = {
+                stepNumber: step.stepNumber,
+                agentName: agent.name,
+                timestamp: new Date().toISOString(),
+                platform: deployResult.platform,
+                previewUrl: deployResult.previewUrl,
+                branchName
+            };
+            deploymentManager.saveDeploymentMetadata(context.runDir, metadata);
+            // add to context deployments
+            if (!context.deployments) {
+                context.deployments = [];
+            }
+            context.deployments.push(metadata);
+        }
+        else if (deployResult.platform === 'none') {
+            logger.info(`  ℹ️  No deployment platform detected (vercel/netlify), skipping`);
+        }
+        else {
+            logger.warn(`  ⚠️  Deployment failed: ${deployResult.error}`);
+        }
+    }
+    catch (error) {
+        const err = error;
+        logger.warn(`  ⚠️  Deployment error: ${err.message}`);
+    }
+}

package/dist/src/deployment-manager.js

@@ -0,0 +1,228 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeploymentManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const logger_1 = require("./logger");
+const logger = (0, logger_1.getLogger)('deployment-manager');
+/**
+ * Deployment Manager - handles preview deployments for Vercel and Netlify
+ */
+class DeploymentManager {
+    toolManager;
+    workingDir;
+    constructor(toolManager, workingDir) {
+        this.toolManager = toolManager;
+        this.workingDir = workingDir || process.cwd();
+    }
+    /**
+     * Detect which deployment platform is configured.
+     * Config files take priority over CLI availability (project-specific > global).
+     */
+    async detectPlatform() {
+        // 1. Check config files first (project-specific, most reliable)
+        const hasVercelConfig = fs.existsSync(path.join(this.workingDir, 'vercel.json'));
+        const hasNetlifyConfig = fs.existsSync(path.join(this.workingDir, 'netlify.toml'));
+        if (hasVercelConfig)
+            return 'vercel';
+        if (hasNetlifyConfig)
+            return 'netlify';
+        // 2. Fall back to CLI availability only when no config files present
+        const tools = await this.toolManager.detectAvailableTools();
+        if (tools.vercel)
+            return 'vercel';
+        if (tools.netlify)
+            return 'netlify';
+        return 'none';
+    }
+    /**
+     * Deploy preview for a branch
+     */
+    async deployPreview(branchName) {
+        const platform = await this.detectPlatform();
+        if (platform === 'none') {
+            return {
+                success: false,
+                platform: 'none',
+                error: 'No deployment platform detected (Vercel or Netlify)'
+            };
+        }
+        if (platform === 'vercel') {
+            return this.deployVercelPreview(branchName);
+        }
+        else {
+            return this.deployNetlifyPreview(branchName);
+        }
+    }
+    /**
+     * Deploy Vercel preview
+     */
+    async deployVercelPreview(_branchName) {
+        const execution = await this.toolManager.executeCommand('vercel', ['deploy', '--yes'], {
+            workingDir: this.workingDir,
+            requireTool: 'vercel'
+        });
+        if (execution.exitCode !== 0) {
+            return {
+                success: false,
+                platform: 'vercel',
+                error: execution.error || 'Vercel deployment failed',
+                ...(execution.output && { output: execution.output })
+            };
+        }
+        // Extract preview URL from Vercel output
+        const previewUrl = this.extractVercelUrl(execution.output || '');
+        return {
+            success: true,
+            platform: 'vercel',
+            ...(previewUrl && { previewUrl }),
+            ...(execution.output && { output: execution.output })
+        };
+    }
+    /**
+     * Deploy Netlify preview
+     */
+    async deployNetlifyPreview(_branchName) {
+        const execution = await this.toolManager.executeCommand('netlify', ['deploy', '--build'], {
+            workingDir: this.workingDir,
+            requireTool: 'netlify'
+        });
+        if (execution.exitCode !== 0) {
+            return {
+                success: false,
+                platform: 'netlify',
+                error: execution.error || 'Netlify deployment failed',
+                ...(execution.output && { output: execution.output })
+            };
+        }
+        // Extract draft URL from Netlify output
+        const previewUrl = this.extractNetlifyUrl(execution.output || '');
+        return {
+            success: true,
+            platform: 'netlify',
+            ...(previewUrl && { previewUrl }),
+            ...(execution.output && { output: execution.output })
+        };
+    }
+    /**
+     * Extract Vercel preview URL from CLI output
+     */
+    extractVercelUrl(output) {
+        // Vercel outputs: "Preview: https://..."
+        const match = output.match(/(?:Preview|Inspect):\s+(https:\/\/[^\s]+)/i);
+        return match ? match[1] : undefined;
+    }
+    /**
+     * Extract Netlify preview URL from CLI output
+     */
+    extractNetlifyUrl(output) {
+        // Netlify outputs: "Draft deploy URL: https://..."
+        const match = output.match(/(?:Draft\s+deploy\s+URL|Website\s+Draft\s+URL):\s+(https:\/\/[^\s]+)/i);
+        return match ? match[1] : undefined;
+    }
+    /**
+     * Save deployment metadata to run artifacts
+     */
+    saveDeploymentMetadata(runDir, metadata) {
+        const deploymentsDir = path.join(runDir, 'deployments');
+        if (!fs.existsSync(deploymentsDir)) {
+            fs.mkdirSync(deploymentsDir, { recursive: true });
+        }
+        const metadataPath = path.join(deploymentsDir, `step-${metadata.stepNumber}-${metadata.platform}.json`);
+        fs.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2), 'utf8');
+        return metadataPath;
+    }
+    /**
+     * Load all deployment metadata from run
+     */
+    loadDeploymentMetadata(runDir) {
+        const deploymentsDir = path.join(runDir, 'deployments');
+        if (!fs.existsSync(deploymentsDir)) {
+            return [];
+        }
+        const files = fs.readdirSync(deploymentsDir);
+        const metadata = [];
+        for (const file of files) {
+            if (file.endsWith('.json')) {
+                const content = fs.readFileSync(path.join(deploymentsDir, file), 'utf8');
+                metadata.push(JSON.parse(content));
+            }
+        }
+        return metadata.sort((a, b) => a.stepNumber - b.stepNumber);
+    }
+    /**
+     * Tag HEAD before deployment so we can roll back if the health check fails.
+     */
+    tagPreDeploy(executionId) {
+        const tag = `pre-deploy/${executionId}`;
+        (0, child_process_1.execSync)(`git tag -f ${tag}`, { cwd: this.workingDir, encoding: 'utf8' });
+        return tag;
+    }
+    /**
+     * HTTP health check against a preview URL. Retries on non-200 responses.
+     */
+    async runHealthCheck(url, retries = 3, intervalMs = 20000) {
+        for (let attempt = 1; attempt <= retries; attempt++) {
+            try {
+                const response = await fetch(url, { signal: AbortSignal.timeout(10000) });
+                if (response.ok)
+                    return true;
+                logger.info(`  [health-check] Attempt ${attempt}/${retries}: HTTP ${response.status}`);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                logger.info(`  [health-check] Attempt ${attempt}/${retries}: ${msg}`);
+            }
+            if (attempt < retries) {
+                await new Promise(resolve => setTimeout(resolve, intervalMs));
+            }
+        }
+        return false;
+    }
+    /**
+     * Roll back HEAD by reverting the latest commit and recording the event.
+     */
+    rollbackToTag(tag) {
+        (0, child_process_1.execSync)('git revert --no-commit HEAD', { cwd: this.workingDir, encoding: 'utf8' });
+        (0, child_process_1.execSync)(`git commit -m "rollback: revert to ${tag} after failed health check"`, {
+            cwd: this.workingDir, encoding: 'utf8'
+        });
+        logger.info(`  [rollback] Reverted HEAD, tagged from ${tag}`);
+    }
+}
+exports.DeploymentManager = DeploymentManager;
+exports.default = DeploymentManager;

package/dist/src/execution-queue.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionQueue = void 0;
+const events_1 = require("events");
+/**
+ * execution queue with concurrency control and retry logic
+ * handles rate limits and quota exhaustion gracefully
+ */
+class ExecutionQueue extends events_1.EventEmitter {
+    queue = [];
+    running = new Map();
+    maxConcurrency;
+    retryConfig;
+    stats = {
+        completed: 0,
+        failed: 0
+    };
+    constructor(maxConcurrency = 3, retryConfig) {
+        super();
+        // High step counts generate many concurrent task-completed listeners
+        this.setMaxListeners(50);
+        this.maxConcurrency = maxConcurrency;
+        this.retryConfig = {
+            maxRetries: retryConfig?.maxRetries ?? 3,
+            baseDelay: retryConfig?.baseDelay ?? 5000,
+            maxDelay: retryConfig?.maxDelay ?? 60000,
+            rateLimitPatterns: retryConfig?.rateLimitPatterns ?? [
+                /rate limit/i,
+                /quota.*exceed/i,
+                /too many requests/i,
+                /429/,
+                /throttle/i
+            ]
+        };
+    }
+    /**
+     * add task to queue with priority
+     */
+    async enqueue(id, task, options) {
+        return new Promise((resolve, reject) => {
+            const queuedTask = {
+                id,
+                priority: options?.priority ?? 0,
+                execute: task,
+                resolve,
+                reject,
+                retries: 0,
+                maxRetries: options?.maxRetries ?? this.retryConfig.maxRetries,
+                metadata: options?.metadata || {}
+            };
+            // insert based on priority (higher priority first)
+            const insertIndex = this.queue.findIndex(t => t.priority < queuedTask.priority);
+            if (insertIndex === -1) {
+                this.queue.push(queuedTask);
+            }
+            else {
+                this.queue.splice(insertIndex, 0, queuedTask);
+            }
+            this.emit('enqueued', { id, stats: this.getStats() });
+            this.processQueue();
+        });
+    }
+    /**
+     * process queued tasks up to concurrency limit
+     */
+    async processQueue() {
+        while (this.running.size < this.maxConcurrency && this.queue.length > 0) {
+            const task = this.queue.shift();
+            if (!task)
+                break;
+            this.running.set(task.id, task);
+            this.emit('started', { id: task.id, stats: this.getStats() });
+            this.executeTask(task);
+        }
+    }
+    /**
+     * execute single task with retry on rate limits
+     */
+    async executeTask(task) {
+        try {
+            const result = await task.execute();
+            this.running.delete(task.id);
+            this.stats.completed++;
+            this.emit('completed', { id: task.id, stats: this.getStats() });
+            task.resolve(result);
+            this.processQueue();
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const isRateLimit = this.retryConfig.rateLimitPatterns.some(pattern => pattern.test(errorMessage));
+            if (isRateLimit && task.retries < task.maxRetries) {
+                // exponential backoff
+                task.retries++;
+                const delay = Math.min(this.retryConfig.baseDelay * Math.pow(2, task.retries - 1), this.retryConfig.maxDelay);
+                this.emit('retrying', {
+                    id: task.id,
+                    attempt: task.retries,
+                    maxRetries: task.maxRetries,
+                    delay,
+                    reason: 'rate_limit',
+                    stats: this.getStats()
+                });
+                this.running.delete(task.id);
+                // re-enqueue after delay
+                setTimeout(() => {
+                    this.queue.unshift(task);
+                    this.processQueue();
+                }, delay);
+            }
+            else {
+                // permanent failure
+                this.running.delete(task.id);
+                this.stats.failed++;
+                this.emit('failed', {
+                    id: task.id,
+                    error: errorMessage,
+                    retries: task.retries,
+                    stats: this.getStats()
+                });
+                task.reject(error instanceof Error ? error : new Error(errorMessage));
+                this.processQueue();
+            }
+        }
+    }
+    /**
+     * get current queue statistics
+     */
+    getStats() {
+        return {
+            running: this.running.size,
+            queued: this.queue.length,
+            completed: this.stats.completed,
+            failed: this.stats.failed,
+            maxConcurrency: this.maxConcurrency
+        };
+    }
+    /**
+     * update max concurrency dynamically
+     */
+    setMaxConcurrency(limit) {
+        if (limit < 1) {
+            throw new Error('Max concurrency must be at least 1');
+        }
+        this.maxConcurrency = limit;
+        this.emit('concurrency_changed', { maxConcurrency: limit });
+        this.processQueue();
+    }
+    /**
+     * pause queue processing
+     */
+    pause() {
+        this.maxConcurrency = 0;
+        this.emit('paused');
+    }
+    /**
+     * resume queue processing
+     */
+    resume(concurrency) {
+        this.maxConcurrency = concurrency ?? 3;
+        this.emit('resumed', { maxConcurrency: this.maxConcurrency });
+        this.processQueue();
+    }
+    /**
+     * clear all queued tasks
+     */
+    clear() {
+        const cleared = this.queue.length;
+        this.queue.forEach(task => {
+            task.reject(new Error('Queue cleared'));
+        });
+        this.queue = [];
+        this.emit('cleared', { cleared });
+    }
+    /**
+     * wait for all tasks to complete
+     */
+    async drain() {
+        return new Promise((resolve) => {
+            const checkDrained = () => {
+                if (this.running.size === 0 && this.queue.length === 0) {
+                    this.removeListener('completed', checkDrained);
+                    this.removeListener('failed', checkDrained);
+                    resolve();
+                }
+            };
+            if (this.running.size === 0 && this.queue.length === 0) {
+                resolve();
+            }
+            else {
+                this.on('completed', checkDrained);
+                this.on('failed', checkDrained);
+            }
+        });
+    }
+}
+exports.ExecutionQueue = ExecutionQueue;