pi-harness-runtime 0.3.2-beta.2 → 0.4.0

package/packages/notification/notification-center.ts

@@ -0,0 +1,286 @@
+/**
+ * Notification Center — RFC-0022
+ *
+ * Main orchestration class for sending notifications across multiple channels.
+ *
+ * Security Rules (RFC-0022):
+ * - Do not send raw cookies, passwords, provider tokens
+ * - Redact sensitive data before sending
+ * - Notification failure does not crash runtime
+ */
+
+import type {
+	NotificationEvent,
+	NotificationPayload,
+	NotificationConfig,
+	NotificationChannelConfig,
+	NotificationResult,
+	NotificationContext,
+} from "./types.js";
+import type { ChannelAdapter } from "./base-adapter.js";
+import { TelegramAdapter } from "./adapters/telegram-adapter.js";
+import { NtfyAdapter } from "./adapters/ntfy-adapter.js";
+import { EmailAdapter } from "./adapters/email-adapter.js";
+import { WebhookAdapter } from "./adapters/webhook-adapter.js";
+
+export class NotificationCenter {
+	private adapters: Map<string, ChannelAdapter> = new Map();
+	private redactPatterns: RegExp[];
+
+	constructor(config?: NotificationConfig) {
+		this.redactPatterns =
+			config?.redactPatterns ?? this.getDefaultRedactPatterns();
+
+		if (config?.channels) {
+			for (const channelConfig of config.channels) {
+				if (channelConfig.enabled) {
+					this.registerAdapter(channelConfig);
+				}
+			}
+		}
+	}
+
+	/**
+	 * Register a new adapter
+	 */
+	registerAdapter(config: NotificationChannelConfig): boolean {
+		try {
+			const adapter = this.createAdapter(config);
+			if (adapter && adapter.isConfigured()) {
+				this.adapters.set(config.id, adapter);
+				return true;
+			}
+		} catch (error) {
+			console.error(
+				`[NotificationCenter] Failed to register adapter: ${error}`,
+			);
+		}
+		return false;
+	}
+
+	/**
+	 * Initialize all registered adapters
+	 */
+	async initialize(): Promise<void> {
+		const adapterEntries = Array.from(this.adapters.entries());
+		for (const [id, adapter] of adapterEntries) {
+			try {
+				const ok = await adapter.initialize();
+				if (!ok) {
+					console.warn(
+						`[NotificationCenter] Adapter ${id} initialization failed`,
+					);
+				}
+			} catch (error) {
+				console.warn(
+					`[NotificationCenter] Adapter ${id} initialization error: ${error}`,
+				);
+			}
+		}
+	}
+
+	/**
+	 * Send a notification to all configured channels
+	 */
+	async notify(
+		event: NotificationEvent,
+		context: NotificationContext,
+	): Promise<NotificationResult[]> {
+		const payload = this.buildPayload(event, context);
+		const results: NotificationResult[] = [];
+
+		// Send to all adapters in parallel
+		const adapterEntries = Array.from(this.adapters.entries());
+		const promises = adapterEntries.map(async ([id, adapter]) => {
+			try {
+				// Redact sensitive data
+				const redactedPayload = this.redact(payload);
+				const result = await adapter.send(redactedPayload);
+				results.push(result);
+			} catch (error) {
+				// Never crash the runtime due to notification failure
+				results.push({
+					success: false,
+					channel: id,
+					error: String(error),
+				});
+			}
+		});
+
+		await Promise.all(promises);
+		return results;
+	}
+
+	/**
+	 * Send notification to a specific channel
+	 */
+	async notifyChannel(
+		channelId: string,
+		event: NotificationEvent,
+		context: NotificationContext,
+	): Promise<NotificationResult> {
+		const adapter = this.adapters.get(channelId);
+		if (!adapter) {
+			return { success: false, channel: channelId, error: "Adapter not found" };
+		}
+
+		try {
+			const payload = this.redact(this.buildPayload(event, context));
+			return await adapter.send(payload);
+		} catch (error) {
+			return { success: false, channel: channelId, error: String(error) };
+		}
+	}
+
+	/**
+	 * Check if any notifications are configured
+	 */
+	hasChannels(): boolean {
+		return this.adapters.size > 0;
+	}
+
+	/**
+	 * List all configured channels
+	 */
+	listChannels(): string[] {
+		return Array.from(this.adapters.keys());
+	}
+
+	// ─── Private Methods ────────────────────────────────────────────────
+
+	private createAdapter(
+		config: NotificationChannelConfig,
+	): ChannelAdapter | null {
+		switch (config.type) {
+			case "telegram":
+				return new TelegramAdapter(
+					config.config as import("./types.js").TelegramConfig,
+				);
+			case "ntfy":
+				return new NtfyAdapter(
+					config.config as import("./types.js").NtfyConfig,
+				);
+			case "email":
+				return new EmailAdapter(
+					config.config as import("./types.js").EmailConfig,
+				);
+			case "webhook":
+				return new WebhookAdapter(
+					config.config as import("./types.js").WebhookConfig,
+				);
+			default:
+				return null;
+		}
+	}
+
+	private buildPayload(
+		event: NotificationEvent,
+		context: NotificationContext,
+	): NotificationPayload {
+		const { title, message } = this.getEventContent(event, context);
+
+		return {
+			event,
+			jobId: context.jobId,
+			timestamp: new Date().toISOString(),
+			title,
+			message,
+			details: {
+				jobId: context.jobId,
+				requirement: context.requirement,
+				...(context.taskId && { taskId: context.taskId }),
+				...(context.taskTitle && { taskTitle: context.taskTitle }),
+				...(context.error && { error: context.error }),
+			},
+		};
+	}
+
+	private getEventContent(
+		event: NotificationEvent,
+		context: NotificationContext,
+	): { title: string; message: string } {
+		const requirement =
+			context.requirement.length > 50
+				? context.requirement.slice(0, 50) + "..."
+				: context.requirement;
+
+		const map: Record<NotificationEvent, { title: string; message: string }> = {
+			JobStarted: {
+				title: "Job Started",
+				message: `Harness job started for: "${requirement}"`,
+			},
+			TaskCompleted: {
+				title: "Task Completed",
+				message: `Task "${context.taskTitle ?? "Unknown"}" completed successfully`,
+			},
+			TaskFailed: {
+				title: "Task Failed",
+				message: `Task "${context.taskTitle ?? "Unknown"}" failed${context.error ? `: ${context.error}` : ""}`,
+			},
+			QuotaPaused: {
+				title: "Quota Paused",
+				message: `Job paused due to quota limit. Will auto-resume when quota resets.`,
+			},
+			ResumeScheduled: {
+				title: "Resume Scheduled",
+				message: `Job will resume work on: "${requirement}"`,
+			},
+			ContextCompacted: {
+				title: "Context Compacted",
+				message: `Session context was compacted to continue work on: "${requirement}"`,
+			},
+			OutputLimitContinued: {
+				title: "Output Limit Continued",
+				message: `Response was continued after hitting output token limit`,
+			},
+			E2EFailed: {
+				title: "E2E Test Failed",
+				message: `End-to-end tests failed for job: "${requirement}"`,
+			},
+			HumanReviewNeeded: {
+				title: "Human Review Needed",
+				message: `Job blocked. Please review and take action.`,
+			},
+			ReadyForClient: {
+				title: "Ready for Review",
+				message: `Job completed successfully and ready for your review: "${requirement}"`,
+			},
+			JobCancelled: {
+				title: "Job Cancelled",
+				message: `Job was cancelled: "${requirement}"`,
+			},
+			Error: {
+				title: "Runtime Error",
+				message: `An error occurred${context.error ? `: ${context.error}` : ""}`,
+			},
+		};
+
+		return map[event] ?? { title: event, message: `Event: ${event}` };
+	}
+
+	private redact(payload: NotificationPayload): NotificationPayload {
+		const details = payload.details ? { ...payload.details } : {};
+
+		// Redact sensitive patterns
+		for (const pattern of this.redactPatterns) {
+			for (const [key, value] of Object.entries(details)) {
+				if (typeof value === "string" && pattern.test(value)) {
+					details[key] = "[REDACTED]";
+				}
+			}
+		}
+
+		return { ...payload, details };
+	}
+
+	private getDefaultRedactPatterns(): RegExp[] {
+		return [
+			/Bearer\s+[\w-]+/gi, // Bearer tokens
+			/password["\s:=]+[^\s,}]+/gi, // passwords
+			/cookie["\s:=]+[^\s,}]+/gi, // cookies
+			/secret["\s:=]+[^\s,}]+/gi, // secrets
+			/api[_-]?key["\s:=]+[^\s,}]+/gi, // API keys
+			/auth["\s:=]+[^\s,}]+/gi, // auth tokens
+		];
+	}
+}

package/packages/notification/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/providers/adapters.ts

@@ -15,7 +15,7 @@ import type {
 	ProviderCapability,
 	ProviderRequest,
 	ProviderResponse,
-} from "../../packages/types/src/runtime-types.ts";
+} from "../../packages/types/src/runtime-types.js";
 
 export interface AdapterConfig {
 	provider: ProviderConfig;
@@ -212,6 +212,86 @@ export class OpenAIAdapter extends BaseProviderAdapter {
 	}
 }
 
+/**
+ * Claude adapter — Anthropic's Claude models
+ */
+export class ClaudeAdapter extends BaseProviderAdapter {
+	readonly id = "anthropic";
+	readonly name = "Anthropic Claude";
+
+	async invoke(request: ProviderRequest): Promise<AdapterResult> {
+		// In practice, this would call the Claude API via Anthropic SDK
+		// For now, return a mock response
+		return {
+			response: {
+				content: "Mock response",
+				usage: { input: 100, output: 200, cost: 0.003 },
+				model: request.model,
+				finishReason: "stop",
+			},
+			retryable: false,
+		};
+	}
+
+	parseError(error: unknown): {
+		quotaExceeded: boolean;
+		rateLimited: boolean;
+		timeout: boolean;
+		serverError: boolean;
+		clientError: boolean;
+		quotaSignal?: QuotaSignal;
+	} {
+		const e = error as Record<string, unknown>;
+		const msg = String(e.message ?? e.error ?? "").toLowerCase();
+		const type = String(e.type ?? "");
+		const errorCode = String(e.code ?? "");
+
+		// Anthropic-specific error handling
+		const isRateLimited =
+			type.includes("rate_limit_error") ||
+			msg.includes("rate limit") ||
+			errorCode.includes("429");
+
+		const isOverloaded =
+			type.includes("overloaded_error") || msg.includes("overloaded");
+
+		return {
+			quotaExceeded:
+				type.includes("quota_error") ||
+				type.includes("insufficient_quota") ||
+				msg.includes("quota exceeded"),
+			rateLimited: isRateLimited || isOverloaded,
+			timeout: type.includes("timeout") || msg.includes("timeout"),
+			serverError: type.includes("api_error") || isOverloaded,
+			clientError:
+				type.includes("invalid_request_error") ||
+				type.includes("authentication_error") ||
+				type.includes("permission_error"),
+			quotaSignal: type.includes("quota_error")
+				? { exhausted: true, resetsAt: undefined }
+				: undefined,
+		};
+	}
+
+	getDefaultModel(): string {
+		return "anthropic/claude-3-5-sonnet-20240620";
+	}
+
+	getMaxTokens(model?: string): number {
+		const limits: Record<string, number> = {
+			"anthropic/claude-3-5-sonnet-20240620": 200000,
+			"anthropic/claude-3-5-haiku-20240620": 200000,
+			"anthropic/claude-3-opus-20240229": 200000,
+			"anthropic/claude-3-sonnet-20240229": 200000,
+			"anthropic/claude-3-haiku-20240307": 200000,
+			"anthropic/claude-2.1": 200000,
+			"anthropic/claude-2": 100000,
+			"anthropic/claude-instant": 100000,
+		};
+		return limits[model ?? this.getDefaultModel()] ?? 200000;
+	}
+}
+
 /**
  * Adapter registry
  */
@@ -256,6 +336,27 @@ export class AdapterRegistry {
 			}),
 		);
 
+		registry.register(
+			new ClaudeAdapter({
+				id: "anthropic",
+				name: "Anthropic Claude",
+				models: [
+					"anthropic/claude-3-5-sonnet-20240620",
+					"anthropic/claude-3-5-haiku-20240620",
+					"anthropic/claude-3-opus-20240229",
+				],
+				capabilities: [
+					"code",
+					"review",
+					"plan",
+					"test",
+					"refactor",
+					"analysis",
+				],
+				rateLimits: {},
+			}),
+		);
+
 		return registry;
 	}
 }

package/packages/types/src/runtime-types.ts

@@ -212,7 +212,9 @@ export type ProviderCapability =
 	| "plan"
 	| "test"
 	| "e2e"
-	| "refactor";
+	| "refactor"
+	| "analysis"
+	| "debug";
 
 export interface RateLimitConfig {
 	requestsPerMinute?: number;

package/skills/harness-runtime/SKILL.md

@@ -1,6 +1,10 @@
+---
+description: Local-first, provider-agnostic AI coding harness runtime for pi.dev with quota management and multi-model coordination
+---
+
 # Harness Runtime — pi Extension
 
-**Status:** v0.2.0 | **RFCs:** 18 defined | **Implementation:** Phase 1-6
+**Status:** v0.3.0 | **RFCs:** 18 defined | **Implementation:** Phase 1-6
 
 ## Overview