pi-harness-runtime 0.9.4 → 0.9.6

package/packages/notification/src/types.ts

@@ -0,0 +1,89 @@
+/**
+ * Notification Center Types — RFC-0022
+ *
+ * Type definitions for notification events, channels, and payloads.
+ */
+
+export type NotificationEvent =
+	| "JobStarted"
+	| "TaskCompleted"
+	| "TaskFailed"
+	| "QuotaPaused"
+	| "ResumeScheduled"
+	| "ContextCompacted"
+	| "OutputLimitContinued"
+	| "E2EFailed"
+	| "HumanReviewNeeded"
+	| "ReadyForClient"
+	| "JobCancelled"
+	| "Error";
+
+export interface NotificationPayload {
+	event: NotificationEvent;
+	jobId: string;
+	timestamp: string;
+	title: string;
+	message: string;
+	details?: Record<string, unknown>;
+	// Redacted fields for security
+	redacted?: string[];
+}
+
+export interface NotificationConfig {
+	channels: NotificationChannelConfig[];
+	// Global settings
+	enabled?: boolean;
+	redactPatterns?: RegExp[];
+}
+
+export interface NotificationChannelConfig {
+	id: string;
+	type: NotificationChannelType;
+	enabled: boolean;
+	config: TelegramConfig | NtfyConfig | EmailConfig | WebhookConfig;
+}
+
+export type NotificationChannelType = "telegram" | "ntfy" | "email" | "webhook";
+
+export interface TelegramConfig {
+	botToken: string;
+	chatId: string;
+	parseMode?: "MarkdownV2" | "HTML" | "Markdown";
+}
+
+export interface NtfyConfig {
+	server: string; // e.g., "https://ntfy.sh"
+	topic: string;
+	authToken?: string;
+}
+
+export interface EmailConfig {
+	smtpHost: string;
+	smtpPort: number;
+	smtpUser: string;
+	smtpPassword: string;
+	from: string;
+	to: string[];
+	tls?: boolean;
+}
+
+export interface WebhookConfig {
+	url: string;
+	method?: "POST" | "PUT";
+	headers?: Record<string, string>;
+	authToken?: string;
+}
+
+export interface NotificationResult {
+	success: boolean;
+	channel: string;
+	error?: string;
+}
+
+export interface NotificationContext {
+	jobId: string;
+	requirement: string;
+	taskId?: string;
+	taskTitle?: string;
+	error?: string;
+}

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

@@ -0,0 +1,372 @@
+/**
+ * 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);
+
+vi.mock("../src/adapters/telegram-adapter.js", () => ({
+	TelegramAdapter: vi.fn().mockImplementation(() => ({
+		send: mockSend,
+		initialize: mockInitialize,
+		isConfigured: mockIsConfigured,
+		id: "telegram",
+		type: "telegram",
+	})),
+}));
+
+vi.mock("../src/adapters/ntfy-adapter.js", () => ({
+	NtfyAdapter: vi.fn().mockImplementation(() => ({
+		send: mockSend,
+		initialize: mockInitialize,
+		isConfigured: mockIsConfigured,
+		id: "ntfy",
+		type: "ntfy",
+	})),
+}));
+
+vi.mock("../src/adapters/email-adapter.js", () => ({
+	EmailAdapter: vi.fn().mockImplementation(() => ({
+		send: mockSend,
+		initialize: mockInitialize,
+		isConfigured: mockIsConfigured,
+		id: "email",
+		type: "email",
+	})),
+}));
+
+vi.mock("../src/adapters/webhook-adapter.js", () => ({
+	WebhookAdapter: vi.fn().mockImplementation(() => ({
+		send: mockSend,
+		initialize: mockInitialize,
+		isConfigured: mockIsConfigured,
+		id: "webhook",
+		type: "webhook",
+	})),
+}));
+
+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/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"]
+}

package/packages/observability/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/observability",
-  "version": "0.9.4",
+  "version": "0.9.6",
   "description": "Comprehensive observability system with structured logging, tracing, metrics, and alerting",
   "type": "module",
   "main": "./dist/index.js",