@redwoodjs/agent-ci 0.1.0 → 0.3.1

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

@@ -175,3 +175,141 @@ describe("buildJobResult", () => {
         expect(result.lastOutputLines).toContain("compile error");
     });
 });
+// ── extractStepOutputs ────────────────────────────────────────────────────────
+describe("extractStepOutputs", () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "step-outputs-test-"));
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it("extracts simple key=value outputs from set_output files", async () => {
+        const { extractStepOutputs } = await import("./result-builder.js");
+        // Simulate the runner's file_commands directory structure
+        const fileCommandsDir = path.join(tmpDir, "_runner_file_commands");
+        fs.mkdirSync(fileCommandsDir, { recursive: true });
+        fs.writeFileSync(path.join(fileCommandsDir, "set_output_abc123"), "skip=false\nshard_count=3\n");
+        const outputs = extractStepOutputs(tmpDir);
+        expect(outputs).toEqual({
+            skip: "false",
+            shard_count: "3",
+        });
+    });
+    it("extracts multiline (heredoc) values", async () => {
+        const { extractStepOutputs } = await import("./result-builder.js");
+        const fileCommandsDir = path.join(tmpDir, "_runner_file_commands");
+        fs.mkdirSync(fileCommandsDir, { recursive: true });
+        fs.writeFileSync(path.join(fileCommandsDir, "set_output_def456"), 'matrix<<EOF\n["1","2","3"]\nEOF\n');
+        const outputs = extractStepOutputs(tmpDir);
+        expect(outputs).toEqual({
+            matrix: '["1","2","3"]',
+        });
+    });
+    it("merges outputs from multiple set_output files", async () => {
+        const { extractStepOutputs } = await import("./result-builder.js");
+        const fileCommandsDir = path.join(tmpDir, "_runner_file_commands");
+        fs.mkdirSync(fileCommandsDir, { recursive: true });
+        fs.writeFileSync(path.join(fileCommandsDir, "set_output_aaa"), "key1=val1\n");
+        fs.writeFileSync(path.join(fileCommandsDir, "set_output_bbb"), "key2=val2\n");
+        const outputs = extractStepOutputs(tmpDir);
+        expect(outputs.key1).toBe("val1");
+        expect(outputs.key2).toBe("val2");
+    });
+    it("returns empty object when no _runner_file_commands directory exists", async () => {
+        const { extractStepOutputs } = await import("./result-builder.js");
+        const outputs = extractStepOutputs(tmpDir);
+        expect(outputs).toEqual({});
+    });
+    it("returns empty object when directory has no set_output files", async () => {
+        const { extractStepOutputs } = await import("./result-builder.js");
+        const fileCommandsDir = path.join(tmpDir, "_runner_file_commands");
+        fs.mkdirSync(fileCommandsDir, { recursive: true });
+        fs.writeFileSync(path.join(fileCommandsDir, "add_path_xyz"), "/usr/local/bin\n");
+        const outputs = extractStepOutputs(tmpDir);
+        expect(outputs).toEqual({});
+    });
+    it("later files override earlier ones for the same key", async () => {
+        const { extractStepOutputs } = await import("./result-builder.js");
+        const fileCommandsDir = path.join(tmpDir, "_runner_file_commands");
+        fs.mkdirSync(fileCommandsDir, { recursive: true });
+        fs.writeFileSync(path.join(fileCommandsDir, "set_output_aaa"), "key=first\n");
+        fs.writeFileSync(path.join(fileCommandsDir, "set_output_zzz"), "key=second\n");
+        const outputs = extractStepOutputs(tmpDir);
+        expect(outputs.key).toBe("second");
+    });
+    it("handles multiline heredoc with multiple lines", async () => {
+        const { extractStepOutputs } = await import("./result-builder.js");
+        const fileCommandsDir = path.join(tmpDir, "_runner_file_commands");
+        fs.mkdirSync(fileCommandsDir, { recursive: true });
+        fs.writeFileSync(path.join(fileCommandsDir, "set_output_multi"), "tests<<DELIM\ntest1.ts\ntest2.ts\ntest3.ts\nDELIM\n");
+        const outputs = extractStepOutputs(tmpDir);
+        expect(outputs.tests).toBe("test1.ts\ntest2.ts\ntest3.ts");
+    });
+});
+// ── resolveJobOutputs ─────────────────────────────────────────────────────────
+describe("resolveJobOutputs", () => {
+    it("resolves step output references in job output templates", async () => {
+        const { resolveJobOutputs } = await import("./result-builder.js");
+        const outputDefs = {
+            skip: "${{ steps.check.outputs.skip }}",
+            count: "${{ steps.counter.outputs.shard_count }}",
+        };
+        const stepOutputs = {
+            skip: "false",
+            shard_count: "3",
+        };
+        const resolved = resolveJobOutputs(outputDefs, stepOutputs);
+        expect(resolved).toEqual({
+            skip: "false",
+            count: "3",
+        });
+    });
+    it("returns empty string for unresolved step outputs", async () => {
+        const { resolveJobOutputs } = await import("./result-builder.js");
+        const outputDefs = {
+            missing: "${{ steps.none.outputs.doesnt_exist }}",
+        };
+        const stepOutputs = {};
+        const resolved = resolveJobOutputs(outputDefs, stepOutputs);
+        expect(resolved).toEqual({ missing: "" });
+    });
+    it("passes through literal values unchanged", async () => {
+        const { resolveJobOutputs } = await import("./result-builder.js");
+        const outputDefs = {
+            version: "1.2.3",
+        };
+        const stepOutputs = {};
+        const resolved = resolveJobOutputs(outputDefs, stepOutputs);
+        expect(resolved).toEqual({ version: "1.2.3" });
+    });
+    it("returns empty object when no output definitions", async () => {
+        const { resolveJobOutputs } = await import("./result-builder.js");
+        const resolved = resolveJobOutputs({}, { some: "output" });
+        expect(resolved).toEqual({});
+    });
+    it("handles JSON values in step outputs", async () => {
+        const { resolveJobOutputs } = await import("./result-builder.js");
+        const outputDefs = {
+            matrix: "${{ steps.plan.outputs.matrix }}",
+        };
+        const stepOutputs = {
+            matrix: '{"shard":[1,2,3]}',
+        };
+        const resolved = resolveJobOutputs(outputDefs, stepOutputs);
+        expect(resolved).toEqual({
+            matrix: '{"shard":[1,2,3]}',
+        });
+    });
+    it("handles templates with surrounding text", async () => {
+        const { resolveJobOutputs } = await import("./result-builder.js");
+        const outputDefs = {
+            label: "shard-${{ steps.plan.outputs.index }}",
+        };
+        const stepOutputs = {
+            index: "5",
+        };
+        const resolved = resolveJobOutputs(outputDefs, stepOutputs);
+        expect(resolved).toEqual({ label: "shard-5" });
+    });
+});

