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

package/packages/auth/src/run-minimax-auth.ts

@@ -0,0 +1,150 @@
+#!/usr/bin/env bun
+/**
+ * run-minimax-auth.ts
+ *
+ * CLI to authenticate with MiniMax using Playwright persistent browser.
+ *
+ * Usage:
+ *   bun packages/auth/src/run-minimax-auth.ts auth    # First-time: login in browser
+ *   bun packages/auth/src/run-minimax-auth.ts scrape  # Scrape usage (silent)
+ *   bun packages/auth/src/run-minimax-auth.ts check   # Check status
+ *   bun packages/auth/src/run-minimax-auth.ts open    # Open browser with profile
+ *
+ * Security:
+ *   - Human logs in manually in the browser
+ *   - Playwright persistent profile auto-saves session
+ *   - No credentials are processed by this code
+ */
+
+import {
+	authenticateWithPersistentBrowser,
+	scrapeWithExistingProfile,
+	checkAuthStatus,
+	getProfileDir,
+	getStatusPath,
+	getLiveSessionPath,
+	startPersistentBrowserDaemon,
+	stopPersistentBrowserDaemon,
+} from "./minimax-browser-auth.js";
+
+async function main() {
+	const args = process.argv.slice(2);
+	const command = args[0] ?? "auth";
+
+	console.log("");
+	console.log("🔐 MiniMax Browser Authentication");
+	console.log("=".repeat(50));
+	console.log("");
+
+	if (command === "check") {
+		console.log("Command: check");
+		console.log("");
+		const status = await checkAuthStatus();
+		console.log("");
+		console.log("Status:");
+		console.log(JSON.stringify(status, null, 2));
+		console.log("");
+		console.log("Profile dir:", getProfileDir());
+		console.log("Status file:", getStatusPath());
+		return;
+	}
+
+	if (command === "scrape" || command === "usage") {
+		console.log(
+			"Command: scrape (prefers live browser, falls back to saved profile)",
+		);
+		console.log("");
+		const status = await scrapeWithExistingProfile();
+		console.log("");
+		console.log("Result:");
+		console.log(JSON.stringify(status, null, 2));
+		return;
+	}
+
+	if (command === "open" || command === "daemon") {
+		console.log("Command: open (live browser daemon mode)");
+		console.log("");
+		console.log("This will:");
+		console.log("1. Launch a real Chrome window with the MiniMax profile");
+		console.log("2. Keep that browser session running for unattended scrapes");
+		console.log("3. Let you sign in manually once and leave the window open");
+		console.log("");
+		console.log("Profile dir:", getProfileDir());
+		console.log("");
+
+		const session = await startPersistentBrowserDaemon();
+		console.log("Live browser session:");
+		console.log(JSON.stringify(session, null, 2));
+		console.log("");
+		console.log("Next:");
+		console.log("- Sign in inside that Chrome window if needed");
+		console.log("- Leave the MiniMax Chrome window open overnight");
+		console.log(
+			"- Later, run: bun packages/auth/src/run-minimax-auth.ts scrape",
+		);
+		console.log(
+			"- To stop it, run: bun packages/auth/src/run-minimax-auth.ts stop",
+		);
+		console.log("Live session file:", getLiveSessionPath());
+		return;
+	}
+
+	if (command === "stop" || command === "close") {
+		console.log("Command: stop");
+		console.log("");
+		const stopped = await stopPersistentBrowserDaemon();
+		console.log(
+			stopped
+				? "✅ Stopped MiniMax live browser session"
+				: "ℹ️  No active MiniMax live browser session was found",
+		);
+		console.log("Live session file:", getLiveSessionPath());
+		return;
+	}
+
+	if (command === "auth" || command === "login") {
+		console.log("Command: auth (persistent browser mode)");
+		console.log("");
+		console.log("This will:");
+		console.log("1. Launch a Chrome browser with persistent profile");
+		console.log("2. Navigate to MiniMax usage page");
+		console.log("3. Let you log in (first time only)");
+		console.log("4. Auto-save profile for future use");
+		console.log("");
+		console.log("Profile dir:", getProfileDir());
+		console.log("");
+
+		const status = await authenticateWithPersistentBrowser();
+		console.log("");
+		console.log("Result:");
+		console.log(JSON.stringify(status, null, 2));
+		return;
+	}
+
+	console.log("Usage:");
+	console.log(
+		"  bun packages/auth/src/run-minimax-auth.ts auth    # Manual login + confirmation",
+	);
+	console.log(
+		"  bun packages/auth/src/run-minimax-auth.ts open    # Start keep-open browser daemon",
+	);
+	console.log(
+		"  bun packages/auth/src/run-minimax-auth.ts scrape  # Scrape usage (prefers live browser)",
+	);
+	console.log(
+		"  bun packages/auth/src/run-minimax-auth.ts stop    # Stop live browser daemon",
+	);
+	console.log(
+		"  bun packages/auth/src/run-minimax-auth.ts check   # Check status",
+	);
+	console.log("");
+	console.log("Security:");
+	console.log("- Human logs in manually in the browser");
+	console.log("- Playwright auto-saves persistent profile");
+	console.log("- No credentials are processed by this code");
+}
+
+main().catch((error) => {
+	console.error("Error:", error.message);
+	process.exit(1);
+});

