@redwoodjs/agent-ci 0.1.0

package/dist/runner/sync.js

@@ -0,0 +1,80 @@
+import path from "path";
+import fs from "fs";
+import { execSync, spawnSync } from "child_process";
+// ─── Retry workspace sync ─────────────────────────────────────────────────────
+/**
+ * Resolve the repo root by walking up from `cwd` to find `.git`.
+ */
+function resolveRepoRoot() {
+    let dir = process.cwd();
+    while (dir !== "/" && !fs.existsSync(path.join(dir, ".git"))) {
+        dir = path.dirname(dir);
+    }
+    return dir === "/" ? process.cwd() : dir;
+}
+/**
+ * Discover the workspace directory inside a run directory.
+ *
+ * The structure is: `<runDir>/work/<repoName>/<repoName>/`
+ */
+function findWorkspaceDir(runDir) {
+    const workDir = path.join(runDir, "work");
+    if (!fs.existsSync(workDir)) {
+        return null;
+    }
+    for (const entry of fs.readdirSync(workDir)) {
+        const nested = path.join(workDir, entry, entry);
+        if (fs.existsSync(nested) && fs.statSync(nested).isDirectory()) {
+            return nested;
+        }
+    }
+    return null;
+}
+/**
+ * Sync source files from the local repo into the run's workspace directory.
+ *
+ * Uses `rsync --delete` to mirror changes (including deleted files), while
+ * preserving `node_modules` and `.git` so installed dependencies and the
+ * fake git repo remain intact.
+ *
+ * Called before sending the `retry` signal so the container sees local edits.
+ */
+export function syncWorkspaceForRetry(runDir) {
+    const workspaceDir = findWorkspaceDir(runDir);
+    if (!workspaceDir) {
+        return;
+    }
+    const repoRoot = resolveRepoRoot();
+    // Get tracked + untracked (respecting .gitignore) file list — same as
+    // copyWorkspace uses for the initial clone.
+    const files = execSync("git ls-files --cached --others --exclude-standard -z", {
+        stdio: "pipe",
+        cwd: repoRoot,
+    })
+        .toString()
+        .split("\0")
+        .filter(Boolean);
+    // Sync via rsync on all platforms (we need --delete semantics).
+    // Pass the file list via stdin to avoid shell injection.
+    const input = files.join("\0");
+    const result = spawnSync("rsync", ["-a", "--delete", "--files-from=-", "--from0", "./", workspaceDir + "/"], {
+        input,
+        stdio: ["pipe", "pipe", "pipe"],
+        cwd: repoRoot,
+    });
+    if (result.status !== 0) {
+        // Fallback: copy files individually
+        for (const file of files) {
+            const src = path.join(repoRoot, file);
+            const dest = path.join(workspaceDir, file);
+            try {
+                fs.mkdirSync(path.dirname(dest), { recursive: true });
+                fs.copyFileSync(src, dest);
+            }
+            catch {
+                // Skip files that can't be copied
+            }
+        }
+    }
+    console.log(`[Agent CI] Synced workspace from ${repoRoot}`);
+}

package/dist/runner/workspace.js

