pi-myusage 0.1.0

package/src/adapters/openai-codex.ts

@@ -0,0 +1,122 @@
+import { windowsSummary, type QuotaWindowMetric } from "../format.ts";
+import { fetchJson, HttpError, safeError, urlOnDomain } from "../http.ts";
+import { snapshot, type Metric, type UsageAdapter, type UsageSnapshot } from "../types.ts";
+
+const USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
+
+interface WhamWindow {
+  used_percent?: number;
+  limit_window_seconds?: number;
+  reset_at?: number;
+  reset_after_seconds?: number;
+}
+
+interface WhamUsageResponse {
+  rate_limit?: {
+    primary_window?: WhamWindow | null;
+    secondary_window?: WhamWindow | null;
+  } | null;
+  credits?: {
+    has_credits?: boolean;
+    balance?: string;
+  } | null;
+}
+
+function windowLabel(window: WhamWindow | null | undefined, fallback: string): string {
+  const seconds = window?.limit_window_seconds;
+  if (seconds === 18_000) return "Codex 5h";
+  if (seconds === 604_800) return "Codex 7d";
+  if (typeof seconds === "number" && seconds > 0) {
+    if (seconds % 86_400 === 0) return `Codex ${seconds / 86_400}d`;
+    if (seconds % 3_600 === 0) return `Codex ${seconds / 3_600}h`;
+  }
+  return fallback;
+}
+
+function parseWindow(
+  window: WhamWindow | null | undefined,
+  id: string,
+  fallbackLabel: string,
+): Metric | undefined {
+  if (!window || typeof window.used_percent !== "number") return undefined;
+  const used = Math.min(100, Math.max(0, window.used_percent));
+  const remainingFraction = Math.min(1, Math.max(0, (100 - used) / 100));
+
+  let resetAt: string | undefined;
+  if (typeof window.reset_at === "number" && window.reset_at > 0) {
+    resetAt = new Date(window.reset_at * 1000).toISOString();
+  } else if (typeof window.reset_after_seconds === "number" && window.reset_after_seconds > 0) {
+    resetAt = new Date(Date.now() + window.reset_after_seconds * 1000).toISOString();
+  }
+
+  return {
+    kind: "quota-window",
+    id,
+    label: windowLabel(window, fallbackLabel),
+    remainingFraction,
+    ...(resetAt ? { resetAt } : {}),
+  };
+}
+
+export const openaiCodexAdapter: UsageAdapter = {
+  id: "openai-codex",
+  label: "OpenAI Codex",
+  canHandle(target) {
+    if (target.providerId.toLowerCase() === "openai-codex") return true;
+    return urlOnDomain(target.baseUrl, "chatgpt.com");
+  },
+  async fetch({ target, signal }): Promise<UsageSnapshot> {
+    try {
+      const creds = target.credentials;
+      const apiKey = creds?.apiKey;
+      if (!apiKey) return snapshot(this, target, "unauthorized", { error: "No API key" });
+
+      const headers: Record<string, string> = {
+        Authorization: `Bearer ${apiKey}`,
+        Accept: "application/json",
+        "User-Agent": "pi-myusage",
+      };
+      if (creds?.accountId) headers["chatgpt-account-id"] = creds.accountId;
+
+      const payload = await fetchJson<WhamUsageResponse>(USAGE_URL, { headers }, signal);
+
+      const metrics: Metric[] = [];
+      const primary = parseWindow(payload.rate_limit?.primary_window, "primary", "Codex 5h");
+      if (primary) metrics.push(primary);
+      const secondary = parseWindow(payload.rate_limit?.secondary_window, "secondary", "Codex 7d");
+      if (secondary) metrics.push(secondary);
+
+      const credits = payload.credits;
+      if (credits?.has_credits === true) {
+        metrics.push({
+          kind: "status",
+          id: "codex-credits",
+          label: "Credits",
+          value: credits.balance ?? "enabled",
+        });
+      }
+
+      if (!metrics.length) return snapshot(this, target, "empty");
+
+      const windows = metrics.filter(
+        (metric): metric is QuotaWindowMetric => metric.kind === "quota-window",
+      );
+      const creditsMetric = metrics.find((metric) => metric.kind === "status");
+      let summary = windowsSummary(windows);
+      if (!summary && creditsMetric && creditsMetric.kind === "status") {
+        summary = `Codex · credits ${creditsMetric.value}`;
+      }
+
+      return snapshot(this, target, "ok", {
+        accounts: [{ id: "openai-codex", label: "Codex", metrics }],
+        summary,
+      });
+    } catch (error) {
+      if (signal.aborted) return snapshot(this, target, "unavailable", { error: "aborted" });
+      if (error instanceof HttpError && (error.status === 401 || error.status === 403)) {
+        return snapshot(this, target, "unauthorized", { error: `HTTP ${error.status}` });
+      }
+      return snapshot(this, target, "unavailable", { error: safeError(error) });
+    }
+  },
+};

