pi-harness-runtime 0.10.11 → 0.10.12

package/harness/e2e/quota-status.ts

@@ -0,0 +1,194 @@
+/**
+ * Quota Status Display — RFC-0031
+ *
+ * Integrates MiniMax quota scraper with harness status display.
+ * Provides real-time quota data for the status bar.
+ */
+
+import {
+	MiniMaxQuotaManager,
+	type MiniMaxQuotaData,
+} from "./minimax-quota-scraper.js";
+
+export interface QuotaStatus {
+	/** Short status for display (e.g., "5h: 100% left") */
+	short: string;
+	/** Extended status (e.g., "5h: 100% left · week: 26% left") */
+	extended: string;
+	/** Whether quota is critical (< 20%) */
+	isCritical: boolean;
+	/** Whether quota is exhausted */
+	isExhausted: boolean;
+	/** Reset time for 5h window */
+	h5ResetsAt?: string;
+	/** Reset time for weekly window */
+	weeklyResetsAt?: string;
+	/** Raw data source */
+	data?: MiniMaxQuotaData;
+}
+
+export interface QuotaDisplayConfig {
+	/** Provider name */
+	provider: string;
+	/** Cookie file path */
+	cookieFile?: string;
+	/** Refresh interval in ms (default: 5 min) */
+	refreshIntervalMs?: number;
+	/** Custom formatter */
+	formatter?: (data: MiniMaxQuotaData) => QuotaStatus;
+}
+
+/**
+ * Format quota data for display
+ */
+export function formatQuotaStatus(data: MiniMaxQuotaData): QuotaStatus {
+	const h5Left = Math.max(0, 100 - data.h5UsedPct);
+	const weeklyLeft = Math.max(0, 100 - data.weeklyUsedPct);
+
+	const short = `5h: ${h5Left.toFixed(0)}% left`;
+	const extendedParts = [short, `week: ${weeklyLeft.toFixed(0)}% left`];
+
+	return {
+		short,
+		extended: extendedParts.join(" · "),
+		isCritical: h5Left < 20,
+		isExhausted: h5Left <= 0,
+		h5ResetsAt: data.h5ResetsAt,
+		weeklyResetsAt: data.weeklyResetsAt,
+		data,
+	};
+}
+
+/**
+ * Quota Status Manager
+ *
+ * Manages quota display with automatic refresh.
+ */
+export class QuotaStatusManager {
+	private manager?: MiniMaxQuotaManager;
+	private lastStatus?: QuotaStatus;
+	private refreshTimer?: ReturnType<typeof setInterval>;
+	private readonly config: QuotaDisplayConfig;
+
+	constructor(config: QuotaDisplayConfig) {
+		this.config = {
+			refreshIntervalMs: 5 * 60 * 1000, // 5 min default
+			...config,
+		};
+
+		if (config.provider === "minimax") {
+			this.manager = new MiniMaxQuotaManager({
+				cookieFile: config.cookieFile,
+				cacheDurationMs: config.refreshIntervalMs,
+			});
+		}
+	}
+
+	/**
+	 * Check if quota tracking is available
+	 */
+	isAvailable(): boolean {
+		if (this.config.provider === "minimax") {
+			return this.manager?.isAvailable() ?? false;
+		}
+		return false;
+	}
+
+	/**
+	 * Get current quota status (async refresh if needed)
+	 */
+	async getStatus(forceRefresh = false): Promise<QuotaStatus | null> {
+		if (!this.manager) {
+			return null;
+		}
+
+		try {
+			const data = await this.manager.getQuota(forceRefresh);
+			this.lastStatus = this.config.formatter
+				? this.config.formatter(data)
+				: formatQuotaStatus(data);
+			return this.lastStatus;
+		} catch (error) {
+			console.warn("[QuotaStatus] Failed to fetch quota:", error);
+			return this.lastStatus ?? null;
+		}
+	}
+
+	/**
+	 * Get last cached status (synchronous)
+	 */
+	getCachedStatus(): QuotaStatus | null {
+		return this.lastStatus ?? null;
+	}
+
+	/**
+	 * Start automatic refresh
+	 */
+	startAutoRefresh(callback?: (status: QuotaStatus) => void): void {
+		if (this.refreshTimer) {
+			return; // Already running
+		}
+
+		// Initial fetch
+		this.getStatus().then((status) => {
+			if (status && callback) {
+				callback(status);
+			}
+		});
+
+		// Periodic refresh
+		this.refreshTimer = setInterval(async () => {
+			const status = await this.getStatus();
+			if (status && callback) {
+				callback(status);
+			}
+		}, this.config.refreshIntervalMs!);
+	}
+
+	/**
+	 * Stop automatic refresh
+	 */
+	stopAutoRefresh(): void {
+		if (this.refreshTimer) {
+			clearInterval(this.refreshTimer);
+			this.refreshTimer = undefined;
+		}
+	}
+
+	/**
+	 * Generate status bar string
+	 */
+	async getStatusBarString(): Promise<string> {
+		const status = await this.getStatus();
+		if (!status) {
+			return `${this.config.provider}: no quota data`;
+		}
+
+		const icon = status.isExhausted ? "🚫" : status.isCritical ? "⚠️" : "✅";
+
+		return `${icon} ${this.config.provider} ${status.extended}`;
+	}
+}
+
+/**
+ * Create a quota status manager from environment variables
+ */
+export function createQuotaStatusManagerFromEnv(
+	provider = process.env.QUOTA_PROVIDER ?? "minimax",
+): QuotaStatusManager | null {
+	// Check if quota tracking is enabled
+	if (process.env.QUOTA_AUTO_FETCH !== "true") {
+		return null;
+	}
+
+	// Check if cookie file exists
+	const cookieFile =
+		process.env.QUOTA_COOKIE_FILE ??
+		`${process.env.HOME ?? process.env.USERPROFILE}/.config/minimax-cookies.txt`;
+
+	return new QuotaStatusManager({
+		provider,
+		cookieFile,
+		refreshIntervalMs: parseInt(process.env.QUOTA_REFRESH_MS ?? "300000", 10),
+	});
+}

