pi-harness-runtime 0.10.13 → 0.10.14

package/harness/e2e/openai-quota-scraper.js

@@ -0,0 +1,332 @@
+/**
+ * OpenAI Quota Scraper — RFC-0031+
+ *
+ * Scrapes quota data from ChatGPT Codex analytics page using Playwright.
+ * Uses cookie-based authentication to access the usage API.
+ *
+ * Target: https://chatgpt.com/backend-api/wham/usage
+ *
+ * Response shape:
+ * {
+ *   "rate_limit": {
+ *     "primary_window": {
+ *       "used_percent": 7,           // Weekly usage percentage (0-100)
+ *       "limit_window_seconds": 604800,  // 7-day window
+ *       "reset_after_seconds": 491924,   // Seconds until reset
+ *       "reset_at": 1785649269          // Unix timestamp
+ *     }
+ *   },
+ *   "credits": {
+ *     "has_credits": false,
+ *     "balance": "0"
+ *   }
+ * }
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+const DEFAULT_COOKIE_FILE = join(homedir(), ".config", "openai-cookies.txt");
+const USAGE_API = "https://chatgpt.com/backend-api/wham/usage";
+const ANALYTICS_URL = "https://chatgpt.com/codex/cloud/settings/analytics#usage";
+/**
+ * Load Netscape-format cookies from file
+ */
+function loadNetscapeCookies(path) {
+    const cookies = [];
+    if (!existsSync(path)) {
+        return cookies;
+    }
+    const lines = readFileSync(path, "utf-8").split("\n");
+    for (const line of lines) {
+        if (!line || (line.startsWith("#") && !line.startsWith("#HttpOnly_"))) {
+            continue;
+        }
+        let httpOnly = false;
+        let trimmed = line;
+        if (trimmed.startsWith("#HttpOnly_")) {
+            httpOnly = true;
+            trimmed = trimmed.slice("#HttpOnly_".length);
+        }
+        const parts = trimmed.split("\t");
+        if (parts.length < 7)
+            continue;
+        const [domain, _flag, cookiePath, secure, expires, name, value] = parts;
+        cookies.push({
+            name,
+            value,
+            domain,
+            path: cookiePath || "/",
+            secure: secure.toUpperCase() === "TRUE",
+            httpOnly,
+            expires: parseInt(expires, 10) || undefined,
+        });
+    }
+    return cookies;
+}
+/**
+ * Format remaining seconds into human-readable string
+ */
+function formatRemainsSeconds(seconds) {
+    if (seconds <= 0)
+        return "soon";
+    const days = Math.floor(seconds / 86400);
+    const hr = Math.floor((seconds % 86400) / 3600);
+    const min = Math.floor((seconds % 3600) / 60);
+    const parts = [];
+    if (days > 0)
+        parts.push(`${days} days`);
+    if (hr > 0)
+        parts.push(`${hr} hr`);
+    if (min > 0 && days === 0)
+        parts.push(`${min} min`);
+    return parts.join(" ") || "0 min";
+}
+/**
+ * OpenAI Quota Scraper
+ *
+ * Uses Playwright to fetch quota data from ChatGPT Codex analytics.
+ */
+export class OpenAIQuotaScraper {
+    config;
+    constructor(config = {}) {
+        this.config = {
+            cookieFile: config.cookieFile ?? DEFAULT_COOKIE_FILE,
+            headless: config.headless ?? true,
+            timeout: config.timeout ?? 60000,
+            chromePath: config.chromePath ?? "",
+            quiet: config.quiet ?? false,
+        };
+    }
+    /**
+     * Set cookie file path
+     */
+    setCookieFile(path) {
+        this.config.cookieFile = path;
+        return this;
+    }
+    /**
+     * Enable/disable quiet mode
+     */
+    setQuiet(quiet) {
+        this.config.quiet = quiet;
+        return this;
+    }
+    /**
+     * Check if any cookie source exists
+     */
+    hasCookieFile() {
+        return existsSync(this.config.cookieFile);
+    }
+    /**
+     * Scrape quota data using Playwright
+     */
+    async scrape() {
+        const { chromium } = await import("playwright");
+        const cookies = loadNetscapeCookies(this.config.cookieFile);
+        if (cookies.length === 0) {
+            const dropHint = join(homedir(), ".pi-harness-runtime", "cookies");
+            const msg = `No OpenAI cookies found.
+Drop your chatgpt.com cookies (Netscape or EditThisCookie JSON) into:
+  ${dropHint}
+Then run: bun run packages/cookie-sanitizer/src/sync.ts`;
+            if (!this.config.quiet)
+                console.error(`[DEBUG OpenAIQuotaScraper] ${msg}`);
+            throw new Error(msg);
+        }
+        // Launch browser
+        if (!this.config.quiet) {
+            console.log("[DEBUG OpenAIQuotaScraper] Launching browser...");
+        }
+        const browser = await chromium.launch({
+            executablePath: this.config.chromePath || undefined,
+            headless: this.config.headless,
+            args: ["--no-sandbox", "--disable-dev-shm-usage"],
+        });
+        const context = await browser.newContext({
+            locale: "en-US",
+            viewport: { width: 1440, height: 900 },
+            userAgent: "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        });
+        // Inject cookies
+        await context.addCookies(cookies.map((c) => ({
+            name: c.name,
+            value: c.value,
+            domain: c.domain,
+            path: c.path,
+            secure: c.secure,
+            httpOnly: c.httpOnly,
+            expires: c.expires,
+        })));
+        const page = await context.newPage();
+        // Capture API responses
+        let usageData = null;
+        page.on("response", async (response) => {
+            const url = response.url();
+            if (url.includes("/wham/usage")) {
+                try {
+                    usageData = await response.json().catch(() => null);
+                }
+                catch {
+                    // Ignore parse errors
+                }
+            }
+        });
+        try {
+            // Navigate to analytics page
+            if (!this.config.quiet) {
+                console.log("[DEBUG OpenAIQuotaScraper] Navigating to analytics page...");
+            }
+            await page.goto(ANALYTICS_URL, {
+                waitUntil: "domcontentloaded",
+                timeout: this.config.timeout,
+            });
+            // Wait for JS to render
+            await page.waitForTimeout(5000);
+            // Wait for network to settle
+            try {
+                await page.waitForLoadState("networkidle", { timeout: 10000 });
+            }
+            catch {
+                // Network idle might not be achievable
+            }
+            // Check if redirected to login
+            const currentUrl = page.url();
+            if (currentUrl.includes("login") || currentUrl.includes("auth")) {
+                const msg = "OpenAI cookies are expired or insufficient. Please re-export cookies from chatgpt.com.";
+                if (!this.config.quiet)
+                    console.error("[DEBUG OpenAIQuotaScraper] " + msg);
+                throw new Error(msg);
+            }
+            // Parse the usage data from the captured API response
+            if (!usageData) {
+                const msg = "Failed to capture usage data from API";
+                if (!this.config.quiet)
+                    console.error("[DEBUG OpenAIQuotaScraper] " + msg);
+                throw new Error(msg);
+            }
+            // Extract weekly usage from primary_window
+            const primaryWindow = usageData?.rate_limit?.primary_window;
+            const weeklyUsedPct = primaryWindow?.used_percent ?? 0;
+            const resetAfterSeconds = primaryWindow?.reset_after_seconds ?? 0;
+            const resetAtEpoch = primaryWindow?.reset_at;
+            const weeklyResetsAt = formatRemainsSeconds(resetAfterSeconds);
+            // Extract credits if available
+            const credits = usageData?.credits;
+            const creditBalance = credits?.has_credits ? credits.balance : undefined;
+            if (!this.config.quiet) {
+                console.log(`[DEBUG OpenAIQuotaScraper] Weekly usage: ${weeklyUsedPct}%, resets in ${weeklyResetsAt}`);
+            }
+            return {
+                provider: "openai",
+                weeklyUsedPct,
+                weeklyResetsAt,
+                weeklyResetsAtEpoch: resetAtEpoch ? resetAtEpoch * 1000 : undefined,
+                resetAfterSeconds,
+                creditBalance,
+                apiEndpoint: USAGE_API,
+                scrapedAt: new Date().toISOString(),
+            };
+        }
+        finally {
+            await browser.close();
+        }
+    }
+    /**
+     * Quick scrape using direct API fetch (faster, but may fail without browser context)
+     */
+    async scrapeDirect() {
+        const cookies = loadNetscapeCookies(this.config.cookieFile);
+        if (cookies.length === 0)
+            return null;
+        const cookieHeader = cookies
+            .map((c) => `${c.name}=${encodeURIComponent(c.value)}`)
+            .join("; ");
+        try {
+            const response = await fetch(USAGE_API, {
+                headers: {
+                    Cookie: cookieHeader,
+                    Accept: "application/json",
+                    "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36",
+                    Referer: "https://chatgpt.com/codex/cloud/settings/analytics",
+                },
+            });
+            if (!response.ok) {
+                if (!this.config.quiet) {
+                    console.log(`[DEBUG OpenAIQuotaScraper] Direct API failed: ${response.status}`);
+                }
+                return null;
+            }
+            const data = (await response.json());
+            const primaryWindow = data?.rate_limit?.primary_window;
+            const weeklyUsedPct = primaryWindow?.used_percent ?? 0;
+            const resetAfterSeconds = primaryWindow?.reset_after_seconds ?? 0;
+            const resetAtEpoch = primaryWindow?.reset_at;
+            const weeklyResetsAt = formatRemainsSeconds(resetAfterSeconds);
+            return {
+                provider: "openai",
+                weeklyUsedPct,
+                weeklyResetsAt,
+                weeklyResetsAtEpoch: resetAtEpoch ? resetAtEpoch * 1000 : undefined,
+                resetAfterSeconds,
+                apiEndpoint: USAGE_API,
+                scrapedAt: new Date().toISOString(),
+            };
+        }
+        catch (error) {
+            if (!this.config.quiet) {
+                console.warn("[DEBUG OpenAIQuotaScraper] Direct API error:", error instanceof Error ? error.message : String(error));
+            }
+            return null;
+        }
+    }
+}
+/**
+ * Integration helper for index.ts
+ */
+export class OpenAIQuotaManager {
+    scraper;
+    lastQuota;
+    lastFetchTime = 0;
+    cacheDurationMs;
+    constructor(config = {}) {
+        this.scraper = new OpenAIQuotaScraper(config);
+        this.cacheDurationMs = config.cacheDurationMs ?? 5 * 60 * 1000; // 5 min default
+    }
+    /**
+     * Get current quota (uses cache)
+     */
+    async getQuota(forceRefresh = false) {
+        const now = Date.now();
+        if (!forceRefresh &&
+            this.lastQuota &&
+            now - this.lastFetchTime < this.cacheDurationMs) {
+            return this.lastQuota;
+        }
+        // Try direct API first (faster)
+        const directResult = await this.scraper.scrapeDirect();
+        if (directResult) {
+            this.lastQuota = directResult;
+            this.lastFetchTime = now;
+            return this.lastQuota;
+        }
+        // Fall back to browser scrape
+        try {
+            this.lastQuota = await this.scraper.scrape();
+            this.lastFetchTime = now;
+            return this.lastQuota;
+        }
+        catch (error) {
+            // Return cached value if available
+            if (this.lastQuota) {
+                return this.lastQuota;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Check if quota is available
+     */
+    isAvailable() {
+        return this.scraper.hasCookieFile();
+    }
+}

package/harness/e2e/playwright-runner.js

@@ -0,0 +1,165 @@
+/**
+ * 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.
+ */
+// Dynamic import for Playwright (optional dependency)
+let playwrightModule = null;
+async function getPlaywright() {
+    if (!playwrightModule) {
+        try {
+            playwrightModule = await import("playwright");
+        }
+        catch {
+            console.warn("[PlaywrightRunner] Playwright not installed. E2E tests will be skipped.");
+            return null;
+        }
+    }
+    return playwrightModule;
+}
+export { MiniMaxQuotaScraper } from "./minimax-quota-scraper.js";
+/**
+ * Playwright E2E Runner for testing workflows
+ *
+ * Real implementation using Playwright library.
+ */
+export class PlaywrightE2ERunner {
+    config;
+    browser = null;
+    context = null;
+    page = null;
+    constructor(config = {}) {
+        this.config = {
+            headless: true,
+            slowMo: 0,
+            timeout: 30000,
+            browser: "chromium",
+            ...config,
+        };
+    }
+    /**
+     * Start the browser
+     */
+    async start() {
+        const pw = await getPlaywright();
+        if (!pw) {
+            throw new Error("Playwright not available. Install with: bun add playwright");
+        }
+        const browserType = this.config.browser === "firefox"
+            ? pw.firefox
+            : this.config.browser === "webkit"
+                ? pw.webkit
+                : pw.chromium;
+        this.browser = await browserType.launch({
+            headless: this.config.headless,
+            slowMo: this.config.slowMo,
+        });
+        this.context = await this.browser.newContext({
+            viewport: this.config.viewport ?? { width: 1280, height: 720 },
+        });
+        this.page = await this.context.newPage();
+    }
+    /**
+     * Stop the browser
+     */
+    async stop() {
+        if (this.page) {
+            await this.page.close();
+            this.page = null;
+        }
+        if (this.context) {
+            await this.context.close();
+            this.context = null;
+        }
+        if (this.browser) {
+            await this.browser.close();
+            this.browser = null;
+        }
+    }
+    /**
+     * Navigate to a URL
+     */
+    async navigate(url) {
+        if (!this.page)
+            throw new Error("Browser not started");
+        await this.page.goto(url, { timeout: this.config.timeout });
+    }
+    /**
+     * Click an element
+     */
+    async click(selector) {
+        if (!this.page)
+            throw new Error("Browser not started");
+        await this.page.waitForSelector(selector, { timeout: this.config.timeout });
+        await this.page.click(selector);
+    }
+    /**
+     * Type text into an input
+     */
+    async type(selector, text) {
+        if (!this.page)
+            throw new Error("Browser not started");
+        await this.page.waitForSelector(selector, { timeout: this.config.timeout });
+        await this.page.fill(selector, text);
+    }
+    /**
+     * Wait for selector
+     */
+    async wait(selector, timeoutMs) {
+        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) {
+        if (!this.page)
+            throw new Error("Browser not started");
+        await this.page.screenshot({ path, fullPage: true });
+    }
+    /**
+     * Assert a condition
+     */
+    async assert(condition, message) {
+        if (!this.page)
+            throw new Error("Browser not started");
+        const result = await this.page.evaluate((cond) => {
+            // eslint-disable-next-line no-eval
+            return eval(String(cond)); // eslint-disable-line
+        }, condition);
+        if (!result && message) {
+            throw new Error(message);
+        }
+        return result;
+    }
+    /**
+     * Get the underlying page for advanced operations
+     */
+    getPage() {
+        return this.page;
+    }
+    /**
+     * Start tracing for debugging
+     */
+    async startTracing(_outputPath) {
+        if (!this.page)
+            throw new Error("Browser not started");
+        await this.page
+            .context()
+            .tracing.start({ screenshots: true, snapshots: true });
+    }
+    /**
+     * Stop tracing and save
+     */
+    async stopTracing(outputPath) {
+        if (!this.page)
+            throw new Error("Browser not started");
+        await this.page.context().tracing.stop({ path: outputPath });
+    }
+}

package/harness/e2e/quota-status.js

@@ -0,0 +1,140 @@
+/**
+ * Quota Status Display — RFC-0031
+ *
+ * Integrates MiniMax quota scraper with harness status display.
+ * Provides real-time quota data for the status bar.
+ */
+import { MiniMaxQuotaManager, } from "./minimax-quota-scraper.js";
+/**
+ * Format quota data for display
+ */
+export function formatQuotaStatus(data) {
+    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 {
+    manager;
+    lastStatus;
+    refreshTimer;
+    config;
+    constructor(config) {
+        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() {
+        if (this.config.provider === "minimax") {
+            return this.manager?.isAvailable() ?? false;
+        }
+        return false;
+    }
+    /**
+     * Get current quota status (async refresh if needed)
+     */
+    async getStatus(forceRefresh = false) {
+        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() {
+        return this.lastStatus ?? null;
+    }
+    /**
+     * Start automatic refresh
+     */
+    startAutoRefresh(callback) {
+        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() {
+        if (this.refreshTimer) {
+            clearInterval(this.refreshTimer);
+            this.refreshTimer = undefined;
+        }
+    }
+    /**
+     * Generate status bar string
+     */
+    async getStatusBarString() {
+        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") {
+    // 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),
+    });
+}