package/packages/notification/adapters/email-adapter.ts

@@ -0,0 +1,126 @@
+/**
+ * Email Adapter — RFC-0022
+ *
+ * Sends notifications via SMTP.
+ */
+
+import type {
+	NotificationPayload,
+	NotificationResult,
+	EmailConfig,
+} from "../types.js";
+import { BaseChannelAdapter } from "../base-adapter.js";
+
+// Simple SMTP client using built-in net module
+async function sendSmtpEmail(
+	host: string,
+	port: number,
+	user: string,
+	password: string,
+	from: string,
+	to: string[],
+	subject: string,
+	body: string,
+	tls: boolean = false,
+): Promise<void> {
+	// For a production implementation, you'd use a proper SMTP library
+	// This is a placeholder that logs the email
+	console.log(`[Email] Would send to ${to.join(", ")}`);
+	console.log(`[Email] Subject: ${subject}`);
+	console.log(`[Email] Body: ${body}`);
+
+	// In practice, you'd use something like:
+	// import { createClient } from "nodemailer";
+	// const transporter = nodemailer.createTransport({ ... });
+	// await transporter.sendMail({ ... });
+}
+
+export class EmailAdapter extends BaseChannelAdapter {
+	readonly id = "email";
+	readonly type = "email";
+
+	constructor(config: EmailConfig) {
+		super({ id: "email", type: "email", enabled: true, config });
+	}
+
+	async initialize(): Promise<boolean> {
+		// Verify SMTP connection
+		try {
+			const cfg = this.config.config as EmailConfig;
+			// In production, verify SMTP credentials
+			return Boolean(
+				cfg.smtpHost && cfg.smtpUser && cfg.from && cfg.to.length > 0,
+			);
+		} catch {
+			return false;
+		}
+	}
+
+	async send(payload: NotificationPayload): Promise<NotificationResult> {
+		try {
+			const cfg = this.config.config as EmailConfig;
+			const subject = `${this.getEmoji(payload.event)} ${payload.title}`;
+			const body = this.formatBody(payload);
+
+			await sendSmtpEmail(
+				cfg.smtpHost,
+				cfg.smtpPort,
+				cfg.smtpUser,
+				cfg.smtpPassword,
+				cfg.from,
+				cfg.to,
+				subject,
+				body,
+				cfg.tls,
+			);
+
+			return { success: true, channel: this.id };
+		} catch (error) {
+			return {
+				success: false,
+				channel: this.id,
+				error: String(error),
+			};
+		}
+	}
+
+	private formatBody(payload: NotificationPayload): string {
+		const lines = [
+			payload.message,
+			"",
+			"---",
+			`Event: ${payload.event}`,
+			`Time: ${payload.timestamp}`,
+		];
+
+		if (payload.details?.taskTitle) {
+			lines.push(`Task: ${payload.details.taskTitle}`);
+		}
+		if (payload.details?.jobId) {
+			lines.push(`Job ID: ${payload.details.jobId}`);
+		}
+		if (payload.details?.error) {
+			lines.push("", `Error: ${payload.details.error}`);
+		}
+
+		return lines.join("\n");
+	}
+
+	private getEmoji(event: NotificationPayload["event"]): string {
+		const map: Record<string, string> = {
+			JobStarted: "[🚀]",
+			TaskCompleted: "[✅]",
+			TaskFailed: "[❌]",
+			QuotaPaused: "[⏸]",
+			ResumeScheduled: "[▶]",
+			ContextCompacted: "[📦]",
+			OutputLimitContinued: "[🔄]",
+			E2EFailed: "[🧪]",
+			HumanReviewNeeded: "[👤]",
+			ReadyForClient: "[🎉]",
+			JobCancelled: "[🚫]",
+			Error: "[⚠]",
+		};
+		return map[event] ?? "[📢]";
+	}
+}

