axusage 2.0.0

package/dist/adapters/github-copilot.js

@@ -0,0 +1,56 @@
+import { ApiError } from "../types/domain.js";
+import { GitHubCopilotUsageResponse as GitHubCopilotUsageResponseSchema } from "../types/github-copilot.js";
+import { toServiceUsageData } from "./parse-github-copilot-usage.js";
+import { acquireAuthManager, releaseAuthManager, } from "../services/shared-browser-auth-manager.js";
+// Copilot web fetches entitlements from this endpoint (requires GitHub session cookies)
+const API_URL = "https://github.com/github-copilot/chat/entitlement";
+/** Functional core is extracted to ./parse-github-copilot-usage.ts */
+/**
+ * GitHub Copilot service adapter
+ */
+export const githubCopilotAdapter = {
+    name: "GitHub Copilot",
+    async fetchUsage() {
+        const manager = acquireAuthManager();
+        try {
+            if (!manager.hasAuth("github-copilot")) {
+                return {
+                    ok: false,
+                    error: new ApiError("No saved authentication for github-copilot. Run 'axusage auth setup github-copilot' first."),
+                };
+            }
+            const body = await manager.makeAuthenticatedRequest("github-copilot", API_URL);
+            const data = JSON.parse(body);
+            const parseResult = GitHubCopilotUsageResponseSchema.safeParse(data);
+            if (!parseResult.success) {
+                return {
+                    ok: false,
+                    error: new ApiError(`Invalid response format: ${parseResult.error.message}`, undefined, data),
+                };
+            }
+            try {
+                return {
+                    ok: true,
+                    value: toServiceUsageData(parseResult.data),
+                };
+            }
+            catch (error) {
+                return {
+                    ok: false,
+                    error: new ApiError(error instanceof Error
+                        ? error.message
+                        : "Unable to parse GitHub Copilot reset date", undefined, parseResult.data.quotas.resetDate),
+                };
+            }
+        }
+        catch (error) {
+            return {
+                ok: false,
+                error: new ApiError(`Browser authentication failed: ${error instanceof Error ? error.message : String(error)}`),
+            };
+        }
+        finally {
+            await releaseAuthManager();
+        }
+    },
+};

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

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

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

@@ -0,0 +1,28 @@
+/**
+ * Converts a ChatGPT rate limit window to common usage window
+ */
+export function toUsageWindow(name, window) {
+    return {
+        name,
+        utilization: window.used_percent,
+        resetsAt: new Date(window.reset_at * 1000),
+        periodDurationMs: window.limit_window_seconds * 1000,
+    };
+}
+/**
+ * Converts ChatGPT response to common domain model
+ */
+export function toServiceUsageData(response) {
+    return {
+        service: "ChatGPT",
+        planType: response.plan_type,
+        windows: [
+            toUsageWindow("Primary Window (~5 hours)", response.rate_limit.primary_window),
+            toUsageWindow("Secondary Window (~7 days)", response.rate_limit.secondary_window),
+        ],
+        metadata: {
+            allowed: response.rate_limit.allowed,
+            limitReached: response.rate_limit.limit_reached,
+        },
+    };
+}

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

@@ -0,0 +1,16 @@
+import type { ServiceUsageData } from "../types/domain.js";
+import type { UsageResponse } from "../types/usage.js";
+/**
+ * Period durations for Claude usage windows
+ */
+export declare const CLAUDE_PERIOD_DURATIONS: {
+    readonly five_hour: number;
+    readonly seven_day: number;
+    readonly seven_day_oauth_apps: number;
+    readonly seven_day_opus: number;
+    readonly seven_day_sonnet: number;
+};
+/**
+ * Converts Claude response to common domain model
+ */
+export declare function toServiceUsageData(response: UsageResponse): ServiceUsageData;

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

