import { mkdtemp, rm, writeFile } from "node:fs/promises"; import { tmpdir } from "node:os"; import { join } from "node:path"; import { afterEach, describe, expect, it, vi } from "vitest"; import { ActivityManager } from "../runtime.ts"; const managers: ActivityManager[] = []; function manager(): ActivityManager { const value = new ActivityManager(); managers.push(value); return value; } async function waitForCompletion( manager: ActivityManager, id: string, after: number, ) { for (let attempt = 0; attempt < 20; attempt++) { const snapshot = await manager.wait(id, after, 5000); if (snapshot.status !== "running" && snapshot.status !== "stopping") return snapshot; after = snapshot.sequence; } throw new Error(`Activity ${id} did not complete within 20 observations`); } afterEach(async () => { await Promise.all(managers.splice(0).map((value) => value.dispose())); }); describe("ActivityManager", () => { it.runIf(process.platform !== "win32")( "retains an unexpected Unix termination signal without inventing an exit code", async () => { const activities = manager(); const job = await activities.start( { kind: "process", command: process.execPath, args: ["-e", "process.kill(process.pid,'SIGTERM')"], }, process.cwd(), ); const done = await waitForCompletion(activities, job.id, job.sequence); expect(done.status).toBe("failed"); expect(done.exitCode).toBeNull(); expect(done.error).toContain("SIGTERM"); }, ); for (const exit of ["normal", "signal"] as const) it.runIf(process.platform !== "win32")( `refuses a stale Windows ${exit} leader PID while preserving Unix descendant cleanup`, async () => { const activities = manager(); const source = "const{spawn}=require('node:child_process');const c=spawn(process.execPath,['-e',\"process.stdout.write('GRANDCHILD_READY');setInterval(()=>{},1000)\"],{stdio:['ignore','inherit','inherit']});c.unref();" + (exit === "signal" ? "process.kill(process.pid,'SIGTERM');" : ""); const job = await activities.start( { kind: "process", command: process.execPath, args: ["-e", source] }, process.cwd(), ); await vi.waitFor( () => expect(activities.read(job.id).output).toContain( "GRANDCHILD_READY", ), { timeout: 3000 }, ); await vi.waitFor( () => expect(() => process.kill(job.pid ?? 0, 0)).toThrow(), { timeout: 3000 }, ); const platform = process.platform; try { // Policy simulation only; this is not Windows runtime verification. Object.defineProperty(process, "platform", { value: "win32" }); const unconfirmed = await activities.stop(job.id); expect(unconfirmed.status).toBe("stopping"); expect(unconfirmed.error).toContain("Skipped taskkill"); } finally { Object.defineProperty(process, "platform", { value: platform }); } await activities.stop(job.id); const done = await waitForCompletion(activities, job.id, 0); expect(done.status).toBe("stopped"); expect(done.error).toBeUndefined(); }, ); it.runIf(process.platform === "win32")( "stops a finite real process descendant with taskkill", async () => { const activities = manager(); const source = "const{spawn}=require('node:child_process');const c=spawn(process.execPath,['-e','setTimeout(()=>process.exit(0),5000)'],{stdio:'ignore'});process.stdout.write(`DESCENDANT:${c.pid}`);setTimeout(()=>process.exit(0),5000);"; const began = performance.now(); const started = await activities.start( { kind: "process", command: process.execPath, args: ["-e", source] }, process.cwd(), ); await vi.waitFor( () => expect(activities.read(started.id).output).toContain("DESCENDANT:"), { timeout: 3000 }, ); const descendant = Number( activities.read(started.id).output?.match(/DESCENDANT:(\d+)/)?.[1], ); expect(descendant).toBeGreaterThan(0); await activities.stop(started.id); const finished = await waitForCompletion(activities, started.id, 0); expect(performance.now() - began).toBeLessThan(4000); expect(finished.status).toBe("stopped"); await vi.waitFor( () => expect(() => process.kill(descendant, 0)).toThrow(), { timeout: 3000, }, ); }, ); for (const action of ["stop", "timeout", "dispose"] as const) it.runIf(process.platform === "win32")( `terminates a native terminal tree on ${action}`, async () => { const activities = manager(); const began = performance.now(); const source = "const{spawn}=require('node:child_process');const c=spawn(process.execPath,['-e','setTimeout(()=>process.exit(0),8000)'],{stdio:'ignore'});process.stdout.write('OWNED_PIDS:'+process.pid+','+c.pid);setTimeout(()=>process.exit(0),8000);"; const started = await activities.start( { kind: "terminal", command: "node", args: ["-e", source], timeoutMs: action === "timeout" ? 1500 : 10000, }, process.cwd(), ); await vi.waitFor( () => expect(activities.read(started.id).output).toMatch( /OWNED_PIDS:\d+,\d+/, ), { timeout: 3000 }, ); const pids = activities .read(started.id) .output?.match(/OWNED_PIDS:(\d+),(\d+)/) ?.slice(1) .map(Number); expect(pids).toHaveLength(2); expect(activities.read(started.id).pid).toBe(pids?.[0]); if (action === "stop") await activities.stop(started.id); if (action === "dispose") await activities.dispose(); else expect( (await waitForCompletion(activities, started.id, 0)).status, ).toBe("stopped"); for (const pid of pids ?? []) await vi.waitFor(() => expect(() => process.kill(pid, 0)).toThrow(), { timeout: 3000, }); expect(performance.now() - began).toBeLessThan(6000); }, ); it.runIf(process.platform === "win32")( "stops a quiet terminal immediately after opening", async () => { const activities = manager(); const started = await activities.start( { kind: "terminal", command: "node", args: ["-e", "setTimeout(()=>process.exit(0),8000)"], }, process.cwd(), ); await activities.stop(started.id); expect((await waitForCompletion(activities, started.id, 0)).status).toBe( "stopped", ); }, ); it("watches literal output across chunks and optionally stops the owned command", async () => { const activities = manager(); const job = await activities.start( { kind: "process", command: process.execPath, args: [ "-e", "process.stdout.write('RE');setTimeout(()=>process.stdout.write('ADY'),50);setInterval(()=>{},1000)", ], match: "READY", stopOnMatch: true, }, process.cwd(), ); const done = await waitForCompletion(activities, job.id, job.sequence); expect(done.status).toBe("stopped"); expect(done.events?.filter((event) => event.type === "match")).toHaveLength( 1, ); expect(done.output).toContain("ADY"); }); it("keeps output bounded and UTF-8 complete after a large burst and tiny suffix", async () => { const activities = manager(); const started = await activities.start( { kind: "process", command: process.execPath, args: [ "-e", "process.stdout.write('😀'.repeat(25000));setTimeout(()=>process.stdout.write('TAIL_OK'),30)", ], }, process.cwd(), ); const done = await waitForCompletion( activities, started.id, started.sequence, ); expect(Buffer.byteLength(done.output ?? "")).toBeLessThanOrEqual(16384); expect(done.output).toContain("TAIL_OK"); expect(done.output).not.toContain("\u0000"); expect(done.output).not.toContain("�"); expect(done.outputTruncated).toBe(true); }); it("retains only bounded completed metadata and uses distinct owner ids", async () => { const activities = manager(); for (let i = 0; i < 36; i++) { const job = await activities.start( { kind: "timer", delayMs: 10 }, process.cwd(), ); await waitForCompletion(activities, job.id, job.sequence); } expect(activities.list()).toHaveLength(32); const a = await activities.start( { kind: "timer", delayMs: 1000 }, process.cwd(), ); const b = await manager().start( { kind: "timer", delayMs: 1000 }, process.cwd(), ); expect(a.id).not.toBe(b.id); }); it("keeps active work and unacknowledged failures in attention until acknowledged", async () => { const activities = manager(); const failed = await activities.start( { kind: "process", command: process.execPath, args: ["-e", "process.exit(3)"], }, process.cwd(), ); const done = await activities.start( { kind: "timer", delayMs: 10 }, process.cwd(), ); await waitForCompletion(activities, failed.id, failed.sequence); await waitForCompletion(activities, done.id, done.sequence); const running = await activities.start( { kind: "timer", delayMs: 60_000 }, process.cwd(), ); const ids = () => activities.attention().map(({ id }) => id); expect(ids().sort()).toEqual([failed.id, running.id].sort()); const listener = vi.fn(); activities.subscribe(listener); activities.acknowledge(running.id); activities.acknowledge("unknown"); expect(listener).not.toHaveBeenCalled(); activities.acknowledge(failed.id); activities.acknowledge(failed.id); expect(listener).toHaveBeenCalledOnce(); expect(ids()).toEqual([running.id]); expect(activities.read(failed.id).status).toBe("failed"); expect(activities.read(failed.id)).not.toHaveProperty("acknowledged"); await activities.stop(running.id); expect(ids()).toEqual([]); }); it("a timed-out wait never stops its activity", async () => { const activities = manager(); const job = await activities.start( { kind: "timer", delayMs: 1000 }, process.cwd(), ); const current = await activities.wait(job.id, job.sequence, 0); expect(current.status).toBe("running"); await activities.stop(job.id); expect(activities.read(job.id).status).toBe("stopped"); }); it("cleans up a terminal launch racing disposal", async () => { const activities = manager(); const starting = activities.start( { kind: "terminal", command: process.execPath, args: ["-e", "setInterval(()=>{},1000)"], }, process.cwd(), ); await activities.dispose(); const result = await starting; expect(result.status).not.toBe("running"); await expect( activities.start({ kind: "timer", delayMs: 10 }, process.cwd()), ).rejects.toThrow("disposed"); }); it("projects timer timing for UI without adding it to agent snapshots", async () => { vi.useFakeTimers(); vi.setSystemTime(0); const activities = manager(); try { const timer = await activities.start( { kind: "timer", delayMs: 1000, repeat: true }, process.cwd(), ); expect(activities.timerView(timer.id)).toEqual({ delayMs: 1000, repeat: true, nextAt: 1000, }); expect(activities.read(timer.id)).not.toHaveProperty("nextAt"); await vi.advanceTimersByTimeAsync(1000); expect(activities.timerView(timer.id)).toEqual({ delayMs: 1000, repeat: true, nextAt: 2000, }); await activities.stop(timer.id); } finally { await activities.dispose(); vi.useRealTimers(); } }); it("runs timers and waits for their terminal state", async () => { const activities = manager(); const started = await activities.start( { kind: "timer", delayMs: 10 }, process.cwd(), ); const finished = await waitForCompletion( activities, started.id, started.sequence, ); expect(finished.status).toBe("completed"); expect(finished.events?.some((event) => event.type === "tick")).toBe(true); }); it("coalesces native watch changes and closes watches", async () => { const root = await mkdtemp(join(tmpdir(), "pi-activity-")); try { const activities = manager(); const started = await activities.start( { kind: "watch", path: "." }, root, ); await writeFile(join(root, "changed.txt"), "changed"); const changed = await activities.wait(started.id, started.sequence, 5000); expect(changed.events?.some((event) => event.type === "change")).toBe( true, ); const stopped = await activities.stop(started.id); expect(stopped.status).toBe("stopped"); } finally { await rm(root, { recursive: true, force: true }); } }); it("captures Unicode output through close and preserves final sentinel", async () => { const activities = manager(); const started = await activities.start( { kind: "process", command: process.execPath, args: ["-e", "process.stdout.write('α😀 final-sentinel')"], }, process.cwd(), ); const finished = await waitForCompletion( activities, started.id, started.sequence, ); expect(finished.status).toBe("completed"); expect(finished.output).toContain("α😀 final-sentinel"); expect(finished.events?.at(-1)?.type).toBe("exit"); }); it("reports failed spawn without leaking an active slot", async () => { const activities = manager(); const failed = await activities.start( { kind: "process", command: "definitely-not-an-activity-command" }, process.cwd(), ); const result = await activities.wait(failed.id, failed.sequence, 5000); expect(result.status).toBe("failed"); expect(result.error).toBeTruthy(); const timer = await activities.start( { kind: "timer", delayMs: 10 }, process.cwd(), ); expect(timer.status).toBe("running"); }); it("enforces active limit under concurrent starts", async () => { const activities = manager(); const results = await Promise.allSettled( Array.from({ length: 9 }, () => activities.start({ kind: "timer", delayMs: 1_000 }, process.cwd()), ), ); expect( results.filter((result) => result.status === "fulfilled"), ).toHaveLength(8); expect( results.filter((result) => result.status === "rejected"), ).toHaveLength(1); }); it("rejects invalid runtime limits before reserving activities", async () => { const activities = manager(); await expect( activities.start({ kind: "timer", delayMs: 9 }, process.cwd()), ).rejects.toThrow("timer delay"); await expect( activities.start( { kind: "watch", path: ".", recursive: true }, process.cwd(), ), ).rejects.toThrow("watch path"); await expect( activities.start( { kind: "process", command: "x".repeat(4_097) }, process.cwd(), ), ).rejects.toThrow("command or arguments"); expect(activities.list()).toHaveLength(0); }); it("aborts waits and stops child process groups", async () => { const activities = manager(); const started = await activities.start( { kind: "process", command: process.execPath, args: ["-e", "setInterval(() => {}, 1000)"], }, process.cwd(), ); const abort = new AbortController(); const waiting = activities.wait( started.id, started.sequence, 5_000, abort.signal, ); abort.abort(); await expect(waiting).rejects.toMatchObject({ name: "AbortError" }); expect(activities.read(started.id).status).toBe("running"); await activities.stop(started.id); const finished = await waitForCompletion(activities, started.id, 0); expect(finished.status).toBe("stopped"); }); it("isolates concurrent timeout, abort, and event waiters", async () => { const activities = manager(); const job = await activities.start( { kind: "timer", delayMs: 1000 }, process.cwd(), ); const abort = new AbortController(); const timedOut = activities.wait(job.id, job.sequence, 0); const cancelled = activities.wait(job.id, job.sequence, 5000, abort.signal); const first = activities.wait(job.id, job.sequence, 5000); const second = activities.wait(job.id, job.sequence, 5000); expect((await timedOut).status).toBe("running"); abort.abort(); await expect(cancelled).rejects.toMatchObject({ name: "AbortError" }); expect(activities.read(job.id).status).toBe("running"); await activities.stop(job.id); const [a, b] = await Promise.all([first, second]); expect(a.sequence).toBeGreaterThan(job.sequence); expect(b.sequence).toBe(a.sequence); expect(a).not.toBe(b); a.title = "mutated snapshot"; expect(b.title).toBe(job.title); expect(activities.read(job.id).title).toBe(job.title); }); it("cleans pending waiters during disposal", async () => { const activities = manager(); const started = await activities.start( { kind: "timer", delayMs: 1_000 }, process.cwd(), ); const waiting = activities.wait(started.id, started.sequence, 5_000); await activities.dispose(); await expect(waiting).rejects.toThrow("manager disposed"); }); });