repositories / pi-ext
pi-ext
bugabingas pi extensions
owned by admin
extensions/activity/__tests__/runtime.test.ts
Rawimport { 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");
});
});