@redwoodjs/agent-ci 0.1.0

package/dist/docker/service-containers.test.js

@@ -0,0 +1,236 @@
+import { describe, it, expect, vi } from "vitest";
+import { startServiceContainers, cleanupServiceContainers, parseHealthCheck, } from "./service-containers.js";
+// ─── Mock Docker client ───────────────────────────────────────────────────────
+function makeMockContainer(id, healthStatus) {
+    return {
+        id,
+        start: vi.fn().mockResolvedValue(undefined),
+        stop: vi.fn().mockResolvedValue(undefined),
+        remove: vi.fn().mockResolvedValue(undefined),
+        inspect: vi.fn().mockResolvedValue({
+            State: {
+                Running: true,
+                Health: healthStatus ? { Status: healthStatus } : undefined,
+            },
+        }),
+    };
+}
+function makeMockDocker(opts) {
+    const containers = new Map();
+    let containerCounter = 0;
+    const mockDocker = {
+        createNetwork: vi.fn().mockResolvedValue({ id: "net-123" }),
+        createContainer: vi.fn().mockImplementation((config) => {
+            containerCounter++;
+            const id = `container-${containerCounter}`;
+            const c = makeMockContainer(id, opts?.healthStatus);
+            containers.set(config.name || id, c);
+            return Promise.resolve(c);
+        }),
+        getContainer: vi.fn().mockImplementation((nameOrId) => {
+            const existing = containers.get(nameOrId);
+            if (existing) {
+                return existing;
+            }
+            return {
+                remove: vi.fn().mockRejectedValue(new Error("not found")),
+                stop: vi.fn().mockRejectedValue(new Error("not found")),
+                inspect: vi.fn().mockResolvedValue({
+                    State: {
+                        Running: true,
+                        Health: opts?.healthStatus ? { Status: opts.healthStatus } : undefined,
+                    },
+                }),
+            };
+        }),
+        getImage: vi.fn().mockReturnValue({
+            inspect: vi.fn().mockResolvedValue({}),
+        }),
+        getNetwork: vi.fn().mockReturnValue({
+            remove: vi.fn().mockResolvedValue(undefined),
+        }),
+        pull: vi.fn(),
+        modem: { followProgress: vi.fn() },
+        _containers: containers,
+    };
+    return mockDocker;
+}
+// ─── parseHealthCheck ─────────────────────────────────────────────────────────
+describe("parseHealthCheck", () => {
+    it("parses all health-check flags from options string", () => {
+        const options = `--health-cmd="mysqladmin ping -h localhost -proot" --health-interval=5s --health-timeout=3s --health-retries=10`;
+        const result = parseHealthCheck(options);
+        expect(result).toBeDefined();
+        expect(result.Test).toEqual(["CMD-SHELL", "mysqladmin ping -h localhost -proot"]);
+        expect(result.Interval).toBe(5000000000);
+        expect(result.Timeout).toBe(3000000000);
+        expect(result.Retries).toBe(10);
+    });
+    it("uses defaults when interval/timeout/retries are missing", () => {
+        const options = `--health-cmd="curl -f http://localhost/"`;
+        const result = parseHealthCheck(options);
+        expect(result).toBeDefined();
+        expect(result.Interval).toBe(10000000000);
+        expect(result.Timeout).toBe(5000000000);
+        expect(result.Retries).toBe(3);
+    });
+    it("returns undefined when no --health-cmd is present", () => {
+        expect(parseHealthCheck("--some-other-flag")).toBeUndefined();
+    });
+    it("returns undefined for empty string", () => {
+        expect(parseHealthCheck("")).toBeUndefined();
+    });
+});
+// ─── startServiceContainers ───────────────────────────────────────────────────
+describe("startServiceContainers", () => {
+    const MYSQL_SERVICE = {
+        name: "mysql",
+        image: "mysql:8.0",
+        env: { MYSQL_ROOT_PASSWORD: "root", MYSQL_DATABASE: "test_db" },
+        ports: ["3306:3306"],
+        options: `--health-cmd="mysqladmin ping" --health-interval=5s --health-timeout=3s --health-retries=10`,
+    };
+    const REDIS_SERVICE = {
+        name: "redis",
+        image: "redis:7",
+        ports: ["6379:6379"],
+    };
+    it("creates a Docker network with agent-ci-net- prefix", async () => {
+        const docker = makeMockDocker({ healthStatus: "healthy" });
+        await startServiceContainers(docker, [REDIS_SERVICE], "agent-ci-42");
+        expect(docker.createNetwork).toHaveBeenCalledWith({
+            Name: "agent-ci-net-agent-ci-42",
+            Driver: "bridge",
+        });
+    });
+    it("creates containers for each service on the shared network", async () => {
+        const docker = makeMockDocker({ healthStatus: "healthy" });
+        await startServiceContainers(docker, [MYSQL_SERVICE, REDIS_SERVICE], "agent-ci-42");
+        expect(docker.createContainer).toHaveBeenCalledTimes(2);
+        const mysqlCall = docker.createContainer.mock.calls[0][0];
+        expect(mysqlCall.Image).toBe("mysql:8.0");
+        expect(mysqlCall.name).toBe("agent-ci-42-svc-mysql");
+        expect(mysqlCall.Env).toContain("MYSQL_ROOT_PASSWORD=root");
+        expect(mysqlCall.Env).toContain("MYSQL_DATABASE=test_db");
+        expect(mysqlCall.HostConfig.NetworkMode).toBe("agent-ci-net-agent-ci-42");
+        expect(mysqlCall.HostConfig.PortBindings).toEqual({ "3306/tcp": [{ HostPort: "3306" }] });
+        expect(mysqlCall.NetworkingConfig.EndpointsConfig["agent-ci-net-agent-ci-42"].Aliases).toContain("mysql");
+        const redisCall = docker.createContainer.mock.calls[1][0];
+        expect(redisCall.Image).toBe("redis:7");
+        expect(redisCall.name).toBe("agent-ci-42-svc-redis");
+        expect(redisCall.NetworkingConfig.EndpointsConfig["agent-ci-net-agent-ci-42"].Aliases).toContain("redis");
+    });
+    it("starts all created containers", async () => {
+        const docker = makeMockDocker({ healthStatus: "healthy" });
+        await startServiceContainers(docker, [MYSQL_SERVICE, REDIS_SERVICE], "agent-ci-42");
+        for (const [, container] of docker._containers) {
+            expect(container.start).toHaveBeenCalledTimes(1);
+        }
+    });
+    it("returns the correct ServiceContext", async () => {
+        const docker = makeMockDocker({ healthStatus: "healthy" });
+        const ctx = await startServiceContainers(docker, [MYSQL_SERVICE, REDIS_SERVICE], "agent-ci-42");
+        expect(ctx.networkName).toBe("agent-ci-net-agent-ci-42");
+        expect(ctx.containerIds).toHaveLength(2);
+        expect(ctx.containerIds[0]).toBe("container-1");
+        expect(ctx.containerIds[1]).toBe("container-2");
+    });
+    it("generates port-forward commands for each port mapping", async () => {
+        const docker = makeMockDocker({ healthStatus: "healthy" });
+        const ctx = await startServiceContainers(docker, [MYSQL_SERVICE, REDIS_SERVICE], "agent-ci-42");
+        expect(ctx.portForwards).toHaveLength(2);
+        expect(ctx.portForwards[0]).toContain("agent-ci-42-svc-mysql");
+        expect(ctx.portForwards[0]).toContain("3306");
+        expect(ctx.portForwards[1]).toContain("agent-ci-42-svc-redis");
+        expect(ctx.portForwards[1]).toContain("6379");
+    });
+    it("applies health-check config from options string", async () => {
+        const docker = makeMockDocker({ healthStatus: "healthy" });
+        await startServiceContainers(docker, [MYSQL_SERVICE], "agent-ci-42");
+        const call = docker.createContainer.mock.calls[0][0];
+        expect(call.Healthcheck).toBeDefined();
+        expect(call.Healthcheck.Test).toEqual(["CMD-SHELL", "mysqladmin ping"]);
+        expect(call.Healthcheck.Retries).toBe(10);
+    });
+    it("does not set Healthcheck when options are absent", async () => {
+        const docker = makeMockDocker();
+        await startServiceContainers(docker, [REDIS_SERVICE], "agent-ci-42");
+        const call = docker.createContainer.mock.calls[0][0];
+        expect(call.Healthcheck).toBeUndefined();
+    });
+    it("handles service with no ports (no port forwards generated)", async () => {
+        const docker = makeMockDocker();
+        const svc = { name: "memcached", image: "memcached:latest" };
+        const ctx = await startServiceContainers(docker, [svc], "agent-ci-42");
+        expect(ctx.portForwards).toHaveLength(0);
+    });
+    it("pre-cleans stale containers with the same name", async () => {
+        const docker = makeMockDocker();
+        await startServiceContainers(docker, [REDIS_SERVICE], "agent-ci-42");
+        expect(docker.getContainer).toHaveBeenCalledWith("agent-ci-42-svc-redis");
+    });
+    it("calls emit with progress messages", async () => {
+        const docker = makeMockDocker({ healthStatus: "healthy" });
+        const lines = [];
+        await startServiceContainers(docker, [MYSQL_SERVICE], "agent-ci-42", (l) => lines.push(l));
+        expect(lines.some((l) => l.includes("Created network"))).toBe(true);
+        expect(lines.some((l) => l.includes("Starting service: mysql"))).toBe(true);
+        expect(lines.some((l) => l.includes("mysql started"))).toBe(true);
+        expect(lines.some((l) => l.includes("Waiting for mysql to become healthy"))).toBe(true);
+        expect(lines.some((l) => l.includes("mysql healthy in"))).toBe(true);
+    });
+    it("sets short service name as a Docker network alias so DB_HOST=mysql resolves", async () => {
+        // Regression: container was named agent-ci-N-svc-mysql but DB_HOST=mysql couldn't resolve.
+        const docker = makeMockDocker({ healthStatus: "healthy" });
+        await startServiceContainers(docker, [MYSQL_SERVICE], "agent-ci-99");
+        const call = docker.createContainer.mock.calls[0][0];
+        const networkName = "agent-ci-net-agent-ci-99";
+        expect(call.NetworkingConfig.EndpointsConfig[networkName]).toBeDefined();
+        const aliases = call.NetworkingConfig.EndpointsConfig[networkName].Aliases;
+        expect(aliases).toContain("mysql");
+        expect(aliases).not.toContain("agent-ci-99-svc-mysql"); // full name is NOT the alias
+    });
+    it("aliases differ per service", async () => {
+        const docker = makeMockDocker({ healthStatus: "healthy" });
+        await startServiceContainers(docker, [MYSQL_SERVICE, REDIS_SERVICE], "agent-ci-42");
+        const networkName = "agent-ci-net-agent-ci-42";
+        const mysqlAliases = docker.createContainer.mock.calls[0][0].NetworkingConfig.EndpointsConfig[networkName].Aliases;
+        const redisAliases = docker.createContainer.mock.calls[1][0].NetworkingConfig.EndpointsConfig[networkName].Aliases;
+        expect(mysqlAliases).toContain("mysql");
+        expect(redisAliases).toContain("redis");
+        expect(mysqlAliases).not.toContain("redis");
+        expect(redisAliases).not.toContain("mysql");
+    });
+});
+// ─── cleanupServiceContainers ─────────────────────────────────────────────────
+describe("cleanupServiceContainers", () => {
+    it("stops and removes all containers, then removes the network", async () => {
+        const docker = makeMockDocker();
+        const ctx = {
+            networkName: "agent-ci-net-test",
+            containerIds: ["c1", "c2"],
+            portForwards: [],
+        };
+        await cleanupServiceContainers(docker, ctx);
+        expect(docker.getContainer).toHaveBeenCalledWith("c1");
+        expect(docker.getContainer).toHaveBeenCalledWith("c2");
+        expect(docker.getNetwork).toHaveBeenCalledWith("agent-ci-net-test");
+    });
+    it("doesn't throw if containers are already gone", async () => {
+        const docker = makeMockDocker();
+        const ctx = {
+            networkName: "agent-ci-net-gone",
+            containerIds: ["nonexistent"],
+            portForwards: [],
+        };
+        await expect(cleanupServiceContainers(docker, ctx)).resolves.toBeUndefined();
+    });
+    it("emits cleanup message", async () => {
+        const docker = makeMockDocker();
+        const ctx = { networkName: "agent-ci-net-test", containerIds: [], portForwards: [] };
+        const lines = [];
+        await cleanupServiceContainers(docker, ctx, (l) => lines.push(l));
+        expect(lines.some((l) => l.includes("Cleaned up"))).toBe(true);
+        expect(lines.some((l) => l.includes("agent-ci-net-test"))).toBe(true);
+    });
+});