package/packages/notification/adapters/ntfy-adapter.ts

@@ -0,0 +1,100 @@
+/**
+ * Ntfy Adapter — RFC-0022
+ *
+ * Sends notifications via ntfy.sh (or self-hosted ntfy server).
+ */
+
+import type {
+	NotificationPayload,
+	NotificationResult,
+	NtfyConfig,
+} from "../types.js";
+import { BaseChannelAdapter } from "../base-adapter.js";
+
+export class NtfyAdapter extends BaseChannelAdapter {
+	readonly id = "ntfy";
+	readonly type = "ntfy";
+
+	constructor(config: NtfyConfig) {
+		super({ id: "ntfy", type: "ntfy", enabled: true, config });
+	}
+
+	async initialize(): Promise<boolean> {
+		// Ntfy doesn't require initialization; it's fire-and-forget
+		return true;
+	}
+
+	async send(payload: NotificationPayload): Promise<NotificationResult> {
+		try {
+			const cfg = this.config.config as NtfyConfig;
+			const message = this.formatMessage(payload);
+			const headers: Record<string, string> = {
+				"Content-Type": "text/plain",
+				Title: payload.title,
+				Tags: this.getTags(payload.event),
+			};
+
+			// Add auth if configured
+			if (cfg.authToken) {
+				headers["Authorization"] = `Bearer ${cfg.authToken}`;
+			}
+
+			const response = await fetch(`${cfg.server}/${cfg.topic}`, {
+				method: "POST",
+				headers,
+				body: message,
+			});
+
+			if (!response.ok) {
+				const error = await response.text();
+				return {
+					success: false,
+					channel: this.id,
+					error: `Ntfy error: ${error}`,
+				};
+			}
+
+			return { success: true, channel: this.id };
+		} catch (error) {
+			return {
+				success: false,
+				channel: this.id,
+				error: String(error),
+			};
+		}
+	}
+
+	private formatMessage(payload: NotificationPayload): string {
+		const lines = [payload.message];
+
+		if (payload.details?.taskTitle) {
+			lines.push(`\nTask: ${payload.details.taskTitle}`);
+		}
+		if (payload.details?.jobId) {
+			lines.push(`Job: ${payload.details.jobId}`);
+		}
+		if (payload.details?.error) {
+			lines.push(`\nError: ${payload.details.error}`);
+		}
+
+		return lines.join("");
+	}
+
+	private getTags(event: NotificationPayload["event"]): string {
+		const map: Record<string, string> = {
+			JobStarted: "rocket",
+			TaskCompleted: "white_check_mark",
+			TaskFailed: "x",
+			QuotaPaused: "pause_button",
+			ResumeScheduled: "play_button",
+			ContextCompacted: "package",
+			OutputLimitContinued: "repeat",
+			E2EFailed: "test_tube",
+			HumanReviewNeeded: "bust_in_silhouette",
+			ReadyForClient: "tada",
+			JobCancelled: "no_entry",
+			Error: "warning",
+		};
+		return map[event] ?? "bell";
+	}
+}

package/packages/notification/adapters/telegram-adapter.ts