@@ -0,0 +1,75 @@
+/**
+ * Period durations for Claude usage windows
+ */
+export const CLAUDE_PERIOD_DURATIONS = {
+    five_hour: 5 * 60 * 60 * 1000,
+    seven_day: 7 * 24 * 60 * 60 * 1000,
+    seven_day_oauth_apps: 7 * 24 * 60 * 60 * 1000,
+    seven_day_opus: 7 * 24 * 60 * 60 * 1000,
+    seven_day_sonnet: 7 * 24 * 60 * 60 * 1000,
+};
+/**
+ * Parses a reset timestamp into a Date while tolerating missing values.
+ * Returns undefined for absent or invalid timestamps to signal "not available".
+ */
+const parseResetTimestamp = (timestamp) => {
+    if (!timestamp)
+        return undefined;
+    const date = new Date(timestamp);
+    // Number.isNaN checks whether getTime() returned NaN (indicating an invalid date).
+    return Number.isNaN(date.getTime()) ? undefined : date;
+};
+// Intentionally avoid sentinel timestamps for missing reset dates.
+// Missing values propagate as undefined so the caller can surface "unknown" states.
+/**
+ * Converts Claude response to common domain model
+ */
+export function toServiceUsageData(response) {
+    return {
+        service: "Claude",
+        windows: [
+            {
+                name: "5-Hour Usage",
+                utilization: response.five_hour.utilization,
+                resetsAt: parseResetTimestamp(response.five_hour.resets_at),
+                periodDurationMs: CLAUDE_PERIOD_DURATIONS.five_hour,
+            },
+            {
+                name: "7-Day Usage",
+                utilization: response.seven_day.utilization,
+                resetsAt: parseResetTimestamp(response.seven_day.resets_at),
+                periodDurationMs: CLAUDE_PERIOD_DURATIONS.seven_day,
+            },
+            ...(response.seven_day_oauth_apps
+                ? [
+                    {
+                        name: "7-Day OAuth Apps",
+                        utilization: response.seven_day_oauth_apps.utilization,
+                        resetsAt: parseResetTimestamp(response.seven_day_oauth_apps.resets_at),
+                        periodDurationMs: CLAUDE_PERIOD_DURATIONS.seven_day_oauth_apps,
+                    },
+                ]
+                : []),
+            ...(response.seven_day_opus
+                ? [
+                    {
+                        name: "7-Day Opus Usage",
+                        utilization: response.seven_day_opus.utilization,
+                        resetsAt: parseResetTimestamp(response.seven_day_opus.resets_at),
+                        periodDurationMs: CLAUDE_PERIOD_DURATIONS.seven_day_opus,
+                    },
+                ]
+                : []),
+            ...(response.seven_day_sonnet
+                ? [
+                    {
+                        name: "7-Day Sonnet Usage",
+                        utilization: response.seven_day_sonnet.utilization,
+                        resetsAt: parseResetTimestamp(response.seven_day_sonnet.resets_at),
+                        periodDurationMs: CLAUDE_PERIOD_DURATIONS.seven_day_sonnet,
+                    },
+                ]
+                : []),
+        ],
+    };
+}

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

@@ -0,0 +1,55 @@
+import type { ServiceUsageData, UsageWindow } from "../types/domain.js";
+import type { GeminiQuotaResponse, GeminiQuotaBucket } from "../types/gemini.js";
+/**
+ * Model quota after grouping buckets by model
+ */
+type ModelQuota = {
+    modelId: string;
+    lowestRemainingFraction: number;
+    resetTime: Date | undefined;
+};
+/**
+ * Quota pool containing models that share the same quota
+ */
+type QuotaPool = {
+    modelIds: string[];
+    remainingFraction: number;
+    resetTime: Date | undefined;
+};
+/**
+ * Parse ISO8601 timestamp to Date
+ */
+export declare function parseResetTime(resetTimeString?: string): Date | undefined;
+/**
+ * Format model ID for display
+ * "gemini-2.5-pro" -> "Gemini 2.5 Pro"
+ */
+export declare function formatModelName(modelId: string): string;
+/**
+ * Format multiple model names for display
+ * Single model: "Gemini 2.5 Pro"
+ * Multiple models: "Gemini 2.0 Flash, 2.5 Flash, 2.5 Flash Lite"
+ */
+export declare function formatPoolName(modelIds: string[]): string;
+/**
+ * Group quota buckets by model, keeping lowest remaining fraction per model
+ * (input tokens are usually more restrictive than output)
+ */
+export declare function groupBucketsByModel(buckets: GeminiQuotaBucket[]): ModelQuota[];
+/**
+ * Group models that share the same quota (same remainingFraction and resetTime)
+ */
+export declare function groupByQuotaPool(modelQuotas: ModelQuota[]): QuotaPool[];
+/**
+ * Convert quota pool to usage window
+ */
+export declare function poolToUsageWindow(pool: QuotaPool): UsageWindow;
+/**
+ * Convert model quota to usage window
+ */
+export declare function toUsageWindow(quota: ModelQuota): UsageWindow;
+/**
+ * Convert Gemini quota response to common domain model
+ */
+export declare function toServiceUsageData(response: GeminiQuotaResponse, planType?: string): ServiceUsageData;
+export {};

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

