pi-harness-runtime 1.1.81 → 1.1.83

package/harness/e2e/unified-quota-manager.ts

@@ -0,0 +1,364 @@
+/**
+ * Unified Quota Manager — Handles all providers with appropriate auth
+ *
+ * Authentication strategies by provider:
+ * | Provider   | Auth Method     | Status    |
+ * |------------|----------------|-----------|
+ * | MiniMax    | Browser cookies| ✅ Working|
+ * | GLM/z.ai   | API Key        | ✅ Exists |
+ * | ChatGPT    | OAuth tokens   | ✅ Exists |
+ * | Codex      | OAuth tokens   | ✅ Exists |
+ * | OpenAI     | API Key        | ✅ Exists |
+ */
+
+import {
+	MiniMaxQuotaManager,
+	type MiniMaxQuotaData,
+} from "./minimax-quota-scraper.js";
+
+import {
+	GLMQuotaManager,
+	GLMQuotaScraper,
+	type GLMQuotaData,
+} from "./glm-quota-scraper.js";
+
+import {
+	ChatGPTQuotaManager,
+	ChatGPTQuotaScraper,
+	type ChatGPTQuotaData,
+} from "./chatgpt-quota-scraper.js";
+
+import {
+	OpenAIQuotaManager,
+	OpenAIQuotaScraper,
+	type OpenAIQuotaData,
+} from "./openai-quota-scraper.js";
+
+export type Provider = "minimax" | "glm" | "chatgpt" | "openai-codex" | "openai";
+
+export interface QuotaData {
+	provider: Provider;
+	/** Usage percentage (0-100) */
+	usagePercent: number;
+	/** Human-readable reset time */
+	resetsAt?: string;
+	/** Epoch ms when quota resets */
+	resetsAtEpoch?: number;
+	/** Plan type */
+	planType?: string;
+	/** Total quota amount */
+	totalQuota?: string;
+	/** Used quota amount */
+	usedQuota?: string;
+	/** Remaining quota */
+	remainingQuota?: string;
+	/** Raw data */
+	raw?: Record<string, unknown>;
+	/** Timestamp */
+	scrapedAt: string;
+}
+
+export interface UnifiedQuotaConfig {
+	/** Provider to use (auto-detect if not specified) */
+	provider?: Provider;
+	/** Cookie file path (for browser-based providers) */
+	cookieFile?: string;
+	/** API key file path (for API-based providers) */
+	apiKeyFile?: string;
+	/** Direct API key value */
+	apiKey?: string;
+	/** Auth file path (for OAuth-based providers) */
+	authFile?: string;
+	/** Cache duration in ms (default: 5 min) */
+	cacheDurationMs?: number;
+	/** Suppress console output */
+	quiet?: boolean;
+}
+
+interface QuotaManager {
+	isAvailable(): boolean;
+	getQuota(forceRefresh?: boolean): Promise<unknown>;
+}
+
+/**
+ * Unified Quota Manager
+ *
+ * Provides a single interface to query quota data from all supported providers.
+ * Automatically detects available providers based on credentials.
+ */
+export class UnifiedQuotaManager {
+	private managers: Map<Provider, QuotaManager> = new Map();
+	private activeProvider?: Provider;
+	private cacheDurationMs: number;
+	private quiet: boolean;
+
+	constructor(config: UnifiedQuotaConfig = {}) {
+		this.cacheDurationMs = config.cacheDurationMs ?? 5 * 60 * 1000;
+		this.quiet = config.quiet ?? false;
+
+		// Initialize managers based on config
+		if (!config.provider || config.provider === "minimax") {
+			const mmManager = new MiniMaxQuotaManager({
+				cookieFile: config.cookieFile,
+				cacheDurationMs: this.cacheDurationMs,
+				quiet: this.quiet,
+			});
+			this.managers.set("minimax", mmManager);
+		}
+
+		if (!config.provider || config.provider === "glm") {
+			const glmManager = new GLMQuotaManager({
+				apiKey: config.apiKey,
+				apiKeyFile: config.apiKeyFile,
+				quiet: this.quiet,
+			});
+			this.managers.set("glm", glmManager);
+		}
+
+		if (!config.provider || config.provider === "chatgpt" || config.provider === "openai-codex") {
+			const chatgptManager = new ChatGPTQuotaManager({
+				authFile: config.authFile,
+				quiet: this.quiet,
+			});
+			this.managers.set("chatgpt", chatgptManager);
+			// openai-codex uses the same ChatGPT quota endpoint
+			this.managers.set("openai-codex", chatgptManager);
+		}
+
+		if (!config.provider || config.provider === "openai") {
+			const openaiManager = new OpenAIQuotaManager({
+				cookieFile: config.cookieFile,
+				quiet: this.quiet,
+			});
+			this.managers.set("openai", openaiManager);
+		}
+
+		// Set active provider
+		if (config.provider) {
+			this.activeProvider = config.provider;
+		} else {
+			// Auto-detect first available provider
+			this.activeProvider = this.detectAvailableProvider();
+		}
+	}
+
+	/**
+	 * Detect the first available provider
+	 */
+	private detectAvailableProvider(): Provider | undefined {
+		const priority: Provider[] = ["minimax", "glm", "chatgpt", "openai-codex", "openai"];
+
+		for (const provider of priority) {
+			const manager = this.managers.get(provider);
+			if (manager && manager.isAvailable()) {
+				if (!this.quiet) {
+					console.log(`[UnifiedQuota] Auto-detected provider: ${provider}`);
+				}
+				return provider;
+			}
+		}
+
+		return undefined;
+	}
+
+	/**
+	 * Get all available providers
+	 */
+	getAvailableProviders(): Provider[] {
+		const available: Provider[] = [];
+		for (const [provider, manager] of this.managers) {
+			if (manager.isAvailable()) {
+				available.push(provider);
+			}
+		}
+		return available;
+	}
+
+	/**
+	 * Check if a provider is available
+	 */
+	isProviderAvailable(provider: Provider): boolean {
+		const manager = this.managers.get(provider);
+		return manager?.isAvailable() ?? false;
+	}
+
+	/**
+	 * Set active provider
+	 */
+	setProvider(provider: Provider): boolean {
+		const manager = this.managers.get(provider);
+		if (manager && manager.isAvailable()) {
+			this.activeProvider = provider;
+			return true;
+		}
+		return false;
+	}
+
+	/**
+	 * Get current provider
+	 */
+	getProvider(): Provider | undefined {
+		return this.activeProvider;
+	}
+
+	/**
+	 * Get quota data from active provider
+	 */
+	async getQuota(forceRefresh = false): Promise<QuotaData | null> {
+		if (!this.activeProvider) {
+			if (!this.quiet) {
+				console.warn("[UnifiedQuota] No provider available");
+			}
+			return null;
+		}
+
+		const manager = this.managers.get(this.activeProvider);
+		if (!manager) {
+			return null;
+		}
+
+		try {
+			const data = await manager.getQuota(forceRefresh);
+			if (!data) return null;
+
+			return this.normalizeData(this.activeProvider, data);
+		} catch (error) {
+			if (!this.quiet) {
+				console.error(`[UnifiedQuota] Failed to fetch quota:`, error);
+			}
+			return null;
+		}
+	}
+
+	/**
+	 * Get quota from specific provider
+	 */
+	async getQuotaForProvider(
+		provider: Provider,
+		forceRefresh = false,
+	): Promise<QuotaData | null> {
+		const manager = this.managers.get(provider);
+		if (!manager) {
+			return null;
+		}
+
+		try {
+			const data = await manager.getQuota(forceRefresh);
+			if (!data) return null;
+
+			return this.normalizeData(provider, data);
+		} catch (error) {
+			if (!this.quiet) {
+				console.error(`[UnifiedQuota] Failed to fetch ${provider} quota:`, error);
+			}
+			return null;
+		}
+	}
+
+	/**
+	 * Normalize provider-specific data to unified format
+	 */
+	private normalizeData(
+		provider: Provider,
+		data: unknown,
+	): QuotaData {
+		const base: QuotaData = {
+			provider,
+			usagePercent: 0,
+			scrapedAt: new Date().toISOString(),
+		};
+
+		switch (provider) {
+			case "minimax": {
+				const d = data as MiniMaxQuotaData;
+				return {
+					...base,
+					usagePercent: d.h5UsedPct,
+					resetsAt: d.h5ResetsAt,
+					resetsAtEpoch: d.h5ResetsAtEpoch,
+					remainingQuota: d.creditBalance,
+					// @ts-expect-error - raw access for diagnostics
+					raw: d,
+				};
+			}
+
+			case "glm": {
+				const d = data as GLMQuotaData;
+				// GLM doesn't provide usage percentage or quota limit directly
+				// Show actual usage - percentage is unknown without quota info
+				return {
+					...base,
+					usagePercent: 0, // Unknown - no quota limit in API response
+					planType: d.modelName,
+					usedQuota: `${(d.totalTokens / 1_000_000).toFixed(1)}M tokens`,
+					totalQuota: "unknown",
+					// @ts-expect-error - raw access for diagnostics
+					raw: d,
+				};
+			}
+
+			case "chatgpt":
+			case "openai-codex": {
+				const d = data as ChatGPTQuotaData;
+				return {
+					...base,
+					usagePercent: d.weeklyUsedPct,
+					resetsAt: d.weeklyResetsAt,
+					resetsAtEpoch: d.weeklyResetsAtEpoch,
+					planType: d.planType,
+					remainingQuota: d.creditBalance,
+					// @ts-expect-error - raw access for diagnostics
+					raw: d,
+				};
+			}
+
+			case "openai": {
+				const d = data as OpenAIQuotaData;
+				return {
+					...base,
+					usagePercent: d.weeklyUsedPct,
+					resetsAt: d.weeklyResetsAt,
+					resetsAtEpoch: d.weeklyResetsAtEpoch,
+					remainingQuota: d.creditBalance,
+					// @ts-expect-error - raw access for diagnostics
+					raw: d,
+				};
+			}
+
+			default:
+				return base;
+		}
+	}
+
+	/**
+	 * Get summary for status display
+	 */
+	async getSummary(): Promise<string> {
+		const quota = await this.getQuota();
+		if (!quota) {
+			return `${this.activeProvider ?? "unknown"}: no data`;
+		}
+
+		const left = Math.max(0, 100 - quota.usagePercent);
+		const reset = quota.resetsAt ? ` · resets ${quota.resetsAt}` : "";
+
+		return `${this.activeProvider}: ${left.toFixed(0)}% left${reset}`;
+	}
+}
+
+/**
+ * Create unified quota manager from environment variables
+ */
+export function createUnifiedQuotaManagerFromEnv(): UnifiedQuotaManager | null {
+	const provider = (process.env.QUOTA_PROVIDER ?? "auto") as Provider | "auto";
+
+	return new UnifiedQuotaManager({
+		provider: provider === "auto" ? undefined : provider,
+		cookieFile: process.env.QUOTA_COOKIE_FILE,
+		apiKeyFile: process.env.QUOTA_API_KEY_FILE,
+		apiKey: process.env.QUOTA_API_KEY,
+		authFile: process.env.QUOTA_AUTH_FILE,
+		cacheDurationMs: parseInt(process.env.QUOTA_CACHE_MS ?? "300000", 10),
+		quiet: process.env.QUOTA_QUIET === "true",
+	});
+}

