pi-harness-runtime 0.10.43 → 1.1.1

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/index.ts

@@ -24,6 +24,8 @@ 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 { ChatGPTQuotaScraper } from "./harness/e2e/chatgpt-quota-scraper.js";
 import { parseMiniMaxQuotaText } from "./harness/e2e/minimax-quota-parser.js";
 import {
 	CookieWatcher,

package/package.json

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

package/packages/a2a-adapter/README.md

@@ -0,0 +1,35 @@
+# @pi/a2a-adapter
+
+Google Agent-to-Agent (A2A) protocol adapter for pi-harness.
+
+## Protocol
+
+Implements [Google A2A Protocol v1.0](https://google.github.io/A2A/).
+
+## Usage
+
+### Expose as A2A Agent
+
+```typescript
+import { createAgentCard, routeTask, getTask } from "@pi/a2a-adapter";
+
+const card = createAgentCard({
+  name: "pi-harness",
+  description: "AI coding harness",
+  url: "http://localhost:3000",
+  version: "0.9.4",
+});
+// Serve card at /.well-known/agent.json
+
+const task = await routeTask({ role: "user", content: "Analyze code" });
+```
+
+### Delegate to Remote Agent
+
+```typescript
+import { A2AClient } from "@pi/a2a-adapter";
+
+const client = new A2AClient("http://remote-agent:3000");
+const agentCard = await client.discoverAgent();
+const handle = await client.sendTask("Analyze my codebase");
+```

package/packages/a2a-adapter/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@pi/a2a-adapter",
+  "version": "0.10.30",
+  "type": "module",
+  "description": "Google Agent-to-Agent (A2A) protocol adapter for pi-harness",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "bun test"
+  },
+  "devDependencies": {
+    "bun-types": "^1.0.0"
+  }
+}

package/packages/a2a-adapter/test/a2a.test.ts

@@ -0,0 +1,151 @@
+/**
+ * A2A Adapter Tests (RFC-0069)
+ */
+
+import { describe, it, expect } from "bun:test";
+import {
+	createAgentCard,
+	routeTask,
+	getTask,
+	cancelTask,
+	taskStatusUpdateSSE,
+} from "../src/agent.js";
+import { A2AClient } from "../src/client.js";
+import { A2ATransport } from "../src/transport.js";
+import {
+	A2A_PROTOCOL_VERSION,
+	WELL_KNOWN_AGENT_PATH,
+} from "../src/protocol.js";
+import type { TaskMessage } from "../src/types.js";
+
+describe("A2A Protocol Constants", () => {
+	it("exports protocol version", () => {
+		expect(A2A_PROTOCOL_VERSION).toBe("1.0.0");
+	});
+
+	it("exports well-known agent path", () => {
+		expect(WELL_KNOWN_AGENT_PATH).toBe("/.well-known/agent.json");
+	});
+});
+
+describe("AgentCard", () => {
+	it("creates agent card with defaults", () => {
+		const card = createAgentCard({
+			name: "pi-harness",
+			description: "AI coding harness",
+			url: "http://localhost:3000",
+			version: "0.9.4",
+		});
+		expect(card.name).toBe("pi-harness");
+		expect(card.capabilities.streaming).toBe(true);
+		expect(card.skills.length).toBeGreaterThan(0);
+		expect(card.skills[0].id).toBe("code-analysis");
+	});
+
+	it("creates agent card with custom skills", () => {
+		const card = createAgentCard({
+			name: "test-agent",
+			description: "Test",
+			url: "http://localhost:3001",
+			version: "1.0.0",
+			skills: [
+				{
+					id: "custom",
+					name: "Custom",
+					description: "Custom skill",
+					tags: ["test"],
+				},
+			],
+		});
+		expect(card.skills).toHaveLength(1);
+		expect(card.skills[0].id).toBe("custom");
+	});
+
+	it("merges custom capabilities", () => {
+		const card = createAgentCard({
+			name: "test",
+			description: "Test",
+			url: "http://localhost:3002",
+			version: "1.0.0",
+			capabilities: { pushNotifications: true },
+		});
+		expect(card.capabilities.streaming).toBe(true);
+		expect(card.capabilities.pushNotifications).toBe(true);
+	});
+});
+
+describe("Task Routing", () => {
+	it("routes a task message", async () => {
+		const message: TaskMessage = { role: "user", content: "Analyze this code" };
+		const task = await routeTask(message);
+		expect(task.id).toMatch(/^task-/);
+		expect(task.status).toBe("completed");
+		expect(task.artifacts).toHaveLength(1);
+		expect(task.artifacts![0].parts[0].text).toContain("Analyze this code");
+	});
+
+	it("stores and retrieves task", async () => {
+		const message: TaskMessage = { role: "user", content: "Test" };
+		const task = await routeTask(message);
+		const retrieved = getTask(task.id);
+		expect(retrieved).not.toBeNull();
+		expect(retrieved!.id).toBe(task.id);
+	});
+
+	it("returns null for unknown task", () => {
+		expect(getTask("nonexistent-task")).toBeNull();
+	});
+
+	it("cancels a task", async () => {
+		const message: TaskMessage = { role: "user", content: "Cancel test" };
+		const task = await routeTask(message);
+		expect(task.status).toBe("completed");
+		const result = cancelTask(task.id);
+		expect(result).toBe(true);
+		expect(getTask(task.id)!.status).toBe("canceled");
+	});
+
+	it("returns false when canceling unknown task", () => {
+		expect(cancelTask("nonexistent")).toBe(false);
+	});
+
+	it("generates SSE status update", async () => {
+		const message: TaskMessage = { role: "user", content: "SSE test" };
+		const task = await routeTask(message);
+		const sse = taskStatusUpdateSSE(task.id);
+		expect(sse).toContain("task_status_update");
+		expect(sse).toContain(task.id);
+		expect(sse).toContain("completed");
+		expect(sse).toContain("final");
+	});
+});
+
+describe("A2AClient", () => {
+	it("creates client with URL", () => {
+		const client = new A2AClient("http://localhost:3000");
+		expect(client).toBeDefined();
+	});
+
+	it("sendTask throws on unreachable server", async () => {
+		const client = new A2AClient("http://localhost:9999");
+		await expect(client.sendTask("test")).rejects.toThrow();
+	});
+
+	it("findAgents returns empty array", async () => {
+		const client = new A2AClient("http://localhost:3000");
+		const results = await client.findAgents({ skill: "test" });
+		expect(results).toEqual([]);
+	});
+});
+
+describe("A2ATransport", () => {
+	it("creates transport with config", () => {
+		const t = new A2ATransport("http://localhost:3000", { timeout: 5000 });
+		expect(t).toBeDefined();
+	});
+
+	it("getAgentCard throws on invalid URL", async () => {
+		const t = new A2ATransport("http://localhost:9999", { timeout: 2000 });
+		await expect(t.getAgentCard()).rejects.toThrow();
+	});
+});

package/packages/architecture-generator/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@pi-harness/architecture-generator",
+  "version": "0.10.30",
+  "description": "Generate ADR and Mermaid diagrams from project analysis",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "echo \"Tests not configured\""
+  },
+  "devDependencies": {
+    "typescript": "^5.4.0"
+  }
+}