agent-limit 0.4.0 → 0.5.0

package/README.md

@@ -1,6 +1,6 @@
 # agent-limit
 
-Terminal dashboard to monitor Claude Code, Codex, and Gemini CLI usage limits.
+Terminal dashboard to monitor Claude Code and Codex usage limits.
 
 ## Install
 
@@ -46,7 +46,7 @@ agent-limit usage
 
 ## Features
 
-- Real-time usage tracking for Claude Code, Codex, and Gemini CLI
+- Real-time usage tracking for Claude Code and Codex
 - Trajectory markers showing if you're ahead or behind your usage pace
 - Auto-refresh every 60 seconds
 - Color-coded usage indicators
@@ -57,7 +57,6 @@ agent-limit usage
 |----------|--------|-------------|
 | Claude Code | Full support | macOS Keychain + Anthropic API |
 | Codex | Full support | `~/.codex/auth.json` + OpenAI API |
-| Gemini CLI | Static limits | `~/.gemini/settings.json` |
 
 ## Development
 
@@ -102,7 +101,6 @@ agent-limit reads credentials from standard locations:
 
 - **Claude Code**: macOS Keychain (`Claude Code-credentials`)
 - **Codex**: `~/.codex/auth.json`
-- **Gemini**: `~/.gemini/settings.json`
 
 It then fetches usage data from each provider's API and displays it in a unified dashboard.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-limit",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Terminal dashboard to monitor Claude Code, Codex, and other agent usage limits",
   "type": "module",
   "main": "src/index.tsx",
@@ -24,7 +24,6 @@
     "dashboard",
     "claude",
     "codex",
-    "gemini",
     "ai",
     "agent",
     "usage",

package/src/App.tsx

