pi-harness-runtime 0.10.13 → 0.10.14

package/harness/continue-prompt.js

@@ -0,0 +1,164 @@
+/**
+ * Continue Prompt Generator — RFC-0029
+ *
+ * Generates context-aware continue prompts after compaction.
+ * Based on the reference implementation's buildContinuePrompt() pattern.
+ */
+// --- Continue Prompt Generator -----------------------------------------------
+export class ContinuePromptGenerator {
+    /**
+     * Generate a comprehensive continue prompt for post-compact resume
+     */
+    generate(context) {
+        const parts = [
+            "# Continue Previous Task",
+            "",
+            "## Task",
+            context.requirement,
+            "",
+        ];
+        if (context.whatWasCompleted.length > 0) {
+            parts.push("## What Was Completed");
+            for (const item of context.whatWasCompleted) {
+                parts.push(`- ${item}`);
+            }
+            parts.push("");
+        }
+        if (context.partialFiles.length > 0) {
+            parts.push("## Partial Files Created");
+            parts.push("Review these files — they may contain incomplete work:");
+            for (const file of context.partialFiles) {
+                parts.push(`- ${file}`);
+            }
+            parts.push("");
+        }
+        if (context.decisions.length > 0) {
+            parts.push("## Key Decisions");
+            for (const decision of context.decisions) {
+                parts.push(`- ${decision}`);
+            }
+            parts.push("");
+        }
+        if (context.whatNeedsToBeDone.length > 0) {
+            parts.push("## What Needs To Be Done");
+            for (const item of context.whatNeedsToBeDone) {
+                parts.push(`- ${item}`);
+            }
+            parts.push("");
+        }
+        parts.push("## Instructions", "", "1. Review any partial files created above", "2. Continue from where the previous session ended", "3. Complete the remaining work listed in 'What Needs To Be Done'", "4. Ensure all tests pass before marking complete", "", "**Do not repeat work that was already completed.**", "");
+        if (context.nextStep) {
+            parts.push("## Suggested Next Step");
+            parts.push(context.nextStep);
+        }
+        if (context.workingDir) {
+            parts.push("", `Working directory: \`${context.workingDir}\``);
+        }
+        return parts.join("\n");
+    }
+    /**
+     * Generate a minimal continue message for quick resume
+     */
+    generateMinimal(context) {
+        const recent = context.recentMessages
+            .slice(-5)
+            .map((m) => `[${m.role}]\n${this.truncateContent(m.content, 500)}`)
+            .join("\n\n");
+        return [
+            "Continue from where you left off.",
+            "",
+            "## Summary of Earlier Work",
+            context.summary,
+            "",
+            "## Recent Context",
+            recent,
+            "",
+            "**Do not repeat work already done.** Focus on completing the remaining work.",
+        ].join("\n");
+    }
+    /**
+     * Generate a compact boundary message for message history
+     */
+    generateBoundary(options) {
+        return [
+            "## Earlier Conversation Summarized",
+            "",
+            `[Compacted due to: ${options.reason}]`,
+            `[${options.messagesCompacted} messages summarized]`,
+            "",
+            options.summary,
+            "",
+            "## Resume Point",
+            "Continue from the messages below.",
+        ].join("\n");
+    }
+    /**
+     * Extract continue context from compact result
+     */
+    static fromCompactResult(result, task) {
+        return {
+            taskId: task.id,
+            requirement: task.requirement,
+            whatWasCompleted: result.summary
+                ? ContinuePromptGenerator.extractCompletedWork(result.summary)
+                : [],
+            whatNeedsToBeDone: ["Continue from where the conversation was compacted"],
+            partialFiles: [],
+            decisions: result.summary
+                ? ContinuePromptGenerator.extractDecisions(result.summary)
+                : [],
+        };
+    }
+    /**
+     * Extract completed work items from summary text
+     */
+    static extractCompletedWork(summary) {
+        const completed = [];
+        // Look for patterns indicating completed work
+        const patterns = [
+            /completed?:?\s*([^\n.]+)/gi,
+            /created?:?\s*([^\n.]+)/gi,
+            /implemented?:?\s*([^\n.]+)/gi,
+            /fixed?:?\s*([^\n.]+)/gi,
+            /passed?:?\s*([^\n.]+)/gi,
+        ];
+        for (const pattern of patterns) {
+            for (const match of summary.matchAll(pattern)) {
+                if (match[1]) {
+                    completed.push(match[1].trim());
+                }
+            }
+        }
+        return completed.slice(0, 5);
+    }
+    /**
+     * Extract decisions from summary text
+     */
+    static extractDecisions(summary) {
+        const decisions = [];
+        const patterns = [
+            /decided?:?\s*([^\n.]+)/gi,
+            /chose?:?\s*([^\n.]+)/gi,
+            /approach?:?\s*([^\n.]+)/gi,
+            /using?:?\s*([^\n.]+)/gi,
+        ];
+        for (const pattern of patterns) {
+            for (const match of summary.matchAll(pattern)) {
+                if (match[1]) {
+                    decisions.push(match[1].trim());
+                }
+            }
+        }
+        return decisions.slice(0, 5);
+    }
+    /**
+     * Truncate content to max length
+     */
+    truncateContent(content, maxLength) {
+        if (content.length <= maxLength)
+            return content;
+        return content.substring(0, maxLength) + "... [truncated]";
+    }
+}
+// --- Singleton Instance ------------------------------------------------------
+export const continuePromptGenerator = new ContinuePromptGenerator();

