axusage 3.1.0 → 3.2.0

package/README.md

@@ -1,6 +1,6 @@
 # axusage
 
-Monitor AI usage across Claude, ChatGPT, GitHub Copilot, and Gemini from a single command.
+Monitor API usage across Claude, ChatGPT, GitHub Copilot, and Gemini from a single CLI.
 
 ## Quick Start
 
@@ -8,127 +8,72 @@ Monitor AI usage across Claude, ChatGPT, GitHub Copilot, and Gemini from a singl
 # Install globally
 npm install -g axusage
 
-# Set up authentication (one-time setup per service)
+# One-time authentication per provider
 claude
 codex
 gemini
-axusage --auth-setup github-copilot --interactive
+gh auth login
 
-# Check authentication status
+# Optional: print service-specific auth instructions
+axusage --auth-setup copilot
+
+# Check auth status
 axusage --auth-status
-# For CLI-auth services, this reports CLI availability; use the CLI to confirm login.
 
-# Fetch usage
+# Fetch usage for all services
 axusage
 ```
 
 ## Requirements
 
-- `claude` CLI (Claude auth) — `npm install -g @anthropic-ai/claude-code`
-- `codex` CLI (ChatGPT auth) — `npm install -g @openai/codex`
-- `gemini` CLI (Gemini auth) — `npm install -g @google/gemini-cli`
-- Playwright Chromium for GitHub Copilot auth (see "Browser installation" below for global install steps)
+- `claude` CLI (Claude auth) - `npm install -g @anthropic-ai/claude-code`
+- `codex` CLI (ChatGPT auth) - `npm install -g @openai/codex`
+- `gemini` CLI (Gemini auth) - `npm install -g @google/gemini-cli`
+- `gh` CLI (GitHub Copilot auth) - `https://cli.github.com/` or `brew install gh`
 
 ### Custom Paths
 
-If the CLIs are not on your `PATH`, override the binaries:
+If CLIs are not on your `PATH`, override binary paths:
 
 ```bash
 export AXUSAGE_CLAUDE_PATH=/path/to/claude
 export AXUSAGE_CODEX_PATH=/path/to/codex
 export AXUSAGE_GEMINI_PATH=/path/to/gemini
+export AXUSAGE_GH_PATH=/path/to/gh
 
-# Optional: adjust CLI dependency check timeout (milliseconds)
+# Optional: dependency check timeout (milliseconds, default: 5000)
 export AXUSAGE_CLI_TIMEOUT_MS=5000
 ```
 
-For Playwright-managed browsers:
-
-```bash
-export PLAYWRIGHT_BROWSERS_PATH=/path/to/playwright-browsers
-```
-
-### Exit Codes
-
-- `0`: success
-- `1`: errors, including partial failures
+`AXUSAGE_GH_PATH` is also used as a Copilot fallback when resolving a token
+via `gh auth token`.
 
 ## Authentication
 