@@ -13,7 +13,6 @@ export function App({ onExit }: AppProps) {
   const [providers, setProviders] = useState<ProviderStatus[]>([
     { provider: "claude", status: "loading", metrics: [] },
     { provider: "codex", status: "loading", metrics: [] },
-    { provider: "gemini", status: "loading", metrics: [] },
   ]);
   const [lastRefresh, setLastRefresh] = useState<Date | null>(null);
   const [isLoading, setIsLoading] = useState(true);

package/src/components/ProviderCard.tsx

@@ -10,7 +10,6 @@ function getProviderDisplayName(provider: string): string {
   switch (provider) {
     case "claude": return "CLAUDE CODE";
     case "codex": return "CODEX";
-    case "gemini": return "GEMINI CLI";
     default: return provider.toUpperCase();
   }
 }

package/src/providers/claude.ts

@@ -1,15 +1,47 @@
-import { getClaudeCredentials } from "../utils/keychain";
+import {
+  getClaudeCredentials,
+  refreshClaudeToken,
+  saveClaudeCredentials,
+  type ClaudeCredentials,
+} from "../utils/keychain";
 import { timeUntil } from "../utils/time";
 import type { ProviderStatus } from "./types";
 
+const TOKEN_REFRESH_BUFFER_MS = 5 * 60 * 1000;
+
 interface ClaudeUsageResponse {
   five_hour: { utilization: number; resets_at: string | null } | null;
   seven_day: { utilization: number; resets_at: string | null } | null;
   seven_day_opus: { utilization: number; resets_at: string | null } | null;
 }
 
+async function tryRefreshCredentials(
+  credentials: ClaudeCredentials
+): Promise<ClaudeCredentials | null> {
+  const refreshed = await refreshClaudeToken(credentials.refreshToken);
+  if (refreshed) {
+    await saveClaudeCredentials(refreshed);
+  }
+  return refreshed;
+}
+
+async function fetchUsageWithCredentials(
+  credentials: ClaudeCredentials
+): Promise<Response> {
+  return fetch("https://api.anthropic.com/api/oauth/usage", {
+    method: "GET",
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      "User-Agent": "monitor/1.0.0",
+      Authorization: `Bearer ${credentials.accessToken}`,
+      "anthropic-beta": "oauth-2025-04-20",
+    },
+  });
+}
+
 export async function fetchClaudeUsage(): Promise<ProviderStatus> {
-  const credentials = await getClaudeCredentials();
+  let credentials = await getClaudeCredentials();
 
   if (!credentials) {
     return {
@@ -20,17 +52,24 @@ export async function fetchClaudeUsage(): Promise<ProviderStatus> {
     };
   }
 
+  const tokenExpiresSoon = credentials.expiresAt < Date.now() + TOKEN_REFRESH_BUFFER_MS;
+  if (tokenExpiresSoon) {
+    const refreshed = await tryRefreshCredentials(credentials);
+    if (refreshed) {
+      credentials = refreshed;
+    }
+  }
+
   try {
-    const response = await fetch("https://api.anthropic.com/api/oauth/usage", {
-      method: "GET",
-      headers: {
-        Accept: "application/json",
-        "Content-Type": "application/json",
-        "User-Agent": "monitor/1.0.0",
-        Authorization: `Bearer ${credentials.accessToken}`,
-        "anthropic-beta": "oauth-2025-04-20",
-      },
-    });
+    let response = await fetchUsageWithCredentials(credentials);
+
+    if (response.status === 401) {
+      const refreshed = await tryRefreshCredentials(credentials);
+      if (refreshed) {
+        credentials = refreshed;
+        response = await fetchUsageWithCredentials(credentials);
+      }
+    }
 
     if (!response.ok) {
       if (response.status === 401) {

package/src/providers/index.ts

@@ -1,19 +1,16 @@
 export * from "./types";
 export { fetchClaudeUsage } from "./claude";
 export { fetchCodexUsage } from "./codex";
-export { fetchGeminiUsage } from "./gemini";
 
 import { fetchClaudeUsage } from "./claude";
 import { fetchCodexUsage } from "./codex";
-import { fetchGeminiUsage } from "./gemini";
 import type { ProviderStatus } from "./types";
 
 export async function fetchAllProviders(): Promise<ProviderStatus[]> {
-  const [claude, codex, gemini] = await Promise.all([
+  const [claude, codex] = await Promise.all([
     fetchClaudeUsage(),
     fetchCodexUsage(),
-    fetchGeminiUsage(),
   ]);
 
-  return [claude, codex, gemini];
+  return [claude, codex];
 }

package/src/providers/types.ts

@@ -1,4 +1,4 @@
-export type ProviderName = "claude" | "codex" | "gemini";
+export type ProviderName = "claude" | "codex";
 
 export type ProviderStatusType = "ok" | "warning" | "error" | "unavailable" | "loading" | "limited";
 

package/src/utils/colors.ts

@@ -18,7 +18,6 @@ export function getStatusColor(status: string): string {
 export const PROVIDER_COLORS = {
   claude: "#d97706",
   codex: "#10b981",
-  gemini: "#3b82f6",
 } as const;
 
 export const UI_COLORS = {

package/src/utils/keychain.ts

@@ -1,5 +1,9 @@
 import { $ } from "bun";
 
+const CLAUDE_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+const CLAUDE_TOKEN_ENDPOINT = "https://console.anthropic.com/v1/oauth/token";
+const KEYCHAIN_SERVICE = "Claude Code-credentials";
+
 export async function getKeychainCredentials(service: string): Promise<string | null> {
   try {
     const result = await $`security find-generic-password -s ${service} -w`
@@ -11,6 +15,16 @@ export async function getKeychainCredentials(service: string): Promise<string |
   }
 }
 
+async function setKeychainCredentials(service: string, data: string): Promise<boolean> {
+  try {
+    await $`security delete-generic-password -s ${service}`.quiet().nothrow();
+    await $`security add-generic-password -s ${service} -w ${data}`.quiet();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 export interface ClaudeCredentials {
   accessToken: string;
   refreshToken: string;
@@ -21,7 +35,7 @@ export interface ClaudeCredentials {
 
 export async function getClaudeCredentials(): Promise<ClaudeCredentials | null> {
   try {
-    const raw = await getKeychainCredentials("Claude Code-credentials");
+    const raw = await getKeychainCredentials(KEYCHAIN_SERVICE);
     if (!raw) return null;
 
     const parsed = JSON.parse(raw);
@@ -31,6 +45,62 @@ export async function getClaudeCredentials(): Promise<ClaudeCredentials | null>
   }
 }
 
+interface TokenRefreshResponse {
+  token_type: string;
+  access_token: string;
+  expires_in: number;
+  refresh_token: string;
+  scope: string;
+}
+
+export async function refreshClaudeToken(
+  refreshToken: string
+): Promise<ClaudeCredentials | null> {
+  try {
+    const response = await fetch(CLAUDE_TOKEN_ENDPOINT, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        grant_type: "refresh_token",
+        refresh_token: refreshToken,
+        client_id: CLAUDE_CLIENT_ID,
+      }),
+    });
+
+    if (!response.ok) {
+      return null;
+    }
+
+    const data: TokenRefreshResponse = await response.json();
+
+    return {
+      accessToken: data.access_token,
+      refreshToken: data.refresh_token,
+      expiresAt: Date.now() + data.expires_in * 1000,
+      scopes: data.scope.split(" "),
+      subscriptionType: "Pro",
+    };
+  } catch {
+    return null;
+  }
+}
+
+export async function saveClaudeCredentials(
+  credentials: ClaudeCredentials
+): Promise<boolean> {
+  try {
+    const raw = await getKeychainCredentials(KEYCHAIN_SERVICE);
+    if (!raw) return false;
+
+    const parsed = JSON.parse(raw);
+    parsed.claudeAiOauth = credentials;
+
+    return await setKeychainCredentials(KEYCHAIN_SERVICE, JSON.stringify(parsed));
+  } catch {
+    return false;
+  }
+}
+
 export interface CodexCredentials {
   accessToken: string;
   accountId: string;
@@ -82,25 +152,3 @@ export async function getCodexCredentials(): Promise<CodexCredentials | null> {
     return null;
   }
 }
-
-export interface GeminiSettings {
-  authType?: "google" | "api_key" | "vertex";
-  apiKey?: string;
-  project?: string;
-}
-
-export async function getGeminiSettings(): Promise<GeminiSettings | null> {
-  try {
-    const homedir = process.env.HOME || "~";
-    const file = Bun.file(`${homedir}/.gemini/settings.json`);
-    
-    if (!(await file.exists())) {
-      return null;
-    }
-
-    const content = await file.json();
-    return content;
-  } catch {
-    return null;
-  }
-}

package/src/providers/gemini.ts

@@ -1,63 +0,0 @@
-import { getGeminiSettings } from "../utils/keychain";
-import type { ProviderStatus, UsageMetric } from "./types";
-
-interface GeminiLimits {
-  requestsPerDay: number;
-  requestsPerMinute: number;
-  plan: string;
-}
-
-function getLimitsForAuthType(authType?: string): GeminiLimits {
-  switch (authType) {
-    case "google":
-      return { requestsPerDay: 1000, requestsPerMinute: 60, plan: "Google (Free)" };
-    case "api_key":
-      return { requestsPerDay: 250, requestsPerMinute: 10, plan: "API Key (Free)" };
-    case "vertex":
-      return { requestsPerDay: -1, requestsPerMinute: -1, plan: "Vertex AI" };
-    default:
-      return { requestsPerDay: 1000, requestsPerMinute: 60, plan: "Unknown" };
-  }
-}
-
-export async function fetchGeminiUsage(): Promise<ProviderStatus> {
-  const settings = await getGeminiSettings();
-
-  if (!settings) {
-    return {
-      provider: "gemini",
-      status: "unavailable",
-      metrics: [],
-      message: "Not configured. Run 'gemini' to set up.",
-    };
-  }
-
-  const limits = getLimitsForAuthType(settings.authType);
-  const metrics: UsageMetric[] = [];
-
-  if (limits.requestsPerDay > 0) {
-    metrics.push({
-      name: "Daily Limit",
-      percentage: -1,
-      resetsAt: null,
-      resetsIn: `${limits.requestsPerDay} req/day`,
-    });
-  }
-
-  if (limits.requestsPerMinute > 0) {
-    metrics.push({
-      name: "Per-Minute",
-      percentage: -1,
-      resetsAt: null,
-      resetsIn: `${limits.requestsPerMinute} req/min`,
-    });
-  }
-
-  return {
-    provider: "gemini",
-    status: "limited",
-    plan: limits.plan,
-    metrics,
-    message: "Live usage not available. Run /stats in Gemini CLI.",
-  };
-}