package/harness/e2e/minimax-quota-parser.js

@@ -0,0 +1,52 @@
+/**
+ * Strip trailing timestamp / reset-window noise that flattened innerText
+ * concatenates onto values (e.g. "1 day 13 hr 00 UTC", "No credits yet 00 UTC").
+ */
+function stripTrailingNoise(value) {
+    return value
+        .replace(/\s+\d{1,2}(?::\d{2})?\s+UTC.*$/i, "")
+        .replace(/\s+UTC.*$/i, "")
+        .replace(/\s+resets?\s+in\s+.*$/i, "")
+        .replace(/\s*\.{2,}.*$/, "")
+        .trim();
+}
+/**
+ * Parse quota data from visible MiniMax usage page text.
+ */
+export function parseMiniMaxQuotaText(text) {
+    const data = {};
+    const normalized = text.replace(/\r/g, "");
+    const h5Match = normalized.match(/5h(?:\s+limit)?[\s\S]{0,200}?Used\s*(\d+(?:\.\d+)?)\s*%/i);
+    if (h5Match) {
+        data.h5UsedPct = parseFloat(h5Match[1]);
+    }
+    const h5ResetMatch = normalized.match(/5h(?:\s+limit)?[\s\S]{0,200}?Resets?\s+in\s+([^\n%]+)/i);
+    if (h5ResetMatch) {
+        data.h5ResetsAt = stripTrailingNoise(h5ResetMatch[1]);
+    }
+    const weeklyMatch = normalized.match(/week(?:ly)?(?:\s+limit)?[\s\S]{0,200}?Used\s*(\d+(?:\.\d+)?)\s*%/i);
+    if (weeklyMatch) {
+        data.weeklyUsedPct = parseFloat(weeklyMatch[1]);
+    }
+    const weeklyResetMatch = normalized.match(/week(?:ly)?(?:\s+limit)?[\s\S]{0,200}?Resets?\s+in\s+([^\n%]+)/i);
+    if (weeklyResetMatch) {
+        data.weeklyResetsAt = stripTrailingNoise(weeklyResetMatch[1]);
+    }
+    const creditMatch = normalized.match(/credit(?:\s+balance)?[^:\n]*:\s*([^\n]+)/i);
+    if (creditMatch) {
+        const cleaned = stripTrailingNoise(creditMatch[1]);
+        if (cleaned) {
+            data.creditBalance = cleaned;
+        }
+    }
+    const tokenSectionMatch = normalized.match(/token[^:]*:?\s*([\d.,]+\s*(?:M|B|K)?\s*tokens?)/gi);
+    if (tokenSectionMatch) {
+        data.tokenUsage = {
+            currentMonth: tokenSectionMatch[0] || "",
+            last7Days: tokenSectionMatch[1] || "",
+            last30Days: tokenSectionMatch[2] || "",
+            total: tokenSectionMatch[3] || "",
+        };
+    }
+    return data;
+}

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

