Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

extensions/activity/__tests__/runtime.test.ts

Raw
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");
	});
});