@@ -0,0 +1,107 @@
+/**
+ * Telegram Adapter — RFC-0022
+ *
+ * Sends notifications via Telegram Bot API.
+ */
+
+import type {
+	NotificationPayload,
+	NotificationResult,
+	TelegramConfig,
+} from "../types.js";
+import { BaseChannelAdapter } from "../base-adapter.js";
+
+export class TelegramAdapter extends BaseChannelAdapter {
+	readonly id = "telegram";
+	readonly type = "telegram";
+
+	constructor(config: TelegramConfig) {
+		super({ id: "telegram", type: "telegram", enabled: true, config });
+	}
+
+	async initialize(): Promise<boolean> {
+		try {
+			const cfg = this.config.config as TelegramConfig;
+			// Verify bot token by calling getMe
+			const response = await fetch(
+				`https://api.telegram.org/bot${cfg.botToken}/getMe`,
+			);
+			return response.ok;
+		} catch {
+			return false;
+		}
+	}
+
+	async send(payload: NotificationPayload): Promise<NotificationResult> {
+		try {
+			const cfg = this.config.config as TelegramConfig;
+			const message = this.formatMessage(payload);
+
+			const response = await fetch(
+				`https://api.telegram.org/bot${cfg.botToken}/sendMessage`,
+				{
+					method: "POST",
+					headers: { "Content-Type": "application/json" },
+					body: JSON.stringify({
+						chat_id: cfg.chatId,
+						text: message,
+						parse_mode: cfg.parseMode ?? "MarkdownV2",
+					}),
+				},
+			);
+
+			if (!response.ok) {
+				const error = await response.text();
+				return {
+					success: false,
+					channel: this.id,
+					error: `Telegram API error: ${error}`,
+				};
+			}
+
+			return { success: true, channel: this.id };
+		} catch (error) {
+			return {
+				success: false,
+				channel: this.id,
+				error: String(error),
+			};
+		}
+	}
+
+	private formatMessage(payload: NotificationPayload): string {
+		const emoji = this.getEmoji(payload.event);
+		const title = `${emoji} ${payload.title}`;
+		const lines = [title, "", payload.message];
+
+		if (payload.details?.taskTitle) {
+			lines.push("", `Task: ${payload.details.taskTitle}`);
+		}
+		if (payload.details?.jobId) {
+			lines.push(`Job: ${payload.details.jobId}`);
+		}
+		if (payload.details?.error) {
+			lines.push("", `Error: ${payload.details.error}`);
+		}
+
+		return lines.filter(Boolean).join("\n");
+	}
+
+	private getEmoji(event: NotificationPayload["event"]): string {
+		const map: Record<string, string> = {
+			JobStarted: "🚀",
+			TaskCompleted: "✅",
+			TaskFailed: "❌",
+			QuotaPaused: "⏸️",
+			ResumeScheduled: "▶️",
+			ContextCompacted: "📦",
+			OutputLimitContinued: "🔄",
+			E2EFailed: "🧪",
+			HumanReviewNeeded: "👤",
+			ReadyForClient: "🎉",
+			JobCancelled: "🚫",
+			Error: "⚠️",
+		};
+		return map[event] ?? "📢";
+	}
+}

package/packages/notification/adapters/webhook-adapter.ts

@@ -0,0 +1,75 @@
+/**
+ * Webhook Adapter — RFC-0022
+ *
+ * Sends notifications to a generic webhook endpoint.
+ */
+
+import type {
+	NotificationPayload,
+	NotificationResult,
+	WebhookConfig,
+} from "../types.js";
+import { BaseChannelAdapter } from "../base-adapter.js";
+
+export class WebhookAdapter extends BaseChannelAdapter {
+	readonly id = "webhook";
+	readonly type = "webhook";
+
+	constructor(config: WebhookConfig) {
+		super({ id: "webhook", type: "webhook", enabled: true, config });
+	}
+
+	async initialize(): Promise<boolean> {
+		try {
+			const cfg = this.config.config as WebhookConfig;
+			return Boolean(cfg.url && cfg.url.startsWith("http"));
+		} catch {
+			return false;
+		}
+	}
+
+	async send(payload: NotificationPayload): Promise<NotificationResult> {
+		try {
+			const cfg = this.config.config as WebhookConfig;
+			const headers: Record<string, string> = {
+				"Content-Type": "application/json",
+				...(cfg.headers ?? {}),
+			};
+
+			// Add auth token if configured
+			if (cfg.authToken) {
+				headers["Authorization"] = `Bearer ${cfg.authToken}`;
+			}
+
+			const response = await fetch(cfg.url, {
+				method: cfg.method ?? "POST",
+				headers,
+				body: JSON.stringify({
+					event: payload.event,
+					jobId: payload.jobId,
+					timestamp: payload.timestamp,
+					title: payload.title,
+					message: payload.message,
+					details: payload.details,
+				}),
+			});
+
+			if (!response.ok) {
+				const error = await response.text();
+				return {
+					success: false,
+					channel: this.id,
+					error: `Webhook error ${response.status}: ${error}`,
+				};
+			}
+
+			return { success: true, channel: this.id };
+		} catch (error) {
+			return {
+				success: false,
+				channel: this.id,
+				error: String(error),
+			};
+		}
+	}
+}

