builderman 1.4.0 → 1.5.1

package/dist/{modules → internal}/task-executor.js

@@ -1,56 +1,45 @@
 import * as path from "node:path";
 import * as fs from "node:fs";
-import { $TASK_INTERNAL } from "../constants.js";
-import { createTaskGraph } from "../graph.js";
-import { PipelineError } from "../pipeline-error.js";
+import { $TASK_INTERNAL, $PIPELINE_INTERNAL } from "./constants.js";
+import { PipelineError } from "../errors.js";
 /**
  * Executes a task (either a regular task or a nested pipeline).
  */
-export function executeTask(task, executorConfig) {
+export function executeTask(task, context, callbacks) {
     // Check if signal is aborted before starting new tasks
-    if (executorConfig.signal?.aborted) {
-        executorConfig.failPipeline(new PipelineError("Aborted", PipelineError.InvalidSignal));
+    if (context.signal?.aborted) {
+        callbacks.onTaskFailed(task[$TASK_INTERNAL].id, new PipelineError("Aborted", PipelineError.Aborted));
         return;
     }
-    const { name: taskName, [$TASK_INTERNAL]: { id: taskId, pipeline: nestedPipeline }, } = task;
-    if (executorConfig.runningTasks.has(taskId))
-        return;
+    const { name: taskName, [$TASK_INTERNAL]: { id, pipeline }, } = task;
     // Handle pipeline tasks
-    if (nestedPipeline) {
-        executeNestedPipeline(task, taskId, taskName, nestedPipeline, executorConfig);
+    if (pipeline) {
+        executeNestedPipeline(task, id, taskName, pipeline, context, callbacks);
         return;
     }
     // Regular task execution
-    executeRegularTask(task, taskId, taskName, executorConfig);
+    executeRegularTask(task, id, taskName, context, callbacks);
 }
-function executeNestedPipeline(task, taskId, taskName, nestedPipeline, executorConfig) {
-    const { config, runningPipelines, pipelineTasksCache, failPipeline, advanceScheduler, updateTaskStatus, } = executorConfig;
+function executeNestedPipeline(task, taskId, taskName, nestedPipeline, context, callbacks) {
+    const { config } = context;
     // Track nested pipeline state for skip behavior
     let nestedSkippedCount = 0;
     let nestedCompletedCount = 0;
     // Get total tasks from nested pipeline
-    const nestedTasks = pipelineTasksCache.get(nestedPipeline);
-    const nestedTotalTasks = nestedTasks
-        ? createTaskGraph(nestedTasks).nodes.size
-        : 0;
-    const commandName = config?.command ?? process.env.NODE_ENV === "production" ? "build" : "dev";
-    // Mark as ready immediately (pipeline entry nodes will handle their own ready state)
+    const nestedTotalTasks = nestedPipeline[$PIPELINE_INTERNAL].graph.nodes.size;
+    const commandName = config?.command ?? (process.env.NODE_ENV === "production" ? "build" : "dev");
+    // Mark as running - nested pipeline tasks handle their own ready state
+    // We don't call onTaskReady here because dependent tasks should wait for
+    // the nested pipeline to complete, not just start
     const startedAt = Date.now();
-    updateTaskStatus(taskId, {
+    context.updateTaskStatus(taskId, {
         status: "running",
         command: commandName,
         startedAt,
     });
-    advanceScheduler({ type: "ready", taskId });
     config?.onTaskBegin?.(taskName);
     // Create an abort controller to stop the nested pipeline if needed
     let pipelineStopped = false;
-    const stopPipeline = () => {
-        pipelineStopped = true;
-        // The nested pipeline will continue running, but we've marked it as stopped
-        // In a more sophisticated implementation, we could propagate stop signals
-    };
-    runningPipelines.set(taskId, { stop: stopPipeline });
     // Merge environment variables: pipeline.env -> task.env (from pipeline.toTask config)
     const taskEnv = task[$TASK_INTERNAL].env;
     const pipelineEnv = config?.env ?? {};
@@ -59,12 +48,14 @@ function executeNestedPipeline(task, taskId, taskName, nestedPipeline, executorC
         ...taskEnv,
     };
     // Run the nested pipeline with signal propagation
+    // Pass the command from parent pipeline to nested pipeline
+    // If undefined, nested pipeline will use its own default (build/dev based on NODE_ENV)
     nestedPipeline
         .run({
-        spawn: executorConfig.spawn,
-        command: config?.command,
+        spawn: context.spawn,
+        command: config?.command, // Pass command to nested pipeline
         strict: config?.strict,
-        signal: executorConfig.signal, // Pass signal to nested pipeline
+        signal: context.signal, // Pass signal to nested pipeline
         env: mergedEnv, // Pass merged env to nested pipeline
         onTaskBegin: (nestedTaskName) => {
             if (pipelineStopped)
@@ -87,17 +78,16 @@ function executeNestedPipeline(task, taskId, taskName, nestedPipeline, executorC
         .then((result) => {
         if (pipelineStopped)
             return;
-        runningPipelines.delete(taskId);
         if (!result.ok) {
             // Nested pipeline failed
             const finishedAt = Date.now();
-            updateTaskStatus(taskId, {
+            context.updateTaskStatus(taskId, {
                 status: "failed",
                 finishedAt,
                 durationMs: finishedAt - startedAt,
                 error: result.error,
             });
-            failPipeline(result.error);
+            callbacks.onTaskFailed(taskId, result.error);
             return;
         }
         // Determine nested pipeline result based on skip behavior:
@@ -107,33 +97,34 @@ function executeNestedPipeline(task, taskId, taskName, nestedPipeline, executorC
         if (nestedSkippedCount === nestedTotalTasks && nestedTotalTasks > 0) {
             // All tasks were skipped
             const finishedAt = Date.now();
-            updateTaskStatus(taskId, {
+            context.updateTaskStatus(taskId, {
                 status: "skipped",
                 finishedAt,
                 durationMs: finishedAt - startedAt,
             });
             config?.onTaskSkipped?.(taskName, commandName);
             setImmediate(() => {
-                advanceScheduler({ type: "skip", taskId });
+                callbacks.onTaskSkipped(taskId);
             });
         }
         else {
             // Some tasks ran (and completed successfully)
             const finishedAt = Date.now();
-            updateTaskStatus(taskId, {
+            context.updateTaskStatus(taskId, {
                 status: "completed",
                 finishedAt,
                 durationMs: finishedAt - startedAt,
             });
             config?.onTaskComplete?.(taskName);
-            advanceScheduler({ type: "complete", taskId });
+            // Mark as complete - this will update dependent tasks and allow them to start
+            callbacks.onTaskComplete(taskId);
         }
     });
 }
-function executeRegularTask(task, taskId, taskName, executorConfig) {
-    const { spawn: spawnFn, signal, config, runningTasks, teardownManager, failPipeline, advanceScheduler, updateTaskStatus, } = executorConfig;
+function executeRegularTask(task, taskId, taskName, context, callbacks) {
+    const { config, spawn: spawnFn, signal, teardownManager, timeoutManager, } = context;
     const { allowSkip, commands, cwd, env: taskEnv } = task[$TASK_INTERNAL];
-    const commandName = config?.command ?? process.env.NODE_ENV === "production" ? "build" : "dev";
+    const commandName = config?.command ?? (process.env.NODE_ENV === "production" ? "build" : "dev");
     const commandConfig = commands[commandName];
     // Check if command exists
     if (commandConfig === undefined) {
@@ -142,18 +133,18 @@ function executeRegularTask(task, taskId, taskName, executorConfig) {
         if (strict && !allowSkip) {
             const error = new PipelineError(`[${taskName}] No command for "${commandName}" and strict mode is enabled`, PipelineError.TaskFailed, taskName);
             const finishedAt = Date.now();
-            updateTaskStatus(taskId, {
+            context.updateTaskStatus(taskId, {
                 status: "failed",
                 command: commandName,
                 finishedAt,
                 error,
             });
-            failPipeline(error);
+            callbacks.onTaskFailed(taskId, error);
             return;
         }
         // Skip the task
         const finishedAt = Date.now();
-        updateTaskStatus(taskId, {
+        context.updateTaskStatus(taskId, {
             status: "skipped",
             command: commandName,
             finishedAt,
@@ -163,13 +154,14 @@ function executeRegularTask(task, taskId, taskName, executorConfig) {
         // Mark as skipped - this satisfies dependencies and unblocks dependents
         // Use setImmediate to ensure scheduler is at idle yield before receiving skip
         setImmediate(() => {
-            advanceScheduler({ type: "skip", taskId });
+            callbacks.onTaskSkipped(taskId);
         });
         return;
     }
     let command;
     let readyWhen;
     let readyTimeout = Infinity;
+    let completedTimeout = Infinity;
     let teardown;
     let commandEnv = {};
     if (typeof commandConfig === "string") {
@@ -179,6 +171,7 @@ function executeRegularTask(task, taskId, taskName, executorConfig) {
         command = commandConfig.run;
         readyWhen = commandConfig.readyWhen;
         readyTimeout = commandConfig.readyTimeout ?? Infinity;
+        completedTimeout = commandConfig.completedTimeout ?? Infinity;
         teardown = commandConfig.teardown;
         commandEnv = commandConfig.env ?? {};
     }
@@ -186,14 +179,14 @@ function executeRegularTask(task, taskId, taskName, executorConfig) {
     if (!fs.existsSync(taskCwd)) {
         const finishedAt = Date.now();
         const pipelineError = new PipelineError(`[${taskName}] Working directory does not exist: ${taskCwd}`, PipelineError.InvalidTask, taskName);
-        updateTaskStatus(taskId, {
+        context.updateTaskStatus(taskId, {
             status: "failed",
             command: commandName,
             finishedAt,
             durationMs: 0,
             error: pipelineError,
         });
-        failPipeline(pipelineError);
+        callbacks.onTaskFailed(taskId, pipelineError);
         return;
     }
     const accumulatedPath = [
@@ -218,9 +211,13 @@ function executeRegularTask(task, taskId, taskName, executorConfig) {
         shell: true,
         env: accumulatedEnv,
     });
-    runningTasks.set(taskId, child);
+    // Update the running task execution with the process
+    const runningTasks = context.queueManager.getRunningTasks();
+    const execution = runningTasks.get(taskId);
+    execution.process = child;
+    context.queueManager.markTaskRunning(taskId, execution);
     const startedAt = Date.now();
-    updateTaskStatus(taskId, {
+    context.updateTaskStatus(taskId, {
         status: "running",
         command: commandName,
         startedAt,
@@ -235,26 +232,53 @@ function executeRegularTask(task, taskId, taskName, executorConfig) {
     }
     config?.onTaskBegin?.(taskName);
     let didMarkReady = false;
-    let readyTimeoutId = null;
-    if (!readyWhen) {
-        advanceScheduler({ type: "ready", taskId });
-        didMarkReady = true;
-    }
-    else if (readyTimeout !== Infinity) {
-        // Set up timeout for readyWhen condition
-        readyTimeoutId = setTimeout(() => {
+    // For tasks without readyWhen, we wait for the process to exit successfully
+    // before allowing dependent tasks to start. This ensures dependencies are
+    // fully completed before dependents begin execution.
+    if (readyWhen && readyTimeout !== Infinity) {
+        // Set up timeout for readyWhen condition using TimeoutManager
+        timeoutManager.setReadyTimeout(taskId, readyTimeout, () => {
             if (!didMarkReady) {
                 const finishedAt = Date.now();
-                const pipelineError = new PipelineError(`[${taskName}] Task did not become ready within ${readyTimeout}ms`, PipelineError.TaskFailed, taskName);
-                updateTaskStatus(taskId, {
+                const pipelineError = new PipelineError(`[${taskName}] Task did not become ready within ${readyTimeout}ms`, PipelineError.TaskReadyTimeout, taskName);
+                // Clear completion timeout if it exists
+                timeoutManager.clearCompletionTimeout(taskId);
+                // Kill the process since it didn't become ready in time
+                try {
+                    child.kill("SIGTERM");
+                }
+                catch { }
+                context.updateTaskStatus(taskId, {
                     status: "failed",
                     finishedAt,
                     durationMs: finishedAt - startedAt,
                     error: pipelineError,
                 });
-                failPipeline(pipelineError);
+                callbacks.onTaskFailed(taskId, pipelineError);
+            }
+        });
+    }
+    // Set up timeout for task completion using TimeoutManager
+    if (completedTimeout !== Infinity) {
+        timeoutManager.setCompletionTimeout(taskId, completedTimeout, () => {
+            // Task didn't complete within the timeout
+            const finishedAt = Date.now();
+            const pipelineError = new PipelineError(`[${taskName}] Task did not complete within ${completedTimeout}ms`, PipelineError.TaskCompletedTimeout, taskName);
+            // Clear ready timeout if it exists (to prevent it from firing after we've already failed)
+            timeoutManager.clearReadyTimeout(taskId);
+            // Kill the process since it didn't complete in time
+            try {
+                child.kill("SIGTERM");
             }
-        }, readyTimeout);
+            catch { }
+            context.updateTaskStatus(taskId, {
+                status: "failed",
+                finishedAt,
+                durationMs: finishedAt - startedAt,
+                error: pipelineError,
+            });
+            callbacks.onTaskFailed(taskId, pipelineError);
+        });
     }
     let output = "";
     child.stdout?.on("data", (buf) => {
@@ -266,11 +290,8 @@ function executeRegularTask(task, taskId, taskName, executorConfig) {
         output += chunk;
         process.stdout.write(chunk);
         if (!didMarkReady && readyWhen && readyWhen(output)) {
-            if (readyTimeoutId) {
-                clearTimeout(readyTimeoutId);
-                readyTimeoutId = null;
-            }
-            advanceScheduler({ type: "ready", taskId });
+            timeoutManager.clearReadyTimeout(taskId);
+            callbacks.onTaskReady(taskId);
             didMarkReady = true;
         }
     });
@@ -281,27 +302,28 @@ function executeRegularTask(task, taskId, taskName, executorConfig) {
         // Task failed before entering running state, so don't execute teardown
         // Remove teardown from map since it was never actually running
         teardownManager.unregister(taskId);
-        // Clear ready timeout if it exists
-        if (readyTimeoutId) {
-            clearTimeout(readyTimeoutId);
-            readyTimeoutId = null;
-        }
+        // Clear all timeouts for this task
+        timeoutManager.clearTaskTimeouts(taskId);
         const finishedAt = Date.now();
         const pipelineError = new PipelineError(`[${taskName}] Failed to start: ${error.message}`, PipelineError.TaskFailed, taskName);
-        updateTaskStatus(taskId, {
+        context.updateTaskStatus(taskId, {
             status: "failed",
             finishedAt,
             durationMs: finishedAt - startedAt,
             error: pipelineError,
         });
-        failPipeline(pipelineError);
+        callbacks.onTaskFailed(taskId, pipelineError);
     });
     child.on("exit", (code, signal) => {
-        runningTasks.delete(taskId);
-        // Clear ready timeout if it exists
-        if (readyTimeoutId) {
-            clearTimeout(readyTimeoutId);
-            readyTimeoutId = null;
+        // Clear all timeouts for this task
+        timeoutManager.clearTaskTimeouts(taskId);
+        // Check if task was already marked as failed (e.g., by timeout handlers)
+        // If so, don't process the exit event to avoid conflicts
+        const currentStats = context.taskStats.get(taskId);
+        if (currentStats?.status === "failed" && currentStats?.error) {
+            // Task was already failed, likely by a timeout handler
+            // Just return to avoid duplicate error handling
+            return;
         }
         const finishedAt = Date.now();
         const durationMs = finishedAt - startedAt;
@@ -309,7 +331,7 @@ function executeRegularTask(task, taskId, taskName, executorConfig) {
         // when the pipeline completes or fails
         if (code !== 0 || signal) {
             const pipelineError = new PipelineError(`[${taskName}] Task failed with non-zero exit code: ${code ?? signal}`, PipelineError.TaskFailed, taskName);
-            updateTaskStatus(taskId, {
+            context.updateTaskStatus(taskId, {
                 status: "failed",
                 finishedAt,
                 durationMs,
@@ -317,10 +339,10 @@ function executeRegularTask(task, taskId, taskName, executorConfig) {
                 signal: signal ?? undefined,
                 error: pipelineError,
             });
-            failPipeline(pipelineError);
+            callbacks.onTaskFailed(taskId, pipelineError);
             return;
         }
-        updateTaskStatus(taskId, {
+        context.updateTaskStatus(taskId, {
             status: "completed",
             finishedAt,
             durationMs,
@@ -328,6 +350,6 @@ function executeRegularTask(task, taskId, taskName, executorConfig) {
         });
         config?.onTaskComplete?.(taskName);
         // 🔑 Notify scheduler and drain newly runnable tasks
-        advanceScheduler({ type: "complete", taskId });
+        callbacks.onTaskComplete(taskId);
     });
 }

package/dist/internal/timeout-manager.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Centralized timeout management for task execution
+ * Handles readyWhen and completion timeouts with proper cleanup
+ */
+export interface TimeoutManager {
+    /**
+     * Set a timeout for a task's readyWhen condition
+     */
+    setReadyTimeout(taskId: string, timeout: number, callback: () => void): void;
+    /**
+     * Set a timeout for a task's completion
+     */
+    setCompletionTimeout(taskId: string, timeout: number, callback: () => void): void;
+    /**
+     * Clear the ready timeout for a specific task
+     */
+    clearReadyTimeout(taskId: string): void;
+    /**
+     * Clear the completion timeout for a specific task
+     */
+    clearCompletionTimeout(taskId: string): void;
+    /**
+     * Clear all timeouts for a specific task
+     */
+    clearTaskTimeouts(taskId: string): void;
+    /**
+     * Clear all timeouts (used during cancellation)
+     */
+    clearAllTimeouts(): void;
+}
+/**
+ * Creates a timeout manager for task execution
+ */
+export declare function createTimeoutManager(): TimeoutManager;

package/dist/internal/timeout-manager.js

@@ -0,0 +1,85 @@
+/**
+ * Creates a timeout manager for task execution
+ */
+export function createTimeoutManager() {
+    const readyTimeouts = new Map();
+    const completionTimeouts = new Map();
+    return {
+        /**
+         * Set a timeout for a task's readyWhen condition
+         */
+        setReadyTimeout(taskId, timeout, callback) {
+            // Clear any existing ready timeout for this task
+            const timeoutId = readyTimeouts.get(taskId);
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+                readyTimeouts.delete(taskId);
+            }
+            const newTimeoutId = setTimeout(callback, timeout);
+            readyTimeouts.set(taskId, newTimeoutId);
+        },
+        /**
+         * Set a timeout for a task's completion
+         */
+        setCompletionTimeout(taskId, timeout, callback) {
+            // Clear any existing completion timeout for this task
+            const timeoutId = completionTimeouts.get(taskId);
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+                completionTimeouts.delete(taskId);
+            }
+            const newTimeoutId = setTimeout(callback, timeout);
+            completionTimeouts.set(taskId, newTimeoutId);
+        },
+        /**
+         * Clear the ready timeout for a specific task
+         */
+        clearReadyTimeout(taskId) {
+            const timeoutId = readyTimeouts.get(taskId);
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+                readyTimeouts.delete(taskId);
+            }
+        },
+        /**
+         * Clear the completion timeout for a specific task
+         */
+        clearCompletionTimeout(taskId) {
+            const timeoutId = completionTimeouts.get(taskId);
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+                completionTimeouts.delete(taskId);
+            }
+        },
+        /**
+         * Clear all timeouts for a specific task
+         */
+        clearTaskTimeouts(taskId) {
+            const readyTimeoutId = readyTimeouts.get(taskId);
+            if (readyTimeoutId) {
+                clearTimeout(readyTimeoutId);
+                readyTimeouts.delete(taskId);
+            }
+            const completionTimeoutId = completionTimeouts.get(taskId);
+            if (completionTimeoutId) {
+                clearTimeout(completionTimeoutId);
+                completionTimeouts.delete(taskId);
+            }
+        },
+        /**
+         * Clear all timeouts (used during cancellation)
+         */
+        clearAllTimeouts() {
+            // Clear all ready timeouts
+            for (const timeoutId of readyTimeouts.values()) {
+                clearTimeout(timeoutId);
+            }
+            readyTimeouts.clear();
+            // Clear all completion timeouts
+            for (const timeoutId of completionTimeouts.values()) {
+                clearTimeout(timeoutId);
+            }
+            completionTimeouts.clear();
+        },
+    };
+}

package/dist/{util.d.ts → internal/util.d.ts}

@@ -1,2 +1,2 @@
-import type { Task } from "./types.js";
+import type { Task } from "../types.js";
 export declare function validateTasks(tasks?: Task[]): void;