axusage 3.0.0 → 3.2.0

package/dist/services/get-service-access-token.js

@@ -7,13 +7,8 @@
  * - "auto": Try vault first if configured, fallback to local
  */
 import { fetchVaultCredentials, getAgentAccessToken, isVaultConfigured, } from "axauth";
-import { getServiceSourceConfig, } from "../config/credential-sources.js";
-/** Map service IDs to agent IDs for axauth/vault */
-const SERVICE_TO_AGENT = {
-    claude: "claude",
-    chatgpt: "codex", // ChatGPT and Codex both use OpenAI API credentials
-    gemini: "gemini",
-};
+import { getServiceSourceConfig } from "../config/credential-sources.js";
+import { getCopilotTokenFromCustomGhPath } from "../utils/copilot-gh-token.js";
 /**
  * Extract access token from vault credentials.
  *
@@ -84,12 +79,17 @@ async function fetchFromVault(agentId, credentialName) {
  */
 async function fetchFromLocal(agentId) {
     try {
-        return await getAgentAccessToken(agentId);
+        const token = await getAgentAccessToken(agentId);
+        if (token)
+            return token;
     }
     catch (error) {
         console.error(`[axusage] Local credential fetch error for ${agentId}: ${error instanceof Error ? error.message : String(error)}`);
-        return undefined;
     }
+    if (agentId === "copilot") {
+        return getCopilotTokenFromCustomGhPath();
+    }
+    return undefined;
 }
 /**
  * Get access token for a service.
@@ -99,7 +99,7 @@ async function fetchFromLocal(agentId) {
  * - "vault": Fetch from axvault server (requires credential name)
  * - "auto": Try vault if configured and name provided, fallback to local
  *
- * @param service - Service ID (e.g., "claude", "chatgpt", "gemini")
+ * @param service - Service ID (e.g., "claude", "codex", "gemini")
  * @returns Access token string or undefined if not available
  *
  * @example
@@ -110,7 +110,7 @@ async function fetchFromLocal(agentId) {
  */
 async function getServiceAccessToken(service) {
     const config = getServiceSourceConfig(service);
-    const agentId = SERVICE_TO_AGENT[service];
+    const agentId = service;
     switch (config.source) {
         case "local": {
             return fetchFromLocal(agentId);

package/dist/services/service-adapter-registry.d.ts

@@ -4,8 +4,8 @@ import type { ServiceAdapter } from "../types/domain.js";
  */
 export declare const SERVICE_ADAPTERS: {
     readonly claude: ServiceAdapter;
-    readonly chatgpt: ServiceAdapter;
-    readonly "github-copilot": ServiceAdapter;
+    readonly codex: ServiceAdapter;
+    readonly copilot: ServiceAdapter;
     readonly gemini: ServiceAdapter;
 };
 /**

package/dist/services/service-adapter-registry.js

@@ -1,14 +1,14 @@
-import { chatGPTAdapter } from "../adapters/chatgpt.js";
+import { codexAdapter } from "../adapters/codex.js";
 import { claudeAdapter } from "../adapters/claude.js";
 import { geminiAdapter } from "../adapters/gemini.js";
-import { githubCopilotAdapter } from "../adapters/github-copilot.js";
+import { copilotAdapter } from "../adapters/copilot.js";
 /**
  * Registry of available service adapters
  */
 export const SERVICE_ADAPTERS = {
     claude: claudeAdapter,
-    chatgpt: chatGPTAdapter,
-    "github-copilot": githubCopilotAdapter,
+    codex: codexAdapter,
+    copilot: copilotAdapter,
     gemini: geminiAdapter,
 };
 /**

package/dist/services/supported-service.d.ts

@@ -1,6 +1,10 @@
+import type { AgentCli } from "axauth";
 /**
- * Supported service names for usage tracking
+ * Supported service names for usage tracking.
+ *
+ * Derived from the canonical AGENT_CLIS list, excluding agents
+ * that axusage doesn't yet support (opencode).
  */
-export type SupportedService = "claude" | "chatgpt" | "github-copilot" | "gemini";
+export type SupportedService = Exclude<AgentCli, "opencode">;
 export declare const SUPPORTED_SERVICES: SupportedService[];
 export declare function validateService(service: string | undefined): SupportedService;

package/dist/services/supported-service.js

@@ -1,9 +1,5 @@
-export const SUPPORTED_SERVICES = [
-    "claude",
-    "chatgpt",
-    "github-copilot",
-    "gemini",
-];
+import { AGENT_CLIS } from "axauth";
+export const SUPPORTED_SERVICES = AGENT_CLIS.filter((cli) => cli !== "opencode");
 export function validateService(service) {
     if (!service) {
         throw new Error(`Service is required. Supported services: ${SUPPORTED_SERVICES.join(", ")}. ` +

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

@@ -2,14 +2,14 @@ import { z } from "zod";
 /**
  * ChatGPT API response schemas
  */
-export declare const ChatGPTRateLimitWindow: z.ZodObject<{
+export declare const CodexRateLimitWindow: z.ZodObject<{
     used_percent: z.ZodNumber;
     limit_window_seconds: z.ZodNumber;
     reset_after_seconds: z.ZodNumber;
     reset_at: z.ZodNumber;
 }, z.core.$strip>;
-export type ChatGPTRateLimitWindow = z.infer<typeof ChatGPTRateLimitWindow>;
-export declare const ChatGPTUsageResponse: z.ZodObject<{
+export type CodexRateLimitWindow = z.infer<typeof CodexRateLimitWindow>;
+export declare const CodexUsageResponse: z.ZodObject<{
     plan_type: z.ZodString;
     rate_limit: z.ZodObject<{
         allowed: z.ZodBoolean;
@@ -29,4 +29,4 @@ export declare const ChatGPTUsageResponse: z.ZodObject<{
     }, z.core.$strip>;
     credits: z.ZodNullable<z.ZodUnknown>;
 }, z.core.$strip>;
-export type ChatGPTUsageResponse = z.infer<typeof ChatGPTUsageResponse>;
+export type CodexUsageResponse = z.infer<typeof CodexUsageResponse>;

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

@@ -2,20 +2,20 @@ import { z } from "zod";
 /**
  * ChatGPT API response schemas
  */
-export const ChatGPTRateLimitWindow = z.object({
+export const CodexRateLimitWindow = z.object({
     used_percent: z.number(),
     limit_window_seconds: z.number(),
     reset_after_seconds: z.number(),
     reset_at: z.number(), // Unix timestamp
 });
-const ChatGPTRateLimit = z.object({
+const CodexRateLimit = z.object({
     allowed: z.boolean(),
     limit_reached: z.boolean(),
-    primary_window: ChatGPTRateLimitWindow,
-    secondary_window: ChatGPTRateLimitWindow,
+    primary_window: CodexRateLimitWindow,
+    secondary_window: CodexRateLimitWindow,
 });
-export const ChatGPTUsageResponse = z.object({
+export const CodexUsageResponse = z.object({
     plan_type: z.string(),
-    rate_limit: ChatGPTRateLimit,
+    rate_limit: CodexRateLimit,
     credits: z.unknown().nullable(),
 });

package/dist/types/copilot.d.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+export declare const CopilotUsageResponse: z.ZodObject<{
+    quota_reset_date_utc: z.ZodString;
+    copilot_plan: z.ZodString;
+    quota_snapshots: z.ZodObject<{
+        premium_interactions: z.ZodObject<{
+            entitlement: z.ZodNumber;
+            remaining: z.ZodNumber;
+            percent_remaining: z.ZodNumber;
+            unlimited: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type CopilotUsageResponse = z.infer<typeof CopilotUsageResponse>;

package/dist/types/copilot.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+/**
+ * GitHub Copilot internal API response schema
+ * Endpoint: GET https://api.github.com/copilot_internal/user
+ */
+const PremiumInteractionsSnapshot = z.object({
+    entitlement: z.number(),
+    remaining: z.number(),
+    percent_remaining: z.number(),
+    unlimited: z.boolean().optional(),
+});
+const QuotaSnapshots = z.object({
+    premium_interactions: PremiumInteractionsSnapshot,
+});
+export const CopilotUsageResponse = z.object({
+    quota_reset_date_utc: z
+        .string()
+        .refine((s) => !Number.isNaN(new Date(s).getTime()), "Invalid date"),
+    copilot_plan: z.string(),
+    quota_snapshots: QuotaSnapshots,
+});

package/dist/utils/check-cli-dependency.d.ts

@@ -3,8 +3,7 @@ type CliDependency = {
     readonly envVar: string;
     readonly installHint: string;
 };
-declare const AUTH_CLI_SERVICES: readonly ["claude", "chatgpt", "gemini"];
-type AuthCliService = (typeof AUTH_CLI_SERVICES)[number];
+type AuthCliService = "claude" | "codex" | "copilot" | "gemini";
 export declare function getAuthCliDependency(service: AuthCliService): CliDependency;
 export declare function checkCliDependency(dep: CliDependency): {
     ok: boolean;
@@ -21,5 +20,4 @@ export declare function ensureAuthCliDependency(service: AuthCliService): {
 export declare function resolveAuthCliDependencyOrReport(service: AuthCliService, options?: {
     readonly setExitCode?: boolean;
 }): string | undefined;
-export { AUTH_CLI_SERVICES };
-export type { AuthCliService };
+export {};

package/dist/utils/check-cli-dependency.js

@@ -11,13 +11,17 @@ const CLI_DEPENDENCIES = {
         envVar: "AXUSAGE_CODEX_PATH",
         installHint: "npm install -g @openai/codex",
     },
+    gh: {
+        command: "gh",
+        envVar: "AXUSAGE_GH_PATH",
+        installHint: "https://cli.github.com/ or brew install gh",
+    },
     gemini: {
         command: "gemini",
         envVar: "AXUSAGE_GEMINI_PATH",
         installHint: "npm install -g @google/gemini-cli",
     },
 };
-const AUTH_CLI_SERVICES = ["claude", "chatgpt", "gemini"];
 function resolveCliDependencyTimeout() {
     const raw = process.env.AXUSAGE_CLI_TIMEOUT_MS;
     if (!raw)
@@ -28,8 +32,8 @@ function resolveCliDependencyTimeout() {
     return Math.round(parsed);
 }
 export function getAuthCliDependency(service) {
-    if (service === "chatgpt")
-        return CLI_DEPENDENCIES.codex;
+    if (service === "copilot")
+        return CLI_DEPENDENCIES.gh;
     return CLI_DEPENDENCIES[service];
 }
 function resolveCliDependencyPath(dep) {
@@ -78,4 +82,3 @@ function reportMissingCliDependency(dependency, path) {
     console.error(chalk.gray(`  2. Set ${dependency.envVar}=/path/to/${dependency.command}`));
     console.error(chalk.gray("Try 'axusage --help' for requirements and overrides."));
 }
-export { AUTH_CLI_SERVICES };

package/dist/utils/copilot-gh-token.d.ts

@@ -0,0 +1 @@
+export declare function getCopilotTokenFromCustomGhPath(): string | undefined;

package/dist/utils/copilot-gh-token.js

@@ -0,0 +1,38 @@
+import { execFileSync } from "node:child_process";
+const GH_PATH_OVERRIDE_ENV = "AXUSAGE_GH_PATH";
+const DEFAULT_TIMEOUT_MS = 5000;
+function resolveCliTimeoutMs() {
+    const rawValue = process.env.AXUSAGE_CLI_TIMEOUT_MS;
+    if (!rawValue)
+        return DEFAULT_TIMEOUT_MS;
+    const parsed = Number(rawValue);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return DEFAULT_TIMEOUT_MS;
+    return Math.round(parsed);
+}
+function resolveGhOverridePath() {
+    const value = process.env[GH_PATH_OVERRIDE_ENV]?.trim();
+    if (!value)
+        return undefined;
+    return value;
+}
+export function getCopilotTokenFromCustomGhPath() {
+    const path = resolveGhOverridePath();
+    if (!path)
+        return undefined;
+    try {
+        const token = execFileSync(path, ["auth", "token"], {
+            encoding: "utf8",
+            stdio: ["pipe", "pipe", "pipe"],
+            timeout: resolveCliTimeoutMs(),
+        }).trim();
+        // Copilot requires fine-grained tokens; reject classic PATs.
+        if (token && !token.startsWith("ghp_")) {
+            return token;
+        }
+    }
+    catch {
+        // Ignore command failures and fall back to other auth sources.
+    }
+    return undefined;
+}

package/dist/utils/validate-root-options.d.ts

@@ -2,10 +2,7 @@ import type { UsageCommandOptions } from "../commands/fetch-service-usage.js";
 export type RootOptions = {
     readonly authSetup?: string;
     readonly authStatus?: string | boolean;
-    readonly authClear?: string;
-    readonly force?: boolean;
     readonly service?: UsageCommandOptions["service"];
     readonly format?: UsageCommandOptions["format"];
-    readonly interactive?: UsageCommandOptions["interactive"];
 };
 export declare function getRootOptionsError(options: RootOptions, formatSource?: string): string | undefined;

package/dist/utils/validate-root-options.js

@@ -1,13 +1,9 @@
 export function getRootOptionsError(options, formatSource) {
     // Commander sets optional args to `true` when provided without a value.
     const authSelectionCount = Number(Boolean(options.authSetup)) +
-        Number(options.authStatus !== undefined) +
-        Number(Boolean(options.authClear));
+        Number(options.authStatus !== undefined);
     if (authSelectionCount > 1) {
-        return "Use only one of --auth-setup, --auth-status, or --auth-clear.";
-    }
-    if (options.force && !options.authClear) {
-        return "--force is only supported with --auth-clear.";
+        return "Use only one of --auth-setup or --auth-status.";
     }
     const hasExplicitFormat = formatSource === "cli";
     const hasUsageOptions = Boolean(options.service) || hasExplicitFormat;

package/package.json

@@ -2,7 +2,7 @@
   "name": "axusage",
   "author": "Łukasz Jerciński",
   "license": "MIT",
-  "version": "3.0.0",
+  "version": "3.2.0",
   "description": "Monitor API usage across Claude, ChatGPT, GitHub Copilot, and Gemini from a single CLI",
   "repository": {
     "type": "git",
@@ -19,7 +19,6 @@
     "LICENSE"
   ],
   "scripts": {
-    "postinstall": "playwright install chromium",
     "prepare": "git config core.hooksPath .githooks",
     "prepublishOnly": "pnpm run rebuild",
     "build": "tsc -p tsconfig.app.json",
@@ -48,35 +47,32 @@
     "llm",
     "monitoring"
   ],
-  "packageManager": "pnpm@10.25.0",
+  "packageManager": "pnpm@10.30.1",
   "engines": {
     "node": ">=22.14.0"
   },
   "dependencies": {
     "@commander-js/extra-typings": "^14.0.0",
-    "@inquirer/prompts": "^8.2.0",
-    "axauth": "^1.11.2",
+    "axauth": "^3.1.6",
     "chalk": "^5.6.2",
-    "commander": "^14.0.2",
-    "conf": "^15.0.2",
-    "env-paths": "^3.0.0",
-    "playwright": "^1.57.0",
+    "commander": "^14.0.3",
+    "conf": "^15.1.0",
+    "env-paths": "^4.0.0",
     "prom-client": "^15.1.3",
-    "trash": "^10.0.1",
-    "zod": "^4.3.5"
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@total-typescript/ts-reset": "^0.6.1",
-    "@types/node": "^25.0.8",
-    "@vitest/coverage-v8": "^4.0.17",
-    "eslint": "^9.39.2",
-    "eslint-config-axkit": "^1.0.0",
+    "@types/node": "^25.3.0",
+    "@vitest/coverage-v8": "^4.0.18",
+    "eslint": "^10.0.1",
+    "eslint-config-axkit": "^1.2.1",
     "fta-check": "^1.5.1",
     "fta-cli": "^3.0.0",
-    "knip": "^5.81.0",
-    "prettier": "3.7.4",
-    "semantic-release": "^25.0.2",
+    "knip": "^5.85.0",
+    "prettier": "3.8.1",
+    "semantic-release": "^25.0.3",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.17"
+    "vitest": "^4.0.18"
   }
 }

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

@@ -1,6 +0,0 @@
-import type { ServiceAdapter } from "../types/domain.js";
-/** Functional core is extracted to ./parse-github-copilot-usage.ts */
-/**
- * GitHub Copilot service adapter
- */
-export declare const githubCopilotAdapter: ServiceAdapter;

package/dist/adapters/github-copilot.js

@@ -1,57 +0,0 @@
-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 --interactive' 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-github-copilot-usage.d.ts

@@ -1,23 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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/commands/auth-clear-command.d.ts

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

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

@@ -1,84 +0,0 @@
-import { confirm } from "@inquirer/prompts";
-import { existsSync, readdirSync } from "node:fs";
-import path from "node:path";
-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";
-import { chalk } from "../utils/color.js";
-import { resolvePromptCapability } from "../utils/resolve-prompt-capability.js";
-function isPromptCancellation(error) {
-    return (error instanceof Error &&
-        (error.name === "AbortPromptError" ||
-            error.name === "CancelPromptError" ||
-            error.name === "ExitPromptError"));
-}
-function collectRelatedArtifacts(filePath) {
-    const directory = path.dirname(filePath);
-    const baseName = path.basename(filePath);
-    try {
-        return readdirSync(directory)
-            .filter((entry) => entry.startsWith(`${baseName}.`) &&
-            (entry.endsWith(".bak") || entry.endsWith(".tmp")))
-            .map((entry) => path.join(directory, entry));
-    }
-    catch {
-        return [];
-    }
-}
-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 artifactTargets = [storage, meta].filter((p) => existsSync(p));
-        const backupTargets = [storage, meta].flatMap((filePath) => collectRelatedArtifacts(filePath));
-        const targets = [...new Set([...artifactTargets, ...backupTargets])];
-        if (targets.length === 0) {
-            console.error(chalk.gray(`\nNo saved authentication found for ${service}.`));
-            return;
-        }
-        if (!options.force) {
-            if (!options.interactive) {
-                console.error(chalk.red("Error: Clearing saved authentication requires confirmation."));
-                console.error(chalk.gray("Re-run with --interactive to confirm, or use --force to skip confirmation."));
-                console.error(chalk.gray("Try 'axusage --help' for details."));
-                process.exitCode = 1;
-                return;
-            }
-            if (!resolvePromptCapability()) {
-                console.error(chalk.red("Error: --interactive requires a TTY-enabled terminal."));
-                console.error(chalk.gray("Re-run in a terminal or pass --force instead."));
-                console.error(chalk.gray("Try 'axusage --help' for details."));
-                process.exitCode = 1;
-                return;
-            }
-            let confirmed = false;
-            try {
-                confirmed = await confirm({
-                    message: `Remove saved authentication for ${service}?`,
-                    default: false,
-                });
-            }
-            catch (error) {
-                if (isPromptCancellation(error)) {
-                    console.error(chalk.gray("Aborted."));
-                    process.exitCode = 1;
-                    return;
-                }
-                throw error;
-            }
-            if (!confirmed) {
-                console.error(chalk.gray("Aborted."));
-                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;
-    }
-}