package/dist/runner/step-wrapper.js

@@ -80,3 +80,72 @@ export function wrapJobSteps(steps, pauseOnFailure) {
         };
     });
 }
+// ─── Output capture step injection ────────────────────────────────────────────
+//
+// Appends a synthetic step that reads `$GITHUB_OUTPUT` files and echoes their
+// contents to stdout with a `::agent-ci-output::` prefix. The DTU parses these
+// lines and persists them to `outputs.json` so the CLI can resolve cross-job
+// outputs via `needs.*.outputs.*`.
+//
+// This step is necessary because the runner's FinalizeJob step deletes
+// `_temp/_runner_file_commands/` _inside_ the container before it exits,
+// making the files unreachable from the host.
+/**
+ * Build the shell script for the output-capture synthetic step.
+ *
+ * Reads all `set_output_*` files from `GITHUB_OUTPUT`'s directory and
+ * echoes each `key=value` line with the prefix `::agent-ci-output::`.
+ * Multiline values (heredoc format) are flattened into single-line JSON.
+ */
+function outputCaptureScript() {
+    return `# Agent CI: capture step outputs for cross-job passing
+DIR="$(dirname "$GITHUB_OUTPUT")"
+if [ -d "$DIR" ]; then
+  for f in "$DIR"/set_output_*; do
+    [ -f "$f" ] || continue
+    while IFS= read -r line || [ -n "$line" ]; do
+      if echo "$line" | grep -q '<<'; then
+        # Heredoc: key<<DELIMITER ... DELIMITER
+        KEY=$(echo "$line" | cut -d'<' -f1)
+        DELIM=$(echo "$line" | sed 's/^[^<]*<<//')
+        VAL=""
+        while IFS= read -r hline || [ -n "$hline" ]; do
+          [ "$hline" = "$DELIM" ] && break
+          [ -n "$VAL" ] && VAL="$VAL\\\\n$hline" || VAL="$hline"
+        done
+        echo "::agent-ci-output::$KEY=$VAL"
+      else
+        echo "::agent-ci-output::$line"
+      fi
+    done < "$f"
+  done
+fi`;
+}
+/**
+ * Create a synthetic step object for output capture.
+ * Uses `if: always()` semantics by setting `Condition` so it runs even
+ * if prior steps failed.
+ */
+export function createOutputCaptureStep() {
+    return {
+        Name: "__agent_ci_output_capture",
+        DisplayName: "Capture outputs",
+        Reference: { Type: "Script" },
+        Inputs: {
+            script: outputCaptureScript(),
+        },
+        Condition: "always()",
+        Environment: {},
+        ContextName: "__agent_ci_output_capture",
+    };
+}
+/**
+ * Append the output-capture step to a steps array.
+ * Only adds it if there are existing steps and the job has outputs defined.
+ */
+export function appendOutputCaptureStep(steps) {
+    if (!steps || steps.length === 0) {
+        return steps;
+    }
+    return [...steps, createOutputCaptureStep()];
+}