@@ -0,0 +1,151 @@
+// Default period duration - Gemini quotas typically reset daily
+const DEFAULT_PERIOD_MS = 24 * 60 * 60 * 1000; // 24 hours
+/**
+ * Parse ISO8601 timestamp to Date
+ */
+export function parseResetTime(resetTimeString) {
+    if (!resetTimeString) {
+        return undefined;
+    }
+    const date = new Date(resetTimeString);
+    return Number.isNaN(date.getTime()) ? undefined : date;
+}
+// Gemini quotas reset daily, so period is always 24 hours
+const PERIOD_DURATION_MS = DEFAULT_PERIOD_MS;
+/**
+ * Format model ID for display
+ * "gemini-2.5-pro" -> "Gemini 2.5 Pro"
+ */
+export function formatModelName(modelId) {
+    return modelId
+        .split("-")
+        .map((part) => {
+        // Capitalize first letter, keep version numbers as-is
+        if (/^\d/u.test(part)) {
+            return part;
+        }
+        return part.charAt(0).toUpperCase() + part.slice(1);
+    })
+        .join(" ");
+}
+/**
+ * Format multiple model names for display
+ * Single model: "Gemini 2.5 Pro"
+ * Multiple models: "Gemini 2.0 Flash, 2.5 Flash, 2.5 Flash Lite"
+ */
+export function formatPoolName(modelIds) {
+    if (modelIds.length === 0) {
+        return "";
+    }
+    if (modelIds.length === 1) {
+        // Length check guarantees element exists, but noUncheckedIndexedAccess requires assertion
+        return formatModelName(modelIds[0]);
+    }
+    // For multiple models, use shortened format: "Gemini 2.0 Flash, 2.5 Flash, 2.5 Flash Lite"
+    const formattedNames = modelIds.map((id) => formatModelName(id));
+    // Extract common prefix (e.g., "Gemini") if all names share it
+    const firstWords = formattedNames.map((name) => name.split(" ")[0] ?? "");
+    const firstPrefix = firstWords[0] ?? "";
+    const allSamePrefix = firstPrefix !== "" && firstWords.every((word) => word === firstPrefix);
+    if (allSamePrefix) {
+        const suffixes = formattedNames.map((name) => name.slice(firstPrefix.length + 1));
+        // Fallback if any suffix is empty (e.g. ["Gemini", "Gemini Pro"] -> would be "Gemini , Pro")
+        if (suffixes.some((s) => !s)) {
+            return formattedNames.join(", ");
+        }
+        return `${firstPrefix} ${suffixes.join(", ")}`;
+    }
+    return formattedNames.join(", ");
+}
+/**
+ * Group quota buckets by model, keeping lowest remaining fraction per model
+ * (input tokens are usually more restrictive than output)
+ */
+export function groupBucketsByModel(buckets) {
+    const modelMap = new Map();
+    for (const bucket of buckets) {
+        const existing = modelMap.get(bucket.modelId);
+        if (!existing ||
+            bucket.remainingFraction < existing.lowestRemainingFraction) {
+            modelMap.set(bucket.modelId, {
+                modelId: bucket.modelId,
+                lowestRemainingFraction: bucket.remainingFraction,
+                resetTime: parseResetTime(bucket.resetTime),
+            });
+        }
+    }
+    return [...modelMap.values()];
+}
+/**
+ * Create a unique key for a quota pool based on remaining fraction and reset time
+ */
+function createPoolKey(remainingFraction, resetTime) {
+    const resetTimeKey = resetTime?.toISOString() ?? "none";
+    return `${remainingFraction.toFixed(6)}|${resetTimeKey}`;
+}
+/**
+ * Group models that share the same quota (same remainingFraction and resetTime)
+ */
+export function groupByQuotaPool(modelQuotas) {
+    const poolMap = new Map();
+    for (const quota of modelQuotas) {
+        const key = createPoolKey(quota.lowestRemainingFraction, quota.resetTime);
+        const existing = poolMap.get(key);
+        if (existing) {
+            existing.modelIds.push(quota.modelId);
+        }
+        else {
+            poolMap.set(key, {
+                modelIds: [quota.modelId],
+                remainingFraction: quota.lowestRemainingFraction,
+                resetTime: quota.resetTime,
+            });
+        }
+    }
+    // Sort model IDs within each pool for consistent ordering
+    for (const pool of poolMap.values()) {
+        pool.modelIds.sort();
+    }
+    return [...poolMap.values()];
+}
+/**
+ * Convert quota pool to usage window
+ */
+export function poolToUsageWindow(pool) {
+    // Convert remaining fraction (0-1) to utilization percentage (0-100)
+    // remaining 0.6 means 40% utilized
+    const utilization = (1 - pool.remainingFraction) * 100;
+    return {
+        name: formatPoolName(pool.modelIds),
+        utilization: Math.round(utilization * 100) / 100, // Round to 2 decimal places
+        resetsAt: pool.resetTime,
+        periodDurationMs: PERIOD_DURATION_MS,
+    };
+}
+/**
+ * Convert model quota to usage window
+ */
+export function toUsageWindow(quota) {
+    // Convert remaining fraction (0-1) to utilization percentage (0-100)
+    // remaining 0.6 means 40% utilized
+    const utilization = (1 - quota.lowestRemainingFraction) * 100;
+    return {
+        name: formatModelName(quota.modelId),
+        utilization: Math.round(utilization * 100) / 100, // Round to 2 decimal places
+        resetsAt: quota.resetTime,
+        periodDurationMs: PERIOD_DURATION_MS,
+    };
+}
+/**
+ * Convert Gemini quota response to common domain model
+ */
+export function toServiceUsageData(response, planType) {
+    const modelQuotas = groupBucketsByModel(response.buckets);
+    const quotaPools = groupByQuotaPool(modelQuotas);
+    const windows = quotaPools.map((pool) => poolToUsageWindow(pool));
+    return {
+        service: "Gemini",
+        planType,
+        windows,
+    };
+}

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

