@redwoodjs/agent-ci 0.3.0 → 0.3.1

package/dist/cli.js

@@ -19,7 +19,7 @@ import { RunStateStore } from "./output/run-state.js";
 import { renderRunState } from "./output/state-renderer.js";
 import { isAgentMode, setQuietMode } from "./output/agent-mode.js";
 import logUpdate from "log-update";
-// ─── Signal helpers for retry / abort commands ────────────────────────────────
+import { createFailedJobResult, wrapJobError, isJobError } from "./runner/job-result.js";
 function findSignalsDir(runnerName) {
     const workDir = getWorkingDirectory();
     const runsDir = path.resolve(workDir, "runs");
@@ -341,6 +341,9 @@ async function runWorkflows(options) {
                     if (s.status === "fulfilled") {
                         allResults.push(...s.value);
                     }
+                    else {
+                        console.error(`\n[Agent CI] Workflow failed: ${s.reason?.message || String(s.reason)}`);
+                    }
                 }
             }
             else {
@@ -349,6 +352,9 @@ async function runWorkflows(options) {
                     if (s.status === "fulfilled") {
                         allResults.push(...s.value);
                     }
+                    else {
+                        console.error(`\n[Agent CI] Workflow failed: ${s.reason?.message || String(s.reason)}`);
+                    }
                 }
             }
         }
@@ -616,20 +622,38 @@ async function handleWorkflow(options) {
                 debugCli("Cold cache — running first job to populate warm modules...");
                 const firstResult = await runOrSkipJob(waveJobs[0]);
                 allResults.push(firstResult);
-                const results = await Promise.allSettled(waveJobs.slice(1).map((ej) => limiter.run(() => runOrSkipJob(ej))));
+                const results = await Promise.allSettled(waveJobs.slice(1).map((ej) => limiter.run(() => runOrSkipJob(ej).catch((error) => {
+                    throw wrapJobError(ej.taskName, error);
+                }))));
                 for (const r of results) {
                     if (r.status === "fulfilled") {
                         allResults.push(r.value);
                     }
+                    else {
+                        const taskName = isJobError(r.reason) ? r.reason.taskName : "unknown";
+                        const errorMessage = isJobError(r.reason) ? r.reason.message : String(r.reason);
+                        console.error(`\n[Agent CI] Job failed with error: ${taskName}`);
+                        console.error(`  Error: ${errorMessage}`);
+                        allResults.push(createFailedJobResult(taskName, workflowPath, r.reason));
+                    }
                 }
                 warm = true;
             }
             else {
-                const results = await Promise.allSettled(waveJobs.map((ej) => limiter.run(() => runOrSkipJob(ej))));
+                const results = await Promise.allSettled(waveJobs.map((ej) => limiter.run(() => runOrSkipJob(ej).catch((error) => {
+                    throw wrapJobError(ej.taskName, error);
+                }))));
                 for (const r of results) {
                     if (r.status === "fulfilled") {
                         allResults.push(r.value);
                     }
+                    else {
+                        const taskName = isJobError(r.reason) ? r.reason.taskName : "unknown";
+                        const errorMessage = isJobError(r.reason) ? r.reason.message : String(r.reason);
+                        console.error(`\n[Agent CI] Job failed with error: ${taskName}`);
+                        console.error(`  Error: ${errorMessage}`);
+                        allResults.push(createFailedJobResult(taskName, workflowPath, r.reason));
+                    }
                 }
             }
             // Check whether to abort remaining waves on failure

package/dist/runner/job-result.js

@@ -0,0 +1,37 @@
+import path from "path";
+export function isJobError(error) {
+    if (typeof error !== "object" || error === null) {
+        return false;
+    }
+    const err = error;
+    return typeof err.taskName === "string";
+}
+export function getErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    return String(error);
+}
+export function createFailedJobResult(taskName, workflowPath, error) {
+    const errorMessage = isJobError(error) ? error.message : getErrorMessage(error);
+    return {
+        name: `agent-ci-error-${taskName}`,
+        workflow: path.basename(workflowPath),
+        taskId: taskName,
+        succeeded: false,
+        durationMs: 0,
+        debugLogPath: "",
+        failedStep: "[Job startup failed]",
+        lastOutputLines: [errorMessage],
+    };
+}
+export function wrapJobError(taskName, error) {
+    return {
+        taskName,
+        message: getErrorMessage(error),
+        originalError: error,
+    };
+}

package/dist/runner/job-result.test.js

