@latentminds/pi-quotas 0.2.6 → 0.3.1

package/src/providers/fetch.ts

@@ -3,14 +3,18 @@ import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import type { AuthStorage } from "@mariozechner/pi-coding-agent";
-import type { QuotasResult, SupportedQuotaProvider } from "../types/quotas.js";
+import type { QuotasErrorKind, QuotasResult, SupportedQuotaProvider } from "../types/quotas.js";
 import {
   parseAnthropicUsage,
   parseCodexUsage,
   parseGitHubCopilotUsage,
   parseOpenRouterUsage,
   parseSyntheticUsage,
+  parseZaiUsage,
+  parseOpenCodeGoUsage,
 } from "./providers.js";
+import { resolveOpenCodeGoConfigCached } from "./opencode-go-config.js";
+import { queryOpenCodeGoQuota } from "./opencode-go.js";
 
 const FETCH_TIMEOUT_MS = 15_000;
 const COPILOT_VERSION = "0.35.0";
@@ -30,6 +34,16 @@ async function providerAccessToken(
   return authStorage.getApiKey(provider);
 }
 
+/**
+ * Detect a raw Anthropic API key (`sk-ant-...`). OAuth subscription tokens
+ * issued by `pi /login` are JWT-shaped (`eyJ...`) or opaque and never carry
+ * the `sk-ant-` prefix, so this reliably distinguishes a direct API key that
+ * has no OAuth subscription usage to report.
+ */
+function isDirectAnthropicApiKey(token: string): boolean {
+  return token.startsWith("sk-ant-");
+}
+
 function codexAccountId(authStorage: AuthStorage): string | undefined {
   const credential = authStorage.get("openai-codex") as any;
   if (typeof credential?.accountId === "string") return credential.accountId;
@@ -51,6 +65,34 @@ type FetchJsonResult =
       kind: "timeout" | "cancelled" | "http" | "network";
     };
 
+/**
+ * Reduce a raw HTTP error body to a short, human-readable message.
+ *
+ * Many APIs return a JSON error object (e.g. Anthropic's
+ * `{"error":{"type":"authentication_error","message":"..."}}` or a
+ * bare `{"message":"..."}`). Surfacing the raw blob in the dashboard or
+ * footer is ugly and confusing, so extract the inner message field when the
+ * body parses as JSON; otherwise return the body unchanged.
+ */
+function cleanHttpErrorMessage(body: string): string {
+  const trimmed = body.trim();
+  if (!trimmed) return "";
+  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return trimmed;
+  try {
+    const parsed = JSON.parse(trimmed) as any;
+    const message =
+      parsed?.error?.message ??
+      parsed?.message ??
+      parsed?.error ??
+      parsed?.detail ??
+      parsed?.error_description;
+    if (typeof message === "string" && message.trim()) return message.trim();
+  } catch {
+    // Not valid JSON — fall through to the raw body.
+  }
+  return trimmed;
+}
+
 async function fetchJson(
   url: string,
   init: RequestInit,
@@ -67,7 +109,7 @@ async function fetchJson(
       return {
         ok: false,
         status: response.status,
-        message: body || response.statusText || `HTTP ${response.status}`,
+        message: cleanHttpErrorMessage(body) || response.statusText || `HTTP ${response.status}`,
         kind: "http",
       };
     }
@@ -87,11 +129,17 @@ async function fetchJson(
   }
 }
 