package/packages/notification/base-adapter.ts

@@ -0,0 +1,75 @@
+/**
+ * Notification Base Adapter — RFC-0022
+ *
+ * Abstract base class for all notification channel adapters.
+ */
+
+import type {
+	NotificationPayload,
+	NotificationChannelConfig,
+	NotificationResult,
+} from "./types.js";
+
+export interface ChannelAdapter {
+	readonly id: string;
+	readonly type: string;
+
+	/**
+	 * Initialize the adapter (e.g., verify credentials)
+	 */
+	initialize(): Promise<boolean>;
+
+	/**
+	 * Send a notification
+	 */
+	send(payload: NotificationPayload): Promise<NotificationResult>;
+
+	/**
+	 * Check if the adapter is properly configured
+	 */
+	isConfigured(): boolean;
+}
+
+export abstract class BaseChannelAdapter implements ChannelAdapter {
+	abstract readonly id: string;
+	abstract readonly type: string;
+
+	constructor(protected config: NotificationChannelConfig) {}
+
+	abstract initialize(): Promise<boolean>;
+	abstract send(payload: NotificationPayload): Promise<NotificationResult>;
+
+	isConfigured(): boolean {
+		return this.config.enabled;
+	}
+
+	/**
+	 * Redact sensitive data from payload before sending
+	 */
+	protected redact(
+		payload: NotificationPayload,
+		patterns: RegExp[],
+	): NotificationPayload {
+		if (patterns.length === 0) return payload;
+
+		const redacted: string[] = [];
+		const details = payload.details ? { ...payload.details } : {};
+
+		for (const [key, value] of Object.entries(details)) {
+			const valStr = String(value);
+			for (const pattern of patterns) {
+				if (pattern.test(valStr)) {
+					redacted.push(key);
+					(details as Record<string, unknown>)[key] = "[REDACTED]";
+					break;
+				}
+			}
+		}
+
+		return {
+			...payload,
+			details,
+			redacted: redacted.length > 0 ? redacted : undefined,
+		};
+	}
+}

package/packages/notification/index.ts

@@ -0,0 +1,51 @@
+/**
+ * Notification Center — RFC-0022
+ *
+ * Mobile notification system for harness runtime events.
+ *
+ * @example
+ * ```typescript
+ * import { NotificationCenter } from "./notification/index.js";
+ *
+ * const center = new NotificationCenter({
+ *   channels: [
+ *     {
+ *       id: "my-telegram",
+ *       type: "telegram",
+ *       enabled: true,
+ *       config: {
+ *         botToken: process.env.TELEGRAM_BOT_TOKEN,
+ *         chatId: "YOUR_CHAT_ID",
+ *       },
+ *     },
+ *   ],
+ * });
+ *
+ * await center.initialize();
+ *
+ * await center.notify("JobStarted", {
+ *   jobId: "job-123",
+ *   requirement: "Build a REST API",
+ * });
+ * ```
+ */
+
+export { NotificationCenter } from "./notification-center.js";
+export { TelegramAdapter } from "./adapters/telegram-adapter.js";
+export { NtfyAdapter } from "./adapters/ntfy-adapter.js";
+export { EmailAdapter } from "./adapters/email-adapter.js";
+export { WebhookAdapter } from "./adapters/webhook-adapter.js";
+
+export type {
+	NotificationEvent,
+	NotificationPayload,
+	NotificationConfig,
+	NotificationChannelConfig,
+	NotificationChannelType,
+	NotificationResult,
+	NotificationContext,
+	TelegramConfig,
+	NtfyConfig,
+	EmailConfig,
+	WebhookConfig,
+} from "./types.js";