tau-coding-agent 0.1.0

package/extensions/usage/anthropic.ts

@@ -0,0 +1,198 @@
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import {
+  clampPercent,
+  formatCurrency,
+  formatPlan,
+  formatWindowLabel,
+  LiveUsageUnavailableError,
+  makeMeterItem,
+  parseISODate,
+  readNumber,
+  readString,
+} from "./shared.js";
+import type { LiveUsageItem, LiveUsageSnapshot, UsageProviderDefinition } from "./types.js";
+
+const PROVIDER_ID = "anthropic";
+const USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
+const BETA_HEADER = "oauth-2025-04-20";
+const USER_AGENT = "claude-code/2.1.0";
+const SESSION_WINDOW_MINUTES = 5 * 60;
+const WEEK_WINDOW_MINUTES = 7 * 24 * 60;
+
+interface UsageWindow {
+  usedPercent: number;
+  resetsAt?: Date;
+}
+
+function makeWindowMeter(
+  key: string,
+  label: string,
+  window: UsageWindow,
+  windowMinutes: number,
+): LiveUsageItem {
+  return makeMeterItem({
+    key,
+    label,
+    usedPercent: window.usedPercent,
+    windowLabel: formatWindowLabel(windowMinutes),
+    resetsAt: window.resetsAt,
+  });
+}
+
+function parseWindow(value: unknown): UsageWindow | undefined {
+  const input = value as Record<string, unknown> | null | undefined;
+  const utilization = readNumber(input?.utilization);
+  if (utilization === undefined) return undefined;
+
+  const resetsAt = parseISODate(readString(input?.resets_at));
+  return {
+    usedPercent: clampPercent(utilization),
+    resetsAt,
+  };
+}
+
+function parseExtraUsage(value: unknown): LiveUsageItem | undefined {
+  const input = value as Record<string, unknown> | null | undefined;
+  if (!input || input.is_enabled !== true) return undefined;
+
+  const monthlyLimitMinor = readNumber(input.monthly_limit);
+  const usedCreditsMinor = readNumber(input.used_credits);
+  const utilization = readNumber(input.utilization);
+  const currency = readString(input.currency) ?? "USD";
+
+  if (
+    monthlyLimitMinor === undefined &&
+    usedCreditsMinor === undefined &&
+    utilization === undefined
+  ) {
+    return undefined;
+  }
+
+  const usedMajor = (usedCreditsMinor ?? 0) / 100;
+  const limitMajor = (monthlyLimitMinor ?? 0) / 100;
+  const usedPercent = clampPercent(
+    utilization ??
+      (monthlyLimitMinor && monthlyLimitMinor > 0
+        ? ((usedCreditsMinor ?? 0) / monthlyLimitMinor) * 100
+        : 0),
+  );
+
+  let detail: string | undefined;
+  if (monthlyLimitMinor !== undefined && monthlyLimitMinor > 0) {
+    detail = `${formatCurrency(usedMajor, currency)} / ${formatCurrency(limitMajor, currency)} used · monthly`;
+  }
+
+  return makeMeterItem({
+    key: "extra-usage",
+    label: "Extra usage",
+    usedPercent,
+    detail,
+  });
+}
+
+function extractErrorMessage(status: number, bodyText: string): string {
+  const defaultMessage = `Claude usage request failed (${status}).`;
+  if (status === 401 || status === 403) {
+    return "Claude login expired. Re-run /login anthropic.";
+  }
+  if (!bodyText.trim()) return defaultMessage;
+
+  try {
+    const parsed = JSON.parse(bodyText) as Record<string, unknown>;
+    const error = parsed.error as Record<string, unknown> | undefined;
+    const message = readString(error?.message) ?? readString(parsed.message);
+    return message ? `${defaultMessage} ${message}` : defaultMessage;
+  } catch {
+    return `${defaultMessage} ${bodyText.trim()}`;
+  }
+}
+
+async function fetchUsage(ctx: ExtensionContext, signal?: AbortSignal): Promise<LiveUsageSnapshot> {
+  const token = await ctx.modelRegistry.getApiKeyForProvider(PROVIDER_ID);
+  if (!token) throw new LiveUsageUnavailableError("no auth configured");
+
+  const credential = ctx.modelRegistry.authStorage.get(PROVIDER_ID);
+  if (credential?.type === "api_key") {
+    throw new LiveUsageUnavailableError("API-key auth does not expose Claude subscription quota");
+  }
+
+  const response = await fetch(USAGE_URL, {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      "anthropic-beta": BETA_HEADER,
+      "User-Agent": USER_AGENT,
+    },
+    signal,
+  });
+
+  if (!response.ok) {
+    const bodyText = await response.text().catch(() => "");
+    throw new Error(extractErrorMessage(response.status, bodyText));
+  }
+
+  const payload = (await response.json()) as Record<string, unknown>;
+  const fiveHour = parseWindow(payload.five_hour);
+  const sevenDay = parseWindow(payload.seven_day);
+  const sevenDaySonnet = parseWindow(payload.seven_day_sonnet);
+  const sevenDayOpus = parseWindow(payload.seven_day_opus);
+  const sevenDayOAuthApps = parseWindow(payload.seven_day_oauth_apps);
+
+  const items: LiveUsageItem[] = [];
+  if (fiveHour) items.push(makeWindowMeter("session", "Session", fiveHour, SESSION_WINDOW_MINUTES));
+  if (sevenDay) items.push(makeWindowMeter("week", "Week", sevenDay, WEEK_WINDOW_MINUTES));
+  if (sevenDaySonnet) {
+    items.push(makeWindowMeter("sonnet", "Sonnet", sevenDaySonnet, WEEK_WINDOW_MINUTES));
+  } else if (sevenDayOpus) {
+    items.push(makeWindowMeter("opus", "Opus", sevenDayOpus, WEEK_WINDOW_MINUTES));
+  } else if (sevenDayOAuthApps) {
+    items.push(makeWindowMeter("apps", "Apps", sevenDayOAuthApps, WEEK_WINDOW_MINUTES));
+  }
+
+  const extraUsage = parseExtraUsage(payload.extra_usage);
+  if (extraUsage) items.push(extraUsage);
+
+  if (items.length === 0) {
+    throw new Error("Claude did not return any live quota data.");
+  }
+
+  const rateLimitTier =
+    credential?.type === "oauth" && typeof credential.rateLimitTier === "string"
+      ? credential.rateLimitTier
+      : undefined;
+
+  return {
+    plan: formatPlan(rateLimitTier),
+    fetchedAt: new Date(),
+    items,
+  };
+}
+
+async function getLiveUsageAvailability(ctx: ExtensionContext) {
+  if (!ctx.modelRegistry.authStorage.hasAuth(PROVIDER_ID)) {
+    return { available: false as const, reason: "no auth configured" };
+  }
+
+  const credential = ctx.modelRegistry.authStorage.get(PROVIDER_ID);
+  if (credential?.type === "oauth") {
+    return { available: true as const };
+  }
+
+  return {
+    available: false as const,
+    reason: "API-key auth does not expose Claude subscription quota",
+  };
+}
+
+const anthropicProvider: UsageProviderDefinition = {
+  id: PROVIDER_ID,
+  label: "Claude",
+  shortLabel: "claude",
+  color: { r: 204, g: 124, b: 94 },
+  getLiveUsageAvailability,
+  fetchLiveUsage: fetchUsage,
+};
+
+export default anthropicProvider;

