@redwoodjs/agent-ci 0.1.0

package/dist/output/state-renderer.test.js

@@ -0,0 +1,488 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { renderRunState } from "./state-renderer.js";
+// Freeze time so spinner frames and elapsed times are deterministic.
+// Date.now() → 0 → Math.floor(0/80) % 10 → frame index 0 → "⠋"
+beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(0);
+});
+afterEach(() => {
+    vi.useRealTimers();
+});
+function makeState(overrides = {}) {
+    return {
+        runId: "test-run",
+        status: "running",
+        startedAt: "1970-01-01T00:00:00.000Z",
+        workflows: [],
+        ...overrides,
+    };
+}
+describe("renderRunState", () => {
+    describe("single workflow, single job", () => {
+        it("renders boot spinner before timeline appears", () => {
+            const state = makeState({
+                workflows: [
+                    {
+                        id: "ci.yml",
+                        path: "/repo/.github/workflows/ci.yml",
+                        status: "running",
+                        jobs: [
+                            {
+                                id: "test",
+                                runnerId: "agent-ci-5",
+                                status: "booting",
+                                startedAt: "1970-01-01T00:00:00.000Z",
+                                steps: [],
+                            },
+                        ],
+                    },
+                ],
+            });
+            const output = renderRunState(state);
+            expect(output).toContain("ci.yml");
+            expect(output).toContain("⠋");
+            expect(output).toContain("Starting runner agent-ci-5 (0s)");
+        });
+        it("renders starting-runner node alongside steps once running", () => {
+            const state = makeState({
+                workflows: [
+                    {
+                        id: "ci.yml",
+                        path: "/repo/.github/workflows/ci.yml",
+                        status: "running",
+                        jobs: [
+                            {
+                                id: "test",
+                                runnerId: "agent-ci-5",
+                                status: "running",
+                                startedAt: "1970-01-01T00:00:00.000Z",
+                                bootDurationMs: 2300,
+                                steps: [
+                                    { name: "Set up job", index: 1, status: "completed", durationMs: 1000 },
+                                    {
+                                        name: "Run pnpm check",
+                                        index: 2,
+                                        status: "running",
+                                        startedAt: "1970-01-01T00:00:00.000Z",
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            });
+            const output = renderRunState(state);
+            expect(output).toContain("ci.yml");
+            expect(output).toContain("Starting runner agent-ci-5 (2.3s)");
+            expect(output).toContain("test");
+            expect(output).toContain("✓ 1. Set up job (1s)");
+            expect(output).toContain("⠋ 2. Run pnpm check (0s...)");
+        });
+        it("renders completed steps with tick icons", () => {
+            const state = makeState({
+                workflows: [
+                    {
+                        id: "ci.yml",
+                        path: "/repo/.github/workflows/ci.yml",
+                        status: "completed",
+                        jobs: [
+                            {
+                                id: "test",
+                                runnerId: "agent-ci-5",
+                                status: "completed",
+                                bootDurationMs: 2000,
+                                steps: [
+                                    { name: "Set up job", index: 1, status: "completed", durationMs: 1000 },
+                                    { name: "Run tests", index: 2, status: "completed", durationMs: 10000 },
+                                    { name: "Complete job", index: 3, status: "completed", durationMs: 200 },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            });
+            const output = renderRunState(state);
+            expect(output).toContain("✓ 1. Set up job (1s)");
+            expect(output).toContain("✓ 2. Run tests (10s)");
+            expect(output).toContain("✓ 3. Complete job (0s)");
+        });
+        it("renders a failed step with ✗ icon", () => {
+            const state = makeState({
+                workflows: [
+                    {
+                        id: "ci.yml",
+                        path: "/repo/.github/workflows/ci.yml",
+                        status: "failed",
+                        jobs: [
+                            {
+                                id: "test",
+                                runnerId: "agent-ci-5",
+                                status: "failed",
+                                failedStep: "Run tests",
+                                bootDurationMs: 1000,
+                                steps: [
+                                    { name: "Set up job", index: 1, status: "completed", durationMs: 500 },
+                                    { name: "Run tests", index: 2, status: "failed", durationMs: 5000 },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            });
+            const output = renderRunState(state);
+            expect(output).toContain("✓ 1. Set up job (1s)");
+            expect(output).toContain("✗ 2. Run tests (5s)");
+        });
+        it("renders a skipped step with ⊘ icon", () => {
+            const state = makeState({
+                workflows: [
+                    {
+                        id: "ci.yml",
+                        path: "/repo/.github/workflows/ci.yml",
+                        status: "completed",
+                        jobs: [
+                            {
+                                id: "test",
+                                runnerId: "agent-ci-5",
+                                status: "completed",
+                                bootDurationMs: 1000,
+                                steps: [
+                                    { name: "Run tests", index: 1, status: "skipped" },
+                                    { name: "Complete job", index: 2, status: "completed", durationMs: 100 },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            });
+            const output = renderRunState(state);
+            expect(output).toContain("⊘ 1. Run tests");
+        });
+        it("renders a pending step with ○ icon", () => {
+            const state = makeState({
+                workflows: [
+                    {
+                        id: "ci.yml",
+                        path: "/repo/.github/workflows/ci.yml",
+                        status: "running",
+                        jobs: [
+                            {
+                                id: "test",
+                                runnerId: "agent-ci-5",
+                                status: "running",
+                                bootDurationMs: 1000,
+                                steps: [
+                                    { name: "Set up job", index: 1, status: "completed", durationMs: 500 },
+                                    { name: "Run tests", index: 2, status: "pending" },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            });
+            const output = renderRunState(state);
+            expect(output).toContain("○ 2. Run tests");
+        });
+        it("renders paused step with frozen timer and retry hints", () => {
+            const state = makeState({
+                workflows: [
+                    {
+                        id: "ci.yml",
+                        path: "/repo/.github/workflows/ci.yml",
+                        status: "running",
+                        jobs: [
+                            {
+                                id: "test",
+                                runnerId: "agent-ci-5",
+                                status: "paused",
+                                bootDurationMs: 1000,
+                                pausedAtStep: "Run tests",
+                                pausedAtMs: "1970-01-01T00:00:05.000Z", // 5s after epoch
+                                attempt: 1,
+                                lastOutputLines: ["Error: assertion failed"],
+                                steps: [
+                                    { name: "Set up job", index: 1, status: "completed", durationMs: 500 },
+                                    {
+                                        name: "Run tests",
+                                        index: 2,
+                                        status: "paused",
+                                        startedAt: "1970-01-01T00:00:03.000Z", // 3s after epoch
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            });
+            const output = renderRunState(state);
+            // Paused step icon
+            expect(output).toContain("⏸ 2. Run tests (2s)"); // 5s - 3s = 2s frozen
+            // Retry attempt indicator
+            expect(output).toContain("Step failed attempt #1");
+            // Trailing retry/abort hints (single-job mode)
+            expect(output).toContain("↻ To retry:");
+            expect(output).toContain("agent-ci retry --runner agent-ci-5");
+            expect(output).toContain("■ To abort:");
+            expect(output).toContain("agent-ci abort --runner agent-ci-5");
+            // Last output lines
+            expect(output).toContain("Last output:");
+            expect(output).toContain("Error: assertion failed");
+        });
+        it("renders retrying step with 'retrying' label", () => {
+            const state = makeState({
+                workflows: [
+                    {
+                        id: "ci.yml",
+                        path: "/repo/.github/workflows/ci.yml",
+                        status: "running",
+                        jobs: [
+                            {
+                                id: "test",
+                                runnerId: "agent-ci-5",
+                                status: "running",
+                                bootDurationMs: 1000,
+                                pausedAtStep: "Run tests", // was paused on this step
+                                attempt: 1, // has been retried
+                                steps: [
+                                    { name: "Set up job", index: 1, status: "completed", durationMs: 500 },
+                                    {
+                                        name: "Run tests",
+                                        index: 2,
+                                        status: "running",
+                                        startedAt: "1970-01-01T00:00:00.000Z",
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            });
+            const output = renderRunState(state);
+            expect(output).toContain("retrying");
+            expect(output).toContain("Run tests");
+        });
+    });
+    describe("multi-job workflow", () => {
+        it("collapses completed jobs to a single summary line", () => {
+            const state = makeState({
+                workflows: [
+                    {
+                        id: "ci.yml",
+                        path: "/repo/.github/workflows/ci.yml",
+                        status: "running",
+                        jobs: [
+                            {
+                                id: "lint",
+                                runnerId: "agent-ci-5-j1",
+                                status: "completed",
+                                durationMs: 5000,
+                                steps: [],
+                            },
+                            {
+                                id: "test",
+                                runnerId: "agent-ci-5-j2",
+                                status: "running",
+                                bootDurationMs: 1000,
+                                steps: [
+                                    {
+                                        name: "Run tests",
+                                        index: 1,
+                                        status: "running",
+                                        startedAt: "1970-01-01T00:00:00.000Z",
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            });
+            const output = renderRunState(state);
+            // Completed job collapsed (includes runner name)
+            expect(output).toContain("✓ lint");
+            expect(output).toContain("agent-ci-5-j1");
+            // Running job shows steps
+            expect(output).toContain("test");
+            expect(output).toContain("agent-ci-5-j2");
+            expect(output).toContain("⠋ 1. Run tests (0s...)");
+            // Does NOT show "Starting runner" for the running job in multi-job mode
+            expect(output).not.toContain("Starting runner agent-ci-5-j2 (");
+        });
+        it("shows ✗ icon for failed completed job", () => {
+            const state = makeState({
+                workflows: [
+                    {
+                        id: "ci.yml",
+                        path: "/repo/.github/workflows/ci.yml",
+                        status: "failed",
+                        jobs: [
+                            {
+                                id: "lint",
+                                runnerId: "agent-ci-5-j1",
+                                status: "failed",
+                                failedStep: "Run lint",
+                                durationMs: 3000,
+                                steps: [],
+                            },
+                            {
+                                id: "test",
+                                runnerId: "agent-ci-5-j2",
+                                status: "completed",
+                                durationMs: 5000,
+                                steps: [],
+                            },
+                        ],
+                    },
+                ],
+            });
+            const output = renderRunState(state);
+            expect(output).toContain("✗ lint");
+            expect(output).toContain("agent-ci-5-j1");
+        });
+        it("shows retry hint as child node in multi-job paused mode", () => {
+            const state = makeState({
+                workflows: [
+                    {
+                        id: "ci.yml",
+                        path: "/repo/.github/workflows/ci.yml",
+                        status: "running",
+                        jobs: [
+                            {
+                                id: "lint",
+                                runnerId: "agent-ci-5-j1",
+                                status: "completed",
+                                durationMs: 5000,
+                                steps: [],
+                            },
+                            {
+                                id: "test",
+                                runnerId: "agent-ci-5-j2",
+                                status: "paused",
+                                pausedAtStep: "Run tests",
+                                pausedAtMs: "1970-01-01T00:00:05.000Z",
+                                attempt: 1,
+                                bootDurationMs: 1000,
+                                steps: [
+                                    {
+                                        name: "Run tests",
+                                        index: 1,
+                                        status: "paused",
+                                        startedAt: "1970-01-01T00:00:03.000Z",
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            });
+            const output = renderRunState(state);
+            // Retry hint is a child node (not trailing output like single-job mode)
+            expect(output).toContain("↻ retry: agent-ci retry --runner agent-ci-5-j2");
+            // No trailing "To retry:" / "To abort:" lines in multi-job mode
+            expect(output).not.toContain("↻ To retry:");
+            expect(output).not.toContain("■ To abort:");
+        });
+    });
+    describe("multi-workflow (--all mode)", () => {
+        it("renders multiple workflow roots", () => {
+            const state = makeState({
+                workflows: [
+                    {
+                        id: "ci.yml",
+                        path: "/repo/.github/workflows/ci.yml",
+                        status: "completed",
+                        jobs: [
+                            {
+                                id: "test",
+                                runnerId: "agent-ci-5-j1",
+                                status: "completed",
+                                durationMs: 15000,
+                                steps: [],
+                            },
+                        ],
+                    },
+                    {
+                        id: "deploy.yml",
+                        path: "/repo/.github/workflows/deploy.yml",
+                        status: "running",
+                        jobs: [
+                            {
+                                id: "deploy",
+                                runnerId: "agent-ci-5-j2",
+                                status: "booting",
+                                startedAt: "1970-01-01T00:00:00.000Z",
+                                steps: [],
+                            },
+                        ],
+                    },
+                ],
+            });
+            const output = renderRunState(state);
+            expect(output).toContain("ci.yml");
+            expect(output).toContain("deploy.yml");
+            expect(output).toContain("✓ test");
+            expect(output).toContain("agent-ci-5-j1");
+            expect(output).toContain("⠋ Starting runner agent-ci-5-j2 (0s)");
+        });
+        it("groups multiple jobs under their respective workflow", () => {
+            const state = makeState({
+                workflows: [
+                    {
+                        id: "ci.yml",
+                        path: "/repo/.github/workflows/ci.yml",
+                        status: "completed",
+                        jobs: [
+                            {
+                                id: "lint",
+                                runnerId: "agent-ci-5-j1",
+                                status: "completed",
+                                durationMs: 5000,
+                                steps: [],
+                            },
+                            {
+                                id: "test",
+                                runnerId: "agent-ci-5-j2",
+                                status: "completed",
+                                durationMs: 10000,
+                                steps: [],
+                            },
+                        ],
+                    },
+                ],
+            });
+            const output = renderRunState(state);
+            // ci.yml appears exactly once as root
+            expect(output.split("ci.yml").length).toBe(2); // 1 occurrence → 2 parts
+            expect(output).toContain("✓ lint");
+            expect(output).toContain("agent-ci-5-j1");
+            expect(output).toContain("✓ test");
+            expect(output).toContain("agent-ci-5-j2");
+        });
+    });
+    describe("boot spinner in booting phase", () => {
+        it("shows elapsed boot time in seconds", () => {
+            // Boot started 7 seconds ago in wall clock time
+            vi.setSystemTime(7000);
+            const state = makeState({
+                workflows: [
+                    {
+                        id: "ci.yml",
+                        path: "/repo/.github/workflows/ci.yml",
+                        status: "running",
+                        jobs: [
+                            {
+                                id: "test",
+                                runnerId: "agent-ci-5",
+                                status: "booting",
+                                startedAt: "1970-01-01T00:00:00.000Z", // epoch
+                                steps: [],
+                            },
+                        ],
+                    },
+                ],
+            });
+            const output = renderRunState(state);
+            expect(output).toContain("Starting runner agent-ci-5 (7s)");
+        });
+    });
+});

package/dist/output/tree-renderer.js

@@ -0,0 +1,52 @@
+// ─── Tree Renderer ────────────────────────────────────────────────────────────
+// Renders a tree structure using Unicode box-drawing characters.
+//
+// Example output:
+//   [*] tests.yml
+//   └── [job] test
+//       └── [run] agent-ci-5
+//           ├── [+] Set up job (1s)
+//           ├── [>] Run pnpm check (12s...)
+//           └── [ ] Pending...
+/**
+ * Render a tree of nodes into a string with box-drawing characters.
+ *
+ * @param nodes    One or more root-level nodes to render.
+ * @param prefix   Internal — the leading whitespace/connector for the current depth.
+ * @param isRoot   Internal — whether we're rendering top-level roots (no connectors).
+ */
+export function renderTree(nodes, prefix = "", isRoot = true) {
+    const lines = [];
+    for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        const isLast = i === nodes.length - 1;
+        if (isRoot) {
+            // Root level — no connector
+            lines.push(node.label);
+        }
+        else {
+            const connector = isLast ? "└── " : "├── ";
+            lines.push(prefix + connector + node.label);
+        }
+        if (node.children && node.children.length > 0) {
+            let childPrefix;
+            if (isRoot) {
+                // Children of root nodes start at the base indentation
+                childPrefix = "";
+            }
+            else {
+                childPrefix = isLast ? prefix + "    " : prefix + "│   ";
+            }
+            lines.push(renderTree(node.children, childPrefix, false));
+        }
+    }
+    const result = lines.filter((l) => l.length > 0).join("\n");
+    // Add 1-space left padding only at the top-level call
+    if (isRoot) {
+        return result
+            .split("\n")
+            .map((l) => ` ${l}`)
+            .join("\n");
+    }
+    return result;
+}

package/dist/output/tree-renderer.test.js

@@ -0,0 +1,105 @@
+import { describe, it, expect } from "vitest";
+import { renderTree } from "./tree-renderer.js";
+describe("renderTree", () => {
+    it("renders a single root node", () => {
+        const nodes = [{ label: "[*] tests.yml" }];
+        expect(renderTree(nodes)).toBe(" [*] tests.yml");
+    });
+    it("renders a linear chain", () => {
+        const tree = [
+            {
+                label: "[*] tests.yml",
+                children: [
+                    {
+                        label: "[job] test",
+                        children: [{ label: "[run] agent-ci-5" }],
+                    },
+                ],
+            },
+        ];
+        const expected = [" [*] tests.yml", " └── [job] test", "     └── [run] agent-ci-5"].join("\n");
+        expect(renderTree(tree)).toBe(expected);
+    });
+    it("renders multiple siblings with correct connectors", () => {
+        const tree = [
+            {
+                label: "[*] tests.yml",
+                children: [
+                    {
+                        label: "[job] test",
+                        children: [
+                            {
+                                label: "[run] agent-ci-5",
+                                children: [
+                                    { label: "[+] Set up job (1s)" },
+                                    { label: "[+] actions/checkout@v4 (2s)" },
+                                    { label: "[>] Run pnpm check (12s...)" },
+                                    { label: "[ ] Pending..." },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            },
+        ];
+        const expected = [
+            " [*] tests.yml",
+            " └── [job] test",
+            "     └── [run] agent-ci-5",
+            "         ├── [+] Set up job (1s)",
+            "         ├── [+] actions/checkout@v4 (2s)",
+            "         ├── [>] Run pnpm check (12s...)",
+            "         └── [ ] Pending...",
+        ].join("\n");
+        expect(renderTree(tree)).toBe(expected);
+    });
+    it("renders multiple root nodes", () => {
+        const tree = [{ label: "[*] a.yml" }, { label: "[*] b.yml" }];
+        const expected = [" [*] a.yml", " [*] b.yml"].join("\n");
+        expect(renderTree(tree)).toBe(expected);
+    });
+    it("renders deep nesting with mixed siblings", () => {
+        const tree = [
+            {
+                label: "[*] tests.yml",
+                children: [
+                    {
+                        label: "[job] test",
+                        children: [
+                            {
+                                label: "[run] agent-ci-5",
+                                children: [
+                                    { label: "[+] Set up job (1s)" },
+                                    {
+                                        label: "[>] Run pnpm check (12s...)",
+                                        children: [{ label: "[output] Checking 142 files..." }],
+                                    },
+                                    { label: "[ ] Pending..." },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            },
+        ];
+        const expected = [
+            " [*] tests.yml",
+            " └── [job] test",
+            "     └── [run] agent-ci-5",
+            "         ├── [+] Set up job (1s)",
+            "         ├── [>] Run pnpm check (12s...)",
+            "         │   └── [output] Checking 142 files...",
+            "         └── [ ] Pending...",
+        ].join("\n");
+        expect(renderTree(tree)).toBe(expected);
+    });
+    it("handles nodes with empty children arrays", () => {
+        const tree = [
+            {
+                label: "root",
+                children: [],
+            },
+        ];
+        expect(renderTree(tree)).toBe(" root");
+    });
+});

package/dist/output/working-directory.js

@@ -0,0 +1,20 @@
+import path from "node:path";
+import os from "node:os";
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+// Pinned to the monorepo root (project root), not the cli package
+export const PROJECT_ROOT = path.resolve(fileURLToPath(import.meta.url), "..", "..", "..");
+// When running inside a container with Docker-outside-of-Docker (shared socket),
+// /tmp is NOT visible to the Docker host. Use a project-relative directory
+// so bind mounts resolve correctly on the host.
+const isInsideDocker = fs.existsSync("/.dockerenv");
+export const DEFAULT_WORKING_DIR = isInsideDocker
+    ? path.join(PROJECT_ROOT, ".agent-ci")
+    : path.join(os.tmpdir(), "agent-ci", path.basename(PROJECT_ROOT));
+let workingDirectory = DEFAULT_WORKING_DIR;
+export function setWorkingDirectory(dir) {
+    workingDirectory = dir;
+}
+export function getWorkingDirectory() {
+    return workingDirectory;
+}