@@ -0,0 +1,475 @@
+/**
+ * MiniMax Quota Scraper — RFC-0031
+ *
+ * Automatically fetches quota data from MiniMax console using Playwright.
+ * Uses cookie-based authentication to access the usage page.
+ *
+ * Based on the tactic in pi-harness-runtime/AGENTS.md:
+ * - Cookie-backed fetch returns static HTML only
+ * - Must use headless Playwright with injected cookies
+ * - Capture API responses for usage data
+ */
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { parseMiniMaxQuotaText } from "./minimax-quota-parser.js";
+const DEFAULT_URL = "https://platform.minimax.io/console/usage?cycle_type=1";
+const DEFAULT_COOKIE_FILE = join(homedir(), ".config", "minimax-cookies.txt");
+// API endpoints to capture
+const API_TERMS = [
+    "api",
+    "usage",
+    "billing",
+    "quota",
+    "consumption",
+    "recharge",
+    "resource",
+    "plan",
+    "subscription",
+    "token_plan",
+];
+/**
+ * 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;
+}
+/**
+ * Redact sensitive values from text
+ */
+function redact(text) {
+    return text
+        .replace(/eyJ[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{10,}/g, "[JWT_REDACTED]")
+        .replace(/api[_ -]?key|access[_ -]?token|refresh[_ -]?token|authorization|cookie|session|secret/gi, (match) => `${match}=[REDACTED]`)
+        .replace(/Bearer\s+[A-Za-z0-9._-]+/gi, "Bearer [REDACTED]");
+}
+/**
+ * Parse a percentage string like "50%" or "2%" into a number.
+ */
+function parsePctStr(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const m = value.match(/(\d+(?:\.\d+)?)/);
+    return m ? parseFloat(m[1]) : undefined;
+}
+/**
+ * Format remaining time until an epoch-ms deadline (e.g. "4 hr 37 min").
+ */
+function formatRemainsMs(epochMs) {
+    if (typeof epochMs !== "number" || epochMs <= 0)
+        return undefined;
+    const ms = epochMs - Date.now();
+    if (ms <= 0)
+        return "soon";
+    const totalMin = Math.floor(ms / 60000);
+    const days = Math.floor(totalMin / 1440);
+    const hr = Math.floor((totalMin % 1440) / 60);
+    const min = totalMin % 60;
+    const parts = [];
+    if (days > 0)
+        parts.push(`${days} day${days > 1 ? "s" : ""}`);
+    if (hr > 0)
+        parts.push(`${hr} hr`);
+    if (min > 0)
+        parts.push(`${min} min`);
+    return parts.join(" ") || "0 min";
+}
+/**
+ * MiniMax Quota Scraper
+ *
+ * Uses headless Playwright to fetch quota data from the MiniMax console.
+ */
+export class MiniMaxQuotaScraper {
+    config;
+    capturedEndpoints = [];
+    constructor(config = {}) {
+        this.config = {
+            cookieFile: config.cookieFile ?? DEFAULT_COOKIE_FILE,
+            url: config.url ?? DEFAULT_URL,
+            headless: config.headless ?? true,
+            timeout: config.timeout ?? 90000,
+            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;
+    }
+    /**
+     * Set MiniMax console URL
+     */
+    setUrl(url) {
+        this.config.url = url;
+        return this;
+    }
+    /**
+     * Scrape quota data. Tries the direct MiniMax API first (fast, no
+     * browser — ~200ms), then falls back to a headless browser scrape.
+     */
+    async scrape() {
+        try {
+            const apiData = await this.scrapeViaDirectApi();
+            if (apiData) {
+                if (!this.config.quiet) {
+                    // console.log("[MiniMaxQuotaScraper] direct API success");
+                }
+                return apiData;
+            }
+            if (!this.config.quiet) {
+                // console.log(
+                // 	"[MiniMaxQuotaScraper] direct API unavailable, falling back to browser",
+                // );
+            }
+        }
+        catch (error) {
+            if (!this.config.quiet) {
+                console.warn("[MiniMaxQuotaScraper] direct API failed:", error instanceof Error ? error.message : String(error));
+            }
+        }
+        return this.scrapeViaBrowser();
+    }
+    /**
+     * Fetch quota directly from the MiniMax API using cookies (no browser).
+     * Uses the same cookie file as the browser path. Returns null when not
+     * authenticated so the caller can decide whether to fall back.
+     */
+    async scrapeViaDirectApi() {
+        const cookies = loadNetscapeCookies(this.config.cookieFile);
+        if (cookies.length === 0)
+            return null;
+        const cookieHeader = cookies
+            .map((c) => `${c.name}=${String(c.value).trim()}`)
+            .join("; ");
+        const headers = {
+            Cookie: cookieHeader,
+            Accept: "application/json, text/plain, */*",
+            "User-Agent": "Mozilla/5.0",
+            Referer: "https://platform.minimax.io/console/usage",
+        };
+        const base = "https://platform.minimax.io";
+        // Primary: remains_percent gives 5h + weekly used % and reset times
+        let general = null;
+        try {
+            const resp = await fetch(`${base}/backend/account/token_plan/remains_percent`, { headers });
+            if (resp.ok) {
+                const json = (await resp.json());
+                const arr = json?.model_remains;
+                if (Array.isArray(arr)) {
+                    general =
+                        arr.find((m) => m.model_name === "general") ?? arr[0] ?? null;
+                }
+            }
+        }
+        catch {
+            /* fall through to null */
+        }
+        // Not authenticated (or request failed) → no data
+        if (!general)
+            return null;
+        const h5UsedPct = parsePctStr(general.current_interval_used_percent);
+        const weeklyUsedPct = parsePctStr(general.current_weekly_used_percent);
+        const h5ResetsAtEpoch = general.end_time;
+        const h5ResetsAt = formatRemainsMs(h5ResetsAtEpoch);
+        const weeklyResetsAtEpoch = general.weekly_end_time;
+        const weeklyResetsAt = formatRemainsMs(weeklyResetsAtEpoch);
+        // Best-effort: token usage summary
+        let tokenUsage;
+        try {
+            const resp = await fetch(`${base}/backend/account/token_plan/usage_summary`, { headers });
+            if (resp.ok) {
+                const json = (await resp.json());
+                if (json?.total_token_consumed) {
+                    tokenUsage = {
+                        total: json.total_token_consumed,
+                        last30Days: "",
+                        last7Days: "",
+                        currentMonth: "",
+                    };
+                }
+            }
+        }
+        catch {
+            /* best-effort */
+        }
+        // Best-effort: credit balance. NOTE: the API response includes an
+        // `api_key` field — we deliberately do NOT read or persist it.
+        let creditBalance;
+        try {
+            const resp = await fetch(`${base}/backend/account/token_plan_credit`, {
+                headers,
+            });
+            if (resp.ok) {
+                const json = (await resp.json());
+                if (typeof json?.remaining_credits === "number" &&
+                    typeof json?.total_credits === "number") {
+                    creditBalance = `${json.remaining_credits} / ${json.total_credits}`;
+                }
+            }
+        }
+        catch {
+            /* best-effort */
+        }
+        return {
+            provider: "minimax",
+            h5UsedPct: h5UsedPct ?? 0,
+            h5ResetsAt,
+            h5ResetsAtEpoch,
+            weeklyUsedPct: weeklyUsedPct ?? 0,
+            weeklyResetsAt,
+            weeklyResetsAtEpoch,
+            creditBalance,
+            tokenUsage,
+            apiEndpoints: [
+                `${base}/backend/account/token_plan/remains_percent`,
+                `${base}/backend/account/token_plan/usage_summary`,
+                `${base}/backend/account/token_plan_credit`,
+            ],
+            scrapedAt: new Date().toISOString(),
+        };
+    }
+    /**
+     * Scrape quota data from MiniMax console using a headless browser.
+     */
+    async scrapeViaBrowser() {
+        // Dynamic import for Playwright
+        let playwright = null;
+        try {
+            playwright = await import("playwright");
+        }
+        catch {
+            const msg = "Playwright not installed. Install with: bun add playwright\nThen install browsers: bunx playwright install chromium";
+            if (!this.config.quiet)
+                console.error("[DEBUG MiniMaxQuotaScraper] " + msg);
+            throw new Error(msg);
+        }
+        // Pre-load the canonical cache so that the runtime-owned file
+        // (written by packages/cookie-sanitizer) takes precedence over
+        // whatever `this.config.cookieFile` points at. Both eventually
+        // resolve to the same standard Netscape format.
+        const cookies = loadNetscapeCookies(this.config.cookieFile);
+        if (cookies.length === 0) {
+            const dropHint = join(homedir(), ".pi-harness-runtime", "cookies");
+            const msg = `No cookies found.
+Drop your platform.minimax.io cookies (Netscape or EditThisCookie JSON) into:
+  ${dropHint}
+…or run: bun packages/auth/src/run-minimax-auth.ts auth`;
+            if (!this.config.quiet)
+                console.error(`[MiniMaxQuotaScraper] ${msg}`);
+            throw new Error(msg);
+        }
+        // Launch browser
+        const browser = await playwright.chromium.launch({
+            executablePath: this.config.chromePath,
+            headless: this.config.headless,
+            args: ["--no-sandbox", "--disable-dev-shm-usage"],
+        });
+        const context = await browser.newContext({
+            locale: "en-US",
+            viewport: { width: 1440, height: 1000 },
+        });
+        // Inject cookies
+        await context.addCookies(cookies);
+        const page = await context.newPage();
+        const capturedResponses = [];
+        // Capture API responses
+        page.on("response", (resp) => {
+            const url = resp.url();
+            if (API_TERMS.some((term) => url.toLowerCase().includes(term))) {
+                capturedResponses.push({
+                    url,
+                    body: "",
+                });
+                // We capture the URL, body will be fetched later
+            }
+        });
+        try {
+            // Navigate to usage page
+            await page.goto(this.config.url, {
+                waitUntil: "domcontentloaded",
+                timeout: this.config.timeout,
+            });
+            // Wait for content to load
+            try {
+                await page.waitForLoadState("networkidle", { timeout: 45000 });
+            }
+            catch {
+                // Network idle might not be achievable
+            }
+            // Additional wait for JS rendering
+            await page.waitForTimeout(5000);
+            // Extract visible text
+            const visibleText = redact(await page.locator("body").innerText({ timeout: 10000 }));
+            // Parse the visible text
+            const quotaData = parseMiniMaxQuotaText(visibleText);
+            // Capture API endpoint URLs
+            this.capturedEndpoints = capturedResponses.map((r) => r.url);
+            const result = {
+                provider: "minimax",
+                h5UsedPct: quotaData.h5UsedPct ?? 0,
+                h5ResetsAt: quotaData.h5ResetsAt,
+                weeklyUsedPct: quotaData.weeklyUsedPct ?? 0,
+                weeklyResetsAt: quotaData.weeklyResetsAt,
+                monthlyUsedPct: quotaData.monthlyUsedPct,
+                monthlyResetsAt: quotaData.monthlyResetsAt,
+                creditBalance: quotaData.creditBalance,
+                tokenUsage: quotaData.tokenUsage,
+                apiEndpoints: this.capturedEndpoints,
+                scrapedAt: new Date().toISOString(),
+            };
+            return result;
+        }
+        finally {
+            await browser.close();
+        }
+    }
+    /**
+     * Check if any cookie source exists.
+     *
+     * "Source" can be either:
+     *   - the canonical cache (this.config.cookieFile) — runtime-owned,
+     *     populated by packages/cookie-sanitizer
+     *   - the user-facing drop folder — ~/.pi-harness-runtime/cookies/
+     *     — populated by humans (any name, any format)
+     *
+     * Either is enough to attempt the scrape.
+     */
+    hasCookieFile() {
+        // Canonical cache present?
+        if (existsSync(this.config.cookieFile))
+            return true;
+        // Drop folder has anything readable? (Sync would normalize it on the next trigger.)
+        try {
+            const dropDir = join(homedir(), ".pi-harness-runtime", "cookies");
+            if (existsSync(dropDir)) {
+                const entries = readdirSync(dropDir);
+                if (entries.length > 0)
+                    return true;
+                // One-level walk into subfolders.
+                for (const name of entries) {
+                    try {
+                        if (statSync(join(dropDir, name)).isDirectory()) {
+                            const sub = readdirSync(join(dropDir, name));
+                            if (sub.length > 0)
+                                return true;
+                        }
+                    }
+                    catch {
+                        // ignore unreadable sub-entry
+                    }
+                }
+            }
+        }
+        catch {
+            // best-effort; treat as no
+        }
+        return false;
+    }
+    /**
+     * Get instructions for setting up cookies
+     */
+    static getSetupInstructions() {
+        return `
+MiniMax Quota Scraper Setup Instructions
+======================================
+
+1. Install Playwright:
+   bun add playwright
+   bunx playwright install chromium
+
+2. Export cookies from your browser:
+   - Install "EditThisCookie" Chrome extension
+   - Go to https://platform.minimax.io
+   - Click the extension icon
+   - Click "Export" → "Netscape"
+   - Save to ~/.config/minimax-cookies.txt
+
+3. Use the scraper:
+   const scraper = new MiniMaxQuotaScraper();
+   const quota = await scraper.scrape();
+   console.log("[DEBUG MiniMaxQuotaScraper] 5h usage:", quota.h5UsedPct, "%");
+`;
+    }
+}
+// --- Quota Manager Integration -----------------------------------------------
+/**
+ * Quota Manager that periodically fetches MiniMax quota data
+ */
+export class MiniMaxQuotaManager {
+    scraper;
+    lastQuota;
+    lastFetchTime = 0;
+    cacheDurationMs;
+    constructor(config = {}) {
+        this.scraper = new MiniMaxQuotaScraper(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 {
+            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();
+    }
+}