@@ -0,0 +1,100 @@
+import { describe, it, expect } from "vitest";
+import { createFailedJobResult, wrapJobError, isJobError, getErrorMessage, } from "./job-result.js";
+describe("getErrorMessage", () => {
+    it("extracts message from Error object", () => {
+        const result = getErrorMessage(new Error("test message"));
+        expect(result).toBe("test message");
+    });
+    it("returns string as-is", () => {
+        const result = getErrorMessage("string error");
+        expect(result).toBe("string error");
+    });
+    it("converts other types to string", () => {
+        expect(getErrorMessage(123)).toBe("123");
+        expect(getErrorMessage(null)).toBe("null");
+        expect(getErrorMessage(undefined)).toBe("undefined");
+        expect(getErrorMessage({ code: "ENOENT" })).toBe("[object Object]");
+    });
+});
+describe("isJobError", () => {
+    it("returns true for valid JobError", () => {
+        const error = {
+            taskName: "test-job",
+            message: "something failed",
+            originalError: new Error("original"),
+        };
+        expect(isJobError(error)).toBe(true);
+    });
+    it("returns false for null", () => {
+        expect(isJobError(null)).toBe(false);
+    });
+    it("returns false for undefined", () => {
+        expect(isJobError(undefined)).toBe(false);
+    });
+    it("returns false for plain Error", () => {
+        expect(isJobError(new Error("test"))).toBe(false);
+    });
+    it("returns false for object without taskName", () => {
+        expect(isJobError({ message: "test" })).toBe(false);
+    });
+});
+describe("wrapJobError", () => {
+    it("wraps Error with taskName", () => {
+        const original = new Error("original error");
+        const wrapped = wrapJobError("my-job", original);
+        expect(wrapped.taskName).toBe("my-job");
+        expect(wrapped.message).toBe("original error");
+        expect(wrapped.originalError).toBe(original);
+    });
+    it("wraps string error with taskName", () => {
+        const wrapped = wrapJobError("my-job", "string error");
+        expect(wrapped.taskName).toBe("my-job");
+        expect(wrapped.message).toBe("string error");
+    });
+});
+describe("createFailedJobResult", () => {
+    it("creates a failed result with error message from Error object", () => {
+        const result = createFailedJobResult("setup_job", "/path/to/workflow.yml", new Error("Missing required secret: API_KEY"));
+        expect(result.succeeded).toBe(false);
+        expect(result.taskId).toBe("setup_job");
+        expect(result.workflow).toBe("workflow.yml");
+        expect(result.name).toBe("agent-ci-error-setup_job");
+        expect(result.failedStep).toBe("[Job startup failed]");
+        expect(result.durationMs).toBe(0);
+        expect(result.debugLogPath).toBe("");
+        expect(result.lastOutputLines).toEqual(["Missing required secret: API_KEY"]);
+    });
+    it("extracts message from JobError", () => {
+        const jobError = {
+            taskName: "wrapped-job",
+            message: "wrapped message",
+            originalError: new Error("original"),
+        };
+        const result = createFailedJobResult("test", "workflow.yml", jobError);
+        expect(result.lastOutputLines).toEqual(["wrapped message"]);
+    });
+    it("handles string errors", () => {
+        const result = createFailedJobResult("build_job", "/home/user/project/.github/workflows/ci.yaml", "Container failed to start");
+        expect(result.succeeded).toBe(false);
+        expect(result.taskId).toBe("build_job");
+        expect(result.workflow).toBe("ci.yaml");
+        expect(result.lastOutputLines).toEqual(["Container failed to start"]);
+    });
+    it("handles errors without message property", () => {
+        const result = createFailedJobResult("test_job", "workflow.yml", {
+            code: "ENOENT",
+            path: "/missing/file",
+        });
+        expect(result.succeeded).toBe(false);
+        expect(result.lastOutputLines).toEqual(["[object Object]"]);
+    });
+    it("handles null/undefined errors", () => {
+        const result = createFailedJobResult("job1", "workflow.yml", null);
+        expect(result.succeeded).toBe(false);
+        expect(result.lastOutputLines).toEqual(["null"]);
+    });
+    it("extracts basename from full workflow path", () => {
+        const result = createFailedJobResult("deploy", "/very/long/path/to/.github/workflows/production.yml", new Error("Deploy failed"));
+        expect(result.workflow).toBe("production.yml");
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redwoodjs/agent-ci",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Local GitHub Actions runner",
   "keywords": [],
   "license": "FSL-1.1-MIT",
@@ -27,7 +27,7 @@
     "log-update": "^7.2.0",
     "minimatch": "^10.2.1",
     "yaml": "^2.8.2",
-    "dtu-github-actions": "0.3.0"
+    "dtu-github-actions": "0.3.1"
   },
   "devDependencies": {
     "@types/dockerode": "^3.3.34",
@@ -35,6 +35,9 @@
     "tsx": "^4.21.0",
     "vitest": "^4.0.18"
   },
+  "engines": {
+    "node": ">=22"
+  },
   "scripts": {
     "build": "tsgo",
     "typecheck": "tsgo",