@@ -0,0 +1,23 @@
+import type { ServiceUsageData } from "../types/domain.js";
+import type { GitHubCopilotUsageResponse } from "../types/github-copilot.js";
+/**
+ * Parses GitHub reset date (YYYY-MM-DD) into a UTC Date
+ */
+export declare function parseResetDate(resetDateString: string): Date;
+/**
+ * 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.
+ *
+ * Example:
+ *   For resetDate = 2025-03-31, calculates duration from 2025-02-28 (clamped)
+ *   to 2025-03-31.
+ */
+export declare function calculatePeriodDuration(resetDate: Date): number;
+/**
+ * Converts GitHub Copilot response to common domain model
+ */
+export declare function toServiceUsageData(response: GitHubCopilotUsageResponse): ServiceUsageData;

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

@@ -0,0 +1,78 @@
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+/**
+ * Parses GitHub reset date (YYYY-MM-DD) into a UTC Date
+ */
+export function parseResetDate(resetDateString) {
+    const parts = resetDateString.split("-");
+    if (parts.length !== 3) {
+        throw new Error(`Invalid reset date format: ${resetDateString}`);
+    }
+    const [yearString, monthString, dayString] = parts;
+    if (!yearString || !monthString || !dayString) {
+        throw new Error(`Invalid reset date components: ${resetDateString}`);
+    }
+    const year = Number(yearString);
+    const month = Number(monthString);
+    const day = Number(dayString);
+    if (Number.isNaN(year) ||
+        Number.isNaN(month) ||
+        Number.isNaN(day) ||
+        month < 1 ||
+        month > 12 ||
+        day < 1 ||
+        day > 31) {
+        throw new Error(`Invalid reset date components: ${resetDateString}`);
+    }
+    return new Date(Date.UTC(year, month - 1, day, 0, 0, 0));
+}
+/**
+ * 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.
+ *
+ * Example:
+ *   For resetDate = 2025-03-31, calculates duration from 2025-02-28 (clamped)
+ *   to 2025-03-31.
+ */
+export function calculatePeriodDuration(resetDate) {
+    const periodEnd = resetDate.getTime();
+    // Determine previous month and clamp day to its last day
+    const year = resetDate.getUTCFullYear();
+    const month = resetDate.getUTCMonth(); // 0-based
+    const day = resetDate.getUTCDate();
+    // First day of current month in UTC
+    const firstOfCurrentMonth = Date.UTC(year, month, 1, 0, 0, 0);
+    // Last day of previous month: subtract 1 day from first of current month
+    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, 0, 0, 0);
+    return Math.max(periodEnd - periodStart, 0);
+}
+/**
+ * Converts GitHub Copilot response to common domain model
+ */
+export function toServiceUsageData(response) {
+    const resetDate = parseResetDate(response.quotas.resetDate);
+    const periodDurationMs = calculatePeriodDuration(resetDate);
+    const used = response.quotas.limits.premiumInteractions -
+        response.quotas.remaining.premiumInteractions;
+    const utilization = (used / response.quotas.limits.premiumInteractions) * 100;
+    return {
+        service: "GitHub Copilot",
+        planType: response.plan,
+        windows: [
+            {
+                name: "Monthly Premium Interactions",
+                utilization: Math.round(utilization * 100) / 100,
+                resetsAt: resetDate,
+                periodDurationMs,
+            },
+        ],
+    };
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+import { Command, Option } from "@commander-js/extra-typings";
+import packageJson from "../package.json" with { type: "json" };
+import { usageCommand } from "./commands/usage-command.js";
+import { authSetupCommand } from "./commands/auth-setup-command.js";
+import { authStatusCommand } from "./commands/auth-status-command.js";
+import { authClearCommand } from "./commands/auth-clear-command.js";
+import { getAvailableServices } from "./services/service-adapter-registry.js";
+import { installAuthManagerCleanup } from "./services/shared-browser-auth-manager.js";
+import { getBrowserContextsDirectory } from "./services/app-paths.js";
+const program = new Command()
+    .name(packageJson.name)
+    .description(packageJson.description)
+    .version(packageJson.version)
+    .showHelpAfterError("(add --help for additional information)")
+    .showSuggestionAfterError()
+    .helpCommand(false)
+    .addHelpText("after", `\nExamples:\n  # Fetch usage for all services\n  ${packageJson.name}\n\n  # JSON output for a single service\n  ${packageJson.name} --service claude --format=json\n\n  # TSV output for piping to cut, awk, sort\n  ${packageJson.name} --format=tsv | tail -n +2 | awk -F'\\t' '{print $1, $4"%"}'\n\n  # Filter Prometheus metrics with standard tools\n  ${packageJson.name} --format=prometheus | grep axusage_utilization_percent\n`);
+// Ensure browser resources are cleaned when process exits
+installAuthManagerCleanup();
+// Usage command (default)
+program
+    .command("usage", { isDefault: true })
+    .description("Fetch API usage statistics (defaults to all: Claude, ChatGPT, GitHub Copilot)")
+    .option("-s, --service <service>", `Service to query (${getAvailableServices().join(", ")}, all) - defaults to all`)
+    .option("-i, --interactive", "allow interactive re-authentication during usage fetch")
+    .addOption(new Option("-o, --format <format>", "Output format")
+    .choices(["text", "tsv", "json", "prometheus"])
+    .default("text"))
+    .addHelpText("after", `\nExamples:\n  # Query all services (default)\n  ${packageJson.name}\n\n  # Query a single service\n  ${packageJson.name} --service claude\n\n  # TSV output for piping to Unix tools\n  ${packageJson.name} --format=tsv | tail -n +2 | cut -f1,4\n\n  # Filter Prometheus metrics\n  ${packageJson.name} --format=prometheus | grep claude\n`)
+    .action(async (options) => {
+    await usageCommand(options);
+});
+// Auth command group
+const auth = program
+    .command("auth")
+    .description("Manage authentication for services")
+    .helpCommand(false)
+    .addHelpText("after", `\nStorage: ${getBrowserContextsDirectory()}\n(respects XDG_DATA_HOME and platform defaults)`);
+auth
+    .command("setup")
+    .description("Set up browser-based authentication for a service")
+    .argument("<service>", "Service to authenticate (claude, chatgpt, github-copilot)")
+    .action(async (service) => {
+    await authSetupCommand({ service });
+});
+auth
+    .command("status")
+    .description("Check authentication status for services")
+    .option("-s, --service <service>", "Check status for specific service")
+    .action((options) => {
+    authStatusCommand(options);
+});
+auth
+    .command("clear")
+    .description("Clear saved browser authentication for a service")
+    .argument("<service>", "Service to clear (claude, chatgpt, github-copilot)")
+    .action(async (service) => {
+    await authClearCommand({ service });
+});
+try {
+    await program.parseAsync();
+}
+catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    if (process.exitCode === undefined)
+        process.exitCode = 1;
+}

