pi-harness-runtime 1.1.0 → 1.1.2

package/harness/e2e/glm-quota-scraper.ts

@@ -0,0 +1,449 @@
+/**
+ * GLM/z.ai Quota Scraper — API Key Authentication
+ *
+ * Scrapes quota/usage data from z.ai API using API key authentication.
+ * Unlike cookie-based scrapers (MiniMax, OpenAI), this uses Bearer token auth.
+ *
+ * Target: https://api.z.ai/api/monitor/usage/model-usage
+ *
+ * Response shape:
+ * {
+ *   "code": 200,
+ *   "data": {
+ *     "x_time": ["2026-08-10 00:00", ...],
+ *     "modelCallCount": [0, 0, 42, ...],
+ *     "tokensUsage": [0, 0, 1200785, ...],
+ *     "totalUsage": {
+ *       "totalModelCallCount": 190,
+ *       "totalTokensUsage": 6170914
+ *     },
+ *     "modelSummaryList": [{"modelName": "GLM-5.2", "totalTokens": 6170914}],
+ *     "granularity": "hourly"
+ *   },
+ *   "success": true
+ * }
+ *
+ * Also fetches subscription info from: /biz/subscription/list
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+export interface GLMQuotaData {
+	provider: "glm";
+	/** Total model calls in the period */
+	totalCalls: number;
+	/** Total tokens used in the period */
+	totalTokens: number;
+	/** Model name (e.g., "GLM-5.2") */
+	modelName: string;
+	/** Hourly timestamps */
+	hourlyTimestamps: string[];
+	/** Hourly call counts */
+	hourlyCalls: number[];
+	/** Hourly token usage */
+	hourlyTokens: number[];
+	/** Raw API response for diagnostics */
+	apiEndpoint?: string;
+	/** Timestamp of scrape */
+	scrapedAt: string;
+}
+
+export interface GLMSubscriptionData {
+	/** Product name (e.g., "GLM Coding Lite") */
+	productName: string;
+	/** Subscription status (e.g., "VALID") */
+	status: string;
+	/** Purchase date */
+	purchaseTime: string;
+	/** Valid period (e.g., "2026-08-28 15:25:25-2026-09-28 15:25:25") */
+	valid: string;
+	/** Current period number */
+	currentPeriod: number;
+	/** Next renewal time */
+	nextRenewTime: string;
+	/** Billing cycle (e.g., "monthly") */
+	billingCycle: string;
+	/** Renewal price */
+	renewPrice: number;
+}
+
+export interface GLMScraperConfig {
+	/** Path to API key file (default: ~/.pi-harness-runtime/keys/zai-api-key.txt) */
+	apiKeyFile?: string;
+	/** Direct API key (optional, takes precedence over file) */
+	apiKey?: string;
+	/** Suppress console output */
+	quiet?: boolean;
+}
+
+const DEFAULT_API_KEY_DIR = join(homedir(), ".pi-harness-runtime", "keys");
+const DEFAULT_API_KEY_FILE = join(DEFAULT_API_KEY_DIR, "zai-api-key.txt");
+
+// Also check legacy location
+const LEGACY_API_KEY_FILE = join(homedir(), ".config", "zai-api-key.txt");
+const API_BASE_URL = "https://api.z.ai/api";
+const USAGE_ENDPOINT = "/monitor/usage/model-usage";
+const SUBSCRIPTION_ENDPOINT = "/biz/subscription/list";
+
+/**
+ * Load API key from file, checking multiple locations
+ */
+function loadApiKey(path: string): string | null {
+	if (existsSync(path)) {
+		try {
+			const key = readFileSync(path, "utf-8").trim();
+			if (key && key.length > 10) return key;
+		} catch {
+			// ignore
+		}
+	}
+	// Fallback to legacy location
+	if (existsSync(LEGACY_API_KEY_FILE)) {
+		try {
+			const key = readFileSync(LEGACY_API_KEY_FILE, "utf-8").trim();
+			if (key && key.length > 10) return key;
+		} catch {
+			// ignore
+		}
+	}
+	return null;
+}
+
+/**
+ * Format remaining seconds into human-readable string
+ */
+function formatRemainsSeconds(seconds: number): string {
+	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: string[] = [];
+	if (days > 0) parts.push(`${days}d`);
+	if (hr > 0) parts.push(`${hr}h`);
+	if (min > 0 && days === 0) parts.push(`${min}m`);
+
+	return parts.join(" ") || "0m";
+}
+
+/**
+ * GLM/z.ai Quota Scraper
+ *
+ * Uses API key authentication to fetch quota data from z.ai.
+ */
+export class GLMQuotaScraper {
+	private config: {
+		apiKeyFile: string;
+		apiKey: string | null;
+		quiet: boolean;
+	};
+
+	constructor(config: GLMScraperConfig = {}) {
+		// Resolve API key: direct value > file > null
+		const apiKey = config.apiKey ?? loadApiKey(config.apiKeyFile ?? DEFAULT_API_KEY_FILE);
+
+		this.config = {
+			apiKeyFile: config.apiKeyFile ?? DEFAULT_API_KEY_FILE,
+			apiKey: apiKey ?? null,
+			quiet: config.quiet ?? false,
+		};
+	}
+
+	/**
+	 * Set API key directly
+	 */
+	setApiKey(key: string): this {
+		this.config.apiKey = key;
+		return this;
+	}
+
+	/**
+	 * Set API key file path
+	 */
+	setApiKeyFile(path: string): this {
+		this.config.apiKeyFile = path;
+		this.config.apiKey = loadApiKey(path) ?? null;
+		return this;
+	}
+
+	/**
+	 * Check if any API key source exists
+	 */
+	hasApiKey(): boolean {
+		if (this.config.apiKey && this.config.apiKey.length > 10) {
+			return true;
+		}
+		// Try loading from default location
+		const key = loadApiKey(this.config.apiKeyFile);
+		return key !== null && key.length > 10;
+	}
+
+	/**
+	 * Get the current API key
+	 */
+	getApiKey(): string | null {
+		return this.config.apiKey ?? loadApiKey(this.config.apiKeyFile);
+	}
+
+	/**
+	 * Fetch usage data from z.ai API
+	 */
+	async fetchUsage(startDate?: Date, endDate?: Date): Promise<GLMQuotaData | null> {
+		const apiKey = this.getApiKey();
+		if (!apiKey) {
+			if (!this.config.quiet) {
+				console.error(
+					`[DEBUG GLMQuotaScraper] No API key found. ` +
+					`Set ZAI_API_KEY env var or drop key into ${DEFAULT_API_KEY_FILE}`,
+				);
+			}
+			return null;
+		}
+
+		// Default to last 7 days
+		const end = endDate ?? new Date();
+		const start = startDate ?? new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
+
+		const startStr = start.toISOString().replace("T", " ").replace("Z", "");
+		const endStr = end.toISOString().replace("T", " ").replace("Z", "");
+
+		const url = `${API_BASE_URL}${USAGE_ENDPOINT}?startTime=${encodeURIComponent(startStr)}&endTime=${encodeURIComponent(endStr)}`;
+
+		try {
+			if (!this.config.quiet) {
+				console.log(`[DEBUG GLMQuotaScraper] Fetching usage from ${startStr} to ${endStr}`);
+			}
+
+			const response = await fetch(url, {
+				method: "GET",
+				headers: {
+					Authorization: `Bearer ${apiKey}`,
+					"Content-Type": "application/json",
+				},
+			});
+
+			if (!response.ok) {
+				if (!this.config.quiet) {
+					console.error(
+						`[DEBUG GLMQuotaScraper] API returned ${response.status}: ${response.statusText}`,
+					);
+				}
+				return null;
+			}
+
+			const data = await response.json() as {
+				code?: number;
+				success?: boolean;
+				data?: {
+					x_time?: string[];
+					modelCallCount?: number[];
+					tokensUsage?: number[];
+					totalUsage?: {
+						totalModelCallCount?: number;
+						totalTokensUsage?: number;
+					};
+					modelSummaryList?: Array<{
+						modelName?: string;
+						totalTokens?: number;
+					}>;
+				};
+				msg?: string;
+			};
+
+			if (!data.success || !data.data) {
+				if (!this.config.quiet) {
+					console.error(`[DEBUG GLMQuotaScraper] API error: ${data.msg ?? "Unknown error"}`);
+				}
+				return null;
+			}
+
+			const d = data.data;
+			const totalUsage = d.totalUsage ?? {};
+			const modelSummary = d.modelSummaryList?.[0];
+
+			const result: GLMQuotaData = {
+				provider: "glm",
+				totalCalls: totalUsage.totalModelCallCount ?? 0,
+				totalTokens: totalUsage.totalTokensUsage ?? 0,
+				modelName: modelSummary?.modelName ?? "Unknown",
+				hourlyTimestamps: d.x_time ?? [],
+				hourlyCalls: d.modelCallCount ?? [],
+				hourlyTokens: d.tokensUsage ?? [],
+				apiEndpoint: url,
+				scrapedAt: new Date().toISOString(),
+			};
+
+			if (!this.config.quiet) {
+				console.log(
+					`[DEBUG GLMQuotaScraper] Total calls: ${result.totalCalls}, ` +
+					`Total tokens: ${result.totalTokens.toLocaleString()}, ` +
+					`Model: ${result.modelName}`,
+				);
+			}
+
+			return result;
+		} catch (error) {
+			if (!this.config.quiet) {
+				console.error(
+					"[DEBUG GLMQuotaScraper] Fetch error:",
+					error instanceof Error ? error.message : String(error),
+				);
+			}
+			return null;
+		}
+	}
+
+	/**
+	 * Fetch subscription info from z.ai API
+	 */
+	async fetchSubscription(): Promise<GLMSubscriptionData | null> {
+		const apiKey = this.getApiKey();
+		if (!apiKey) {
+			return null;
+		}
+
+		const url = `${API_BASE_URL}${SUBSCRIPTION_ENDPOINT}`;
+
+		try {
+			const response = await fetch(url, {
+				method: "GET",
+				headers: {
+					Authorization: `Bearer ${apiKey}`,
+					"Content-Type": "application/json",
+				},
+			});
+
+			if (!response.ok) {
+				return null;
+			}
+
+			const data = await response.json() as {
+				code?: number;
+				success?: boolean;
+				data?: Array<{
+					productName?: string;
+					status?: string;
+					purchaseTime?: string;
+					valid?: string;
+					currentPeriod?: number;
+					nextRenewTime?: string;
+					billingCycle?: string;
+					renewPrice?: number;
+				}>;
+			};
+
+			if (!data.success || !data.data || data.data.length === 0) {
+				return null;
+			}
+
+			const sub = data.data[0];
+			return {
+				productName: sub.productName ?? "Unknown",
+				status: sub.status ?? "Unknown",
+				purchaseTime: sub.purchaseTime ?? "",
+				valid: sub.valid ?? "",
+				currentPeriod: sub.currentPeriod ?? 0,
+				nextRenewTime: sub.nextRenewTime ?? "",
+				billingCycle: sub.billingCycle ?? "monthly",
+				renewPrice: sub.renewPrice ?? 0,
+			};
+		} catch {
+			return null;
+		}
+	}
+
+	/**
+	 * Convenience method: get both usage and subscription data
+	 */
+	async scrape(): Promise<{
+		usage: GLMQuotaData | null;
+		subscription: GLMSubscriptionData | null;
+	}> {
+		const [usage, subscription] = await Promise.all([
+			this.fetchUsage(),
+			this.fetchSubscription(),
+		]);
+		return { usage, subscription };
+	}
+
+	/**
+	 * Get weekly usage percentage (calls vs quota)
+	 * For GLM, this calculates based on typical weekly allocation
+	 */
+	async getWeeklyUsagePercentage(): Promise<number | null> {
+		const usage = await this.fetchUsage();
+		if (!usage || usage.totalTokens === 0) {
+			return null;
+		}
+
+		// GLM Coding Lite typically has a weekly token quota
+		// Based on the subscription (monthly), we estimate weekly allocation
+		// Typical allocation: ~50M tokens/month = ~12.5M tokens/week
+		const WEEKLY_TOKEN_QUOTA = 12_500_000;
+		const pct = Math.min(100, (usage.totalTokens / WEEKLY_TOKEN_QUOTA) * 100);
+		return Math.round(pct);
+	}
+
+	/**
+	 * Get when the quota resets (typically weekly on Sunday midnight or monthly)
+	 */
+	getQuotaResetInfo(): { resetsAt: string; resetAfterSeconds: number } {
+		// GLM quotas typically reset weekly (Sunday midnight UTC) or monthly
+		const now = new Date();
+		const nextSunday = new Date(now);
+		nextSunday.setDate(now.getDate() + (7 - now.getDay()));
+		nextSunday.setUTCHours(0, 0, 0, 0);
+
+		const diffMs = nextSunday.getTime() - now.getTime();
+		const diffSeconds = Math.max(0, Math.floor(diffMs / 1000));
+
+		return {
+			resetsAt: formatRemainsSeconds(diffSeconds),
+			resetAfterSeconds: diffSeconds,
+		};
+	}
+}
+
+/**
+ * Integration helper for index.ts
+ */
+export class GLMQuotaManager {
+	private scraper: GLMQuotaScraper;
+	private lastQuota?: GLMQuotaData;
+	private lastFetchTime = 0;
+	private readonly cacheDurationMs: number;
+
+	constructor(config: GLMScraperConfig & { cacheDurationMs?: number } = {}) {
+		this.scraper = new GLMQuotaScraper(config);
+		this.cacheDurationMs = config.cacheDurationMs ?? 15 * 60 * 1000; // 15 min default
+	}
+
+	/**
+	 * Get current quota (uses cache)
+	 */
+	async getQuota(forceRefresh = false): Promise<GLMQuotaData | null> {
+		const now = Date.now();
+
+		if (
+			!forceRefresh &&
+			this.lastQuota &&
+			now - this.lastFetchTime < this.cacheDurationMs
+		) {
+			return this.lastQuota;
+		}
+
+		this.lastQuota = await this.scraper.fetchUsage() ?? undefined;
+		this.lastFetchTime = now;
+		return this.lastQuota ?? null;
+	}
+
+	/**
+	 * Check if quota is available
+	 */
+	isAvailable(): boolean {
+		return this.scraper.hasApiKey();
+	}
+}

