axusage 2.1.0 → 3.0.0

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.1.0",
+  "version": "3.0.0",
   "description": "Monitor API usage across Claude, ChatGPT, GitHub Copilot, and Gemini from a single CLI",
   "repository": {
     "type": "git",
@@ -54,33 +54,29 @@
   },
   "dependencies": {
     "@commander-js/extra-typings": "^14.0.0",
-    "axauth": "^1.5.0",
+    "@inquirer/prompts": "^8.2.0",
+    "axauth": "^1.11.2",
     "chalk": "^5.6.2",
     "commander": "^14.0.2",
+    "conf": "^15.0.2",
     "env-paths": "^3.0.0",
     "playwright": "^1.57.0",
     "prom-client": "^15.1.3",
     "trash": "^10.0.1",
-    "zod": "^4.2.0"
+    "zod": "^4.3.5"
   },
   "devDependencies": {
-    "@eslint/compat": "^2.0.0",
-    "@eslint/js": "^9.39.2",
     "@total-typescript/ts-reset": "^0.6.1",
-    "@types/node": "^25.0.2",
-    "@vitest/coverage-v8": "^4.0.15",
-    "@vitest/eslint-plugin": "^1.5.2",
+    "@types/node": "^25.0.8",
+    "@vitest/coverage-v8": "^4.0.17",
     "eslint": "^9.39.2",
-    "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-unicorn": "^62.0.0",
-    "fta-check": "^1.5.0",
+    "eslint-config-axkit": "^1.0.0",
+    "fta-check": "^1.5.1",
     "fta-cli": "^3.0.0",
-    "globals": "^16.5.0",
-    "knip": "^5.73.4",
+    "knip": "^5.81.0",
     "prettier": "3.7.4",
     "semantic-release": "^25.0.2",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.49.0",
-    "vitest": "^4.0.15"
+    "vitest": "^4.0.17"
   }
 }