axusage 2.2.0 → 3.0.0

package/dist/commands/usage-command.js

@@ -1,9 +1,9 @@
-import chalk from "chalk";
 import { formatServiceUsageData, formatServiceUsageDataAsJson, formatServiceUsageAsTsv, toJsonObject, } from "../utils/format-service-usage.js";
 import { formatPrometheusMetrics } from "../utils/format-prometheus-metrics.js";
 import { fetchServiceUsage, selectServicesToQuery, } from "./fetch-service-usage.js";
 import { fetchServiceUsageWithAutoReauth } from "./fetch-service-usage-with-reauth.js";
 import { isAuthFailure } from "./run-auth-setup.js";
+import { chalk } from "../utils/color.js";
 /**
  * Fetches usage for services using hybrid strategy:
  * 1. Try all services in parallel first (fast path for valid credentials)
@@ -79,7 +79,9 @@ export async function usageCommand(options) {
     }
     if (!interactive && authFailureServices.size > 0) {
         const list = [...authFailureServices].join(", ");
-        console.error(chalk.gray(`Authentication required for: ${list}. Run 'axusage auth setup <service>' or re-run with '--interactive' to re-authenticate during fetch.`));
+        console.error(chalk.gray(`Authentication required for: ${list}. ` +
+            "For GitHub Copilot, run 'axusage --auth-setup github-copilot --interactive'. " +
+            "For CLI-auth services, run the provider CLI (claude/codex/gemini), or re-run with '--interactive' to re-authenticate during fetch."));
         if (successes.length > 0) {
             console.error();
         }
@@ -141,6 +143,6 @@ export async function usageCommand(options) {
         }
     }
     if (hasPartialFailures) {
-        process.exitCode = 2;
+        process.exitCode = 1;
     }
 }

package/dist/config/credential-sources.js

@@ -26,6 +26,7 @@ function getConfig() {
     if (!configInstance) {
         configInstance = new Conf({
             projectName: "axusage",
+            projectSuffix: "",
             schema: {
                 sources: {
                     type: "object",
@@ -33,9 +34,30 @@ function getConfig() {
                 },
             },
         });
+        // Migration runs once per process when the config is first initialized.
+        migrateLegacySources(configInstance);
     }
     return configInstance;
 }
+function migrateLegacySources(config) {
+    // Respect explicit new config values; never overwrite them with legacy data.
+    if (config.get("sources") !== undefined)
+        return;
+    // Conf defaults to the legacy "-nodejs" suffix, which matches older configs.
+    const legacyConfig = new Conf({
+        projectName: "axusage",
+    });
+    const legacySources = legacyConfig.get("sources");
+    if (!legacySources)
+        return;
+    const parsed = SourcesConfig.safeParse(legacySources);
+    if (!parsed.success) {
+        console.error("Warning: Legacy axusage config contains invalid sources; skipping migration. Check your legacy config and migrate manually if needed.");
+        return;
+    }
+    config.set("sources", parsed.data);
+    console.error("Migrated credential source configuration from legacy axusage-nodejs config path.");
+}
 /**
  * Get the full credential source configuration.
  *

package/dist/services/create-auth-context.js

@@ -27,7 +27,8 @@ export async function loadStoredUserAgent(dataDirectory, service) {
 export async function createAuthContext(browser, dataDirectory, service) {
     const storageStatePath = getStorageStatePathFor(dataDirectory, service);
     if (!existsSync(storageStatePath)) {
-        throw new Error(`No saved authentication for ${service}. Run 'axusage auth setup ${service}' first.`);
+        throw new Error(`No saved authentication for ${service}. ` +
+            `Run 'axusage --auth-setup ${service} --interactive' first.`);
     }
     const userAgent = await loadStoredUserAgent(dataDirectory, service);
     return browser.newContext({ storageState: storageStatePath, userAgent });

package/dist/services/do-setup-auth.js

@@ -1,7 +1,7 @@
 import { setupAuthInContext } from "./setup-auth-flow.js";
-import { writeFile, chmod } from "node:fs/promises";
 import path from "node:path";
 import { getAuthMetaPathFor } from "./auth-storage-path.js";
+import { writeAtomicJson } from "../utils/write-atomic-json.js";
 export async function doSetupAuth(service, context, storagePath, instructions) {
     console.error(`\n${instructions}`);
     console.error("Waiting for login to complete (or press Enter to continue)\n");
@@ -9,13 +9,7 @@ export async function doSetupAuth(service, context, storagePath, instructions) {
     try {
         if (userAgent) {
             const metaPath = getAuthMetaPathFor(path.dirname(storagePath), service);
-            await writeFile(metaPath, JSON.stringify({ userAgent }), "utf8");
-            try {
-                await chmod(metaPath, 0o600);
-            }
-            catch {
-                // best effort
-            }
+            await writeAtomicJson(metaPath, { userAgent }, 0o600);
         }
     }
     catch {

package/dist/services/persist-storage-state.d.ts

@@ -1,6 +1,6 @@
 import type { BrowserContext } from "playwright";
 /**
  * Persist context storage state to disk with secure permissions (0o600).
- * Errors are silently ignored to avoid blocking the main operation.
+ * Errors are logged as warnings to avoid blocking the main operation.
  */
 export declare function persistStorageState(context: BrowserContext, storagePath: string): Promise<void>;