package/harness/herdr-agents.ts

@@ -9,6 +9,10 @@ import {
 	ensureHerdrWorkspace,
 } from "../packages/event-bus/src/herdr-bus.js";
 
+// Suppress stack traces — only show error message to keep TUI clean
+const logError = (err: unknown) =>
+	console.error(`[herdr] Error: ${err instanceof Error ? err.message : String(err)}`);
+
 async function startReviewAgent(): Promise<void> {
 	console.log("[herdr:review] Starting review agent...");
 	const bus = createHerdrBus("review-agent");
@@ -78,10 +82,10 @@ function showStatus(): void {
 const [command] = process.argv.slice(2);
 switch (command) {
 	case "review":
-		startReviewAgent().catch(console.error);
+		startReviewAgent().catch(logError);
 		break;
 	case "code":
-		startCodeAgent().catch(console.error);
+		startCodeAgent().catch(logError);
 		break;
 	case "status":
 		showStatus();

package/harness/loop-code-agent.ts

@@ -20,6 +20,9 @@ import type { BlackboardRecord } from "../packages/types/src/runtime-types.js";
 const AGENT_ID = "code-agent";
 const AGENT_TYPE = "code";
 const POLL_MS = 1000;
+// Suppress stack traces — only show error message to keep TUI clean
+const logError = (err: unknown) =>
+	console.error(`[${AGENT_ID}] Error: ${err instanceof Error ? err.message : String(err)}`);
 
 async function main(): Promise<void> {
 	console.log(`[${AGENT_ID}] Starting...`);
@@ -281,4 +284,4 @@ function sleep(ms: number): Promise<void> {
 	return new Promise((r) => setTimeout(r, ms));
 }
 
-main().catch(console.error);
+main().catch(logError);

package/harness/loop-review-agent.ts

@@ -16,7 +16,6 @@ import {
 import { SharedBlackboard } from "./blackboard.js";
 import type {
 	LoopNextAction,
-	LoopAgentReport,
 	LoopVerdict,
 } from "./loop-types.js";
 
@@ -24,6 +23,9 @@ const AGENT_ID = "review-agent";
 const AGENT_TYPE = "review";
 const POLL_MS = 1000;
 const REVIEW_TIMEOUT_MS = 5 * 60 * 1000;
+// Suppress stack traces — only show error message to keep TUI clean
+const logError = (err: unknown) =>
+	console.error(`[${AGENT_ID}] Error: ${err instanceof Error ? err.message : String(err)}`);
 
 async function main(): Promise<void> {
 	console.log(`[${AGENT_ID}] Starting...`);
@@ -231,7 +233,7 @@ function updateTaskStatus(
 	verdict: LoopVerdict,
 ): void {
 	const node = record.tasks.nodes[taskId] as
-		| { status: string; result?: string }
+		| { status: string; result?: string; updatedAt?: string }
 		| undefined;
 	if (node) {
 		node.status = verdict === "blocked" ? "blocked" : "done";
@@ -268,9 +270,6 @@ function getNextWriteTask(
 	record: { tasks: { nodes: Record<string, { status: string }> } },
 	currentReviewIteration: number,
 ): string | null {
-	const writeCount = Object.keys(record.tasks.nodes).filter((id) =>
-		id.startsWith("write-"),
-	).length;
 	// After review N, next write is N+1
 	const nextWrite = currentReviewIteration + 1;
 	const taskId = `write-${nextWrite}`;
@@ -292,4 +291,4 @@ function sleep(ms: number): Promise<void> {
 	return new Promise((r) => setTimeout(r, ms));
 }
 
-main().catch(console.error);
+main().catch(logError);

package/harness/notification-events.ts

@@ -10,12 +10,12 @@
  *   E2EFailed, HumanReviewNeeded, ReadyForClient, JobCancelled, Error
  */
 
-import { NotificationCenter } from "../packages/notification/notification-center.js";
+import { NotificationCenter } from "../packages/notification/dist/notification-center.js";
 import type {
 	NotificationConfig,
 	NotificationEvent,
 	NotificationContext,
-} from "../packages/notification/types.js";
+} from "../packages/notification/dist/types.js";
 import type { JobStateMachine } from "./job-state-machine.js";
 import type { TaskGraphManager } from "./task-graph.js";
 

package/harness/task-graph.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Task Graph Manager — RFC-0028 Phase 3
+ *
+ * Manages task dependency graph for compact-aware scheduling.
+ * Currently a stub — integrates with CompactOrchestrator for
+ * dependency-aware compaction prioritization.
+ *
+ * Future work:
+ * - Track task dependencies (blocking/ready tasks)
+ * - Prioritize compaction to keep blocking path messages
+ * - Track which tasks depend on which checkpoint artifacts
+ */
+import type { RuntimeTask } from "../packages/types/src/runtime-types.js";
+export interface TaskNode {
+    task: RuntimeTask;
+    dependencies: Set<string>;
+    dependents: Set<string>;
+    status: "pending" | "ready" | "running" | "done" | "blocked";
+}
+export interface TaskGraphManager {
+    /** Add a task to the graph */
+    addTask(task: RuntimeTask): void;
+    /** Mark a task as done and update dependents */
+    completeTask(taskId: string): void;
+    /** Get tasks ready for execution */
+    getReadyTasks(): RuntimeTask[];
+    /** Get tasks blocked by a given task */
+    getBlockedTasks(taskId: string): RuntimeTask[];
+    /** Get all pending tasks */
+    getPendingTasks(): RuntimeTask[];
+    /** Get all tasks */
+    getAllTasks(): RuntimeTask[];
+    /** Get current progress summary */
+    getProgressSummary(): {
+        total: number;
+        done: number;
+        running: number;
+        failed: number;
+    };
+    /** Get compact priority: tasks to keep in context vs prune */
+    getCompactPriority(): {
+        keep: string[];
+        prune: string[];
+    };
+}
+/**
+ * Creates a new TaskGraphManager instance.
+ * Stub implementation — returns minimal working graph.
+ */
+export declare function createTaskGraphManager(): TaskGraphManager;
+//# sourceMappingURL=task-graph.d.ts.map