-Claude, ChatGPT, and Gemini use their respective CLI OAuth sessions. GitHub
-Copilot uses browser-based authentication for persistent, long-lived sessions.
-
-**Setup (one-time per service):**
-
-```bash
-# Set up authentication for each service
-claude
-codex
-gemini
-axusage --auth-setup github-copilot --interactive
-
-# Check authentication status
-axusage --auth-status
-```
-
-`--auth-status` reports browser-auth status for GitHub Copilot and CLI availability
-for Claude/ChatGPT/Gemini. Use `claude`, `codex`, or `gemini` to confirm CLI login.
-
-When you run `axusage --auth-setup github-copilot --interactive`, a browser window will open.
-Simply log in to GitHub as you normally would. Your authentication will be
-saved and automatically used for future requests.
-
-**Authenticated sessions directory (via [`env-paths`](https://github.com/sindresorhus/env-paths)):**
-
-- Linux: `~/.local/share/axusage/browser-contexts/` (or `$XDG_DATA_HOME/axusage/browser-contexts/`)
-- macOS: `~/Library/Application Support/axusage/browser-contexts/`
-- Windows: `%LOCALAPPDATA%\axusage\Data\browser-contexts\`
+Authentication is managed by provider CLIs for all services.
 
-You can override the location by providing `BrowserAuthConfig.dataDir`, but the CLI defaults to these platform-appropriate directories.
+- Claude: `claude`
+- ChatGPT: `codex`
+- Gemini: `gemini`
+- GitHub Copilot: `gh auth login`
 
-> **Migration from `agent-usage`:** If upgrading from the old `agent-usage` package, copy your authentication contexts:
->
-> - Linux/macOS: `mkdir -p ~/.local/share/axusage/ && cp -r ~/.local/share/agent-usage/* ~/.local/share/axusage/`
-> - Windows: Copy from `%LOCALAPPDATA%\agent-usage\` to `%LOCALAPPDATA%\axusage\`
-
-Security notes:
-
-- Files in this directory contain sensitive session data. They are created with owner-only permissions (0600 for files, 0700 for the directory) where possible.
-- To revoke access for GitHub Copilot, clear saved browser auth:
-
-```bash
-axusage --auth-clear github-copilot --interactive
-```
-
-This moves the saved browser files to your system Trash/Recycle Bin (recoverable).
-
-Use `--force` to skip confirmation in scripts.
-
-Browser installation:
-
-- Playwright Chromium is installed automatically on `pnpm install` via a postinstall script. If this fails in your environment, install manually:
+Use:
 
 ```bash
-pnpm exec playwright install chromium --with-deps
+axusage --auth-setup <service>
 ```
 
-**Global installation with pnpm:**
+to print the correct command for a given service.
 
-pnpm blocks postinstall scripts for global packages by default (npm runs them automatically). After installing globally, approve and run the postinstall script:
+Check auth status with:
 
 ```bash
-pnpm add -g axusage
-pnpm approve-builds -g          # Select axusage when prompted
-pnpm add -g axusage             # Reinstall to run postinstall
+axusage --auth-status
+axusage --auth-status claude
 ```
 
-Alternatively, install the browser manually after global installation. Use the Playwright binary that ships with the global package so the browser is installed in the right location:
-
-```bash
-pnpm add -g axusage
-PLAYWRIGHT_BIN="$(pnpm root -g)/axusage/node_modules/.bin/playwright"
-"$PLAYWRIGHT_BIN" install chromium --with-deps
-```
+`--auth-status` checks whether each service is authenticated and reports the
+detected auth method. It does not validate API token freshness.
 
 ## Usage
 
@@ -136,165 +81,104 @@ PLAYWRIGHT_BIN="$(pnpm root -g)/axusage/node_modules/.bin/playwright"
 # Query all services
 axusage
 
-# Allow interactive re-authentication during usage fetch
-axusage --interactive
-
-# Single service
+# Query a single service
 axusage --service claude
-axusage --service chatgpt
-axusage --service github-copilot
+axusage -s codex
+axusage -s copilot
 
-# JSON output
-axusage --format=json
-axusage --service claude --format=json
+# Output formats
+axusage --format text
+axusage --format tsv
+axusage --format json
+axusage --format prometheus
 
-# TSV output (parseable with cut, awk, sort)
-axusage --format=tsv
+# Auth utilities
+axusage --auth-setup claude
+axusage --auth-status
 
 # Disable color output
 axusage --no-color
 ```
 
+### Exit Codes
+
+- `0`: Success
+- `1`: One or more failures (including partial failures)
+
+## Credential Sources
+
+Credential source config is read from:
+
+- Config file path shown in `axusage --help`
+- `AXUSAGE_SOURCES` environment variable (JSON), which overrides file config
+
 ## Examples
 
 ### Extract service and utilization (TSV + awk)
 
 ```bash
-axusage --format=tsv | tail -n +2 | awk -F'\t' '{print $1, $4"%"}'
+axusage --format tsv | tail -n +2 | awk -F'\t' '{print $1, $4"%"}'
 ```
 
 ### Count windows by service (TSV + cut/sort/uniq)
 
 ```bash
-axusage --format=tsv | tail -n +2 | cut -f1 | sort | uniq -c
+axusage --format tsv | tail -n +2 | cut -f1 | sort | uniq -c
 ```
 
 ### Filter by utilization threshold (TSV + awk)
 
 ```bash
-axusage --format=tsv | tail -n +2 | awk -F'\t' '$4 > 50 {print $1, $3, $4"%"}'
+axusage --format tsv | tail -n +2 | awk -F'\t' '$4 > 50 {print $1, $3, $4"%"}'
 ```
 
 ### Extract utilization as JSON (JSON + jq)
 
 ```bash
-axusage --format=json \
+axusage --format json \
   | jq -r '(.results? // .) | (if type=="array" then . else [.] end) | .[] | .windows[] | [.name, (.utilization|tostring)] | @tsv'
 ```
 
 ## Output
 
-Human-readable format shows:
+Human-readable output includes:
 
-- Utilization percentage per window (5-hour, 7-day, monthly)
+- Utilization percentage per window
 - Usage rate vs expected rate
 - Reset times
-- Color coding: 🟢 on track | 🟡 over budget | 🔴 significantly over
-
-JSON format returns structured data for programmatic use.
-
-## Agent Rule
+- Color coding: on track / over budget / significantly over
 
-Add to your `CLAUDE.md` or `AGENTS.md`:
-
-```markdown
-# Rule: `axusage` Usage
-
-Run `npx -y axusage --help` to learn available options.
-
-Use `axusage` when you need a quick, scriptable snapshot of API usage across Claude, ChatGPT, GitHub Copilot, and Gemini. It standardizes output (text, JSON, Prometheus) so you can alert, dashboard, or pipe it into other Unix tools.
-```
+JSON output provides structured data for automation.
+Prometheus output emits text metrics suitable for scraping.
 
 ## Troubleshooting
 
-### Authentication setup hangs
-
-- The CLI shows a countdown while waiting for login.
-- If you have completed login, press Enter in the terminal to continue.
-- If it still fails, run `axusage --auth-clear <service> --interactive` and retry.
-
-### "No saved authentication" error
-
-- Check which services are authenticated: `axusage --auth-status`.
-- For GitHub Copilot, set up the missing service: `axusage --auth-setup <service> --interactive`.
-- For Claude/ChatGPT/Gemini, run the provider CLI to authenticate.
-
-### Sessions expire
-
-- Browser sessions can expire based on provider policy. Re-run `axusage --auth-setup <service> --interactive` for the affected service when you see authentication errors.
+### "Required dependency '... not found'"
 
-## Remote authentication and Prometheus export
+Install the missing CLI or set the corresponding override env var (for example, `AXUSAGE_GH_PATH`).
 
-You can perform the interactive login flow on a workstation (for example, a local macOS laptop) and reuse the resulting browser session on a headless Linux server that collects usage and exports it for Prometheus.
+### Authentication errors (401 / unauthorized / no saved authentication)
 
-### 1. Authenticate on a workstation
+1. Run `axusage --auth-status` to see which services are not authenticated.
+2. Re-authenticate in the provider CLI (`claude`, `codex`, `gemini`, `gh auth login`).
+3. Retry `axusage`.
 
-1. Install globally and authenticate the CLIs you need, then set up browser
-   auth for GitHub Copilot:
+### Partial failures
 
-   ```bash
-   npm install -g axusage
+`axusage` exits with code `1` if any service fails, even when other services succeed. Check warnings in stderr for the failed service(s).
 
-   claude
-   codex
-   gemini
-   axusage --auth-setup github-copilot --interactive
-   ```
-
-2. Confirm the workstation has valid sessions:
-
-   ```bash
-   axusage --auth-status
-   ```
-
-   For CLI-auth services, run `claude`, `codex`, or `gemini` to confirm login.
-
-3. Package the saved contexts so they can be transferred. Set `CONTEXT_DIR` to the path for your platform (see the table above):
-
-   ```bash
-   CONTEXT_DIR="$HOME/.local/share/axusage/browser-contexts"  # Linux default; adjust on macOS/Windows
-   tar czf axusage-contexts.tgz -C "$(dirname "$CONTEXT_DIR")" "$(basename "$CONTEXT_DIR")"
-   ```
-
-   Archive structure: `browser-contexts/github-copilot-auth.json` plus matching
-   `github-copilot-auth.meta.json` (CLI-auth services do not use browser contexts).
-
-### 2. Transfer the browser contexts to the Linux server
-
-1. Copy the archive to the server with `scp` (replace `user@server` with your login):
-
-   ```bash
-   scp axusage-contexts.tgz user@server:~/
-   ```
-
-2. On the server, create the target directory if it does not already exist, unpack the archive, and lock down the permissions:
-
-   ```bash
-   ssh user@server
-   CONTEXT_DIR="$HOME/.local/share/axusage/browser-contexts"  # Linux default; adjust per platform
-   AXUSAGE_DIR="$(dirname "$CONTEXT_DIR")"
-   mkdir -p "$CONTEXT_DIR"
-   tar xzf ~/axusage-contexts.tgz -C "$AXUSAGE_DIR"
-   # Directories 700, files 600
-   find "$AXUSAGE_DIR" -type d -exec chmod 700 {} +
-   find "$CONTEXT_DIR" -type f -exec chmod 600 {} +
-   ```
-
-3. Verify that the sessions are available on the server:
+## Agent Rule
 
-   ```bash
-   axusage --auth-status
-   ```
+Add to your `CLAUDE.md` or `AGENTS.md`:
 
-   If the server does not yet have the tool installed, run `npm install -g axusage` before checking the status.
+```markdown
+# Rule: `axusage` Usage
 
-Notes:
+Run `npx -y axusage --help` to learn available options.
 
-- Use `--service <name>` to restrict services.
-- Sessions may expire or become invalid if you change your password or log out of the service in another browser. Re-run `axusage --auth-setup <service> --interactive` as needed.
-- If you transfer browser contexts between machines, ensure the target system is secure and permissions are restricted to the intended user.
-- The CLI stores authentication data in the platform-specific directories listed above; protect that directory to prevent unauthorized access.
+Use `axusage` when you need a quick, scriptable snapshot of API usage across Claude, ChatGPT, GitHub Copilot, and Gemini. It standardizes output (text, JSON, Prometheus) so you can alert, dashboard, or pipe it into other Unix tools.
+```
 
 ## Development
 
-For local development in this repository, `pnpm run start` triggers a clean rebuild before executing the CLI. Use `pnpm run usage` only when `dist/` is already up to date. End users installing globally should run the `axusage` binary directly.
+For local development in this repository, `pnpm run start` triggers a clean rebuild before executing the CLI. Use `node bin/axusage` only when `dist/` is already up to date. End users installing globally should run the `axusage` binary directly.

package/dist/adapters/claude.js

@@ -51,12 +51,15 @@ export const claudeAdapter = {
             };
         }
         try {
-            const response = await fetch(USAGE_API_URL, {
-                headers: {
-                    Authorization: `Bearer ${accessToken}`,
-                    "anthropic-beta": ANTHROPIC_BETA_HEADER,
-                },
-            });
+            const [response, planType] = await Promise.all([
+                fetch(USAGE_API_URL, {
+                    headers: {
+                        Authorization: `Bearer ${accessToken}`,
+                        "anthropic-beta": ANTHROPIC_BETA_HEADER,
+                    },
+                }),
+                fetchPlanType(accessToken),
+            ]);
             if (!response.ok) {
                 const errorText = await response.text().catch(() => "");
                 return {
@@ -76,8 +79,6 @@ export const claudeAdapter = {
                     error: new ApiError(`Invalid response format: ${parseResult.error.message}`, undefined, data),
                 };
             }
-            // Fetch plan type (best effort, don't fail if unavailable)
-            const planType = await fetchPlanType(accessToken);
             const usageData = toServiceUsageData(parseResult.data);
             return {
                 ok: true,

package/dist/adapters/coalesce-claude-usage-response.js

@@ -47,12 +47,15 @@ const resolveUtilization = (candidate) => {
         return candidate.utilization;
     return candidate.percentage ?? candidate.percent ?? 0;
 };
-const selectMetric = (candidates, matchers) => {
+const selectMetric = (candidates, matchers, exclude = []) => {
     for (const candidate of candidates) {
         const label = normalizeLabel(candidate);
         if (!label)
             continue;
         const tokens = tokenizeLabel(label);
+        const hasExcludedToken = exclude.some((ex) => tokens.has(ex) || label.includes(ex));
+        if (hasExcludedToken)
+            continue;
         const matches = matchers.includes(label) ||
             matchers.some((matcher) => tokens.has(matcher));
         if (!matches)
@@ -88,12 +91,7 @@ export function coalesceClaudeUsageResponse(data) {
         "5",
         "5hour",
     ]);
-    const sevenDay = selectMetric(candidates, [
-        "seven_day",
-        "seven",
-        "7",
-        "week",
-    ]);
+    const sevenDay = selectMetric(candidates, ["seven_day", "seven", "7", "week"], ["opus", "sonnet", "oauth"]);
     const sevenDayOpus = selectMetric(candidates, ["seven_day_opus", "opus"]);
     const sevenDaySonnet = selectMetric(candidates, [
         "seven_day_sonnet",

package/dist/adapters/{chatgpt.d.ts → codex.d.ts}

@@ -5,4 +5,4 @@ import type { ServiceAdapter } from "../types/domain.js";
  * Uses the OAuth token from Codex CLI's credential store (~/.codex/auth.json)
  * to make direct API calls to ChatGPT's usage endpoint.
  */
-export declare const chatGPTAdapter: ServiceAdapter;
+export declare const codexAdapter: ServiceAdapter;

package/dist/adapters/{chatgpt.js → codex.js}

@@ -1,7 +1,7 @@
 import { ApiError } from "../types/domain.js";
 import { getServiceAccessToken } from "../services/get-service-access-token.js";
-import { ChatGPTUsageResponse as ChatGPTUsageResponseSchema } from "../types/chatgpt.js";
-import { toServiceUsageData } from "./parse-chatgpt-usage.js";
+import { CodexUsageResponse as CodexUsageResponseSchema } from "../types/codex.js";
+import { toServiceUsageData } from "./parse-codex-usage.js";
 const API_URL = "https://chatgpt.com/backend-api/wham/usage";
 /**
  * ChatGPT service adapter using direct API access.
@@ -9,10 +9,10 @@ const API_URL = "https://chatgpt.com/backend-api/wham/usage";
  * Uses the OAuth token from Codex CLI's credential store (~/.codex/auth.json)
  * to make direct API calls to ChatGPT's usage endpoint.
  */
-export const chatGPTAdapter = {
+export const codexAdapter = {
     name: "ChatGPT",
     async fetchUsage() {
-        const accessToken = await getServiceAccessToken("chatgpt");
+        const accessToken = await getServiceAccessToken("codex");
         if (!accessToken) {
             return {
                 ok: false,
@@ -33,7 +33,7 @@ export const chatGPTAdapter = {
                 };
             }
             const data = await response.json();
-            const parseResult = ChatGPTUsageResponseSchema.safeParse(data);
+            const parseResult = CodexUsageResponseSchema.safeParse(data);
             if (!parseResult.success) {
                 return {
                     ok: false,

package/dist/adapters/copilot.d.ts

@@ -0,0 +1,7 @@
+import type { ServiceAdapter } from "../types/domain.js";
+/**
+ * GitHub Copilot service adapter using token-based API access.
+ *
+ * Credentials resolved via getServiceAccessToken (vault, local axauth, gh CLI).
+ */
+export declare const copilotAdapter: ServiceAdapter;

package/dist/adapters/copilot.js

@@ -0,0 +1,58 @@
+import { ApiError } from "../types/domain.js";
+import { CopilotUsageResponse as CopilotUsageResponseSchema } from "../types/copilot.js";
+import { toServiceUsageData } from "./parse-copilot-usage.js";
+import { getServiceAccessToken } from "../services/get-service-access-token.js";
+// Internal/undocumented GitHub API used by VS Code, JetBrains, and other
+// first-party Copilot integrations. May change without notice.
+const API_URL = "https://api.github.com/copilot_internal/user";
+/**
+ * GitHub Copilot service adapter using token-based API access.
+ *
+ * Credentials resolved via getServiceAccessToken (vault, local axauth, gh CLI).
+ */
+export const copilotAdapter = {
+    name: "GitHub Copilot",
+    async fetchUsage() {
+        const accessToken = await getServiceAccessToken("copilot");
+        if (!accessToken) {
+            return {
+                ok: false,
+                error: new ApiError("No GitHub Copilot credentials found. Run 'gh auth login' to authenticate."),
+            };
+        }
+        try {
+            const response = await fetch(API_URL, {
+                headers: {
+                    Authorization: `Bearer ${accessToken}`,
+                    Accept: "application/json",
+                },
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => "");
+                return {
+                    ok: false,
+                    error: new ApiError(`GitHub Copilot API request failed: ${String(response.status)} ${response.statusText}${errorText ? ` - ${errorText}` : ""}`, response.status),
+                };
+            }
+            const data = await response.json();
+            const parseResult = CopilotUsageResponseSchema.safeParse(data);
+            if (!parseResult.success) {
+                return {
+                    ok: false,
+                    error: new ApiError(`Invalid response format: ${parseResult.error.message}`, undefined, data),
+                };
+            }
+            return {
+                ok: true,
+                value: toServiceUsageData(parseResult.data),
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                ok: false,
+                error: new ApiError(`Failed to fetch GitHub Copilot usage: ${message}`),
+            };
+        }
+    },
+};

package/dist/adapters/{parse-chatgpt-usage.d.ts → parse-codex-usage.d.ts}

@@ -1,9 +1,9 @@
 import type { ServiceUsageData } from "../types/domain.js";
-import type { ChatGPTUsageResponse, ChatGPTRateLimitWindow } from "../types/chatgpt.js";
+import type { CodexUsageResponse, CodexRateLimitWindow } from "../types/codex.js";
 /**
  * Converts a ChatGPT rate limit window to common usage window
  */
-export declare function toUsageWindow(name: string, window: ChatGPTRateLimitWindow): {
+export declare function toUsageWindow(name: string, window: CodexRateLimitWindow): {
     name: string;
     utilization: number;
     resetsAt: Date;
@@ -12,4 +12,4 @@ export declare function toUsageWindow(name: string, window: ChatGPTRateLimitWind
 /**
  * Converts ChatGPT response to common domain model
  */
-export declare function toServiceUsageData(response: ChatGPTUsageResponse): ServiceUsageData;
+export declare function toServiceUsageData(response: CodexUsageResponse): ServiceUsageData;

package/dist/adapters/parse-copilot-usage.d.ts

@@ -0,0 +1,15 @@
+import type { ServiceUsageData } from "../types/domain.js";
+import type { CopilotUsageResponse } from "../types/copilot.js";
+/**
+ * Calculates monthly period duration ending at the reset date.
+ *
+ * Determines the period start by going back one month from the reset
+ * date and clamping the day to the last valid day of that previous
+ * month. This handles edge cases like Jan 31 → Feb 28/29 where the
+ * target month has fewer days than the reset date's day component.
+ */
+export declare function calculatePeriodDuration(resetDate: Date): number;
+/**
+ * Converts GitHub Copilot API response to common domain model.
+ */
+export declare function toServiceUsageData(response: CopilotUsageResponse): ServiceUsageData;

package/dist/adapters/parse-copilot-usage.js

@@ -0,0 +1,61 @@
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+/**
+ * Calculates monthly period duration ending at the reset date.
+ *
+ * Determines the period start by going back one month from the reset
+ * date and clamping the day to the last valid day of that previous
+ * month. This handles edge cases like Jan 31 → Feb 28/29 where the
+ * target month has fewer days than the reset date's day component.
+ */
+export function calculatePeriodDuration(resetDate) {
+    const periodEnd = resetDate.getTime();
+    const year = resetDate.getUTCFullYear();
+    const month = resetDate.getUTCMonth();
+    const day = resetDate.getUTCDate();
+    const firstOfCurrentMonth = Date.UTC(year, month, 1, 0, 0, 0);
+    const lastPreviousMonthDate = new Date(firstOfCurrentMonth - MS_PER_DAY);
+    const lastPreviousMonthDay = lastPreviousMonthDate.getUTCDate();
+    const previousMonth = lastPreviousMonthDate.getUTCMonth();
+    const previousYear = lastPreviousMonthDate.getUTCFullYear();
+    const targetDay = Math.min(day, lastPreviousMonthDay);
+    const periodStart = Date.UTC(previousYear, previousMonth, targetDay, resetDate.getUTCHours(), resetDate.getUTCMinutes(), resetDate.getUTCSeconds(), resetDate.getUTCMilliseconds());
+    return Math.max(periodEnd - periodStart, 0);
+}
+/**
+ * Converts GitHub Copilot API response to common domain model.
+ */
+export function toServiceUsageData(response) {
+    const { premium_interactions } = response.quota_snapshots;
+    if (premium_interactions.unlimited) {
+        return {
+            service: "GitHub Copilot",
+            planType: response.copilot_plan,
+            windows: [
+                {
+                    name: "Monthly Premium Interactions",
+                    utilization: 0,
+                    resetsAt: undefined,
+                    periodDurationMs: 0,
+                },
+            ],
+        };
+    }
+    const resetDate = new Date(response.quota_reset_date_utc);
+    const periodDurationMs = calculatePeriodDuration(resetDate);
+    const used = premium_interactions.entitlement - premium_interactions.remaining;
+    const utilization = premium_interactions.entitlement === 0
+        ? 0
+        : (used / premium_interactions.entitlement) * 100;
+    return {
+        service: "GitHub Copilot",
+        planType: response.copilot_plan,
+        windows: [
+            {
+                name: "Monthly Premium Interactions",
+                utilization: Math.round(utilization * 100) / 100,
+                resetsAt: resetDate,
+                periodDurationMs,
+            },
+        ],
+    };
+}