package/src/adapters/opencode-go.ts

@@ -0,0 +1,83 @@
+import { windowsSummary, type QuotaWindowMetric } from "../format.ts";
+import { fetchJson, HttpError, safeError, urlOnDomain } from "../http.ts";
+import { snapshot, type Metric, type UsageAdapter, type UsageSnapshot } from "../types.ts";
+
+const USAGE_URL = "https://opencode.ai/zen/go/v1/usage";
+
+interface UsageWindow {
+  status?: string;
+  percent?: number;
+  resetsAt?: string;
+}
+
+interface UsageResponse {
+  usage?: {
+    rolling?: UsageWindow;
+    weekly?: UsageWindow;
+    monthly?: UsageWindow;
+  };
+}
+
+function windowMetric(id: string, label: string, w: UsageWindow | undefined): Metric | undefined {
+  if (w?.status && w.status !== "ok" && w.status !== "rate-limited") return undefined;
+  if (!w || typeof w.percent !== "number" || !Number.isFinite(w.percent)) return undefined;
+  const used = Math.min(100, Math.max(0, w.percent));
+  const resetAt =
+    w.resetsAt && !Number.isNaN(Date.parse(w.resetsAt)) ? new Date(w.resetsAt).toISOString() : undefined;
+  return {
+    kind: "quota-window",
+    id,
+    label,
+    remainingFraction: Math.max(0, (100 - used) / 100),
+    ...(resetAt ? { resetAt } : {}),
+  };
+}
+
+export const opencodeGoAdapter: UsageAdapter = {
+  id: "opencode-go",
+  label: "OpenCode Zen",
+  canHandle(target) {
+    const pid = target.providerId.toLowerCase();
+    if (["opencode-go", "opencode", "opencode-zen"].includes(pid)) return true;
+    return urlOnDomain(target.baseUrl, "opencode.ai");
+  },
+  async fetch({ target, signal }): Promise<UsageSnapshot> {
+    try {
+      const apiKey = target.credentials?.apiKey;
+      if (!apiKey) return snapshot(this, target, "unauthorized", { error: "No API key" });
+
+      let payload: UsageResponse;
+      try {
+        payload = await fetchJson<UsageResponse>(
+          USAGE_URL,
+          { headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json" } },
+          signal,
+        );
+      } catch (error) {
+        if (
+          error instanceof HttpError &&
+          (error.status === 401 || error.status === 403)
+        ) {
+          return snapshot(this, target, "unauthorized", { error: safeError(error) });
+        }
+        throw error;
+      }
+
+      const metrics = [
+        windowMetric("opencode-go-5h", "OpenCode 5h", payload.usage?.rolling),
+        windowMetric("opencode-go-weekly", "OpenCode Weekly", payload.usage?.weekly),
+        windowMetric("opencode-go-monthly", "OpenCode Monthly", payload.usage?.monthly),
+      ].filter((m): m is QuotaWindowMetric => m !== undefined);
+      if (!metrics.length) return snapshot(this, target, "empty", { error: "No usage windows returned" });
+
+      const summary = windowsSummary(metrics);
+      return snapshot(this, target, "ok", {
+        accounts: [{ id: "opencode-go-account", label: "OpenCode Zen", metrics }],
+        summary: summary ? `${summary} · Zen` : "Zen",
+      });
+    } catch (error) {
+      if (signal.aborted) return snapshot(this, target, "unavailable", { error: "aborted" });
+      return snapshot(this, target, "unavailable", { error: safeError(error) });
+    }
+  },
+};

package/src/adapters/openrouter.ts

@@ -0,0 +1,101 @@
+import { fetchJson, HttpError, safeError, urlOnDomain } from "../http.ts";
+import { snapshot, type UsageAdapter, type UsageSnapshot } from "../types.ts";
+
+const KEY_URL = "https://openrouter.ai/api/v1/key";
+const CREDITS_URL = "https://openrouter.ai/api/v1/credits";
+
+interface KeyResponse {
+  data?: {
+    label?: string;
+    usage?: number;
+    limit?: number | null;
+  };
+}
+
+interface CreditsResponse {
+  data?: {
+    total_credits?: number;
+    total_usage?: number;
+  };
+}
+
+export const openrouterAdapter: UsageAdapter = {
+  id: "openrouter",
+  label: "OpenRouter",
+  canHandle(target) {
+    if (target.providerId.toLowerCase() === "openrouter") return true;
+    return urlOnDomain(target.baseUrl, "openrouter.ai");
+  },
+  async fetch({ target, signal }): Promise<UsageSnapshot> {
+    try {
+      const apiKey = target.credentials?.apiKey;
+      if (!apiKey) return snapshot(this, target, "unauthorized", { error: "No API key" });
+      const headers = { Authorization: `Bearer ${apiKey}`, Accept: "application/json" };
+
+      const [keyResult, creditsResult] = await Promise.allSettled([
+        fetchJson<KeyResponse>(KEY_URL, { headers }, signal),
+        fetchJson<CreditsResponse>(CREDITS_URL, { headers }, signal),
+      ]);
+      if (keyResult.status === "rejected") throw keyResult.reason;
+      const keyInfo = keyResult.value.data;
+      const usage = typeof keyInfo?.usage === "number" && Number.isFinite(keyInfo.usage) ? keyInfo.usage : 0;
+      const limit = typeof keyInfo?.limit === "number" && Number.isFinite(keyInfo.limit) ? keyInfo.limit : undefined;
+      const credits = creditsResult.status === "fulfilled" ? creditsResult.value.data : undefined;
+
+      const balance =
+        typeof credits?.total_credits === "number" && typeof credits?.total_usage === "number"
+          ? Math.max(0, credits.total_credits - credits.total_usage)
+          : undefined;
+
+      const metrics = [
+        ...(limit !== undefined
+          ? [
+              {
+                kind: "usage-limit" as const,
+                id: "openrouter-usage",
+                label: "Usage",
+                used: usage,
+                limit,
+                unit: "USD",
+              },
+            ]
+          : []),
+        ...(balance !== undefined
+          ? [
+              {
+                kind: "balance" as const,
+                id: "openrouter-balance",
+                label: "Balance",
+                amount: balance,
+                currency: "USD",
+                detail:
+                  credits && typeof credits.total_usage === "number"
+                    ? `credits ${credits.total_credits} · used ${credits.total_usage.toFixed(2)}`
+                    : undefined,
+              },
+            ]
+          : []),
+      ];
+      if (!metrics.length) return snapshot(this, target, "empty");
+
+      const summary =
+        limit !== undefined
+          ? `$${usage.toFixed(2)}/$${limit % 1 === 0 ? limit.toString() : limit.toFixed(2)} · OpenRouter`
+          : balance !== undefined
+            ? `$${balance.toFixed(2)} · OpenRouter`
+            : `Used $${usage.toFixed(2)} · OpenRouter`;
+      return snapshot(this, target, "ok", {
+        accounts: [
+          { id: "openrouter-account", label: keyInfo?.label ? `OpenRouter (${keyInfo.label})` : "OpenRouter", metrics },
+        ],
+        summary,
+      });
+    } catch (error) {
+      if (signal.aborted) return snapshot(this, target, "unavailable", { error: "aborted" });
+      if (error instanceof HttpError && (error.status === 401 || error.status === 403)) {
+        return snapshot(this, target, "unauthorized", { error: `HTTP ${error.status}` });
+      }
+      return snapshot(this, target, "unavailable", { error: safeError(error) });
+    }
+  },
+};

package/src/adapters/vercel.ts

@@ -0,0 +1,80 @@
+import { fetchJson, HttpError, safeError, urlOnDomain } from "../http.ts";
+import { snapshot, type UsageAdapter, type UsageSnapshot } from "../types.ts";
+
+const CREDITS_URL = "https://ai-gateway.vercel.sh/v1/credits";
+
+interface CreditsResponse {
+  balance?: string | number;
+  total_used?: string | number;
+}
+
+function amount(value: string | number | undefined): number | undefined {
+  const n = typeof value === "number" ? value : typeof value === "string" && value.trim() !== "" ? Number(value) : NaN;
+  return Number.isFinite(n) && n >= 0 ? n : undefined;
+}
+
+export const vercelGatewayAdapter: UsageAdapter = {
+  id: "vercel-ai-gateway",
+  label: "Vercel AI Gateway",
+  canHandle(target) {
+    if (target.providerId.toLowerCase() === "vercel-ai-gateway") return true;
+    return urlOnDomain(target.baseUrl, "vercel.sh") || urlOnDomain(target.baseUrl, "ai-gateway.vercel.sh");
+  },
+  async fetch({ target, signal }): Promise<UsageSnapshot> {
+    try {
+      const apiKey = target.credentials?.apiKey;
+      if (!apiKey) return snapshot(this, target, "unauthorized", { error: "No API key" });
+
+      const payload = await fetchJson<CreditsResponse>(
+        CREDITS_URL,
+        { headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json" } },
+        signal,
+      );
+
+      const balance = amount(payload.balance);
+      const lifetime = amount(payload.total_used);
+      if (balance === undefined && lifetime === undefined) {
+        return snapshot(this, target, "empty", { error: "No credits data returned" });
+      }
+
+      const metrics = [
+        ...(balance !== undefined
+          ? [
+              {
+                kind: "balance" as const,
+                id: "vercel-credits",
+                label: "Credits remaining",
+                amount: balance,
+                currency: "USD",
+                detail: lifetime !== undefined ? `lifetime spend ${lifetime.toFixed(2)}` : undefined,
+              },
+            ]
+          : []),
+        ...(balance !== undefined && lifetime !== undefined && balance + lifetime > 0
+          ? [
+              {
+                kind: "usage-limit" as const,
+                id: "vercel-lifetime",
+                label: "Lifetime spend",
+                used: lifetime,
+                limit: balance + lifetime,
+                unit: "USD",
+                detail: "lifetime credits issued",
+              },
+            ]
+          : []),
+      ];
+      const primary = balance ?? lifetime ?? 0;
+      return snapshot(this, target, "ok", {
+        accounts: [{ id: "vercel-gateway-account", label: "Vercel AI Gateway", metrics }],
+        summary: `${balance !== undefined ? `$${balance.toFixed(2)} left` : `$${primary.toFixed(2)} used`} · Vercel AI Gateway`,
+      });
+    } catch (error) {
+      if (signal.aborted) return snapshot(this, target, "unavailable", { error: "aborted" });
+      if (error instanceof HttpError && (error.status === 401 || error.status === 403)) {
+        return snapshot(this, target, "unauthorized", { error: `HTTP ${error.status}` });
+      }
+      return snapshot(this, target, "unavailable", { error: safeError(error) });
+    }
+  },
+};

package/src/adapters/vertex.ts

@@ -0,0 +1,23 @@
+import { urlOnDomain } from "../http.ts";
+import { snapshot, type UsageAdapter, type UsageSnapshot } from "../types.ts";
+
+export const vertexAdapter: UsageAdapter = {
+  id: "google-vertex",
+  label: "Google Vertex AI",
+  canHandle(target) {
+    if (["vertex", "google-vertex", "vertex-ai"].includes(target.providerId.toLowerCase())) return true;
+    return urlOnDomain(target.baseUrl, "aiplatform.googleapis.com") || urlOnDomain(target.baseUrl, "geminivertexai");
+  },
+  async fetch({ target }): Promise<UsageSnapshot> {
+    return snapshot(this, target, "ok", {
+      accounts: [
+        {
+          id: "vertex-billing",
+          label: "Google Vertex AI",
+          metrics: [{ kind: "status", id: "vertex-billing", label: "Billing", value: "pay-as-you-go (GCP billing)" }],
+        },
+      ],
+      summary: "Vertex · PAYG",
+    });
+  },
+};

package/src/adapters/xai.ts

@@ -0,0 +1,208 @@
+import { shortReset, windowsSummary, type QuotaWindowMetric } from "../format.ts";
+import { fetchJson, safeError, urlOnDomain, HttpError } from "../http.ts";
+import { snapshot, type Metric, type UsageAdapter, type UsageSnapshot } from "../types.ts";
+
+const USER_URL = "https://cli-chat-proxy.grok.com/v1/user?include=subscription";
+const BILLING_URL = "https://cli-chat-proxy.grok.com/v1/billing?format=credits";
+const USERINFO_URL = "https://auth.x.ai/oauth2/userinfo";
+
+const CLI_HEADERS: Record<string, string> = {
+  "X-XAI-Token-Auth": "xai-grok-cli",
+  "x-grok-client-version": "1.0.10",
+  "x-grok-client-mode": "interactive",
+};
+
+interface CentWrapper {
+  val?: number;
+}
+
+interface BillingConfig {
+  creditUsagePercent?: number | null;
+  monthlyLimit?: CentWrapper | null;
+  used?: CentWrapper | null;
+  onDemandCap?: CentWrapper | null;
+  onDemandUsed?: CentWrapper | null;
+  prepaidBalance?: CentWrapper | null;
+  currentPeriod?: { type?: string; start?: string; end?: string } | null;
+  billingPeriodStart?: string | null;
+  billingPeriodEnd?: string | null;
+}
+
+interface UserResponse {
+  userId?: string;
+  subscriptionTier?: string;
+}
+
+interface UserinfoResponse {
+  sub?: string;
+  name?: string;
+  email?: string;
+}
+
+function cents(value: CentWrapper | null | undefined): number | undefined {
+  if (!value || typeof value.val !== "number" || !Number.isFinite(value.val)) return undefined;
+  return value.val / 100;
+}
+
+function isoOrNull(value: unknown): string | undefined {
+  if (typeof value !== "string") return undefined;
+  const ms = Date.parse(value);
+  return Number.isFinite(ms) ? new Date(ms).toISOString() : undefined;
+}
+
+function isAuthError(error: unknown): boolean {
+  return error instanceof HttpError && (error.status === 401 || error.status === 403);
+}
+
+async function fetchConsumer(
+  adapter: UsageAdapter,
+  target: Parameters<UsageAdapter["fetch"]>[0]["target"],
+  token: string,
+  signal: AbortSignal,
+): Promise<UsageSnapshot> {
+  const authHeaders = { Authorization: `Bearer ${token}`, ...CLI_HEADERS };
+  const user = await fetchJson<UserResponse>(USER_URL, { headers: authHeaders }, signal);
+
+  const billingHeaders: Record<string, string> = { ...authHeaders };
+  if (user.userId) billingHeaders["x-userid"] = user.userId;
+  const payload = await fetchJson<{ config?: BillingConfig | null }>(
+    BILLING_URL,
+    { headers: billingHeaders },
+    signal,
+  );
+  const config = payload.config ?? undefined;
+
+  const metrics: Metric[] = [];
+  const resetAt = isoOrNull(config?.currentPeriod?.end) ?? isoOrNull(config?.billingPeriodEnd);
+  const percent = config?.creditUsagePercent;
+  const usedUsd = cents(config?.used);
+  const limitUsd = cents(config?.monthlyLimit);
+
+  if (typeof percent === "number" && Number.isFinite(percent) && percent >= 0 && percent <= 100) {
+    metrics.push({
+      kind: "quota-window",
+      id: "grok-allowance",
+      label: "Included allowance",
+      remainingFraction: (100 - percent) / 100,
+      ...(resetAt ? { resetAt } : {}),
+    });
+  } else if (usedUsd !== undefined || limitUsd !== undefined) {
+    metrics.push({
+      kind: "usage-limit",
+      id: "grok-allowance",
+      label: "Included allowance",
+      used: usedUsd ?? 0,
+      limit: limitUsd ?? 0,
+      unit: "USD",
+      ...(resetAt ? { detail: `resets ${shortReset(resetAt)}` } : {}),
+    });
+  }
+
+  const onDemandUsed = cents(config?.onDemandUsed);
+  const onDemandCap = cents(config?.onDemandCap);
+  if (onDemandUsed !== undefined || onDemandCap !== undefined) {
+    metrics.push({
+      kind: "usage-limit",
+      id: "grok-on-demand",
+      label: "On-demand usage",
+      used: onDemandUsed ?? 0,
+      limit: onDemandCap ?? 0,
+      unit: "USD",
+    });
+  }
+
+  const prepaid = cents(config?.prepaidBalance);
+  if (prepaid !== undefined) {
+    metrics.push({
+      kind: "balance",
+      id: "grok-prepaid",
+      label: "Prepaid balance",
+      amount: prepaid,
+      currency: "USD",
+    });
+  }
+
+  if (user.subscriptionTier) {
+    metrics.push({ kind: "status", id: "grok-plan", label: "Plan", value: user.subscriptionTier });
+  }
+
+  if (!metrics.length) return snapshot(adapter, target, "empty");
+
+  const windows = metrics.filter(
+    (metric): metric is QuotaWindowMetric => metric.kind === "quota-window",
+  );
+  let summary: string | undefined;
+  if (windows.length) {
+    summary = windowsSummary(windows);
+  } else if (prepaid !== undefined) {
+    summary = `Grok · $${prepaid.toFixed(2)}`;
+  } else if (user.subscriptionTier) {
+    summary = `Grok · ${user.subscriptionTier}`;
+  }
+
+  return snapshot(adapter, target, "ok", {
+    accounts: [{ id: user.userId ?? "xai-user", label: "Grok Account", metrics }],
+    summary,
+  });
+}
+
+async function fetchUserinfo(
+  adapter: UsageAdapter,
+  target: Parameters<UsageAdapter["fetch"]>[0]["target"],
+  token: string,
+  signal: AbortSignal,
+): Promise<UsageSnapshot> {
+  const info = await fetchJson<UserinfoResponse>(
+    USERINFO_URL,
+    { headers: { Authorization: `Bearer ${token}`, Accept: "application/json" } },
+    signal,
+  );
+
+  const label = info.email || info.name || "Grok Account";
+  const metrics: Metric[] = [
+    { kind: "status", id: "grok-identity", label: "Account", value: label.slice(0, 40) },
+    { kind: "status", id: "grok-subscription", label: "Subscription", value: "Active" },
+  ];
+
+  return snapshot(adapter, target, "ok", {
+    accounts: [{ id: info.sub ?? "xai-user", label, metrics }],
+    summary: `Grok · ${label === "Grok Account" ? "Active" : label.slice(0, 40)}`,
+  });
+}
+
+export const xaiAdapter: UsageAdapter = {
+  id: "xai",
+  label: "xAI Grok",
+  canHandle(target) {
+    const pid = target.providerId.toLowerCase();
+    if (pid === "xai" || pid === "grok") return true;
+    return urlOnDomain(target.baseUrl, "x.ai") || urlOnDomain(target.baseUrl, "grok.com");
+  },
+  async fetch({ target, signal }): Promise<UsageSnapshot> {
+    try {
+      const token = target.credentials?.apiKey;
+      if (!token) return snapshot(this, target, "unauthorized", { error: "No API key" });
+
+      let consumerFailure: unknown;
+      try {
+        return await fetchConsumer(this, target, token, signal);
+      } catch (error) {
+        if (signal.aborted) throw error;
+        consumerFailure = error;
+      }
+
+      try {
+        return await fetchUserinfo(this, target, token, signal);
+      } catch (error) {
+        if (signal.aborted) throw error;
+        if (isAuthError(error) || isAuthError(consumerFailure)) {
+          return snapshot(this, target, "unauthorized", { error: safeError(error) });
+        }
+        throw error;
+      }
+    } catch (error) {
+      if (signal.aborted) return snapshot(this, target, "unavailable", { error: "aborted" });
+      return snapshot(this, target, "unavailable", { error: safeError(error) });
+    }
+  },
+};