package/harness/e2e/test-engine.ts

@@ -0,0 +1,398 @@
+/**
+ * E2E Test Engine — RFC-0013
+ *
+ * Browser-based end-to-end testing before work is marked ready for client.
+ *
+ * Artifact Layout:
+ *   harness/e2e/
+ *     scenarios/
+ *     test-data/
+ *     reports/
+ *     artifacts/screenshots/
+ *     artifacts/traces/
+ *     artifacts/videos/
+ */
+
+import type {
+	E2EScenario,
+	E2EStep,
+	E2EResult,
+	E2EReport,
+} from "../../packages/types/src/runtime-types.js";
+import { writeJson, appendJsonl } from "../../cli.js";
+import { join } from "node:path";
+
+// Re-export from playwright-runner for backwards compatibility
+export type { E2ERunner as PlaywrightRunner } from "./playwright-runner.js";
+
+// Also import locally for use in this file
+import type { E2ERunner } from "./playwright-runner.js";
+
+export interface E2EConfig {
+	baseUrl: string;
+	headless?: boolean;
+	screenshotOnFailure?: boolean;
+	videoOnFailure?: boolean;
+	traceOnFailure?: boolean;
+	timeout?: number;
+}
+
+export class E2ETestEngine {
+	private readonly rootDir: string;
+	private readonly config: E2EConfig;
+	private runner: E2ERunner | null = null;
+
+	constructor(rootDir: string, config: E2EConfig) {
+		this.rootDir = rootDir;
+		this.config = {
+			headless: true,
+			screenshotOnFailure: true,
+			videoOnFailure: false,
+			traceOnFailure: false,
+			timeout: 30000,
+			...config,
+		};
+	}
+
+	/**
+	 * Set the Playwright runner
+	 */
+	setRunner(runner: E2ERunner): void {
+		this.runner = runner;
+	}
+
+	/**
+	 * Run a single E2E scenario
+	 */
+	async runScenario(
+		scenario: E2EScenario,
+		context?: Record<string, unknown>,
+	): Promise<E2EResult> {
+		if (!this.runner) {
+			return this.createErrorResult(scenario.id, "No runner configured");
+		}
+
+		const startTime = Date.now();
+		let stepsExecuted = 0;
+		let stepsPassed = 0;
+		let stepsFailed = 0;
+		let screenshotPath: string | undefined;
+		let failedStep: number | undefined;
+
+		try {
+			for (let i = 0; i < scenario.steps.length; i++) {
+				const step = scenario.steps[i];
+				stepsExecuted++;
+
+				try {
+					const success = await this.executeStep(step, context);
+					if (success) {
+						stepsPassed++;
+					} else {
+						stepsFailed++;
+						failedStep = i;
+						if (this.config.screenshotOnFailure) {
+							screenshotPath = await this.captureScreenshot(scenario.id, i);
+						}
+						break; // Stop on first failure
+					}
+				} catch (error) {
+					stepsFailed++;
+					failedStep = i;
+					if (this.config.screenshotOnFailure) {
+						screenshotPath = await this.captureScreenshot(scenario.id, i);
+					}
+					break;
+				}
+			}
+
+			const duration = Date.now() - startTime;
+
+			return {
+				scenarioId: scenario.id,
+				status: stepsFailed > 0 ? "failed" : "passed",
+				duration,
+				stepsExecuted,
+				stepsPassed,
+				stepsFailed,
+				screenshotPath,
+				executedAt: new Date().toISOString(),
+				failedStep,
+			};
+		} catch (error) {
+			return this.createErrorResult(scenario.id, String(error));
+		}
+	}
+
+	/**
+	 * Run all scenarios for a job
+	 */
+	async runAllScenarios(
+		jobId: string,
+		scenarios: E2EScenario[],
+		context?: Record<string, unknown>,
+	): Promise<E2EReport> {
+		const results: E2EResult[] = [];
+		let totalDuration = 0;
+
+		for (const scenario of scenarios) {
+			if (!scenario.required) {
+				// Skip non-required scenarios on failure of required ones
+				const result = await this.runScenario(scenario, context);
+				results.push(result);
+				totalDuration += result.duration;
+			} else {
+				const result = await this.runScenario(scenario, context);
+				results.push(result);
+				totalDuration += result.duration;
+
+				// Stop on first required failure
+				if (result.status === "failed") {
+					// Run remaining non-required scenarios
+					for (const nextScenario of scenarios.slice(
+						scenarios.indexOf(scenario) + 1,
+					)) {
+						if (!nextScenario.required) {
+							const nextResult = await this.runScenario(nextScenario, context);
+							results.push(nextResult);
+							totalDuration += nextResult.duration;
+						}
+					}
+					break;
+				}
+			}
+		}
+
+		const report: E2EReport = {
+			jobId,
+			scenarios,
+			results,
+			summary: {
+				total: results.length,
+				passed: results.filter((r) => r.status === "passed").length,
+				failed: results.filter((r) => r.status === "failed").length,
+				skipped: results.filter((r) => r.status === "skipped").length,
+				duration: totalDuration,
+			},
+			createdAt: new Date().toISOString(),
+		};
+
+		// Save report
+		this.saveReport(report);
+
+		return report;
+	}
+
+	/**
+	 * Create a scenario from a natural language description
+	 */
+	createScenario(
+		id: string,
+		name: string,
+		description: string,
+		required: boolean = true,
+	): E2EScenario {
+		return {
+			id,
+			name,
+			description,
+			steps: [],
+			required,
+		};
+	}
+
+	/**
+	 * Add a step to a scenario
+	 */
+	addStep(
+		scenario: E2EScenario,
+		action: E2EStep["action"],
+		options?: Partial<E2EStep>,
+	): void {
+		scenario.steps.push({
+			action,
+			selector: options?.selector,
+			value: options?.value,
+			timeout: options?.timeout,
+			assertCondition: options?.assertCondition,
+		});
+	}
+
+	/**
+	 * Execute a single step
+	 */
+	private async executeStep(
+		step: E2EStep,
+		context?: Record<string, unknown>,
+	): Promise<boolean> {
+		if (!this.runner) return false;
+
+		const timeout = step.timeout ?? this.config.timeout ?? 30000;
+
+		switch (step.action) {
+			case "navigate":
+				await this.runner.navigate(
+					this.resolveValue(step.value ?? "", context),
+				);
+				return true;
+
+			case "click":
+				await this.runner.wait(step.selector!, timeout);
+				await this.runner.click(step.selector!);
+				return true;
+
+			case "type":
+				await this.runner.wait(step.selector!, timeout);
+				await this.runner.type(
+					step.selector!,
+					this.resolveValue(step.value ?? "", context),
+				);
+				return true;
+
+			case "wait":
+				await this.runner.wait(step.selector!, timeout);
+				return true;
+
+			case "screenshot": {
+				const path = this.resolveValue(step.value ?? "screenshot.png", context);
+				await this.runner.screenshot(path);
+				return true;
+			}
+
+			case "assert":
+				return await this.runner.assert(
+					step.assertCondition ?? "true",
+					`Assertion failed: ${step.assertCondition}`,
+				);
+
+			case "hover":
+				await this.runner.wait(step.selector!, timeout);
+				// await this.runner.hover(step.selector!);
+				return true;
+
+			case "select":
+				await this.runner.wait(step.selector!, timeout);
+				// await this.runner.select(step.selector!, step.value!);
+				return true;
+
+			case "upload":
+				await this.runner.wait(step.selector!, timeout);
+				// await this.runner.upload(step.selector!, step.value!);
+				return true;
+
+			default:
+				console.warn(`Unknown step action: ${step.action}`);
+				return false;
+		}
+	}
+
+	/**
+	 * Capture screenshot
+	 */
+	private async captureScreenshot(
+		scenarioId: string,
+		stepIndex: number,
+	): Promise<string> {
+		const path = join(
+			this.rootDir,
+			"harness",
+			"e2e",
+			"artifacts",
+			"screenshots",
+			`${scenarioId}-step-${stepIndex}.png`,
+		);
+		if (this.runner) {
+			await this.runner.screenshot(path);
+		}
+		return path;
+	}
+
+	/**
+	 * Create error result
+	 */
+	private createErrorResult(scenarioId: string, error: string): E2EResult {
+		return {
+			scenarioId,
+			status: "error",
+			duration: 0,
+			stepsExecuted: 0,
+			stepsPassed: 0,
+			stepsFailed: 0,
+			errorMessage: error,
+			executedAt: new Date().toISOString(),
+		};
+	}
+
+	/**
+	 * Save report to file
+	 */
+	private saveReport(report: E2EReport): void {
+		const reportPath = join(
+			this.rootDir,
+			"harness",
+			"e2e",
+			"reports",
+			`${report.jobId}-${Date.now()}.json`,
+		);
+		writeJson(reportPath, report);
+
+		// Also append to a log
+		const logPath = join(
+			this.rootDir,
+			"harness",
+			"e2e",
+			"reports",
+			`${report.jobId}.jsonl`,
+		);
+		appendJsonl(logPath, report);
+	}
+
+	/**
+	 * Resolve variables in values
+	 */
+	private resolveValue(
+		value: string,
+		context?: Record<string, unknown>,
+	): string {
+		if (!context) return value;
+		let result = value;
+		for (const [key, val] of Object.entries(context)) {
+			result = result.replace(new RegExp(`{{${key}}}`, "g"), String(val));
+		}
+		return result;
+	}
+
+	/**
+	 * Load scenarios from directory
+	 */
+	loadScenarios(_scenariosDir: string): E2EScenario[] {
+		// In practice, this would read from the scenarios directory
+		return [];
+	}
+}
+
+/**
+ * Default E2E steps for common workflows
+ */
+export const CommonSteps = {
+	login: (username: string, password: string): E2EStep[] => [
+		{ action: "navigate", value: "/login" },
+		{ action: "type", selector: "#username", value: username },
+		{ action: "type", selector: "#password", value: password },
+		{ action: "click", selector: 'button[type="submit"]' },
+		{ action: "wait", selector: ".dashboard", timeout: 10000 },
+	],
+
+	logout: (): E2EStep[] => [
+		{ action: "click", selector: ".user-menu" },
+		{ action: "click", selector: 'a[href="/logout"]' },
+	],
+
+	fillForm: (fields: Record<string, string>): E2EStep[] => {
+		const steps: E2EStep[] = [];
+		for (const [selector, value] of Object.entries(fields)) {
+			steps.push({ action: "type", selector, value });
+		}
+		return steps;
+	},
+};