-function success(provider: SupportedQuotaProvider, windows: ReturnType<typeof parseAnthropicUsage>): QuotasResult {
+function success(
+  provider: SupportedQuotaProvider,
+  windows: ReturnType<typeof parseAnthropicUsage>,
+): QuotasResult {
   return { success: true, data: { provider, windows } };
 }
 
-function failure(message: string, kind: "cancelled" | "timeout" | "config" | "http" | "network"): QuotasResult {
+function failure(
+  message: string,
+  kind: QuotasErrorKind,
+): QuotasResult {
   return { success: false, error: { message, kind } };
 }
 
@@ -100,6 +148,16 @@ export async function fetchAnthropicQuotasWithToken(
   signal?: AbortSignal,
 ): Promise<QuotasResult> {
   if (!accessToken) return failure("No Anthropic OAuth token found", "config");
+  // The /api/oauth/usage endpoint requires OAuth subscription credentials.
+  // A direct API key (e.g. `sk-ant-api03-...` registered via `pi /login`) is
+  // not an OAuth token, so the call would always fail. Detect it up front and
+  // return a silent "not applicable" result rather than a warning.
+  if (isDirectAnthropicApiKey(accessToken)) {
+    return failure(
+      "Direct Anthropic API key — no subscription usage to report",
+      "not_applicable",
+    );
+  }
   const result = await fetchJson(
     "https://api.anthropic.com/api/oauth/usage",
     {
@@ -158,11 +216,13 @@ function copilotHeaders(authHeader: string): Record<string, string> {
  */
 function ghCliToken(): string | undefined {
   try {
-    return execFileSync("gh", ["auth", "token"], {
-      timeout: 5000,
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
-    }).trim() || undefined;
+    return (
+      execFileSync("gh", ["auth", "token"], {
+        timeout: 5000,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+      }).trim() || undefined
+    );
   } catch {
     return undefined;
   }
@@ -194,13 +254,22 @@ async function fetchGitHubCopilotQuotasWithGitHubToken(
   githubToken: string | undefined,
   signal?: AbortSignal,
 ): Promise<QuotasResult> {
-  if (!githubToken) return failure("No GitHub Copilot OAuth token found", "config");
+  if (!githubToken)
+    return failure("No GitHub Copilot OAuth token found", "config");
 
-  const bearerUsage = await tryGitHubUserEndpoint(`Bearer ${githubToken}`, signal);
-  if (bearerUsage.ok) return success("github-copilot", parseGitHubCopilotUsage(bearerUsage.data));
+  const bearerUsage = await tryGitHubUserEndpoint(
+    `Bearer ${githubToken}`,
+    signal,
+  );
+  if (bearerUsage.ok)
+    return success("github-copilot", parseGitHubCopilotUsage(bearerUsage.data));
 
-  const tokenUsage = await tryGitHubUserEndpoint(`token ${githubToken}`, signal);
-  if (tokenUsage.ok) return success("github-copilot", parseGitHubCopilotUsage(tokenUsage.data));
+  const tokenUsage = await tryGitHubUserEndpoint(
+    `token ${githubToken}`,
+    signal,
+  );
+  if (tokenUsage.ok)
+    return success("github-copilot", parseGitHubCopilotUsage(tokenUsage.data));
 
   return failure(bearerUsage.message, bearerUsage.kind);
 }
@@ -209,7 +278,8 @@ export async function fetchGitHubCopilotQuotasWithToken(
   accessToken: string | undefined,
   signal?: AbortSignal,
 ): Promise<QuotasResult> {
-  if (!accessToken) return failure("No GitHub Copilot OAuth token found", "config");
+  if (!accessToken)
+    return failure("No GitHub Copilot OAuth token found", "config");
 
   // 1) Try Copilot token exchange with stored Pi token
   const exchange = await fetchJson(
@@ -219,19 +289,28 @@ export async function fetchGitHubCopilotQuotasWithToken(
   );
 
   if (exchange.ok && exchange.data?.token) {
-    const usage = await tryGitHubUserEndpoint(`Bearer ${exchange.data.token}`, signal);
-    if (usage.ok) return success("github-copilot", parseGitHubCopilotUsage(usage.data));
+    const usage = await tryGitHubUserEndpoint(
+      `Bearer ${exchange.data.token}`,
+      signal,
+    );
+    if (usage.ok)
+      return success("github-copilot", parseGitHubCopilotUsage(usage.data));
   }
 
   // 2) Try stored token directly
-  const directUsage = await tryGitHubUserEndpoint(`token ${accessToken}`, signal);
-  if (directUsage.ok) return success("github-copilot", parseGitHubCopilotUsage(directUsage.data));
+  const directUsage = await tryGitHubUserEndpoint(
+    `token ${accessToken}`,
+    signal,
+  );
+  if (directUsage.ok)
+    return success("github-copilot", parseGitHubCopilotUsage(directUsage.data));
 
   // 3) Fallback: gh CLI token
   const cliToken = ghCliToken();
   if (cliToken && cliToken !== accessToken) {
     const cliUsage = await tryGitHubUserEndpoint(`token ${cliToken}`, signal);
-    if (cliUsage.ok) return success("github-copilot", parseGitHubCopilotUsage(cliUsage.data));
+    if (cliUsage.ok)
+      return success("github-copilot", parseGitHubCopilotUsage(cliUsage.data));
     return failure(cliUsage.message, cliUsage.kind);
   }
 
@@ -242,7 +321,10 @@ export async function fetchAnthropicQuotas(
   authStorage: AuthStorage,
   signal?: AbortSignal,
 ): Promise<QuotasResult> {
-  return fetchAnthropicQuotasWithToken(await providerAccessToken(authStorage, "anthropic"), signal);
+  return fetchAnthropicQuotasWithToken(
+    await providerAccessToken(authStorage, "anthropic"),
+    signal,
+  );
 }
 
 export async function fetchCodexQuotas(
@@ -312,7 +394,11 @@ export async function fetchSyntheticQuotas(
   signal?: AbortSignal,
 ): Promise<QuotasResult> {
   const apiKey = process.env.SYNTHETIC_API_KEY;
-  if (!apiKey) return failure("No Synthetic API key found (set SYNTHETIC_API_KEY)", "config");
+  if (!apiKey)
+    return failure(
+      "No Synthetic API key found (set SYNTHETIC_API_KEY)",
+      "config",
+    );
 
   const result = await fetchJson(
     "https://api.synthetic.new/v2/quotas",
@@ -325,10 +411,69 @@ export async function fetchSyntheticQuotas(
   return success("synthetic", parseSyntheticUsage(result.data));
 }
 
+export async function fetchOpenCodeGoQuotas(
+  _authStorage: AuthStorage,
+  signal?: AbortSignal,
+): Promise<QuotasResult> {
+  const configResult = await resolveOpenCodeGoConfigCached();
+  if (configResult.state === "none") {
+    return failure(
+      "No OpenCode Go config. Set OPENCODE_GO_WORKSPACE_ID +" +
+        " OPENCODE_GO_AUTH_COOKIE, or create" +
+        " ~/.config/opencode/opencode-quota/opencode-go.json",
+      "config",
+    );
+  }
+  if (configResult.state === "incomplete") {
+    return failure(
+      `OpenCode Go config incomplete: missing ${configResult.missing}`,
+      "config",
+    );
+  }
+  if (configResult.state === "invalid") {
+    return failure(
+      `OpenCode Go config invalid: ${configResult.error}`,
+      "config",
+    );
+  }
+
+  const result = await queryOpenCodeGoQuota(configResult.config, signal);
+  if (!result.success) return failure(result.error, "http");
+  return success("opencode-go", parseOpenCodeGoUsage(result));
+}
+
+export async function fetchZaiQuotasWithToken(
+  apiKey: string | undefined,
+  signal?: AbortSignal,
+): Promise<QuotasResult> {
+  if (!apiKey) return failure("No Z.ai API key found", "config");
+  const result = await fetchJson(
+    "https://api.z.ai/api/monitor/usage/quota/limit",
+    {
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        Accept: "application/json",
+      },
+    },
+    signal,
+  );
+  if (!result.ok) return failure(result.message, result.kind);
+  return success("zai", parseZaiUsage(result.data));
+}
+
+export async function fetchZaiQuotas(
+  authStorage: AuthStorage,
+  signal?: AbortSignal,
+): Promise<QuotasResult> {
+  return fetchZaiQuotasWithToken(await providerAccessToken(authStorage, "zai"), signal);
+}
+
 export const PROVIDER_FETCHERS = {
   anthropic: fetchAnthropicQuotas,
   "openai-codex": fetchCodexQuotas,
   "github-copilot": fetchGitHubCopilotQuotas,
   openrouter: fetchOpenRouterQuotas,
   synthetic: fetchSyntheticQuotas,
+  zai: fetchZaiQuotas,
+  "opencode-go": fetchOpenCodeGoQuotas,
 } as const;

package/src/providers/opencode-go-config.ts

@@ -0,0 +1,127 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+export interface OpenCodeGoConfig {
+  workspaceId: string;
+  authCookie: string;
+}
+
+export type ResolvedOpenCodeGoConfig =
+  | { state: "none" }
+  | { state: "configured"; config: OpenCodeGoConfig; source: string }
+  | { state: "incomplete"; source: string; missing: string }
+  | { state: "invalid"; source: string; error: string };
+
+function getConfigCandidatePaths(): string[] {
+  const home = homedir();
+  return [
+    join(home, ".config", "opencode", "opencode-quota", "opencode-go.json"),
+    join(home, ".config", "opencode-go", "config.json"),
+  ];
+}
+
+async function readConfigFile(
+  path: string,
+): Promise<
+  | { state: "missing" }
+  | { state: "loaded"; config: Partial<OpenCodeGoConfig> }
+  | { state: "invalid"; error: string }
+> {
+  try {
+    const data = await readFile(path, "utf-8");
+    const parsed = JSON.parse(data) as Record<string, unknown>;
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return {
+        state: "invalid",
+        error: "Config file must contain a JSON object",
+      };
+    }
+    return { state: "loaded", config: parsed as Partial<OpenCodeGoConfig> };
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException | undefined)?.code === "ENOENT") {
+      return { state: "missing" };
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      state: "invalid",
+      error: `Failed to read config file: ${message}`,
+    };
+  }
+}
+
+export function resolveOpenCodeGoConfigFromEnv(
+  env: NodeJS.ProcessEnv = process.env,
+): ResolvedOpenCodeGoConfig | null {
+  const workspaceId = env.OPENCODE_GO_WORKSPACE_ID?.trim();
+  const authCookie = env.OPENCODE_GO_AUTH_COOKIE?.trim();
+
+  if (!workspaceId && !authCookie) return null;
+
+  if (workspaceId && authCookie) {
+    return {
+      state: "configured",
+      config: { workspaceId, authCookie },
+      source: "env",
+    };
+  }
+
+  return {
+    state: "incomplete",
+    source: "env",
+    missing: workspaceId
+      ? "OPENCODE_GO_AUTH_COOKIE"
+      : "OPENCODE_GO_WORKSPACE_ID",
+  };
+}
+
+export async function resolveOpenCodeGoConfig(): Promise<ResolvedOpenCodeGoConfig> {
+  const envResult = resolveOpenCodeGoConfigFromEnv();
+  if (envResult) return envResult;
+
+  const candidates = getConfigCandidatePaths();
+  for (const path of candidates) {
+    const fileResult = await readConfigFile(path);
+    if (fileResult.state === "missing") continue;
+    if (fileResult.state === "invalid") {
+      return { state: "invalid", source: path, error: fileResult.error };
+    }
+
+    const config = fileResult.config;
+    const workspaceId =
+      typeof config.workspaceId === "string" ? config.workspaceId.trim() : "";
+    const authCookie =
+      typeof config.authCookie === "string" ? config.authCookie.trim() : "";
+
+    if (workspaceId && authCookie) {
+      return {
+        state: "configured",
+        config: { workspaceId, authCookie },
+        source: path,
+      };
+    }
+
+    const missing = !workspaceId ? "workspaceId" : "authCookie";
+    return { state: "incomplete", source: path, missing };
+  }
+
+  return { state: "none" };
+}
+
+let cachedConfig: ResolvedOpenCodeGoConfig | null = null;
+let cachedAt = 0;
+
+const CACHE_MAX_AGE_MS = 30_000;
+
+export async function resolveOpenCodeGoConfigCached(params?: {
+  maxAgeMs?: number;
+}): Promise<ResolvedOpenCodeGoConfig> {
+  const maxAgeMs = Math.max(0, params?.maxAgeMs ?? CACHE_MAX_AGE_MS);
+  const now = Date.now();
+  if (cachedConfig && now - cachedAt < maxAgeMs) {
+    return cachedConfig;
+  }
+  cachedConfig = await resolveOpenCodeGoConfig();
+  cachedAt = now;
+  return cachedConfig;
+}

package/src/providers/opencode-go.ts

@@ -0,0 +1,183 @@
+/**
+ * OpenCode Go client.
+ *
+ * Fetches usage data from OpenCode Go dashboard using workspace ID and auth cookie.
+ * Scrapes SolidJS SSR hydration output for usage windows.
+ *
+ * Configuration:
+ * - Environment: OPENCODE_GO_WORKSPACE_ID + OPENCODE_GO_AUTH_COOKIE
+ * - Config file: ~/.config/opencode/opencode-quota/opencode-go.json
+ */
+
+const DASHBOARD_URL_PREFIX = "https://opencode.ai/workspace/";
+const DASHBOARD_URL_SUFFIX = "/go";
+const USER_AGENT =
+  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) Gecko/20100101 Firefox/148.0";
+const REQUEST_TIMEOUT_MS = 10_000;
+
+const SCRAPED_NUMBER_PATTERN = String.raw`(-?\d+(?:\.\d+)?)`;
+
+const RE_ROLLING_PCT_FIRST = new RegExp(
+  String.raw`rollingUsage:\$R\[\d+\]=\{[^}]*usagePercent:${SCRAPED_NUMBER_PATTERN}[^}]*resetInSec:${SCRAPED_NUMBER_PATTERN}[^}]*\}`,
+);
+const RE_ROLLING_RESET_FIRST = new RegExp(
+  String.raw`rollingUsage:\$R\[\d+\]=\{[^}]*resetInSec:${SCRAPED_NUMBER_PATTERN}[^}]*usagePercent:${SCRAPED_NUMBER_PATTERN}[^}]*\}`,
+);
+
+const RE_WEEKLY_PCT_FIRST = new RegExp(
+  String.raw`weeklyUsage:\$R\[\d+\]=\{[^}]*usagePercent:${SCRAPED_NUMBER_PATTERN}[^}]*resetInSec:${SCRAPED_NUMBER_PATTERN}[^}]*\}`,
+);
+const RE_WEEKLY_RESET_FIRST = new RegExp(
+  String.raw`weeklyUsage:\$R\[\d+\]=\{[^}]*resetInSec:${SCRAPED_NUMBER_PATTERN}[^}]*usagePercent:${SCRAPED_NUMBER_PATTERN}[^}]*\}`,
+);
+
+const RE_MONTHLY_PCT_FIRST = new RegExp(
+  String.raw`monthlyUsage:\$R\[\d+\]=\{[^}]*usagePercent:${SCRAPED_NUMBER_PATTERN}[^}]*resetInSec:${SCRAPED_NUMBER_PATTERN}[^}]*\}`,
+);
+const RE_MONTHLY_RESET_FIRST = new RegExp(
+  String.raw`monthlyUsage:\$R\[\d+\]=\{[^}]*resetInSec:${SCRAPED_NUMBER_PATTERN}[^}]*usagePercent:${SCRAPED_NUMBER_PATTERN}[^}]*\}`,
+);
+
+interface ScrapedWindowUsage {
+  usagePercent: number;
+  resetInSec: number;
+}
+
+export interface OpenCodeGoWindow {
+  usagePercent: number;
+  resetInSec: number;
+  percentRemaining: number;
+  resetTimeIso: string;
+}
+
+export interface OpenCodeGoQuotaResult {
+  success: true;
+  rolling?: OpenCodeGoWindow;
+  weekly?: OpenCodeGoWindow;
+  monthly?: OpenCodeGoWindow;
+}
+
+export interface OpenCodeGoQuotaError {
+  success: false;
+  error: string;
+}
+
+export type OpenCodeGoResult = OpenCodeGoQuotaResult | OpenCodeGoQuotaError;
+
+export interface OpenCodeGoConfig {
+  workspaceId: string;
+  authCookie: string;
+}
+
+function parseWindowUsage(
+  html: string,
+  rePctFirst: RegExp,
+  reResetFirst: RegExp,
+): ScrapedWindowUsage | null {
+  const pctFirstMatch = rePctFirst.exec(html);
+  if (pctFirstMatch) {
+    const usagePercent = Number(pctFirstMatch[1]);
+    const resetInSec = Number(pctFirstMatch[2]);
+    if (Number.isFinite(usagePercent) && Number.isFinite(resetInSec)) {
+      return { usagePercent, resetInSec };
+    }
+  }
+
+  const resetFirstMatch = reResetFirst.exec(html);
+  if (resetFirstMatch) {
+    const resetInSec = Number(resetFirstMatch[1]);
+    const usagePercent = Number(resetFirstMatch[2]);
+    if (Number.isFinite(usagePercent) && Number.isFinite(resetInSec)) {
+      return { usagePercent, resetInSec };
+    }
+  }
+
+  return null;
+}
+
+function normalizeWindowUsage(
+  window: ScrapedWindowUsage,
+  now: number,
+): OpenCodeGoWindow {
+  const usagePercent = Math.max(0, window.usagePercent);
+  const resetInSec = Math.max(0, window.resetInSec);
+  return {
+    usagePercent,
+    resetInSec,
+    percentRemaining: 100 - usagePercent,
+    resetTimeIso: new Date(now + resetInSec * 1000).toISOString(),
+  };
+}
+
+export async function queryOpenCodeGoQuota(
+  config: OpenCodeGoConfig,
+  signal?: AbortSignal,
+): Promise<OpenCodeGoResult> {
+  try {
+    const url = `${DASHBOARD_URL_PREFIX}${encodeURIComponent(config.workspaceId)}${DASHBOARD_URL_SUFFIX}`;
+    const signals: AbortSignal[] = [AbortSignal.timeout(REQUEST_TIMEOUT_MS)];
+    if (signal) signals.push(signal);
+    const combined = AbortSignal.any(signals);
+
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        "User-Agent": USER_AGENT,
+        Accept: "text/html",
+        Cookie: `auth=${config.authCookie}`,
+      },
+      signal: combined,
+    });
+
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      return {
+        success: false,
+        error: `OpenCode Go dashboard error ${response.status}: ${text.slice(0, 120)}`,
+      };
+    }
+
+    const html = await response.text();
+    const rolling = parseWindowUsage(
+      html,
+      RE_ROLLING_PCT_FIRST,
+      RE_ROLLING_RESET_FIRST,
+    );
+    const weekly = parseWindowUsage(
+      html,
+      RE_WEEKLY_PCT_FIRST,
+      RE_WEEKLY_RESET_FIRST,
+    );
+    const monthly = parseWindowUsage(
+      html,
+      RE_MONTHLY_PCT_FIRST,
+      RE_MONTHLY_RESET_FIRST,
+    );
+
+    if (!rolling && !weekly && !monthly) {
+      return {
+        success: false,
+        error: "Could not parse OpenCode Go dashboard usage windows",
+      };
+    }
+
+    const now = Date.now();
+    return {
+      success: true,
+      ...(rolling ? { rolling: normalizeWindowUsage(rolling, now) } : {}),
+      ...(weekly ? { weekly: normalizeWindowUsage(weekly, now) } : {}),
+      ...(monthly ? { monthly: normalizeWindowUsage(monthly, now) } : {}),
+    };
+  } catch (err) {
+    if (err instanceof Error && err.name === "TimeoutError") {
+      return { success: false, error: "Request timed out" };
+    }
+    if (err instanceof Error && err.name === "AbortError") {
+      return { success: false, error: "Request cancelled" };
+    }
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : "Unknown error",
+    };
+  }
+}