package/dist/commands/auth-clear-command.d.ts

@@ -0,0 +1,5 @@
+type AuthClearOptions = {
+    readonly service?: string;
+};
+export declare function authClearCommand(options: AuthClearOptions): Promise<void>;
+export {};

package/dist/commands/auth-clear-command.js

@@ -0,0 +1,25 @@
+import chalk from "chalk";
+import { existsSync } from "node:fs";
+import trash from "trash";
+import { validateService } from "../services/supported-service.js";
+import { getAuthMetaPathFor, getStorageStatePathFor, } from "../services/auth-storage-path.js";
+import { getBrowserContextsDirectory } from "../services/app-paths.js";
+export async function authClearCommand(options) {
+    const service = validateService(options.service);
+    const dataDirectory = getBrowserContextsDirectory();
+    const storage = getStorageStatePathFor(dataDirectory, service);
+    const meta = getAuthMetaPathFor(dataDirectory, service);
+    try {
+        const targets = [storage, meta].filter((p) => existsSync(p));
+        if (targets.length === 0) {
+            console.error(chalk.gray(`\nNo saved authentication found for ${service}.`));
+            return;
+        }
+        await trash(targets, { glob: false });
+        console.error(chalk.green(`\n✓ Cleared authentication for ${service}`));
+    }
+    catch (error) {
+        console.error(chalk.red(`\n✗ Failed to clear authentication for ${service}: ${error instanceof Error ? error.message : String(error)}`));
+        process.exitCode = 1;
+    }
+}

