pi-harness-runtime 0.2.0 → 0.3.1

package/harness/e2e/playwright-runner.ts

@@ -0,0 +1,252 @@
+/**
+ * Playwright Adapter — RFC-0004
+ *
+ * Uses a persistent browser profile to read provider console information
+ * when no official usage API exists. Initial target: MiniMax usage console.
+ *
+ * Also used as the E2E runner for testing workflows.
+ */
+
+export interface PlaywrightRunnerConfig {
+	headless?: boolean;
+	slowMo?: number;
+	timeout?: number;
+	browser?: "chromium" | "firefox" | "webkit";
+	profileDir?: string;
+}
+
+export interface PlaywrightBrowser {
+	new (config?: PlaywrightRunnerConfig): PlaywrightBrowserInstance;
+}
+
+export interface PlaywrightBrowserInstance {
+	page(): PlaywrightPage;
+	close(): Promise<void>;
+}
+
+export interface PlaywrightPage {
+	goto(url: string): Promise<void>;
+	click(selector: string): Promise<void>;
+	fill(selector: string, value: string): Promise<void>;
+	waitForSelector(
+		selector: string,
+		options?: { timeout?: number },
+	): Promise<void>;
+	screenshot(options?: { path?: string }): Promise<void>;
+	evaluate<T>(fn: (...args: unknown[]) => T, ...args: unknown[]): Promise<T>;
+	content(): Promise<string>;
+	url(): Promise<string>;
+}
+
+export interface QuotaPageData {
+	provider: string;
+	h5UsedPct: number;
+	h5ResetsAt?: string;
+	weeklyUsedPct: number;
+	weeklyResetsAt?: string;
+	dailyUsedPct?: number;
+	dailyResetsAt?: string;
+	raw?: string;
+}
+
+/**
+ * MiniMax quota scraper using Playwright
+ */
+export class MiniMaxQuotaScraper {
+	private config: PlaywrightRunnerConfig;
+
+	constructor(config: PlaywrightRunnerConfig = {}) {
+		this.config = {
+			headless: true,
+			timeout: 30000,
+			browser: "chromium",
+			...config,
+		};
+	}
+
+	/**
+	 * Scrape quota data from MiniMax console
+	 */
+	async scrape(): Promise<QuotaPageData> {
+		// In a real implementation, this would use playwright
+		// For now, return a placeholder
+		return {
+			provider: "minimax",
+			h5UsedPct: 0,
+			weeklyUsedPct: 0,
+			raw: "Playwright integration placeholder",
+		};
+	}
+
+	/**
+	 * Wait for quota data to load
+	 */
+	async waitForQuotaLoad(
+		page: PlaywrightPage,
+		timeoutMs?: number,
+	): Promise<void> {
+		const selectors = [
+			".quota-used",
+			".usage-percentage",
+			"[data-quota]",
+			".limit-bar",
+		];
+
+		const timeout = timeoutMs ?? this.config.timeout ?? 30000;
+
+		for (const selector of selectors) {
+			try {
+				await page.waitForSelector(selector, { timeout });
+				return;
+			} catch {
+				// Try next selector
+			}
+		}
+
+		throw new Error("Could not find quota element on page");
+	}
+
+	/**
+	 * Parse quota percentage from text
+	 */
+	parsePercentage(text: string): number {
+		const match = text.match(/(\d+(?:\.\d+)?)\s*%/);
+		return match ? parseFloat(match[1]) : 0;
+	}
+
+	/**
+	 * Parse reset time from text
+	 */
+	parseResetTime(text: string): string | undefined {
+		// Examples: "Resets in 4 hr 56 min", "Resets in 2d 13h"
+		const match = text.match(/Resets?\s+in\s+(\d+d\s*)?(\d+h\s*)?(\d+m?)?/i);
+		if (!match) return undefined;
+
+		const parts = [];
+		if (match[1]) parts.push(match[1]);
+		if (match[2]) parts.push(match[2]);
+		if (match[3]) parts.push(match[3]);
+
+		return parts.join("").trim();
+	}
+}
+
+/**
+ * Playwright E2E Runner for testing workflows
+ */
+export class PlaywrightE2ERunner {
+	private config: PlaywrightRunnerConfig;
+	private browser: PlaywrightBrowserInstance | null = null;
+	private page: PlaywrightPage | null = null;
+
+	constructor(config: PlaywrightRunnerConfig = {}) {
+		this.config = {
+			headless: true,
+			slowMo: 0,
+			timeout: 30000,
+			browser: "chromium",
+			...config,
+		};
+	}
+
+	/**
+	 * Start the browser
+	 */
+	async start(): Promise<void> {
+		// In a real implementation, this would launch Playwright
+		// this.browser = await chromium.launch({ headless: this.config.headless });
+		// this.page = await this.browser.newPage();
+	}
+
+	/**
+	 * Stop the browser
+	 */
+	async stop(): Promise<void> {
+		if (this.page) {
+			// await this.page.close();
+			this.page = null;
+		}
+		if (this.browser) {
+			// await this.browser.close();
+			this.browser = null;
+		}
+	}
+
+	/**
+	 * Navigate to a URL
+	 */
+	async navigate(url: string): Promise<void> {
+		if (!this.page) throw new Error("Browser not started");
+		await this.page.goto(url);
+	}
+
+	/**
+	 * Click an element
+	 */
+	async click(selector: string): Promise<void> {
+		if (!this.page) throw new Error("Browser not started");
+		await this.page.waitForSelector(selector, { timeout: this.config.timeout });
+		await this.page.click(selector);
+	}
+
+	/**
+	 * Fill an input
+	 */
+	async fill(selector: string, value: string): Promise<void> {
+		if (!this.page) throw new Error("Browser not started");
+		await this.page.waitForSelector(selector, { timeout: this.config.timeout });
+		await this.page.fill(selector, value);
+	}
+
+	/**
+	 * Wait for selector
+	 */
+	async wait(selector: string, timeoutMs?: number): Promise<void> {
+		if (!this.page) throw new Error("Browser not started");
+		await this.page.waitForSelector(selector, {
+			timeout: timeoutMs ?? this.config.timeout,
+		});
+	}
+
+	/**
+	 * Take a screenshot
+	 */
+	async screenshot(path: string): Promise<void> {
+		if (!this.page) throw new Error("Browser not started");
+		await this.page.screenshot({ path });
+	}
+
+	/**
+	 * Evaluate JavaScript
+	 */
+	async evaluate<T>(fn: () => T): Promise<T> {
+		if (!this.page) throw new Error("Browser not started");
+		return this.page.evaluate(fn);
+	}
+
+	/**
+	 * Get current URL
+	 */
+	async getUrl(): Promise<string> {
+		if (!this.page) throw new Error("Browser not started");
+		return this.page.url();
+	}
+
+	/**
+	 * Assert a condition
+	 */
+	async assert(condition: string, message?: string): Promise<boolean> {
+		if (!this.page) throw new Error("Browser not started");
+
+		const result = await this.page.evaluate((cond: unknown) => {
+			// eslint-disable-next-line no-eval
+			return eval(String(cond)) as boolean; // eslint-disable-line
+		}, condition);
+
+		if (!result && message) {
+			throw new Error(message);
+		}
+
+		return result;
+	}
+}

package/harness/e2e/test-engine.ts

@@ -0,0 +1,402 @@
+/**
+ * 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.ts";
+import { writeJson, appendJsonl } from "../../cli.ts";
+// @ts-expect-error - Bun has built-in Node.js types
+import { join } from "node:path";
+
+export interface PlaywrightRunner {
+	navigate(url: string): Promise<void>;
+	click(selector: string): Promise<void>;
+	type(selector: string, text: string): Promise<void>;
+	wait(selector: string, timeout?: number): Promise<void>;
+	screenshot(path: string): Promise<void>;
+	assert(condition: string, message?: string): Promise<boolean>;
+}
+
+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: PlaywrightRunner | 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: PlaywrightRunner): 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;
+	},
+};