pi-harness-runtime 1.1.440 → 1.1.441

package/packages/notification/test/notification.test.ts

@@ -1,375 +0,0 @@
-/**
- * Notification Center Tests
- */
-
-import { describe, it, expect, beforeEach, vi } from "bun:test";
-import { NotificationCenter } from "../src/notification-center.js";
-import type { NotificationChannelConfig } from "../src/types.js";
-
-// Mock adapters
-const mockSend = vi.fn();
-const mockInitialize = vi.fn().mockResolvedValue(true);
-const mockIsConfigured = vi.fn().mockReturnValue(true);
-
-// The mocks are classes, not mock functions: the notification center checks
-// the adapter with "instanceof", and a mocked constructor makes that check
-// throw for every test file that is loaded after this one.
-vi.mock("../src/adapters/telegram-adapter.js", () => ({
-	TelegramAdapter: class {
-		id = "telegram";
-		type = "telegram";
-		send = mockSend;
-		initialize = mockInitialize;
-		isConfigured = mockIsConfigured;
-	},
-}));
-
-vi.mock("../src/adapters/ntfy-adapter.js", () => ({
-	NtfyAdapter: class {
-		id = "ntfy";
-		type = "ntfy";
-		send = mockSend;
-		initialize = mockInitialize;
-		isConfigured = mockIsConfigured;
-	},
-}));
-
-vi.mock("../src/adapters/email-adapter.js", () => ({
-	EmailAdapter: class {
-		id = "email";
-		type = "email";
-		send = mockSend;
-		initialize = mockInitialize;
-		isConfigured = mockIsConfigured;
-	},
-}));
-
-vi.mock("../src/adapters/webhook-adapter.js", () => ({
-	WebhookAdapter: class {
-		id = "webhook";
-		type = "webhook";
-		send = mockSend;
-		initialize = mockInitialize;
-		isConfigured = mockIsConfigured;
-	},
-}));
-
-describe("NotificationCenter", () => {
-	beforeEach(() => {
-		mockSend.mockReset().mockResolvedValue({ success: true, channel: "mock" });
-		mockInitialize.mockReset().mockResolvedValue(true);
-		mockIsConfigured.mockReturnValue(true);
-	});
-
-	describe("construction", () => {
-		it("creates instance without config", () => {
-			const center = new NotificationCenter();
-			expect(center).toBeDefined();
-		});
-
-		it("has no channels by default", () => {
-			const center = new NotificationCenter();
-			expect(center.hasChannels()).toBe(false);
-			expect(center.listChannels()).toEqual([]);
-		});
-	});
-
-	describe("registerAdapter", () => {
-		it("registers a telegram adapter", () => {
-			const center = new NotificationCenter();
-			const config: NotificationChannelConfig = {
-				id: "telegram-main",
-				type: "telegram",
-				enabled: true,
-				config: { botToken: "tok", chatId: "chat" },
-			};
-			const result = center.registerAdapter(config);
-			expect(result).toBe(true);
-			expect(center.hasChannels()).toBe(true);
-			expect(center.listChannels()).toContain("telegram-main");
-		});
-
-		it("returns false when adapter not configured", () => {
-			const center = new NotificationCenter();
-			mockIsConfigured.mockReturnValue(false);
-			const config: NotificationChannelConfig = {
-				id: "telegram-fail",
-				type: "telegram",
-				enabled: false,
-				config: { botToken: "", chatId: "" },
-			};
-			expect(center.registerAdapter(config)).toBe(false);
-		});
-	});
-
-	describe("notify", () => {
-		it("notifies all channels", async () => {
-			const center = new NotificationCenter();
-			center.registerAdapter({
-				id: "ch1",
-				type: "telegram",
-				enabled: true,
-				config: { botToken: "tok", chatId: "chat" },
-			});
-			center.registerAdapter({
-				id: "ch2",
-				type: "ntfy",
-				enabled: true,
-				config: { server: "https://ntfy.sh", topic: "test" },
-			});
-
-			mockSend.mockResolvedValue({ success: true });
-
-			const results = await center.notify("JobStarted", {
-				jobId: "job-1",
-				requirement: "Fix login bug",
-			});
-
-			expect(results.length).toBeGreaterThanOrEqual(1);
-		});
-
-		it("returns failure result when adapter throws", async () => {
-			const center = new NotificationCenter();
-			center.registerAdapter({
-				id: "ch1",
-				type: "telegram",
-				enabled: true,
-				config: { botToken: "tok", chatId: "chat" },
-			});
-			mockSend.mockRejectedValue(new Error("network error"));
-
-			const results = await center.notify("TaskFailed", {
-				jobId: "job-2",
-				requirement: "Fix bug",
-				taskId: "task-1",
-				taskTitle: "Fix login",
-				error: "NullPointerException",
-			});
-
-			expect(results.some((r) => !r.success)).toBe(true);
-		});
-	});
-
-	describe("notifyChannel", () => {
-		it("notifies specific channel", async () => {
-			const center = new NotificationCenter();
-			center.registerAdapter({
-				id: "telegram-main",
-				type: "telegram",
-				enabled: true,
-				config: { botToken: "tok", chatId: "chat" },
-			});
-			mockSend.mockResolvedValue({ success: true });
-
-			const result = await center.notifyChannel(
-				"telegram-main",
-				"TaskCompleted",
-				{
-					jobId: "job-1",
-					requirement: "Add feature",
-					taskId: "task-1",
-					taskTitle: "Add login",
-				},
-			);
-
-			expect(result.success).toBe(true);
-		});
-
-		it("returns failure for unknown channel", async () => {
-			const center = new NotificationCenter();
-			const result = await center.notifyChannel("nonexistent", "Error", {
-				jobId: "job-1",
-				requirement: "test",
-			});
-
-			expect(result.success).toBe(false);
-			expect(result.error).toContain("not found");
-		});
-	});
-
-	describe("event content mapping", () => {
-		it("builds correct content for ReadyForClient", async () => {
-			const center = new NotificationCenter();
-			center.registerAdapter({
-				id: "ch1",
-				type: "telegram",
-				enabled: true,
-				config: { botToken: "tok", chatId: "chat" },
-			});
-			mockSend.mockImplementation(async (payload: any) => {
-				expect(payload.title).toBe("Ready for Review");
-				expect(payload.event).toBe("ReadyForClient");
-				return { success: true };
-			});
-
-			await center.notify("ReadyForClient", {
-				jobId: "job-1",
-				requirement: "Build feature X",
-			});
-
-			expect(mockSend).toHaveBeenCalled();
-		});
-
-		it("builds correct content for TaskFailed", async () => {
-			const center = new NotificationCenter();
-			center.registerAdapter({
-				id: "ch1",
-				type: "telegram",
-				enabled: true,
-				config: { botToken: "tok", chatId: "chat" },
-			});
-			mockSend.mockImplementation(async (payload: any) => {
-				expect(payload.title).toBe("Task Failed");
-				expect(payload.event).toBe("TaskFailed");
-				return { success: true };
-			});
-
-			await center.notify("TaskFailed", {
-				jobId: "job-1",
-				requirement: "Fix bug",
-				taskId: "task-1",
-				taskTitle: "Fix login",
-				error: "NullPointerException",
-			});
-
-			expect(mockSend).toHaveBeenCalled();
-		});
-
-		it("builds correct content for QuotaPaused", async () => {
-			const center = new NotificationCenter();
-			center.registerAdapter({
-				id: "ch1",
-				type: "telegram",
-				enabled: true,
-				config: { botToken: "tok", chatId: "chat" },
-			});
-			mockSend.mockImplementation(async (payload: any) => {
-				expect(payload.title).toBe("Quota Paused");
-				return { success: true };
-			});
-
-			await center.notify("QuotaPaused", {
-				jobId: "job-1",
-				requirement: "Continue work",
-			});
-
-			expect(mockSend).toHaveBeenCalled();
-		});
-
-		it("handles E2EFailed event", async () => {
-			const center = new NotificationCenter();
-			center.registerAdapter({
-				id: "ch1",
-				type: "telegram",
-				enabled: true,
-				config: { botToken: "tok", chatId: "chat" },
-			});
-			mockSend.mockImplementation(async (payload: any) => {
-				expect(payload.title).toBe("E2E Test Failed");
-				return { success: true };
-			});
-
-			await center.notify("E2EFailed", {
-				jobId: "job-1",
-				requirement: "Test workflow",
-			});
-
-			expect(mockSend).toHaveBeenCalled();
-		});
-
-		it("handles HumanReviewNeeded event", async () => {
-			const center = new NotificationCenter();
-			center.registerAdapter({
-				id: "ch1",
-				type: "telegram",
-				enabled: true,
-				config: { botToken: "tok", chatId: "chat" },
-			});
-			mockSend.mockImplementation(async (payload: any) => {
-				expect(payload.title).toBe("Human Review Needed");
-				return { success: true };
-			});
-
-			await center.notify("HumanReviewNeeded", {
-				jobId: "job-1",
-				requirement: "Approval needed",
-			});
-
-			expect(mockSend).toHaveBeenCalled();
-		});
-	});
-
-	describe("redaction", () => {
-		it("redacts bearer tokens", async () => {
-			const center = new NotificationCenter();
-			center.registerAdapter({
-				id: "ch1",
-				type: "telegram",
-				enabled: true,
-				config: { botToken: "tok", chatId: "chat" },
-			});
-			mockSend.mockImplementation(async (payload: any) => {
-				const details = payload.details ?? {};
-				expect(details.token).toBe("[REDACTED]");
-				return { success: true };
-			});
-
-			await center.notify("TaskCompleted", {
-				jobId: "job-1",
-				requirement: "Test",
-				taskId: "task-1",
-				taskTitle: "Test task",
-			});
-
-			expect(mockSend).toHaveBeenCalled();
-		});
-
-		it("redacts passwords", async () => {
-			const center = new NotificationCenter({
-				channels: [],
-				redactPatterns: [/password["\s:=]+[^\s,}]+/gi],
-			});
-			center.registerAdapter({
-				id: "ch1",
-				type: "telegram",
-				enabled: true,
-				config: { botToken: "tok", chatId: "chat" },
-			});
-			mockSend.mockImplementation(async (payload: any) => {
-				// Pattern should redact password field
-				expect(payload).toBeDefined();
-				return { success: true };
-			});
-
-			await center.notify("TaskCompleted", {
-				jobId: "job-1",
-				requirement: "Test",
-				taskId: "task-1",
-				taskTitle: "Test task",
-			});
-
-			expect(mockSend).toHaveBeenCalled();
-		});
-	});
-
-	describe("initialize", () => {
-		it("initializes all adapters", async () => {
-			const center = new NotificationCenter();
-			center.registerAdapter({
-				id: "ch1",
-				type: "telegram",
-				enabled: true,
-				config: { botToken: "tok", chatId: "chat" },
-			});
-			center.registerAdapter({
-				id: "ch2",
-				type: "ntfy",
-				enabled: true,
-				config: { server: "https://ntfy.sh", topic: "test" },
-			});
-
-			await center.initialize();
-			// Should not throw
-		});
-	});
-});

package/packages/notification/test/pending-question-lifecycle.test.ts

@@ -1,195 +0,0 @@
-/**
- * Pending question lifecycle tests.
- *
- * One question, one canonical request ID, one resolver. A stale, duplicated
- * or unauthorized callback resolves nothing, the first human answer wins, and
- * an autonomous Jev decision is never reported as a user answer.
- */
-
-import { describe, it, expect, beforeEach } from "bun:test";
-import {
-	PendingQuestionController,
-	type JevOutcome,
-} from "../src/pending-question.js";
-
-describe("pending question lifecycle", () => {
-	let controller: PendingQuestionController;
-	let requestId: string;
-
-	beforeEach(() => {
-		controller = new PendingQuestionController();
-		const question = controller.createQuestion({
-			text: "Want me to implement the toggle buttons now?",
-			sessionId: "session-1",
-			workspacePath: "/tmp",
-			kind: "approval",
-		});
-		requestId = question.requestId;
-	});
-
-	describe("the risk facts of a question", () => {
-		it("keeps the recorded risk facts with the request", () => {
-			const local = new PendingQuestionController();
-			const question = local.createQuestion({
-				text: "Shall I drop the production table?",
-				sessionId: "session-1",
-				workspacePath: "/tmp",
-				kind: "approval",
-				risk: {
-					requiresExplicitAuthorization: true,
-					destructive: true,
-					reversible: false,
-					external: true,
-					signals: ["drop-object", "production"],
-				},
-			});
-
-			expect(question.requiresExplicitAuthorization).toBe(true);
-			expect(question.destructive).toBe(true);
-			expect(question.reversible).toBe(false);
-			expect(question.external).toBe(true);
-			expect(question.riskSignals).toContain("drop-object");
-
-			// The facts travel with the request.
-			expect(local.getCurrentQuestion()?.destructive).toBe(true);
-		});
-
-		it("leaves the facts unknown when they were not determined", () => {
-			const local = new PendingQuestionController();
-			const question = local.createQuestion({
-				text: "Should I continue?",
-				sessionId: "session-1",
-				workspacePath: "/tmp",
-				kind: "routine",
-			});
-
-			expect(question.requiresExplicitAuthorization).toBeUndefined();
-			expect(question.destructive).toBeUndefined();
-			expect(question.reversible).toBeUndefined();
-		});
-	});
-
-	describe("stale and unauthorized callbacks", () => {
-		it("ignores a callback with a stale request ID", () => {
-			const applied = controller.applyApproval("approve", "q-not-the-question", "telegram");
-
-			expect(applied.applied).toBe(false);
-			// The current question is untouched.
-			expect(controller.hasPendingQuestion()).toBe(true);
-			expect(controller.getResolution()).toBeUndefined();
-		});
-
-		it("ignores a duplicate click", () => {
-			const first = controller.applyApproval("approve", requestId, "telegram");
-			const second = controller.applyApproval("approve", requestId, "telegram");
-
-			expect(first.applied).toBe(true);
-			expect(second.applied).toBe(false);
-			expect(controller.getResolution()).toBe("yes");
-			// The first answer wins, the duplicate changes nothing.
-			expect(controller.getCurrentQuestion()?.resolvedChannel).toBe("telegram");
-		});
-
-		it("ignores an unknown action", () => {
-			const applied = controller.applyApproval("explode", requestId, "telegram");
-
-			expect(applied.applied).toBe(false);
-			expect(controller.hasPendingQuestion()).toBe(true);
-		});
-
-		it("reports a closed question as not actionable", () => {
-			expect(controller.isActionable(requestId)).toBe(true);
-
-			controller.applyApproval("approve", requestId, "telegram");
-
-			expect(controller.isActionable(requestId)).toBe(false);
-			expect(controller.isActionable("q-another")).toBe(false);
-		});
-	});
-
-	describe("first answer wins", () => {
-		it("keeps the Telegram answer when LINE answers later", () => {
-			const telegram = controller.applyApproval("approve", requestId, "telegram");
-			const line = controller.applyApproval("reject", requestId, "line");
-
-			expect(telegram.applied).toBe(true);
-			expect(line.applied).toBe(false);
-			expect(controller.getResolution()).toBe("yes");
-			expect(controller.getCurrentQuestion()?.resolvedChannel).toBe("telegram");
-		});
-
-		it("does not let Jev overwrite a human answer", () => {
-			controller.applyApproval("approve", requestId, "line");
-
-			const closed = controller.resolveByJev(requestId, "reject", "jev decided");
-
-			expect(closed).toBe(false);
-			expect(controller.getResolution()).toBe("yes");
-			expect(controller.getCurrentQuestion()?.jevOutcome).toBeUndefined();
-			expect(controller.getCurrentQuestion()?.resolvedBy).toBe("user");
-		});
-	});
-
-	describe("a Jev decision", () => {
-		it("closes the question without injecting a user answer", () => {
-			const answers: string[] = [];
-			controller.onUserAnswer((_question, answer) => {
-				answers.push(answer);
-			});
-			const decisions: string[] = [];
-			controller.onJevDecision((_question, decision) => {
-				decisions.push(decision.action);
-			});
-
-			const closed = controller.resolveByJev(requestId, "approve", "low risk");
-
-			expect(closed).toBe(true);
-			// No synthetic "yes" is dispatched as if a human had clicked.
-			expect(answers).toHaveLength(0);
-			expect(decisions).toEqual(["continue"]);
-
-			const question = controller.getCurrentQuestion();
-			expect(question?.resolvedBy).toBe("jev");
-			expect(question?.jevOutcome).toBe("approve");
-			expect(question?.jevReason).toBe("low risk");
-			expect(question?.resolvedChannel).toBeUndefined();
-			// A closed question is not a pending question any more.
-			expect(controller.hasPendingQuestion()).toBe(false);
-			expect(controller.isActionable(requestId)).toBe(false);
-		});
-
-		it("maps every outcome to the question state", () => {
-			const outcomes: JevOutcome[] = [
-				"approve",
-				"reject",
-				"wait",
-				"proceed_with_caution",
-			];
-
-			for (const outcome of outcomes) {
-				const local = new PendingQuestionController();
-				const question = local.createQuestion({
-					text: "Want me to continue?",
-					sessionId: "session-1",
-					workspacePath: "/tmp",
-					kind: "approval",
-				});
-
-				const closed = local.resolveByJev(question.requestId, outcome, "reason");
-
-				expect(closed).toBe(true);
-				expect(local.getCurrentQuestion()?.jevOutcome).toBe(outcome);
-				expect(local.getCurrentQuestion()?.resolvedBy).toBe("jev");
-				expect(local.hasPendingQuestion()).toBe(false);
-			}
-		});
-
-		it("ignores a Jev decision for an unknown request", () => {
-			const closed = controller.resolveByJev("q-not-the-question", "approve");
-
-			expect(closed).toBe(false);
-			expect(controller.hasPendingQuestion()).toBe(true);
-			expect(controller.getCurrentQuestion()?.resolvedBy).toBeUndefined();
-		});
-	});
-});