package/index.ts

@@ -23,6 +23,7 @@ import { UsageTracker } from "./tracker.ts";
 import { MirrorStore, type MirrorRecord } from "./mirror.ts";
 import { MiniMaxQuotaScraper } from "./harness/e2e/minimax-quota-scraper.js";
 import { OpenAIQuotaScraper } from "./harness/e2e/openai-quota-scraper.js";
+import { GLMQuotaScraper } from "./harness/e2e/glm-quota-scraper.js";
 import { parseMiniMaxQuotaText } from "./harness/e2e/minimax-quota-parser.js";
 import {
 	CookieWatcher,
@@ -755,7 +756,9 @@ Run \`bd ready\` to see current bd issues.
 	// --- Smart quota fetch for OpenAI status -------------------------
 	const OPENAI_REFRESH_MIN_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
 	const _openaiQuotaScraper = new OpenAIQuotaScraper({ quiet: true });
+	const _glmQuotaScraper = new GLMQuotaScraper({ quiet: true });
 	let lastOpenAIQuotaFetchAt = 0;
+	let lastGLMQuotaFetchAt = 0;
 
 	// --- Cookie sanitizer integration ------------------------------------
 	// The drop folder is the user-facing, forgiving input. The canonical
@@ -1135,6 +1138,47 @@ Run \`bd ready\` to see current bd issues.
 		}
 	}
 
+	/**
+	 * Auto-fetch GLM quota via z.ai API.
+	 * GLM has both 5h and weekly windows.
+	 */
+	async function autoFetchGLMQuota(options?: {
+		suppressErrors?: boolean;
+	}): Promise<boolean> {
+		const suppressErrors = options?.suppressErrors === true;
+
+		try {
+			const data = await _glmQuotaScraper.fetchUsage();
+			if (!data) {
+				if (!suppressErrors) {
+					console.error("[pi-harness] GLM quota auto-fetch: no data returned");
+				}
+				return false;
+			}
+
+			writeMirrorRecord("glm", {
+					synced_at: data.scrapedAt,
+					source: "scrape",
+					h5_used_pct: data.h5UsedPct,
+					h5_resets_at: data.h5ResetsAt,
+					h5_resets_at_epoch: data.h5ResetsAtEpoch,
+					weekly_used_pct: data.weeklyUsedPct,
+					weekly_resets_at: data.weeklyResetsAt,
+					weekly_resets_at_epoch: data.weeklyResetsAtEpoch,
+					model: data.modelName,
+				});
+			return true;
+		} catch (error) {
+			if (!suppressErrors) {
+				console.error(
+					"[pi-harness] GLM quota auto-fetch skipped:",
+					error instanceof Error ? error.message : String(error),
+				);
+			}
+			return false;
+		}
+	}
+
 	async function maybeAutoFetchQuota(
 		modelId: string | null | undefined,
 	): Promise<void> {
@@ -1199,7 +1243,52 @@ Run \`bd ready\` to see current bd issues.
 			return;
 		}
 
-		// Other providers (GLM, Anthropic, etc.) - TUI signal path only for now
+		// OpenAI Codex path (uses OAuth tokens from ~/.codex/auth.json)
+		if (provider === "openai-codex") {
+			if (quotaAutoFetchInFlight) return;
+
+
+			const nowMs = Date.now();
+			if (nowMs - lastOpenAIQuotaFetchAt < OPENAI_REFRESH_MIN_INTERVAL_MS) {
+				return;
+			}
+
+			// Check if Codex auth file exists
+			const codexAuthFile = join(homedir(), ".codex", "auth.json");
+			if (!existsSync(codexAuthFile)) {
+				return;
+			}
+
+			quotaAutoFetchInFlight = true;
+			lastOpenAIQuotaFetchAt = nowMs;
+			try {
+				await autoFetchOpenAIQuota({ suppressErrors: true });
+			} finally {
+				quotaAutoFetchInFlight = false;
+			}
+			return;
+		}
+
+		// GLM path (z.ai has both 5h and weekly windows)
+		if (provider === "glm") {
+			if (quotaAutoFetchInFlight) return;
+
+			const nowMs = Date.now();
+			if (nowMs - lastGLMQuotaFetchAt < OPENAI_REFRESH_MIN_INTERVAL_MS) {
+				return;
+			}
+
+			quotaAutoFetchInFlight = true;
+			lastGLMQuotaFetchAt = nowMs;
+			try {
+				await autoFetchGLMQuota({ suppressErrors: true });
+			} finally {
+				quotaAutoFetchInFlight = false;
+			}
+			return;
+		}
+
+		// Other providers (Anthropic, OpenRouter) - TUI signal path only for now
 		return;
 	}
 

package/mirror.ts

@@ -58,34 +58,38 @@ export type MirrorSource = "scrape" | "tui-signal" | "manual";
 
 /** Per-provider mirror record. */
 export interface ProviderMirrorRecord {
-	/** ISO-8601 UTC timestamp when this row was last updated. */
-	synced_at: string;
-	/** Provider id (e.g. "minimax", "openai", "glm"). Must match the key. */
-	provider: string;
-	/** Source of the data — used for diagnostics. */
-	source: MirrorSource;
-	/** Optional model id the data was captured for. */
-	model?: string;
-	/** 5h window used percent (0-100). Provider-reported when available. */
-	h5_used_pct?: number;
-	/** When the 5h window resets — human-readable or ISO. */
-	h5_resets_at?: string;
-	/** Epoch ms when the 5h window resets — precise UTC timestamp. */
-	h5_resets_at_epoch?: number;
-	/** Weekly used percent. */
-	weekly_used_pct?: number;
-	/** When the weekly window resets. */
-	weekly_resets_at?: string;
-	/** Epoch ms when the weekly window resets — precise UTC timestamp. */
-	weekly_resets_at_epoch?: number;
-	/** Set when a limit was hit and we have the exhaustion signal. */
-	exhausted?: boolean;
-	/** Limit type from TUI signal: tokens, context_window, rate_limit, unknown. */
-	limitType?: "tokens" | "context_window" | "rate_limit" | "unknown";
-	/** Remaining pct (0-100) at exhaustion — 0 means exactly exhausted. */
-	remainingPct?: number;
-	/** ISO-8601 reset timestamp from TUI signal, if absolute. */
-	resets_at?: string;
+/** ISO-8601 UTC timestamp when this row was last updated. */
+synced_at: string;
+/** Provider id (e.g. "minimax", "openai", "glm"). Must match the key. */
+provider: string;
+/** Source of the data — used for diagnostics. */
+source: MirrorSource;
+/** Optional model id the data was captured for. */
+model?: string;
+/** 5h window used percent (0-100). Provider-reported when available. */
+h5_used_pct?: number;
+/** When the 5h window resets — human-readable or ISO. */
+h5_resets_at?: string;
+/** Epoch ms when the 5h window resets — precise UTC timestamp. */
+h5_resets_at_epoch?: number;
+/** Weekly used percent. */
+weekly_used_pct?: number;
+/** When the weekly window resets. */
+weekly_resets_at?: string;
+/** Epoch ms when the weekly window resets — precise UTC timestamp. */
+weekly_resets_at_epoch?: number;
+/** Raw tokens used (for GLM which has no percentage). */
+weekly_used_tokens?: number;
+/** Monthly quota in tokens (for GLM). */
+monthly_quota_tokens?: number;
+/** Set when a limit was hit and we have the exhaustion signal. */
+exhausted?: boolean;
+/** Limit type from TUI signal: tokens, context_window, rate_limit, unknown. */
+limitType?: "tokens" | "context_window" | "rate_limit" | "unknown";
+/** Remaining pct (0-100) at exhaustion — 0 means exactly exhausted. */
+remainingPct?: number;
+/** ISO-8601 reset timestamp from TUI signal, if absolute. */
+resets_at?: string;
 }
 
 /** Map of provider id → its mirror record. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-harness-runtime",
-  "version": "1.1.81",
+  "version": "1.1.83",
   "description": "[BETA] Codex-style /usage status + autonomous coding harness for pi. Not production ready — expect breaking changes.",
   "type": "module",
   "scripts": {

package/packages/a2a-adapter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/a2a-adapter",
-  "version": "1.1.81",
+  "version": "1.1.83",
   "type": "module",
   "description": "Google Agent-to-Agent (A2A) protocol adapter for pi-harness",
   "main": "dist/index.js",

package/packages/architecture-generator/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/architecture-generator",
-  "version": "1.1.81",
+  "version": "1.1.83",
   "description": "Generate ADR and Mermaid diagrams from project analysis",
   "type": "module",
   "main": "./dist/index.js",

package/packages/auth/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/auth",
-  "version": "1.1.81",
+  "version": "1.1.83",
   "description": "pi-harness-runtime — auth",
   "type": "module",
   "main": "./dist/index.js",

package/packages/autonomous-refactor/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/autonomous-refactor",
-  "version": "1.1.81",
+  "version": "1.1.83",
   "type": "module",
   "description": "Autonomous refactoring engine",
   "main": "dist/index.js",

package/packages/autonomous-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/autonomous-runtime",
-  "version": "1.1.81",
+  "version": "1.1.83",
   "description": "Autonomous Operations Runtime — task inbox, lease management, and worker lifecycle (RFC-0101)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/cache-strategy/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/cache-strategy",
-  "version": "1.1.81",
+  "version": "1.1.83",
   "type": "module",
   "description": "Smart caching with TTL and invalidation strategies (RFC-0022)",
   "main": "dist/index.js",

package/packages/capability-registry/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/capability-registry",
-  "version": "1.1.81",
+  "version": "1.1.83",
   "description": "Capability Registry for pi-harness-runtime — tracks model capabilities and enables capability-based routing",
   "type": "module",
   "main": "./dist/index.js",

package/packages/checkpoint/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/checkpoint",
-  "version": "1.1.81",
+  "version": "1.1.83",
   "description": "Enhanced checkpoint system with incremental snapshots, diff-based storage, and recovery strategies",
   "type": "module",
   "main": "./dist/index.js",

package/packages/cli-plugin-sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/cli-plugin-sdk",
-  "version": "1.1.81",
+  "version": "1.1.83",
   "type": "module",
   "description": "CLI Plugin SDK for pi-harness — install, list, remove, update, invoke plugins",
   "main": "dist/index.js",

package/packages/clipboard/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/clipboard",
-  "version": "1.1.81",
+  "version": "1.1.83",
   "type": "module",
   "main": "src/index.ts",
   "exports": {

package/packages/clipboard-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/clipboard-plugin",
-  "version": "1.1.81",
+  "version": "1.1.83",
   "type": "module",
   "main": "src/index.ts",
   "exports": {

package/packages/code-generation/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/code-generation",
-  "version": "1.1.81",
+  "version": "1.1.83",
   "description": "Code generation pipeline for pi-harness-runtime",
   "type": "module",
   "main": "./dist/index.js",

package/packages/code-review/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/code-review",
-  "version": "1.1.81",
+  "version": "1.1.83",
   "description": "Automated code review engine for pi-harness-runtime",
   "type": "module",
   "main": "./dist/index.js",

package/packages/codex-adapter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/codex-adapter",
-  "version": "1.1.81",
+  "version": "1.1.83",
   "type": "module",
   "description": "OpenAI Codex provider adapter for pi-harness",
   "main": "dist/index.js",