package/dist/docker/shutdown.js

@@ -0,0 +1,120 @@
+import fs from "node:fs";
+import path from "node:path";
+import { execSync } from "node:child_process";
+// ─── Docker container cleanup ─────────────────────────────────────────────────
+/**
+ * Force-kill a specific runner and its associated service containers + network.
+ * Used when stopping a single workflow run.
+ */
+export function killRunnerContainers(runnerName) {
+    // 1. Force-remove the runner container itself
+    try {
+        execSync(`docker rm -f ${runnerName}`, {
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+    }
+    catch {
+        // already gone
+    }
+    // 2. Force-remove any svc-* sidecars for this runner
+    try {
+        const ids = execSync(`docker ps -aq --filter "name=${runnerName}-svc-"`, {
+            encoding: "utf8",
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+        if (ids) {
+            execSync(`docker rm -f ${ids.split("\n").join(" ")}`, {
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+        }
+    }
+    catch {
+        // no sidecars or Docker not reachable
+    }
+    // 3. Remove the shared bridge network
+    try {
+        execSync(`docker network rm agent-ci-net-${runnerName}`, {
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+    }
+    catch {
+        // network doesn't exist or already removed
+    }
+}
+/**
+ * Remove orphaned Docker resources left behind by previous runs:
+ *   1. `agent-ci-net-*` networks with no connected containers
+ *   2. Dangling volumes (anonymous volumes from service containers like MySQL)
+ *
+ * Call this proactively before creating new resources to prevent Docker from
+ * exhausting its address pool ("all predefined address pools have been fully subnetted").
+ */
+export function pruneOrphanedDockerResources() {
+    // 1. Remove orphaned agent-ci-net-* networks
+    try {
+        const nets = execSync(`docker network ls -q --filter "name=agent-ci-net-"`, {
+            encoding: "utf8",
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+        if (nets) {
+            for (const netId of nets.split("\n")) {
+                try {
+                    // docker network rm fails if containers are still attached — that's fine,
+                    // we only want to remove truly orphaned networks.
+                    execSync(`docker network rm ${netId}`, {
+                        stdio: ["pipe", "pipe", "pipe"],
+                    });
+                }
+                catch {
+                    // Network still in use — skip
+                }
+            }
+        }
+    }
+    catch {
+        // Docker not reachable — skip
+    }
+    // 2. Remove dangling volumes (anonymous volumes from service containers)
+    try {
+        execSync(`docker volume prune -f`, {
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+    }
+    catch {
+        // Docker not reachable — skip
+    }
+}
+// ─── Workspace pruning ────────────────────────────────────────────────────────
+/**
+ * Remove stale `agent-ci-*` run directories older than `maxAgeMs` from
+ * `<workDir>/runs/`. Each run dir contains logs, work, shims, and diag
+ * co-located, so a single rm removes everything for that run.
+ *
+ * Returns an array of directory names that were pruned.
+ */
+export function pruneStaleWorkspaces(workDir, maxAgeMs) {
+    const runsPath = path.join(workDir, "runs");
+    if (!fs.existsSync(runsPath)) {
+        return [];
+    }
+    const now = Date.now();
+    const pruned = [];
+    for (const entry of fs.readdirSync(runsPath, { withFileTypes: true })) {
+        if (!entry.isDirectory() || !entry.name.startsWith("agent-ci-")) {
+            continue;
+        }
+        const dirPath = path.join(runsPath, entry.name);
+        try {
+            const stat = fs.statSync(dirPath);
+            const ageMs = now - stat.mtimeMs;
+            if (ageMs > maxAgeMs) {
+                fs.rmSync(dirPath, { recursive: true, force: true });
+                pruned.push(entry.name);
+            }
+        }
+        catch {
+            // Skip dirs we can't stat
+        }
+    }
+    return pruned;
+}

package/dist/docker/shutdown.test.js

@@ -0,0 +1,148 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+// ── Signal handling cleanup ───────────────────────────────────────────────────
+describe("Signal handler cleanup", () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "agent-ci-signal-test-"));
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it("cleanup function removes all temp directories", () => {
+        // With the new layout, work/shims/diag are co-located under runs/<runnerName>/
+        const runDir = path.join(tmpDir, "runs", "agent-ci-sig");
+        const dirs = {
+            containerWorkDir: path.join(runDir, "work"),
+            workspaceDir: path.join(runDir, "work", "workspace"),
+            shimsDir: path.join(runDir, "shims"),
+            diagDir: path.join(runDir, "diag"),
+        };
+        for (const d of Object.values(dirs)) {
+            fs.mkdirSync(d, { recursive: true });
+            fs.writeFileSync(path.join(d, "test.txt"), "data");
+        }
+        // Simulate signal handler cleanup — just remove the entire runDir
+        try {
+            fs.rmSync(runDir, { recursive: true, force: true });
+        }
+        catch { }
+        for (const d of Object.values(dirs)) {
+            expect(fs.existsSync(d)).toBe(false);
+        }
+    });
+    it("cleanup function is idempotent (handles missing dirs)", () => {
+        const dirs = [path.join(tmpDir, "nonexistent-1"), path.join(tmpDir, "nonexistent-2")];
+        // Should not throw
+        for (const d of dirs) {
+            try {
+                fs.rmSync(d, { recursive: true, force: true });
+            }
+            catch { }
+        }
+        // If we got here, idempotency works
+        expect(true).toBe(true);
+    });
+});
+// ── Stale workspace pruning ───────────────────────────────────────────────────
+describe("Stale workspace pruning", () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "agent-ci-prune-test-"));
+        // pruneStaleWorkspaces scans <workDir>/runs/
+        fs.mkdirSync(path.join(tmpDir, "runs"), { recursive: true });
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it("removes agent-ci-* dirs older than maxAge", async () => {
+        // Create a stale run dir — the entire runDir is removed (includes logs, work, shims, diag)
+        const staleDir = path.join(tmpDir, "runs", "agent-ci-100");
+        fs.mkdirSync(path.join(staleDir, "logs"), { recursive: true });
+        fs.writeFileSync(path.join(staleDir, "logs", "output.log"), "stale");
+        // Backdate it to 48 hours ago
+        const oldTime = new Date(Date.now() - 48 * 60 * 60 * 1000);
+        fs.utimesSync(staleDir, oldTime, oldTime);
+        const { pruneStaleWorkspaces } = await import("./shutdown.js");
+        const pruned = pruneStaleWorkspaces(tmpDir, 24 * 60 * 60 * 1000);
+        expect(pruned).toContain("agent-ci-100");
+        expect(fs.existsSync(staleDir)).toBe(false);
+    });
+    it("keeps agent-ci-* dirs newer than maxAge", async () => {
+        // Create a fresh run dir
+        const freshDir = path.join(tmpDir, "runs", "agent-ci-200");
+        fs.mkdirSync(path.join(freshDir, "logs"), { recursive: true });
+        fs.writeFileSync(path.join(freshDir, "logs", "output.log"), "fresh");
+        const { pruneStaleWorkspaces } = await import("./shutdown.js");
+        const pruned = pruneStaleWorkspaces(tmpDir, 24 * 60 * 60 * 1000);
+        expect(pruned).toEqual([]);
+        expect(fs.existsSync(freshDir)).toBe(true);
+    });
+    it("ignores non-agent-ci dirs", async () => {
+        const otherDir = path.join(tmpDir, "runs", "workspace-12345");
+        fs.mkdirSync(otherDir, { recursive: true });
+        // Backdate it
+        const oldTime = new Date(Date.now() - 48 * 60 * 60 * 1000);
+        fs.utimesSync(otherDir, oldTime, oldTime);
+        const { pruneStaleWorkspaces } = await import("./shutdown.js");
+        const pruned = pruneStaleWorkspaces(tmpDir, 24 * 60 * 60 * 1000);
+        expect(pruned).toEqual([]);
+        expect(fs.existsSync(otherDir)).toBe(true);
+    });
+});
+describe("containerWorkDir cleanup on exit", () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "agent-ci-cleanup-test-"));
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it("cleans entire runDir on success", () => {
+        // New layout: work/shims/diag are all under runs/<runnerName>/
+        const runDir = path.join(tmpDir, "runs", "agent-ci-1");
+        const containerWorkDir = path.join(runDir, "work");
+        const shimsDir = path.join(runDir, "shims");
+        const diagDir = path.join(runDir, "diag");
+        const logDir = path.join(runDir, "logs");
+        // Create all dirs
+        for (const d of [containerWorkDir, shimsDir, diagDir, logDir]) {
+            fs.mkdirSync(d, { recursive: true });
+            fs.writeFileSync(path.join(d, "test.txt"), "data");
+        }
+        const jobSucceeded = true;
+        // On success: clean the entire runDir (logs kept via archiving externally)
+        if (jobSucceeded && fs.existsSync(runDir)) {
+            fs.rmSync(runDir, { recursive: true, force: true });
+        }
+        expect(fs.existsSync(runDir)).toBe(false);
+        expect(fs.existsSync(containerWorkDir)).toBe(false);
+        expect(fs.existsSync(shimsDir)).toBe(false);
+        expect(fs.existsSync(diagDir)).toBe(false);
+    });
+    it("retains runDir on failure for debugging", () => {
+        const runDir = path.join(tmpDir, "runs", "agent-ci-2");
+        const containerWorkDir = path.join(runDir, "work");
+        const shimsDir = path.join(runDir, "shims");
+        const diagDir = path.join(runDir, "diag");
+        const logDir = path.join(runDir, "logs");
+        for (const d of [containerWorkDir, shimsDir, diagDir, logDir]) {
+            fs.mkdirSync(d, { recursive: true });
+            fs.writeFileSync(path.join(d, "test.txt"), "data");
+        }
+        const jobSucceeded = false;
+        // On failure: keep runDir so the developer can inspect work/, shims/, diag/, logs/
+        if (jobSucceeded && fs.existsSync(runDir)) {
+            fs.rmSync(runDir, { recursive: true, force: true });
+        }
+        // runDir should be RETAINED
+        expect(fs.existsSync(runDir)).toBe(true);
+        expect(fs.readFileSync(path.join(containerWorkDir, "test.txt"), "utf-8")).toBe("data");
+        // All subdirs retained
+        expect(fs.existsSync(containerWorkDir)).toBe(true);
+        expect(fs.existsSync(shimsDir)).toBe(true);
+        expect(fs.existsSync(diagDir)).toBe(true);
+    });
+});

package/dist/output/agent-mode.js

@@ -0,0 +1,7 @@
+let quietFlag = false;
+export function setQuietMode(value) {
+    quietFlag = value;
+}
+export function isAgentMode() {
+    return quietFlag || process.env.AI_AGENT === "1";
+}

package/dist/output/agent-mode.test.js

@@ -0,0 +1,36 @@
+import { describe, it, expect, afterEach } from "vitest";
+import { isAgentMode, setQuietMode } from "./agent-mode.js";
+describe("isAgentMode", () => {
+    const originalEnv = process.env.AI_AGENT;
+    afterEach(() => {
+        if (originalEnv === undefined) {
+            delete process.env.AI_AGENT;
+        }
+        else {
+            process.env.AI_AGENT = originalEnv;
+        }
+        setQuietMode(false);
+    });
+    it("returns true when AI_AGENT=1", () => {
+        process.env.AI_AGENT = "1";
+        expect(isAgentMode()).toBe(true);
+    });
+    it("returns false when AI_AGENT is unset", () => {
+        delete process.env.AI_AGENT;
+        expect(isAgentMode()).toBe(false);
+    });
+    it("returns false when AI_AGENT is something other than 1", () => {
+        process.env.AI_AGENT = "true";
+        expect(isAgentMode()).toBe(false);
+    });
+    it("returns true when --quiet flag is set", () => {
+        delete process.env.AI_AGENT;
+        setQuietMode(true);
+        expect(isAgentMode()).toBe(true);
+    });
+    it("returns true when both --quiet and AI_AGENT=1 are set", () => {
+        process.env.AI_AGENT = "1";
+        setQuietMode(true);
+        expect(isAgentMode()).toBe(true);
+    });
+});