@selesai/code 0.2.1 → 0.3.1

package/dist/extensions/pi-subagents/test/unit/scheduled-runs.test.ts

@@ -0,0 +1,478 @@
+import assert from "node:assert/strict";
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { after, before, describe, it } from "node:test";
+import {
+	SCHEDULED_RUNS_DIR,
+	ScheduledRunManager,
+	createScheduledRunManager,
+	isScheduledRunAction,
+	parseScheduledRunTime,
+	scheduledRunStorePath,
+	scheduledRunsEnabled,
+} from "../../src/runs/background/scheduled-runs.ts";
+import type { ExtensionConfig } from "../../src/shared/types.ts";
+import type { ExtensionContext } from "@selesai/code";
+
+type TimerHandle = number;
+
+class FakeTimers {
+	readonly scheduled = new Map<TimerHandle, { cb: () => void; delay: number }>();
+	private nextHandle = 1;
+
+	setTimeout = (cb: () => void, delay: number): TimerHandle => {
+		const handle = this.nextHandle++;
+		this.scheduled.set(handle, { cb, delay });
+		return handle;
+	};
+
+	clearTimeout = (handle: TimerHandle): void => {
+		this.scheduled.delete(handle);
+	};
+
+	fireAll(): void {
+		// Snapshot first: fire() re-arms by clearing the fired handle and adding a new one.
+		const entries = [...this.scheduled.values()];
+		for (const entry of entries) entry.cb();
+	}
+
+	pendingCount(): number {
+		return this.scheduled.size;
+	}
+}
+
+type LaunchRecord = {
+	params: Record<string, unknown>;
+	ctx: ExtensionContext;
+	signal: AbortSignal;
+	resolve: (result: { content: Array<{ type: "text"; text: string }>; details: Record<string, unknown>; isError?: boolean }) => void;
+	promise: Promise<{ content: Array<{ type: "text"; text: string }>; details: Record<string, unknown>; isError?: boolean }>;
+};
+
+type TestHarness = {
+	manager: ScheduledRunManager;
+	timers: FakeTimers;
+	launches: LaunchRecord[];
+	clock: { now: number };
+	storeRoot: string;
+	ctx: ExtensionContext;
+};
+
+function makeCtx(cwd = "/project", sessionFile = "/sessions/abc.jsonl"): ExtensionContext {
+	return {
+		cwd,
+		sessionManager: {
+			getSessionFile: () => sessionFile,
+			getSessionId: () => path.basename(sessionFile, ".jsonl"),
+		},
+	} as unknown as ExtensionContext;
+}
+
+function makeConfig(overrides: Partial<ExtensionConfig["scheduledRuns"]> = {}): ExtensionConfig {
+	return { scheduledRuns: { enabled: true, ...overrides } };
+}
+
+async function flushMicrotasks(times = 10): Promise<void> {
+	for (let i = 0; i < times; i++) await Promise.resolve();
+}
+
+function createHarness(options: { config?: ExtensionConfig; storeRoot?: string; now?: number } = {}): TestHarness {
+	const timers = new FakeTimers();
+	const launches: LaunchRecord[] = [];
+	const clock = { now: options.now ?? 1_000_000 };
+	const storeRoot = options.storeRoot ?? fs.mkdtempSync(path.join(os.tmpdir(), "sched-test-"));
+	const manager = createScheduledRunManager({
+		config: options.config ?? makeConfig(),
+		storeRoot,
+		now: () => clock.now,
+		randomId: () => "id-" + randomUUID().slice(0, 4),
+		timers,
+		launch: (params, ctx, signal) => {
+			let resolve!: LaunchRecord["resolve"];
+			const promise = new Promise<{ content: Array<{ type: "text"; text: string }>; details: Record<string, unknown>; isError?: boolean }>((res) => {
+				resolve = res;
+			});
+			launches.push({ params: params as unknown as Record<string, unknown>, ctx, signal, resolve, promise });
+			return promise as ReturnType<TestHarness["manager"]["handleToolCall"]>;
+		},
+	});
+	const ctx = makeCtx();
+	return { manager, timers, launches, clock, storeRoot, ctx };
+}
+
+function extractId(result: { content: Array<{ type: "text"; text: string }> }): string {
+	const text = result.content[0]!.text;
+	const match = text.match(/Scheduled subagent run (id-[a-z0-9]+)/);
+	assert.ok(match, `expected scheduled run id in: ${text}`);
+	return match[1]!;
+}
+
+function isError(result: { isError?: boolean }): boolean {
+	return result.isError === true;
+}
+
+describe("scheduled-runs helpers", () => {
+	it("isScheduledRunAction narrows the four actions", () => {
+		assert.equal(isScheduledRunAction("schedule"), true);
+		assert.equal(isScheduledRunAction("schedule-cancel"), true);
+		assert.equal(isScheduledRunAction("status"), false);
+		assert.equal(isScheduledRunAction(undefined), false);
+	});
+
+	it("scheduledRunsEnabled is true only when explicitly enabled", () => {
+		assert.equal(scheduledRunsEnabled({}), false);
+		assert.equal(scheduledRunsEnabled({ scheduledRuns: {} }), false);
+		assert.equal(scheduledRunsEnabled({ scheduledRuns: { enabled: false } }), false);
+		assert.equal(scheduledRunsEnabled({ scheduledRuns: { enabled: true } }), true);
+	});
+
+	it("scheduledRunStorePath is stable per cwd+session and distinct otherwise", () => {
+		const root = path.join("tmp", "sched-root");
+		const project = path.join("project");
+		const other = path.join("other");
+		const a = scheduledRunStorePath(project, "sess1", root);
+		const aAgain = scheduledRunStorePath(project, "sess1", root);
+		const b = scheduledRunStorePath(project, "sess2", root);
+		const c = scheduledRunStorePath(other, "sess1", root);
+		assert.equal(a, aAgain);
+		assert.notEqual(a, b);
+		assert.notEqual(a, c);
+		assert.ok(a.startsWith(root));
+		assert.ok(a.endsWith(".json"));
+	});
+
+	it("parseScheduledRunTime handles relative delays and ISO timestamps", () => {
+		const base = 1_000_000;
+		assert.equal(parseScheduledRunTime("+10m", base), base + 10 * 60_000);
+		assert.equal(parseScheduledRunTime("+1h", base), base + 3_600_000);
+		assert.equal(parseScheduledRunTime("+2d", base), base + 2 * 86_400_000);
+		assert.equal(parseScheduledRunTime("+30s", base), base + 30_000);
+		assert.equal(parseScheduledRunTime("2030-01-01T00:00:00Z", base), new Date("2030-01-01T00:00:00Z").getTime());
+		assert.equal(parseScheduledRunTime("2030-01-01T09:00:00+05:30", base), new Date("2030-01-01T09:00:00+05:30").getTime());
+	});
+
+	it("parseScheduledRunTime rejects past, zero, malformed, and ambiguous schedules", () => {
+		assert.throws(() => parseScheduledRunTime("+0m", 1_000_000), /positive/);
+		assert.throws(() => parseScheduledRunTime("+9000000000000d", 1_000_000), /too large/);
+		assert.throws(() => parseScheduledRunTime("2020-01-01T00:00:00Z", Date.now() + 60_000), /in the past/);
+		assert.throws(() => parseScheduledRunTime("2030-01-01T00:00:00", 1_000_000), /must include a timezone/);
+		assert.throws(() => parseScheduledRunTime("2030-02-30T00:00:00Z", 1_000_000), /valid future ISO/);
+		assert.throws(() => parseScheduledRunTime("next tuesday", 1_000_000), /Invalid schedule/);
+		assert.throws(() => parseScheduledRunTime("+5w", 1_000_000), /Invalid schedule/);
+	});
+});
+
+describe("ScheduledRunManager create/list/status/cancel", () => {
+	let storeRoots: string[] = [];
+	after(() => {
+		for (const root of storeRoots) {
+			try {
+				fs.rmSync(root, { recursive: true, force: true });
+			} catch {
+				// best-effort cleanup of temp test dirs
+			}
+		}
+	});
+
+	function freshHarness(options: { config?: ExtensionConfig; now?: number } = {}): TestHarness {
+		const harness = createHarness(options);
+		storeRoots.push(harness.storeRoot);
+		return harness;
+	}
+
+	it("rejects schedule actions when the feature is disabled", async () => {
+		const harness = freshHarness({ config: makeConfig({ enabled: false }) });
+		const result = await harness.manager.handleToolCall({ action: "schedule", agent: "scout", task: "x", schedule: "+10m" }, harness.ctx);
+		assert.equal(isError(result), true);
+		assert.match(result.content[0]!.text, /disabled/);
+		assert.equal(harness.timers.pendingCount(), 0);
+	});
+
+	it("creates a scheduled job and arms a timer", async () => {
+		const harness = freshHarness();
+		const result = await harness.manager.handleToolCall({ action: "schedule", agent: "scout", task: "review later", schedule: "+10m", scheduleName: "nightly review" }, harness.ctx);
+		assert.equal(isError(result), false);
+		assert.match(result.content[0]!.text, /Scheduled subagent run id-/);
+		assert.match(result.content[0]!.text, /nightly review/);
+		assert.equal(harness.timers.pendingCount(), 1);
+		const list = await harness.manager.handleToolCall({ action: "schedule-list" }, harness.ctx);
+		assert.match(list.content[0]!.text, /nightly review/);
+	});
+
+	it("requires exactly one execution mode", async () => {
+		const harness = freshHarness();
+		// tasks + chain is genuinely ambiguous (both are execution arrays)
+		const chainAndTasks = await harness.manager.handleToolCall({ action: "schedule", tasks: [{ agent: "scout", task: "x" }], chain: [{ agent: "scout", task: "y" }], schedule: "+10m" }, harness.ctx);
+		assert.match(chainAndTasks.content[0]!.text, /exactly one execution mode/);
+		// no execution mode at all
+		const none = await harness.manager.handleToolCall({ action: "schedule", schedule: "+10m" }, harness.ctx);
+		assert.match(none.content[0]!.text, /exactly one execution mode/);
+	});
+
+	it("requires a schedule and rejects fork/async-false/clarify-true", async () => {
+		const harness = freshHarness();
+		const noSchedule = await harness.manager.handleToolCall({ action: "schedule", agent: "scout", task: "x" }, harness.ctx);
+		assert.match(noSchedule.content[0]!.text, /requires schedule/);
+		const fork = await harness.manager.handleToolCall({ action: "schedule", agent: "scout", task: "x", schedule: "+10m", context: "fork" }, harness.ctx);
+		assert.match(fork.content[0]!.text, /fresh context/);
+		const sync = await harness.manager.handleToolCall({ action: "schedule", agent: "scout", task: "x", schedule: "+10m", async: false }, harness.ctx);
+		assert.match(sync.content[0]!.text, /always async/);
+		const clarify = await harness.manager.handleToolCall({ action: "schedule", agent: "scout", task: "x", schedule: "+10m", clarify: true }, harness.ctx);
+		assert.match(clarify.content[0]!.text, /clarify/);
+	});
+
+	it("rejects a past schedule time", async () => {
+		const harness = freshHarness({ now: Date.now() + 60_000 });
+		const result = await harness.manager.handleToolCall({ action: "schedule", agent: "scout", task: "x", schedule: "2020-01-01T00:00:00Z" }, harness.ctx);
+		assert.match(result.content[0]!.text, /in the past/);
+	});
+
+	it("enforces maxPending", async () => {
+		const harness = freshHarness({ config: makeConfig({ maxPending: 1 }) });
+		const first = await harness.manager.handleToolCall({ action: "schedule", agent: "scout", task: "x", schedule: "+10m" }, harness.ctx);
+		assert.equal(isError(first), false);
+		const second = await harness.manager.handleToolCall({ action: "schedule", agent: "scout", task: "y", schedule: "+20m" }, harness.ctx);
+		assert.match(second.content[0]!.text, /limit reached/);
+	});
+
+	it("status resolves by exact id and prefix, and rejects ambiguous/missing", async () => {
+		const harness = freshHarness();
+		const created = await harness.manager.handleToolCall({ action: "schedule", agent: "scout", task: "x", schedule: "+10m" }, harness.ctx);
+		const id = extractId(created);
+		const status = await harness.manager.handleToolCall({ action: "schedule-status", id }, harness.ctx);
+		assert.match(status.content[0]!.text, /State: scheduled/);
+		assert.match(status.content[0]!.text, /Cancel: subagent/);
+		const byPrefix = await harness.manager.handleToolCall({ action: "schedule-status", id: id.slice(0, 4) }, harness.ctx);
+		assert.match(byPrefix.content[0]!.text, /State: scheduled/);
+		const missing = await harness.manager.handleToolCall({ action: "schedule-status", id: "nope" }, harness.ctx);
+		assert.match(missing.content[0]!.text, /not found/);
+		const noId = await harness.manager.handleToolCall({ action: "schedule-status" }, harness.ctx);
+		assert.match(noId.content[0]!.text, /requires id/);
+	});
+
+	it("cancel clears the timer and marks the job canceled", async () => {
+		const harness = freshHarness();
+		const created = await harness.manager.handleToolCall({ action: "schedule", agent: "scout", task: "x", schedule: "+10m" }, harness.ctx);
+		const id = extractId(created);
+		assert.equal(harness.timers.pendingCount(), 1);
+		const canceled = await harness.manager.handleToolCall({ action: "schedule-cancel", id }, harness.ctx);
+		assert.match(canceled.content[0]!.text, /Canceled scheduled subagent run/);
+		assert.equal(harness.timers.pendingCount(), 0);
+		const status = await harness.manager.handleToolCall({ action: "schedule-status", id }, harness.ctx);
+		assert.match(status.content[0]!.text, /State: canceled/);
+	});
+
+	it("cancel refuses a terminal job", async () => {
+		const harness = freshHarness();
+		const created = await harness.manager.handleToolCall({ action: "schedule", agent: "scout", task: "x", schedule: "+10m" }, harness.ctx);
+		const id = extractId(created);
+		await harness.manager.handleToolCall({ action: "schedule-cancel", id }, harness.ctx);
+		const again = await harness.manager.handleToolCall({ action: "schedule-cancel", id }, harness.ctx);
+		assert.match(again.content[0]!.text, /already canceled/);
+	});
+
+	it("reports malformed persisted job records instead of dropping them", async () => {
+		const harness = freshHarness();
+		const sessionId = harness.ctx.sessionManager.getSessionFile()!;
+		const storePath = scheduledRunStorePath(harness.ctx.cwd, sessionId, harness.storeRoot);
+		fs.mkdirSync(path.dirname(storePath), { recursive: true });
+		fs.writeFileSync(storePath, JSON.stringify({ version: 1, cwd: harness.ctx.cwd, sessionId, jobs: [{ id: "bad" }] }), "utf-8");
+		const result = await harness.manager.handleToolCall({ action: "schedule-list" }, harness.ctx);
+		assert.equal(isError(result), true);
+		assert.match(result.content[0]!.text, /job 0 has invalid string fields/);
+	});
+
+	it("reports JSON parse errors from a corrupted persisted store", async () => {
+		const harness = freshHarness();
+		const sessionId = harness.ctx.sessionManager.getSessionFile()!;
+		const storePath = scheduledRunStorePath(harness.ctx.cwd, sessionId, harness.storeRoot);
+		fs.mkdirSync(path.dirname(storePath), { recursive: true });
+		fs.writeFileSync(storePath, "{ not-json", "utf-8");
+		const result = await harness.manager.handleToolCall({ action: "schedule-list" }, harness.ctx);
+		assert.equal(isError(result), true);
+		assert.match(result.content[0]!.text, /Failed to parse scheduled subagent store/);
+		assert.match(result.content[0]!.text, /JSON/);
+	});
+});
+
+describe("ScheduledRunManager firing", () => {
+	let storeRoots: string[] = [];
+	after(() => {
+		for (const root of storeRoots) {
+			try {
+				fs.rmSync(root, { recursive: true, force: true });
+			} catch {
+				// best-effort cleanup of temp test dirs
+			}
+		}
+	});
+
+	function freshHarness(options: { config?: ExtensionConfig; now?: number } = {}): TestHarness {
+		const harness = createHarness(options);
+		storeRoots.push(harness.storeRoot);
+		return harness;
+	}
+
+	it("launches the sanitized async run when the timer fires", async () => {
+		const harness = freshHarness();
+		const created = await harness.manager.handleToolCall({ action: "schedule", agent: "scout", task: "review", schedule: "+10m", scheduleName: "rev" }, harness.ctx);
+		const id = extractId(created);
+		harness.clock.now += 10 * 60_000; // advance to runAt so fire() launches instead of re-arming
+		harness.timers.fireAll();
+		assert.equal(harness.launches.length, 1, "launch should be invoked once when the timer fires");
+		const launch = harness.launches[0]!;
+		assert.equal(launch.params.async, true);
+		assert.equal(launch.params.clarify, false);
+		assert.equal(launch.params.context, "fresh");
+		assert.equal(launch.params.agent, "scout");
+		assert.equal(launch.params.task, "review");
+		assert.equal((launch.params as { action?: string }).action, undefined, "action must be stripped before launch");
+		assert.equal((launch.params as { schedule?: string }).schedule, undefined, "schedule must be stripped before launch");
+
+		launch.resolve({
+			content: [{ type: "text", text: "Async: scout [run-xyz]" }],
+			details: { mode: "single", runId: "run-xyz", asyncId: "run-xyz", asyncDir: "/tmp/async-xyz", results: [] },
+		});
+		await flushMicrotasks();
+
+		const status = await harness.manager.handleToolCall({ action: "schedule-status", id }, harness.ctx);
+		assert.match(status.content[0]!.text, /State: fired/);
+		assert.match(status.content[0]!.text, /Launched async run: run-xyz/);
+		assert.match(status.content[0]!.text, /Async dir: \/tmp\/async-xyz/);
+	});
+
+	it("marks the job failed when launch returns an error result", async () => {
+		const harness = freshHarness();
+		const created = await harness.manager.handleToolCall({ action: "schedule", agent: "scout", task: "x", schedule: "+1m" }, harness.ctx);
+		const id = extractId(created);
+		harness.clock.now += 60_000; // advance to runAt
+		harness.timers.fireAll();
+		assert.equal(harness.launches.length, 1);
+		harness.launches[0]!.resolve({
+			content: [{ type: "text", text: "Async mode requires jiti" }],
+			details: { mode: "single", results: [] },
+			isError: true,
+		});
+		await flushMicrotasks();
+		const status = await harness.manager.handleToolCall({ action: "schedule-status", id }, harness.ctx);
+		assert.match(status.content[0]!.text, /State: failed/);
+		assert.match(status.content[0]!.text, /Async mode requires jiti/);
+	});
+
+	it("marks the job failed when launch throws", async () => {
+		const storeRoot = fs.mkdtempSync(path.join(os.tmpdir(), "sched-throw-"));
+		storeRoots.push(storeRoot);
+		const ctx = makeCtx();
+		const timers = new FakeTimers();
+		const clock = { now: 1_000_000 };
+		const throwingManager = createScheduledRunManager({
+			config: makeConfig(),
+			storeRoot,
+			now: () => clock.now,
+			randomId: () => "id-" + randomUUID().slice(0, 4),
+			timers,
+			launch: () => Promise.reject(new Error("spawn ENOENT")),
+		});
+		throwingManager.bindSession(ctx);
+		const created = await throwingManager.handleToolCall({ action: "schedule", agent: "scout", task: "x", schedule: "+1m" }, ctx);
+		const id = extractId(created);
+		clock.now += 60_000; // advance to runAt
+		timers.fireAll();
+		await flushMicrotasks();
+		const status = await throwingManager.handleToolCall({ action: "schedule-status", id }, ctx);
+		assert.match(status.content[0]!.text, /State: failed/);
+		assert.match(status.content[0]!.text, /spawn ENOENT/);
+	});
+
+	it("re-arms instead of launching when a capped timer fires before runAt", async () => {
+		const harness = freshHarness({ now: 1_000_000 });
+		// +25d exceeds MAX_TIMER_DELAY_MS so the armed timer is capped and would fire "early" in fake time.
+		const created = await harness.manager.handleToolCall({ action: "schedule", agent: "scout", task: "x", schedule: "+25d" }, harness.ctx);
+		const id = extractId(created);
+		harness.timers.fireAll();
+		assert.equal(harness.launches.length, 0, "must not launch before runAt");
+		assert.equal(harness.timers.pendingCount(), 1, "must re-arm a new timer");
+		// Advance time to runAt and fire again -> now it launches.
+		harness.clock.now = 1_000_000 + 25 * 86_400_000;
+		harness.timers.fireAll();
+		assert.equal(harness.launches.length, 1, "must launch once runAt is reached");
+		harness.launches[0]!.resolve({
+			content: [{ type: "text", text: "Async: scout [run-1]" }],
+			details: { mode: "single", runId: "run-1", asyncId: "run-1", results: [] },
+		});
+		await flushMicrotasks();
+		const status = await harness.manager.handleToolCall({ action: "schedule-status", id }, harness.ctx);
+		assert.match(status.content[0]!.text, /State: fired/);
+	});
+
+	it("cancel before fire prevents the launch", async () => {
+		const harness = freshHarness();
+		const created = await harness.manager.handleToolCall({ action: "schedule", agent: "scout", task: "x", schedule: "+10m" }, harness.ctx);
+		const id = extractId(created);
+		await harness.manager.handleToolCall({ action: "schedule-cancel", id }, harness.ctx);
+		harness.timers.fireAll();
+		assert.equal(harness.launches.length, 0, "a canceled job must not launch");
+	});
+});
+
+describe("ScheduledRunManager restart restore", () => {
+	let storeRoots: string[] = [];
+	after(() => {
+		for (const root of storeRoots) {
+			try {
+				fs.rmSync(root, { recursive: true, force: true });
+			} catch {
+				// best-effort cleanup of temp test dirs
+			}
+		}
+	});
+
+	it("re-arms pending jobs and marks stale jobs missed after a restart", async () => {
+		const storeRoot = fs.mkdtempSync(path.join(os.tmpdir(), "sched-restore-"));
+		storeRoots.push(storeRoot);
+		const ctx = makeCtx();
+		const clock = { now: 1_000_000 };
+		const timersA = new FakeTimers();
+		const managerA = createScheduledRunManager({
+			config: makeConfig({ maxLatenessMs: 60_000 }),
+			storeRoot,
+			now: () => clock.now,
+			randomId: () => "id-" + randomUUID().slice(0, 4),
+			timers: timersA,
+			launch: () => Promise.resolve({ content: [{ type: "text", text: "ok" }], details: { mode: "single", results: [] } }),
+		});
+		managerA.bindSession(ctx);
+		const soon = await managerA.handleToolCall({ action: "schedule", agent: "scout", task: "soon", schedule: "+10m" }, ctx);
+		const later = await managerA.handleToolCall({ action: "schedule", agent: "scout", task: "later", schedule: "+1h" }, ctx);
+		const soonId = extractId(soon);
+		const laterId = extractId(later);
+		assert.equal(timersA.pendingCount(), 2);
+		managerA.stop();
+
+		// Simulate Pi being offline past the first job's window but before the second fires.
+		clock.now = 1_000_000 + 20 * 60_000; // +20m: soon is 10m overdue (> maxLateness 1m), later is still 40m out.
+		const timersB = new FakeTimers();
+		const managerB = createScheduledRunManager({
+			config: makeConfig({ maxLatenessMs: 60_000 }),
+			storeRoot,
+			now: () => clock.now,
+			randomId: () => "id-" + randomUUID().slice(0, 4),
+			timers: timersB,
+			launch: () => Promise.resolve({ content: [{ type: "text", text: "ok" }], details: { mode: "single", results: [] } }),
+		});
+		managerB.bindSession(ctx);
+		const soonStatus = await managerB.handleToolCall({ action: "schedule-status", id: soonId }, ctx);
+		assert.match(soonStatus.content[0]!.text, /State: missed/);
+		const laterStatus = await managerB.handleToolCall({ action: "schedule-status", id: laterId }, ctx);
+		assert.match(laterStatus.content[0]!.text, /State: scheduled/);
+		assert.equal(timersB.pendingCount(), 1, "only the still-future job should be re-armed");
+		managerB.stop();
+	});
+
+	it("store path lives under the scheduled runs dir by default", () => {
+		const p = scheduledRunStorePath("/project", "sess1");
+		assert.ok(p.startsWith(SCHEDULED_RUNS_DIR), `${p} should be under ${SCHEDULED_RUNS_DIR}`);
+	});
+});