package/dist/workflow/workflow-parser.js

@@ -19,7 +19,7 @@ async function loadWorkflowParser() {
  *  - github.sha → '0000000000000000000000000000000000000000'
  *  - (others) → empty string (safe: no commas injected)
  */
-export function expandExpressions(value, repoPath, secrets, matrixContext) {
+export function expandExpressions(value, repoPath, secrets, matrixContext, needsContext) {
     return value.replace(/\$\{\{([\s\S]*?)\}\}/g, (_match, expr) => {
         const trimmed = expr.trim();
         // hashFiles('glob1', 'glob2', ...)
@@ -62,6 +62,45 @@ export function expandExpressions(value, repoPath, secrets, matrixContext) {
                 return "0000000000000000000000000000000000000000";
             }
         }
+        // fromJSON(expr) — parse JSON from a string (or inner expression)
+        const fromJsonMatch = trimmed.match(/^fromJSON\(([\s\S]+)\)$/);
+        if (fromJsonMatch) {
+            const inner = fromJsonMatch[1].trim();
+            // If the inner arg is a quoted string literal, use it directly
+            let rawValue;
+            if ((inner.startsWith("'") && inner.endsWith("'")) ||
+                (inner.startsWith('"') && inner.endsWith('"'))) {
+                rawValue = inner.slice(1, -1);
+            }
+            else {
+                // Otherwise, treat it as an expression and expand it
+                rawValue = expandExpressions(`\${{ ${inner} }}`, repoPath, secrets, matrixContext, needsContext);
+            }
+            try {
+                const parsed = JSON.parse(rawValue);
+                if (typeof parsed === "string") {
+                    return parsed;
+                }
+                return JSON.stringify(parsed);
+            }
+            catch {
+                return "";
+            }
+        }
+        // toJSON(expr) — serialize a value to JSON
+        const toJsonMatch = trimmed.match(/^toJSON\(([\s\S]+)\)$/);
+        if (toJsonMatch) {
+            const inner = toJsonMatch[1].trim();
+            let rawValue;
+            if ((inner.startsWith("'") && inner.endsWith("'")) ||
+                (inner.startsWith('"') && inner.endsWith('"'))) {
+                rawValue = inner.slice(1, -1);
+            }
+            else {
+                rawValue = expandExpressions(`\${{ ${inner} }}`, repoPath, secrets, matrixContext, needsContext);
+            }
+            return JSON.stringify(rawValue);
+        }
         // format('template {0} {1}', arg0, arg1)
         const formatMatch = trimmed.match(/^format\(([\s\S]+)\)$/);
         if (formatMatch) {
@@ -132,6 +171,20 @@ export function expandExpressions(value, repoPath, secrets, matrixContext) {
         if (trimmed.startsWith("steps.")) {
             return "";
         }
+        if (trimmed.startsWith("needs.") && needsContext) {
+            // needs.<jobId>.outputs.<name> or needs.<jobId>.result
+            const parts = trimmed.split(".");
+            const jobId = parts[1];
+            const jobOutputs = needsContext[jobId];
+            if (parts[2] === "outputs" && parts[3]) {
+                return jobOutputs?.[parts[3]] ?? "";
+            }
+            if (parts[2] === "result") {
+                // If the job is in the needsContext, it completed (default to 'success')
+                return jobOutputs ? (jobOutputs["__result"] ?? "success") : "";
+            }
+            return "";
+        }
         if (trimmed.startsWith("needs.")) {
             return "";
         }
@@ -224,7 +277,7 @@ export async function parseMatrixDef(filePath, jobId) {
     }
     return Object.keys(result).length > 0 ? result : null;
 }
-export async function parseWorkflowSteps(filePath, taskName, secrets, matrixContext) {
+export async function parseWorkflowSteps(filePath, taskName, secrets, matrixContext, needsContext) {
     const template = await getWorkflowTemplate(filePath);
     const rawYaml = parseYaml(fs.readFileSync(filePath, "utf8"));
     // Derive repoPath from filePath (.../repoPath/.github/workflows/foo.yml → repoPath)
@@ -244,10 +297,12 @@ export async function parseWorkflowSteps(filePath, taskName, secrets, matrixCont
     return job.steps
         .map((step, index) => {
         const stepId = step.id || `step-${index + 1}`;
-        let stepName = step.name
-            ? expandExpressions(step.name.toString(), repoPath, secrets, matrixContext)
-            : stepId;
         const rawStep = rawSteps[index] || {};
+        // Prefer raw YAML name to preserve ${{ }} expressions for our own expansion
+        const rawName = rawStep.name != null ? String(rawStep.name) : step.name?.toString();
+        let stepName = rawName
+            ? expandExpressions(rawName, repoPath, secrets, matrixContext, needsContext)
+            : stepId;
         // If a step lacks an explicit name, we map it to standard GitHub Actions defaults
         if (!step.name) {
             if ("run" in step) {
@@ -270,7 +325,7 @@ export async function parseWorkflowSteps(filePath, taskName, secrets, matrixCont
             // string is always the complete literal block scalar.
             const rawScript = rawStep.run != null ? String(rawStep.run) : step.run.toString();
             const inputs = {
-                script: expandExpressions(rawScript, repoPath, secrets, matrixContext),
+                script: expandExpressions(rawScript, repoPath, secrets, matrixContext, needsContext),
             };
             if (rawStep["working-directory"]) {
                 inputs.workingDirectory = rawStep["working-directory"];
@@ -287,7 +342,7 @@ export async function parseWorkflowSteps(filePath, taskName, secrets, matrixCont
                 Env: rawStep.env
                     ? Object.fromEntries(Object.entries(rawStep.env).map(([k, v]) => [
                         k,
-                        expandExpressions(String(v), repoPath, secrets),
+                        expandExpressions(String(v), repoPath, secrets, undefined, needsContext),
                     ]))
                     : undefined,
             };
@@ -322,13 +377,13 @@ export async function parseWorkflowSteps(filePath, taskName, secrets, matrixCont
                     ...(step.with
                         ? Object.fromEntries(Object.entries(step.with).map(([k, v]) => [
                             k,
-                            expandExpressions(String(v), repoPath, secrets, matrixContext),
+                            expandExpressions(String(v), repoPath, secrets, matrixContext, needsContext),
                         ]))
                         : {}),
                     // Merge from raw YAML (overrides parsed values), expanding expressions
                     ...Object.fromEntries(Object.entries(stepWith).map(([k, v]) => [
                         k,
-                        expandExpressions(String(v), repoPath, secrets, matrixContext),
+                        expandExpressions(String(v), repoPath, secrets, matrixContext, needsContext),
                     ])),
                     ...(isCheckout
                         ? {
@@ -338,7 +393,7 @@ export async function parseWorkflowSteps(filePath, taskName, secrets, matrixCont
                             submodules: "false",
                             ...Object.fromEntries(Object.entries(stepWith).map(([k, v]) => [
                                 k,
-                                expandExpressions(String(v), repoPath),
+                                expandExpressions(String(v), repoPath, secrets, undefined, needsContext),
                             ])),
                         }
                         : {}), // Prevent actions/checkout from wiping the rsynced workspace
@@ -346,7 +401,7 @@ export async function parseWorkflowSteps(filePath, taskName, secrets, matrixCont
                 Env: rawStep.env
                     ? Object.fromEntries(Object.entries(rawStep.env).map(([k, v]) => [
                         k,
-                        expandExpressions(String(v), repoPath, secrets, matrixContext),
+                        expandExpressions(String(v), repoPath, secrets, matrixContext, needsContext),
                     ]))
                     : undefined,
             };
@@ -554,3 +609,183 @@ export function validateSecrets(filePath, taskName, secrets, secretsFilePath) {
         missing.map((n) => `${n}=`).join("\n") +
         "\n");
 }
+/**
+ * Parse `jobs.<id>.outputs` definitions from a workflow YAML file.
+ * Returns a Record<outputName, expressionTemplate> (e.g. { skip: "${{ steps.check.outputs.skip }}" }).
+ * Returns {} if the job has no outputs or doesn't exist.
+ */
+export function parseJobOutputDefs(filePath, jobId) {
+    const yaml = parseYaml(fs.readFileSync(filePath, "utf8"));
+    const outputs = yaml?.jobs?.[jobId]?.outputs;
+    if (!outputs || typeof outputs !== "object") {
+        return {};
+    }
+    const result = {};
+    for (const [k, v] of Object.entries(outputs)) {
+        result[k] = String(v);
+    }
+    return result;
+}
+/**
+ * Parse the `if:` condition from a workflow job.
+ * Returns the raw expression string (with `${{ }}` wrapper stripped if present),
+ * or null if the job has no `if:`.
+ */
+export function parseJobIf(filePath, jobId) {
+    const yaml = parseYaml(fs.readFileSync(filePath, "utf8"));
+    const rawIf = yaml?.jobs?.[jobId]?.if;
+    if (rawIf == null) {
+        return null;
+    }
+    let expr = String(rawIf).trim();
+    // Strip ${{ }} wrapper if present
+    const wrapped = expr.match(/^\$\{\{\s*([\s\S]*?)\s*\}\}$/);
+    if (wrapped) {
+        expr = wrapped[1];
+    }
+    return expr;
+}
+/**
+ * Evaluate a job-level `if:` condition.
+ *
+ * @param expr       The expression string (already stripped of `${{ }}`)
+ * @param jobResults Record<jobId, "success" | "failure"> for upstream jobs
+ * @param needsCtx   Optional needs output context (same shape as expandExpressions needsContext)
+ * @returns          Whether the job should run
+ */
+export function evaluateJobIf(expr, jobResults, needsCtx) {
+    const trimmed = expr.trim();
+    // Empty expression defaults to success()
+    if (!trimmed) {
+        return evaluateAtom("success()", jobResults, needsCtx);
+    }
+    // Handle || (split first — lower precedence)
+    if (trimmed.includes("||")) {
+        const parts = splitOnOperator(trimmed, "||");
+        if (parts.length > 1) {
+            return parts.some((p) => evaluateJobIf(p.trim(), jobResults, needsCtx));
+        }
+    }
+    // Handle &&
+    if (trimmed.includes("&&")) {
+        const parts = splitOnOperator(trimmed, "&&");
+        if (parts.length > 1) {
+            return parts.every((p) => evaluateJobIf(p.trim(), jobResults, needsCtx));
+        }
+    }
+    return evaluateAtom(trimmed, jobResults, needsCtx);
+}
+/**
+ * Split an expression on a logical operator, respecting parentheses and quotes.
+ */
+function splitOnOperator(expr, op) {
+    const parts = [];
+    let depth = 0;
+    let inQuote = null;
+    let current = "";
+    for (let i = 0; i < expr.length; i++) {
+        const ch = expr[i];
+        if (inQuote) {
+            current += ch;
+            if (ch === inQuote) {
+                inQuote = null;
+            }
+            continue;
+        }
+        if (ch === "'" || ch === '"') {
+            inQuote = ch;
+            current += ch;
+            continue;
+        }
+        if (ch === "(") {
+            depth++;
+        }
+        if (ch === ")") {
+            depth--;
+        }
+        if (depth === 0 && expr.slice(i, i + op.length) === op) {
+            parts.push(current);
+            current = "";
+            i += op.length - 1;
+            continue;
+        }
+        current += ch;
+    }
+    parts.push(current);
+    return parts;
+}
+/**
+ * Evaluate a single atomic condition (no && or ||).
+ */
+function evaluateAtom(expr, jobResults, needsCtx) {
+    const trimmed = expr.trim();
+    // Status check functions
+    if (trimmed === "always()") {
+        return true;
+    }
+    if (trimmed === "cancelled()") {
+        return false;
+    }
+    if (trimmed === "success()") {
+        return Object.values(jobResults).every((r) => r === "success");
+    }
+    if (trimmed === "failure()") {
+        return Object.values(jobResults).some((r) => r === "failure");
+    }
+    // != comparison
+    const neqMatch = trimmed.match(/^(.+?)\s*!=\s*(.+)$/);
+    if (neqMatch) {
+        const left = resolveValue(neqMatch[1].trim(), needsCtx);
+        const right = resolveValue(neqMatch[2].trim(), needsCtx);
+        return left !== right;
+    }
+    // == comparison
+    const eqMatch = trimmed.match(/^(.+?)\s*==\s*(.+)$/);
+    if (eqMatch) {
+        const left = resolveValue(eqMatch[1].trim(), needsCtx);
+        const right = resolveValue(eqMatch[2].trim(), needsCtx);
+        return left === right;
+    }
+    // Bare truthy value (e.g. needs.setup.outputs.run_tests)
+    const val = resolveValue(trimmed, needsCtx);
+    return val !== "" && val !== "false" && val !== "0";
+}
+/**
+ * Resolve a value reference in a condition expression.
+ */
+function resolveValue(raw, needsCtx) {
+    const trimmed = raw.trim();
+    // Quoted string literal
+    if ((trimmed.startsWith("'") && trimmed.endsWith("'")) ||
+        (trimmed.startsWith('"') && trimmed.endsWith('"'))) {
+        return trimmed.slice(1, -1);
+    }
+    // needs.<jobId>.outputs.<name>
+    if (trimmed.startsWith("needs.") && needsCtx) {
+        const parts = trimmed.split(".");
+        const jobId = parts[1];
+        const jobOutputs = needsCtx[jobId];
+        if (parts[2] === "outputs" && parts[3]) {
+            return jobOutputs?.[parts[3]] ?? "";
+        }
+        if (parts[2] === "result") {
+            return jobOutputs ? (jobOutputs["__result"] ?? "success") : "";
+        }
+    }
+    return trimmed;
+}
+/**
+ * Parse `strategy.fail-fast` for a job.
+ * Returns true/false if explicitly set, undefined if not specified.
+ */
+export function parseFailFast(filePath, jobId) {
+    const yaml = parseYaml(fs.readFileSync(filePath, "utf8"));
+    const strategy = yaml?.jobs?.[jobId]?.strategy;
+    if (!strategy || typeof strategy !== "object") {
+        return undefined;
+    }
+    if ("fail-fast" in strategy) {
+        return Boolean(strategy["fail-fast"]);
+    }
+    return undefined;
+}