package/dist/services/persist-storage-state.js

@@ -1,16 +1,16 @@
-import { chmod } from "node:fs/promises";
+import { writeAtomicJson } from "../utils/write-atomic-json.js";
+import { chalk } from "../utils/color.js";
 /**
  * Persist context storage state to disk with secure permissions (0o600).
- * Errors are silently ignored to avoid blocking the main operation.
+ * Errors are logged as warnings to avoid blocking the main operation.
  */
 export async function persistStorageState(context, storagePath) {
     try {
-        await context.storageState({ path: storagePath });
-        await chmod(storagePath, 0o600).catch(() => {
-            // best effort: permissions may already be correct or OS may ignore
-        });
+        const state = await context.storageState();
+        await writeAtomicJson(storagePath, state, 0o600);
     }
-    catch {
-        // ignore persistence errors; do not block request completion
+    catch (error) {
+        const details = error instanceof Error ? error.message : String(error);
+        console.error(chalk.yellow(`Warning: Failed to persist auth state to ${storagePath} (${details}).`));
     }
 }

package/dist/services/setup-auth-flow.js

@@ -1,7 +1,29 @@
 import { getServiceAuthConfig } from "./service-auth-configs.js";
 import { waitForLogin } from "./wait-for-login.js";
 import { verifySessionByFetching } from "./verify-session.js";
-import { chmod } from "node:fs/promises";
+import { writeAtomicJson } from "../utils/write-atomic-json.js";
+function describeLoginOutcome(outcome) {
+    switch (outcome) {
+        case "manual": {
+            return "after manual continuation";
+        }
+        case "timeout": {
+            return "after login timeout";
+        }
+        case "closed": {
+            return "after the browser window closed";
+        }
+        case "aborted": {
+            return "after prompt cancellation";
+        }
+        case "selector": {
+            return "after detecting a login signal";
+        }
+        case "skipped": {
+            return "without waiting for a login signal";
+        }
+    }
+}
 export async function setupAuthInContext(service, context, storagePath) {
     const page = await context.newPage();
     try {
@@ -9,24 +31,27 @@ export async function setupAuthInContext(service, context, storagePath) {
         await page.goto(config.url);
         const selectors = config.waitForSelectors ??
             (config.waitForSelector ? [config.waitForSelector] : []);
-        await waitForLoginForService(page, selectors);
+        const loginOutcome = await waitForLoginForService(page, selectors);
+        const outcomeLabel = describeLoginOutcome(loginOutcome);
+        if (loginOutcome === "aborted") {
+            throw new Error("Authentication was canceled. Authentication was not saved.");
+        }
         if (config.verifyUrl) {
             const ok = config.verifyFunction
                 ? await config.verifyFunction(context, config.verifyUrl)
                 : await verifySessionByFetching(context, config.verifyUrl);
             if (!ok) {
-                console.warn(`\n⚠ Unable to verify session via ${config.verifyUrl}. Saving state anyway...`);
+                throw new Error(`Unable to verify session via ${config.verifyUrl} ${outcomeLabel}. Authentication was not saved. Ensure login completed successfully and retry.`);
             }
         }
+        else if (selectors.length > 0 && loginOutcome !== "selector") {
+            // Without a verification URL, we only persist when a login selector confirms success.
+            throw new Error(`Login was not confirmed ${outcomeLabel}. Authentication was not saved.`);
+        }
         // Capture user agent for future headless contexts
         const userAgent = await page.evaluate(() => navigator.userAgent);
-        await context.storageState({ path: storagePath });
-        try {
-            await chmod(storagePath, 0o600);
-        }
-        catch {
-            // best effort to restrict sensitive storage state
-        }
+        const state = await context.storageState();
+        await writeAtomicJson(storagePath, state, 0o600);
         return userAgent;
     }
     finally {
@@ -35,6 +60,8 @@ export async function setupAuthInContext(service, context, storagePath) {
 }
 async function waitForLoginForService(page, selectors) {
     if (selectors.length > 0) {
-        await waitForLogin(page, selectors);
+        return waitForLogin(page, selectors);
     }
+    // When no selectors are configured, skip waiting and rely on verification if available.
+    return "skipped";
 }

package/dist/services/supported-service.js

@@ -6,11 +6,13 @@ export const SUPPORTED_SERVICES = [
 ];
 export function validateService(service) {
     if (!service) {
-        throw new Error(`Service is required. Supported services: ${SUPPORTED_SERVICES.join(", ")}`);
+        throw new Error(`Service is required. Supported services: ${SUPPORTED_SERVICES.join(", ")}. ` +
+            "Run 'axusage --help' for usage.");
     }
     const normalizedService = service.toLowerCase();
     if (!SUPPORTED_SERVICES.includes(normalizedService)) {
-        throw new Error(`Unsupported service: ${service}. Supported services: ${SUPPORTED_SERVICES.join(", ")}`);
+        throw new Error(`Unsupported service: ${service}. Supported services: ${SUPPORTED_SERVICES.join(", ")}. ` +
+            "Run 'axusage --help' for usage.");
     }
     return normalizedService;
 }

package/dist/services/wait-for-login.d.ts

@@ -1,5 +1,6 @@
-import type { Page } from "playwright";
+import { type Page } from "playwright";
 /**
  * Waits until one of the selectors appears on the page, or the user presses Enter to continue.
  */
-export declare function waitForLogin(page: Page, selectors: readonly string[]): Promise<void>;
+export type LoginWaitOutcome = "selector" | "manual" | "timeout" | "closed" | "aborted" | "skipped";
+export declare function waitForLogin(page: Page, selectors: readonly string[]): Promise<LoginWaitOutcome>;

package/dist/services/wait-for-login.js

@@ -1,24 +1,73 @@
-import { createInterface } from "node:readline/promises";
-import { stdin as input, stdout as output } from "node:process";
+import { errors } from "playwright";
 import { LOGIN_TIMEOUT_MS } from "./auth-timeouts.js";
-/**
- * Waits until one of the selectors appears on the page, or the user presses Enter to continue.
- */
+import { input } from "@inquirer/prompts";
+function isTimeoutError(error) {
+    return error instanceof errors.TimeoutError;
+}
+const SELECTOR_CLOSED_MESSAGES = [
+    "target closed",
+    "page closed",
+    "context closed",
+    "execution context was destroyed",
+];
+function isSelectorClosedError(error) {
+    if (!(error instanceof Error))
+        return false;
+    const message = error.message.toLowerCase();
+    return SELECTOR_CLOSED_MESSAGES.some((snippet) => message.includes(snippet));
+}
+function classifySelectorFailure(error) {
+    if (isTimeoutError(error))
+        return "timeout";
+    if (isSelectorClosedError(error))
+        return "closed";
+    return undefined;
+}
+function classifySelectorAggregate(error) {
+    if (error instanceof AggregateError) {
+        const outcomes = error.errors.map((item) => classifySelectorFailure(item));
+        if (outcomes.every((item) => item === "timeout"))
+            return "timeout";
+        if (outcomes.every((item) => item === "timeout" || item === "closed") &&
+            outcomes.includes("closed")) {
+            return "closed";
+        }
+        return undefined;
+    }
+    return classifySelectorFailure(error);
+}
 export async function waitForLogin(page, selectors) {
-    const reader = createInterface({ input, output });
-    const manual = reader.question("Press Enter to continue without waiting for login... ");
-    // Absorb rejection when the interface is closed to prevent
-    // unhandled promise rejection (AbortError) after a selector wins.
-    const manualSilenced = manual.catch(() => { });
     const timeoutMs = LOGIN_TIMEOUT_MS;
-    const deadline = Date.now() + timeoutMs;
-    // Prevent unhandled rejections if the page closes before all waiters finish
-    const waiters = selectors.map((sel) => page.waitForSelector(sel, { timeout: timeoutMs }).catch(() => {
-        // Intentionally ignored: the page may navigate/close before selector resolves
-    }));
-    const shouldShowCountdown = process.stderr.isTTY;
+    const canPrompt = process.stdin.isTTY && process.stdout.isTTY;
+    // Non-TTY sessions rely solely on selector waits (no manual continuation).
+    if (!canPrompt && selectors.length === 0) {
+        return "skipped";
+    }
+    const waiters = selectors.map((sel) => page.waitForSelector(sel, { timeout: timeoutMs }));
+    const shouldShowCountdown = process.stderr.isTTY && waiters.length > 0;
     let interval;
+    const manualController = canPrompt ? new AbortController() : undefined;
+    const manualPromise = manualController
+        ? input({
+            message: "Press Enter after completing login in the browser...",
+            default: "",
+        }, { signal: manualController.signal })
+            .then(() => "manual")
+            .catch((error) => {
+            if (error instanceof Error &&
+                (error.name === "AbortPromptError" || error.name === "AbortError")) {
+                // Expected when we cancel the prompt after a selector wins.
+                // Returning "manual" keeps the promise resolved for the race.
+                return "manual";
+            }
+            if (error instanceof Error && error.name === "ExitPromptError") {
+                return "aborted";
+            }
+            throw error;
+        })
+        : undefined;
     if (shouldShowCountdown) {
+        const deadline = Date.now() + timeoutMs;
         interval = setInterval(() => {
             const remaining = deadline - Date.now();
             if (remaining <= 0) {
@@ -34,11 +83,33 @@ export async function waitForLogin(page, selectors) {
         }, 60_000);
     }
     try {
-        await Promise.race([manualSilenced, ...waiters]);
+        const selectorPromise = waiters.length > 0
+            ? Promise.any(waiters)
+                .then(() => "selector")
+                .catch((error) => {
+                // Promise.any only rejects once all selectors have settled.
+                const outcome = classifySelectorAggregate(error);
+                if (outcome)
+                    return outcome;
+                throw error;
+            })
+            : undefined;
+        if (selectorPromise) {
+            // Avoid unhandled rejections if the manual prompt wins the race.
+            void selectorPromise.catch(() => { });
+        }
+        const raceTargets = [];
+        if (manualPromise)
+            raceTargets.push(manualPromise);
+        if (selectorPromise)
+            raceTargets.push(selectorPromise);
+        if (raceTargets.length === 0)
+            return "skipped";
+        return await Promise.race(raceTargets);
     }
     finally {
         if (interval)
             clearInterval(interval);
-        reader.close();
+        manualController?.abort();
     }
 }

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

@@ -0,0 +1,25 @@
+type CliDependency = {
+    readonly command: string;
+    readonly envVar: string;
+    readonly installHint: string;
+};
+declare const AUTH_CLI_SERVICES: readonly ["claude", "chatgpt", "gemini"];
+type AuthCliService = (typeof AUTH_CLI_SERVICES)[number];
+export declare function getAuthCliDependency(service: AuthCliService): CliDependency;
+export declare function checkCliDependency(dep: CliDependency): {
+    ok: boolean;
+    path: string;
+};
+export declare function ensureAuthCliDependency(service: AuthCliService): {
+    ok: true;
+    path: string;
+} | {
+    ok: false;
+    dependency: CliDependency;
+    path: string;
+};
+export declare function resolveAuthCliDependencyOrReport(service: AuthCliService, options?: {
+    readonly setExitCode?: boolean;
+}): string | undefined;
+export { AUTH_CLI_SERVICES };
+export type { AuthCliService };

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

@@ -0,0 +1,81 @@
+import { execFileSync } from "node:child_process";
+import { chalk } from "./color.js";
+const CLI_DEPENDENCIES = {
+    claude: {
+        command: "claude",
+        envVar: "AXUSAGE_CLAUDE_PATH",
+        installHint: "npm install -g @anthropic-ai/claude-code",
+    },
+    codex: {
+        command: "codex",
+        envVar: "AXUSAGE_CODEX_PATH",
+        installHint: "npm install -g @openai/codex",
+    },
+    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)
+        return 5000;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return 5000;
+    return Math.round(parsed);
+}
+export function getAuthCliDependency(service) {
+    if (service === "chatgpt")
+        return CLI_DEPENDENCIES.codex;
+    return CLI_DEPENDENCIES[service];
+}
+function resolveCliDependencyPath(dep) {
+    const environmentValue = process.env[dep.envVar]?.trim();
+    // Treat empty env vars as unset to fall back to the default command.
+    if (environmentValue)
+        return environmentValue;
+    return dep.command;
+}
+export function checkCliDependency(dep) {
+    const path = resolveCliDependencyPath(dep);
+    try {
+        const timeout = resolveCliDependencyTimeout();
+        execFileSync(path, ["--version"], {
+            stdio: "ignore",
+            timeout,
+        });
+        return { ok: true, path };
+    }
+    catch {
+        return { ok: false, path };
+    }
+}
+export function ensureAuthCliDependency(service) {
+    const dependency = getAuthCliDependency(service);
+    const result = checkCliDependency(dependency);
+    if (result.ok)
+        return { ok: true, path: result.path };
+    return { ok: false, dependency, path: result.path };
+}
+export function resolveAuthCliDependencyOrReport(service, options = {}) {
+    const result = ensureAuthCliDependency(service);
+    if (!result.ok) {
+        reportMissingCliDependency(result.dependency, result.path);
+        if (options.setExitCode)
+            process.exitCode = 1;
+        return undefined;
+    }
+    return result.path;
+}
+function reportMissingCliDependency(dependency, path) {
+    console.error(chalk.red(`Error: Required dependency '${dependency.command}' not found.`));
+    console.error(chalk.gray(`Looked for: ${path}`));
+    console.error(chalk.gray("\nTo fix, either:"));
+    console.error(chalk.gray(`  1. Install it: ${dependency.installHint}`));
+    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/color.d.ts

@@ -0,0 +1,5 @@
+export { default as chalk } from "chalk";
+type ColorConfig = {
+    readonly enabled?: boolean;
+};
+export declare function configureColor(config?: ColorConfig): void;

package/dist/utils/color.js

@@ -0,0 +1,27 @@
+import chalkBase from "chalk";
+export { default as chalk } from "chalk";
+function resolveColorOverride(enabled) {
+    if (enabled === false)
+        return "disable";
+    if (enabled === true)
+        return "force";
+    if (process.env.FORCE_COLOR === "0")
+        return "disable";
+    if (process.env.NO_COLOR !== undefined && process.env.NO_COLOR !== "") {
+        return "disable";
+    }
+    return "auto";
+}
+const autoLevel = chalkBase.level;
+export function configureColor(config = {}) {
+    const mode = resolveColorOverride(config.enabled);
+    if (mode === "disable") {
+        chalkBase.level = 0;
+        return;
+    }
+    if (mode === "force") {
+        chalkBase.level = 3;
+        return;
+    }
+    chalkBase.level = autoLevel;
+}

package/dist/utils/format-service-usage.js

@@ -1,4 +1,4 @@
-import chalk from "chalk";
+import { chalk } from "./color.js";
 import { calculateUsageRate } from "./calculate-usage-rate.js";
 import { classifyUsageRate } from "./classify-usage-rate.js";
 /**

package/dist/utils/resolve-prompt-capability.d.ts

@@ -0,0 +1 @@
+export declare function resolvePromptCapability(): boolean;

package/dist/utils/resolve-prompt-capability.js

@@ -0,0 +1,3 @@
+export function resolvePromptCapability() {
+    return process.stdin.isTTY && process.stdout.isTTY;
+}

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

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

@@ -0,0 +1,18 @@
+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));
+    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.";
+    }
+    const hasExplicitFormat = formatSource === "cli";
+    const hasUsageOptions = Boolean(options.service) || hasExplicitFormat;
+    if (authSelectionCount > 0 && hasUsageOptions) {
+        return "Usage options cannot be combined with auth operations.";
+    }
+    return undefined;
+}

package/dist/utils/write-atomic-json.d.ts

@@ -0,0 +1 @@
+export declare function writeAtomicJson(filePath: string, data: unknown, mode?: number): Promise<void>;

package/dist/utils/write-atomic-json.js

@@ -0,0 +1,56 @@
+import { chmod, rename, unlink, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+function getErrorCode(error) {
+    if (error instanceof Error && "code" in error) {
+        return error.code;
+    }
+    return undefined;
+}
+export async function writeAtomicJson(filePath, data, mode) {
+    const temporaryPath = `${filePath}.${randomUUID()}.tmp`;
+    const writeOptions = mode === undefined ? "utf8" : { encoding: "utf8", mode };
+    await writeFile(temporaryPath, JSON.stringify(data), writeOptions);
+    if (mode !== undefined) {
+        await chmod(temporaryPath, mode).catch(() => {
+            // Best-effort: some filesystems ignore chmod, but the mode was set at write.
+        });
+    }
+    try {
+        await rename(temporaryPath, filePath);
+    }
+    catch (error) {
+        const code = getErrorCode(error);
+        if (code === "EPERM" || code === "EACCES" || code === "EEXIST") {
+            // Windows can reject rename over an existing file; fall back to a backup swap.
+            // Best-effort: not fully atomic and assumes a single writer. Backups are
+            // cleaned up by auth-clear when possible.
+            const backupPath = `${filePath}.${randomUUID()}.bak`;
+            let hasBackup = false;
+            try {
+                await rename(filePath, backupPath);
+                hasBackup = true;
+            }
+            catch {
+                // Best-effort: source file may not exist or be locked.
+            }
+            try {
+                await rename(temporaryPath, filePath);
+            }
+            catch (fallbackError) {
+                if (hasBackup) {
+                    await rename(backupPath, filePath).catch(() => {
+                        console.warn(`Warning: Failed to restore backup from ${backupPath}`);
+                    });
+                }
+                await unlink(temporaryPath).catch(() => { });
+                throw fallbackError;
+            }
+            if (hasBackup) {
+                await unlink(backupPath).catch(() => { });
+            }
+            return;
+        }
+        await unlink(temporaryPath).catch(() => { });
+        throw error;
+    }
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "axusage",
   "author": "Łukasz Jerciński",
   "license": "MIT",
-  "version": "2.2.0",
+  "version": "3.0.0",
   "description": "Monitor API usage across Claude, ChatGPT, GitHub Copilot, and Gemini from a single CLI",
   "repository": {
     "type": "git",
@@ -54,6 +54,7 @@
   },
   "dependencies": {
     "@commander-js/extra-typings": "^14.0.0",
+    "@inquirer/prompts": "^8.2.0",
     "axauth": "^1.11.2",
     "chalk": "^5.6.2",
     "commander": "^14.0.2",