package/dist/commands/auth-setup-command.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Options for the auth setup command
+ */
+type AuthSetupOptions = {
+    readonly service?: string;
+};
+/**
+ * Set up authentication for a service
+ */
+export declare function authSetupCommand(options: AuthSetupOptions): Promise<void>;
+export {};

package/dist/commands/auth-setup-command.js

@@ -0,0 +1,45 @@
+import chalk from "chalk";
+import { BrowserAuthManager } from "../services/browser-auth-manager.js";
+import { validateService } from "../services/supported-service.js";
+/**
+ * Set up authentication for a service
+ */
+export async function authSetupCommand(options) {
+    const service = validateService(options.service);
+    // CLI-based auth - users should run the native CLI directly
+    if (service === "gemini") {
+        console.error(chalk.yellow("\nGemini uses CLI-based authentication managed by the Gemini CLI."));
+        console.error(chalk.gray("\nTo authenticate, run:"));
+        console.error(chalk.cyan("  gemini"));
+        console.error(chalk.gray("\nThe Gemini CLI will guide you through the OAuth login process.\n"));
+        return;
+    }
+    if (service === "claude") {
+        console.error(chalk.yellow("\nClaude uses CLI-based authentication managed by Claude Code."));
+        console.error(chalk.gray("\nTo authenticate, run:"));
+        console.error(chalk.cyan("  claude"));
+        console.error(chalk.gray("\nClaude Code will guide you through authentication.\n"));
+        return;
+    }
+    if (service === "chatgpt") {
+        console.error(chalk.yellow("\nChatGPT uses CLI-based authentication managed by Codex."));
+        console.error(chalk.gray("\nTo authenticate, run:"));
+        console.error(chalk.cyan("  codex"));
+        console.error(chalk.gray("\nCodex will guide you through authentication.\n"));
+        return;
+    }
+    const manager = new BrowserAuthManager({ headless: false });
+    try {
+        console.error(chalk.blue(`\nSetting up authentication for ${service}...\n`));
+        await manager.setupAuth(service);
+        console.error(chalk.green(`\n✓ Authentication for ${service} is complete!`));
+        console.error(chalk.gray(`\nYou can now run: ${chalk.cyan(`axusage usage --service ${service}`)}`));
+    }
+    catch (error) {
+        console.error(chalk.red(`\n✗ Failed to set up authentication for ${service}: ${error instanceof Error ? error.message : String(error)}`));
+        process.exitCode = 1;
+    }
+    finally {
+        await manager.close();
+    }
+}

package/dist/commands/auth-status-command.d.ts

@@ -0,0 +1,5 @@
+type AuthStatusOptions = {
+    readonly service?: string;
+};
+export declare function authStatusCommand(options: AuthStatusOptions): void;
+export {};