@@ -0,0 +1,66 @@
+import { execSync } from "child_process";
+import { copyWorkspace } from "../output/cleanup.js";
+import { findRepoRoot } from "./metadata.js";
+import { config } from "../config.js";
+/**
+ * Copy source files into the workspace directory, then initialise a fake
+ * git repo so `actions/checkout` finds a valid workspace.
+ */
+export function prepareWorkspace(opts) {
+    const { workflowPath, headSha, githubRepo, workspaceDir } = opts;
+    // Resolve repo root — needed for both archive and rsync paths.
+    // Derive from the workflow path (which lives inside the target repo) so we copy
+    // from the correct repo, not from the CLI's CWD (which is agent-ci).
+    let repoRoot;
+    if (workflowPath) {
+        repoRoot = findRepoRoot(workflowPath);
+    }
+    if (!repoRoot) {
+        repoRoot = execSync(`git rev-parse --show-toplevel`).toString().trim();
+    }
+    if (headSha && headSha !== "HEAD") {
+        // Specific SHA requested — use git archive (clean snapshot)
+        execSync(`git archive ${headSha} | tar -x -C ${workspaceDir}`, {
+            stdio: "pipe",
+            cwd: repoRoot,
+        });
+    }
+    else {
+        // Default: copy the working directory as-is, including dirty/untracked files.
+        // Uses git ls-files to respect .gitignore (avoids copying node_modules, _/, etc.)
+        // On macOS: per-file APFS CoW clones. On Linux: rsync. Fallback: fs.cpSync.
+        copyWorkspace(repoRoot, workspaceDir);
+    }
+    initFakeGitRepo(workspaceDir, githubRepo || config.GITHUB_REPO);
+}
+// ─── Fake git init ────────────────────────────────────────────────────────────
+/**
+ * Initialise a fake git repository in `dir` so that `actions/checkout`
+ * finds a valid workspace with a remote origin and detached HEAD.
+ */
+export function initFakeGitRepo(dir, githubRepo) {
+    // The remote URL must exactly match what actions/checkout computes via URL.origin.
+    // Node.js URL.origin strips the default port (80), so we must NOT include :80.
+    execSync(`git init`, { cwd: dir, stdio: "pipe" });
+    execSync(`git config user.name "agent-ci"`, { cwd: dir, stdio: "pipe" });
+    execSync(`git config user.email "agent-ci@example.com"`, {
+        cwd: dir,
+        stdio: "pipe",
+    });
+    execSync(`git remote add origin http://127.0.0.1/${githubRepo}`, {
+        cwd: dir,
+        stdio: "pipe",
+    });
+    execSync(`git add . && git commit -m "workspace" || true`, {
+        cwd: dir,
+        stdio: "pipe",
+    });
+    // Create main and refs/remotes/origin/main pointing to this commit
+    execSync(`git branch -M main`, { cwd: dir, stdio: "pipe" });
+    execSync(`git update-ref refs/remotes/origin/main HEAD`, {
+        cwd: dir,
+        stdio: "pipe",
+    });
+    // Detach HEAD so checkout can freely delete ALL branches (it can't delete the current branch)
+    execSync(`git checkout --detach HEAD`, { cwd: dir, stdio: "pipe" });
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/workflow/job-scheduler.js

@@ -0,0 +1,62 @@
+import fs from "node:fs";
+import { parse as parseYaml } from "yaml";
+/**
+ * Parse job `needs:` dependencies from raw workflow YAML.
+ * Returns a Map<jobId, string[]> of upstream job IDs each job depends on.
+ */
+export function parseJobDependencies(workflowPath) {
+    const deps = new Map();
+    try {
+        const yaml = parseYaml(fs.readFileSync(workflowPath, "utf-8"));
+        const jobs = yaml?.jobs ?? {};
+        for (const [jobId, jobDef] of Object.entries(jobs)) {
+            const needs = jobDef?.needs;
+            if (!needs) {
+                deps.set(jobId, []);
+            }
+            else if (typeof needs === "string") {
+                deps.set(jobId, [needs]);
+            }
+            else if (Array.isArray(needs)) {
+                deps.set(jobId, needs.map(String));
+            }
+            else {
+                deps.set(jobId, []);
+            }
+        }
+    }
+    catch {
+        // Can't parse — return empty deps
+    }
+    return deps;
+}
+/**
+ * Topological sort of job IDs by their dependencies.
+ * Returns an array of waves; each wave is a set of job IDs that can run in parallel.
+ * Falls back to a single wave containing all remaining jobs if a cycle is detected.
+ */
+export function topoSort(deps) {
+    const waves = [];
+    const remaining = new Map(deps);
+    const completed = new Set();
+    while (remaining.size > 0) {
+        // Find jobs whose all dependencies are already completed
+        const wave = [];
+        for (const [jobId, needs] of remaining) {
+            if (needs.every((n) => completed.has(n))) {
+                wave.push(jobId);
+            }
+        }
+        if (wave.length === 0) {
+            // Cycle detected or unresolvable dependency — run remaining in one wave
+            waves.push(Array.from(remaining.keys()));
+            break;
+        }
+        for (const jobId of wave) {
+            remaining.delete(jobId);
+            completed.add(jobId);
+        }
+        waves.push(wave);
+    }
+    return waves;
+}

package/dist/workflow/job-scheduler.test.js

@@ -0,0 +1,130 @@
+import { describe, it, expect } from "vitest";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { parseJobDependencies, topoSort } from "./job-scheduler.js";
+describe("parseJobDependencies", () => {
+    let tmpDir;
+    function writeWorkflow(content) {
+        const filePath = path.join(tmpDir, "workflow.yml");
+        fs.writeFileSync(filePath, content, "utf-8");
+        return filePath;
+    }
+    it("returns empty deps for jobs without needs", () => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sched-test-"));
+        const wf = writeWorkflow(`
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - run: echo hello
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - run: echo world
+`);
+        const deps = parseJobDependencies(wf);
+        expect(deps.get("build")).toEqual([]);
+        expect(deps.get("test")).toEqual([]);
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it("parses string needs", () => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sched-test-"));
+        const wf = writeWorkflow(`
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - run: echo build
+  test:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - run: echo test
+`);
+        const deps = parseJobDependencies(wf);
+        expect(deps.get("build")).toEqual([]);
+        expect(deps.get("test")).toEqual(["build"]);
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it("parses array needs", () => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sched-test-"));
+        const wf = writeWorkflow(`
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - run: echo build
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - run: echo lint
+  deploy:
+    needs: [build, lint]
+    runs-on: ubuntu-latest
+    steps:
+      - run: echo deploy
+`);
+        const deps = parseJobDependencies(wf);
+        expect(deps.get("build")).toEqual([]);
+        expect(deps.get("lint")).toEqual([]);
+        expect(deps.get("deploy")).toEqual(["build", "lint"]);
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it("returns empty map for non-existent file", () => {
+        const deps = parseJobDependencies("/tmp/nonexistent.yml");
+        expect(deps.size).toBe(0);
+    });
+});
+describe("topoSort", () => {
+    it("puts all independent jobs in one wave", () => {
+        const deps = new Map([
+            ["a", []],
+            ["b", []],
+            ["c", []],
+        ]);
+        const waves = topoSort(deps);
+        expect(waves).toEqual([["a", "b", "c"]]);
+    });
+    it("creates two waves for a simple dependency chain", () => {
+        const deps = new Map([
+            ["build", []],
+            ["test", ["build"]],
+        ]);
+        const waves = topoSort(deps);
+        expect(waves).toEqual([["build"], ["test"]]);
+    });
+    it("creates correct waves for mixed dependencies", () => {
+        const deps = new Map([
+            ["build", []],
+            ["lint", []],
+            ["test", ["build"]],
+            ["deploy", ["build", "lint"]],
+        ]);
+        const waves = topoSort(deps);
+        // Wave 1: build, lint (no deps)
+        // Wave 2: test, deploy (all deps in wave 1)
+        expect(waves[0]).toEqual(expect.arrayContaining(["build", "lint"]));
+        expect(waves[1]).toEqual(expect.arrayContaining(["test", "deploy"]));
+        expect(waves.length).toBe(2);
+    });
+    it("creates three waves for a chain: build -> test -> deploy", () => {
+        const deps = new Map([
+            ["build", []],
+            ["test", ["build"]],
+            ["deploy", ["test"]],
+        ]);
+        const waves = topoSort(deps);
+        expect(waves).toEqual([["build"], ["test"], ["deploy"]]);
+    });
+    it("handles cycles gracefully by dumping remaining into one wave", () => {
+        const deps = new Map([
+            ["a", ["b"]],
+            ["b", ["a"]],
+        ]);
+        const waves = topoSort(deps);
+        // Should still produce output (fallback to one wave)
+        expect(waves.length).toBe(1);
+        expect(waves[0]).toEqual(expect.arrayContaining(["a", "b"]));
+    });
+});