package/extensions/usage/github-copilot.ts

@@ -0,0 +1,204 @@
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import {
+  clampPercent,
+  formatCount,
+  formatPlan,
+  makeMeterItem,
+  parseISODate,
+  readNumber,
+  readString,
+} from "./shared.js";
+import type { LiveUsageItem, LiveUsageSnapshot, UsageProviderDefinition } from "./types.js";
+
+const PROVIDER_ID = "github-copilot";
+
+interface QuotaSnapshot {
+  entitlement: number;
+  remaining: number;
+  percentRemaining: number;
+}
+
+function normalizeDomain(input: string): string | undefined {
+  const value = input.trim();
+  if (!value) return undefined;
+  try {
+    const url = value.includes("://") ? new URL(value) : new URL(`https://${value}`);
+    return url.hostname;
+  } catch {
+    return undefined;
+  }
+}
+
+function parseQuotaSnapshot(value: unknown): QuotaSnapshot | undefined {
+  const input = value as Record<string, unknown> | null | undefined;
+  if (!input || typeof input !== "object") return undefined;
+
+  const entitlement = readNumber(input.entitlement) ?? 0;
+  const remaining = readNumber(input.remaining) ?? 0;
+  const explicitPercent = readNumber(input.percent_remaining);
+  const derivedPercent = entitlement > 0 ? (remaining / entitlement) * 100 : undefined;
+  const percentRemaining = explicitPercent ?? derivedPercent ?? 0;
+  const quotaId = readString(input.quota_id) ?? "";
+
+  if (explicitPercent === undefined && derivedPercent === undefined) return undefined;
+  if (entitlement === 0 && remaining === 0 && percentRemaining === 0 && !quotaId) return undefined;
+
+  return {
+    entitlement,
+    remaining,
+    percentRemaining: clampPercent(percentRemaining),
+  };
+}
+
+function parseQuotaSnapshots(payload: Record<string, unknown>): {
+  premiumInteractions?: QuotaSnapshot;
+  chat?: QuotaSnapshot;
+} {
+  const quotaSnapshots = payload.quota_snapshots as Record<string, unknown> | undefined;
+  let premiumInteractions = parseQuotaSnapshot(quotaSnapshots?.premium_interactions);
+  let chat = parseQuotaSnapshot(quotaSnapshots?.chat);
+
+  if ((!premiumInteractions || !chat) && quotaSnapshots && typeof quotaSnapshots === "object") {
+    let firstUsable: QuotaSnapshot | undefined;
+    for (const [key, rawValue] of Object.entries(quotaSnapshots)) {
+      const snapshot = parseQuotaSnapshot(rawValue);
+      if (!snapshot) continue;
+      const lowerKey = key.toLowerCase();
+      if (!firstUsable) firstUsable = snapshot;
+      if (!chat && lowerKey.includes("chat")) {
+        chat = snapshot;
+        continue;
+      }
+      if (
+        !premiumInteractions &&
+        (lowerKey.includes("premium") ||
+          lowerKey.includes("completion") ||
+          lowerKey.includes("code"))
+      ) {
+        premiumInteractions = snapshot;
+      }
+    }
+    if (!premiumInteractions && !chat) chat = firstUsable;
+  }
+
+  const monthlyQuotas = payload.monthly_quotas as Record<string, unknown> | undefined;
+  const limitedUserQuotas = payload.limited_user_quotas as Record<string, unknown> | undefined;
+
+  if (!premiumInteractions) {
+    const entitlement = readNumber(monthlyQuotas?.completions);
+    const remaining = readNumber(limitedUserQuotas?.completions);
+    if (entitlement !== undefined && entitlement > 0 && remaining !== undefined) {
+      premiumInteractions = {
+        entitlement,
+        remaining,
+        percentRemaining: clampPercent((remaining / entitlement) * 100),
+      };
+    }
+  }
+
+  if (!chat) {
+    const entitlement = readNumber(monthlyQuotas?.chat);
+    const remaining = readNumber(limitedUserQuotas?.chat);
+    if (entitlement !== undefined && entitlement > 0 && remaining !== undefined) {
+      chat = {
+        entitlement,
+        remaining,
+        percentRemaining: clampPercent((remaining / entitlement) * 100),
+      };
+    }
+  }
+
+  return { premiumInteractions, chat };
+}
+
+function makeQuotaMeter(
+  key: string,
+  label: string,
+  quota: QuotaSnapshot,
+  resetsAt?: Date,
+): LiveUsageItem {
+  const usedPercent = clampPercent(100 - quota.percentRemaining);
+  return makeMeterItem({
+    key,
+    label,
+    usedPercent,
+    resetsAt,
+    detail:
+      quota.entitlement > 0
+        ? `${formatCount(quota.remaining)} / ${formatCount(quota.entitlement)} remaining`
+        : undefined,
+  });
+}
+
+function buildUsageUrl(enterpriseUrl?: string): string {
+  const domain = enterpriseUrl ? normalizeDomain(enterpriseUrl) : undefined;
+  const host = domain && domain !== "github.com" ? `api.${domain}` : "api.github.com";
+  return `https://${host}/copilot_internal/user`;
+}
+
+async function fetchUsage(ctx: ExtensionContext, signal?: AbortSignal): Promise<LiveUsageSnapshot> {
+  const credential = ctx.modelRegistry.authStorage.get(PROVIDER_ID);
+  if (
+    credential?.type !== "oauth" ||
+    typeof credential.refresh !== "string" ||
+    !credential.refresh.trim()
+  ) {
+    throw new Error("Not logged in to GitHub Copilot.");
+  }
+
+  const enterpriseUrl =
+    typeof credential.enterpriseUrl === "string" ? credential.enterpriseUrl : undefined;
+  const response = await fetch(buildUsageUrl(enterpriseUrl), {
+    method: "GET",
+    headers: {
+      Authorization: `token ${credential.refresh}`,
+      Accept: "application/json",
+      "Editor-Version": "vscode/1.107.0",
+      "Editor-Plugin-Version": "copilot-chat/0.35.0",
+      "User-Agent": "GitHubCopilotChat/0.35.0",
+      "X-Github-Api-Version": "2025-04-01",
+    },
+    signal,
+  });
+
+  if (response.status === 401 || response.status === 403) {
+    throw new Error("GitHub Copilot login expired. Re-run /login.");
+  }
+  if (!response.ok) {
+    const bodyText = await response.text().catch(() => "");
+    throw new Error(
+      bodyText.trim()
+        ? `GitHub Copilot usage request failed (${response.status}): ${bodyText.trim()}`
+        : `GitHub Copilot usage request failed (${response.status}).`,
+    );
+  }
+
+  const payload = (await response.json()) as Record<string, unknown>;
+  const { premiumInteractions, chat } = parseQuotaSnapshots(payload);
+  const resetsAt = parseISODate(readString(payload.quota_reset_date));
+
+  const items: LiveUsageItem[] = [];
+  if (premiumInteractions)
+    items.push(makeQuotaMeter("premium", "Premium", premiumInteractions, resetsAt));
+  if (chat) items.push(makeQuotaMeter("chat", "Chat", chat, resetsAt));
+
+  if (items.length === 0) {
+    throw new Error("GitHub Copilot did not return premium or chat quota data.");
+  }
+
+  return {
+    plan: formatPlan(readString(payload.copilot_plan)),
+    fetchedAt: new Date(),
+    items,
+  };
+}
+
+const githubCopilotProvider: UsageProviderDefinition = {
+  id: PROVIDER_ID,
+  label: "GitHub Copilot",
+  shortLabel: "copilot",
+  color: { r: 168, g: 85, b: 247 },
+  fetchLiveUsage: fetchUsage,
+};
+
+export default githubCopilotProvider;

package/extensions/usage/google-gemini-cli.ts

@@ -0,0 +1,232 @@
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import {
+  clampPercent,
+  LiveUsageUnavailableError,
+  makeMeterItem,
+  parseISODate,
+  readArray,
+  readString,
+} from "./shared.js";
+import type { LiveUsageItem, LiveUsageSnapshot, UsageProviderDefinition } from "./types.js";
+
+const PROVIDER_ID = "google-gemini-cli";
+const QUOTA_URL = "https://cloudcode-pa.googleapis.com/v1internal:retrieveUserQuota";
+const LOAD_CODE_ASSIST_URL = "https://cloudcode-pa.googleapis.com/v1internal:loadCodeAssist";
+
+type GeminiTier = "free-tier" | "legacy-tier" | "standard-tier";
+
+interface GeminiAuthPayload {
+  token?: string;
+  projectId?: string;
+}
+
+interface GeminiQuota {
+  modelId: string;
+  percentLeft: number;
+  resetTime?: Date;
+}
+
+function readAuthPayload(value: string): GeminiAuthPayload {
+  try {
+    return JSON.parse(value) as GeminiAuthPayload;
+  } catch {
+    throw new LiveUsageUnavailableError("Gemini CLI OAuth login is required for live quota data");
+  }
+}
+
+function parsePlan(tier: GeminiTier | undefined): string | undefined {
+  switch (tier) {
+    case "standard-tier":
+      return "Paid";
+    case "free-tier":
+      return "Free";
+    case "legacy-tier":
+      return "Legacy";
+    default:
+      return undefined;
+  }
+}
+
+function parseModelLabel(modelId: string): string {
+  const value = modelId.trim();
+  const slash = value.lastIndexOf("/");
+  return slash === -1 ? value : value.slice(slash + 1);
+}
+
+function isFlashLiteModel(id: string): boolean {
+  return id.includes("flash-lite");
+}
+
+function isFlashModel(id: string): boolean {
+  return id.includes("flash") && !isFlashLiteModel(id);
+}
+
+function isProModel(id: string): boolean {
+  return id.includes("pro");
+}
+
+function makeMeter(key: string, label: string, quota: GeminiQuota): LiveUsageItem {
+  return makeMeterItem({
+    key,
+    label,
+    usedPercent: clampPercent(100 - quota.percentLeft),
+    windowLabel: "24h",
+    resetsAt: quota.resetTime,
+  });
+}
+
+async function fetchJson(
+  url: string,
+  token: string,
+  body: Record<string, unknown>,
+  signal?: AbortSignal,
+): Promise<Record<string, unknown>> {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(body),
+    signal,
+  });
+
+  if (response.status === 401 || response.status === 403) {
+    throw new Error("Gemini CLI login expired. Re-run /login google-gemini-cli.");
+  }
+
+  if (!response.ok) {
+    const bodyText = await response.text().catch(() => "");
+    throw new Error(
+      bodyText.trim()
+        ? `Gemini usage request failed (${response.status}): ${bodyText.trim()}`
+        : `Gemini usage request failed (${response.status}).`,
+    );
+  }
+
+  return (await response.json()) as Record<string, unknown>;
+}
+
+async function loadCodeAssistStatus(
+  token: string,
+  signal?: AbortSignal,
+): Promise<{ tier?: GeminiTier }> {
+  try {
+    const payload = await fetchJson(
+      LOAD_CODE_ASSIST_URL,
+      token,
+      { metadata: { ideType: "GEMINI_CLI", pluginType: "GEMINI" } },
+      signal,
+    );
+
+    const currentTier = payload.currentTier as Record<string, unknown> | undefined;
+    const tierId = readString(currentTier?.id);
+
+    return {
+      tier:
+        tierId === "free-tier" || tierId === "legacy-tier" || tierId === "standard-tier"
+          ? tierId
+          : undefined,
+    };
+  } catch {
+    return {};
+  }
+}
+
+function parseQuotas(payload: Record<string, unknown>): GeminiQuota[] {
+  const buckets = readArray<Record<string, unknown>>(payload.buckets);
+  const quotaByModel = new Map<string, GeminiQuota>();
+
+  for (const bucket of buckets) {
+    const input = bucket as Record<string, unknown> | null | undefined;
+    const modelId = readString(input?.modelId);
+    const remainingFraction =
+      typeof input?.remainingFraction === "number" ? input.remainingFraction : undefined;
+    if (!modelId || remainingFraction === undefined) continue;
+
+    const percentLeft = clampPercent(remainingFraction * 100);
+    const resetTime = parseISODate(readString(input?.resetTime));
+    const quota: GeminiQuota = {
+      modelId,
+      percentLeft,
+      resetTime,
+    };
+
+    const existing = quotaByModel.get(modelId);
+    if (!existing || quota.percentLeft < existing.percentLeft) {
+      quotaByModel.set(modelId, quota);
+    }
+  }
+
+  return [...quotaByModel.values()].sort((left, right) =>
+    left.modelId.localeCompare(right.modelId),
+  );
+}
+
+function buildItems(quotas: GeminiQuota[]): LiveUsageItem[] {
+  const lower = quotas.map((quota) => ({ quota, modelId: quota.modelId.toLowerCase() }));
+  const pro = lower.filter((entry) => isProModel(entry.modelId)).map((entry) => entry.quota);
+  const flash = lower.filter((entry) => isFlashModel(entry.modelId)).map((entry) => entry.quota);
+  const flashLite = lower
+    .filter((entry) => isFlashLiteModel(entry.modelId))
+    .map((entry) => entry.quota);
+
+  const items: LiveUsageItem[] = [];
+  const proMin = pro.sort((left, right) => left.percentLeft - right.percentLeft)[0];
+  const flashMin = flash.sort((left, right) => left.percentLeft - right.percentLeft)[0];
+  const flashLiteMin = flashLite.sort((left, right) => left.percentLeft - right.percentLeft)[0];
+
+  if (proMin) items.push(makeMeter("pro", "Pro", proMin));
+  if (flashMin) items.push(makeMeter("flash", "Flash", flashMin));
+  if (flashLiteMin) items.push(makeMeter("flash-lite", "Flash Lite", flashLiteMin));
+
+  if (items.length > 0) return items;
+
+  for (const quota of quotas.slice(0, 3)) {
+    items.push(makeMeter(quota.modelId, parseModelLabel(quota.modelId), quota));
+  }
+  return items;
+}
+
+async function fetchUsage(ctx: ExtensionContext, signal?: AbortSignal): Promise<LiveUsageSnapshot> {
+  const apiKey = await ctx.modelRegistry.getApiKeyForProvider(PROVIDER_ID);
+  if (!apiKey) throw new LiveUsageUnavailableError("no auth configured");
+
+  const auth = readAuthPayload(apiKey);
+  const token = typeof auth.token === "string" ? auth.token.trim() : "";
+  if (!token) {
+    throw new LiveUsageUnavailableError("Gemini CLI OAuth login is required for live quota data");
+  }
+
+  const authProjectId = typeof auth.projectId === "string" ? auth.projectId.trim() : undefined;
+  const statusPromise = loadCodeAssistStatus(token, signal);
+  const quotaPromise = fetchJson(
+    QUOTA_URL,
+    token,
+    authProjectId ? { project: authProjectId } : {},
+    signal,
+  );
+
+  const [status, quotaPayload] = await Promise.all([statusPromise, quotaPromise]);
+  const quotas = parseQuotas(quotaPayload);
+
+  if (quotas.length === 0) {
+    throw new Error("Gemini did not return any live quota data.");
+  }
+
+  return {
+    plan: parsePlan(status.tier),
+    fetchedAt: new Date(),
+    items: buildItems(quotas),
+  };
+}
+
+const googleGeminiCliProvider: UsageProviderDefinition = {
+  id: PROVIDER_ID,
+  label: "Gemini CLI",
+  shortLabel: "gemini",
+  color: { r: 171, g: 135, b: 234 },
+  fetchLiveUsage: fetchUsage,
+};
+
+export default googleGeminiCliProvider;