axusage 3.0.0 → 3.2.0

package/dist/commands/fetch-service-usage-with-reauth.d.ts

@@ -1,7 +0,0 @@
-import type { ServiceResult } from "../types/domain.js";
-/**
- * Fetch usage for a service, with automatic re-authentication on auth errors.
- * Prompts the user to re-authenticate if the initial fetch fails with an auth error,
- * then retries the fetch. Returns the original result if re-authentication fails.
- */
-export declare function fetchServiceUsageWithAutoReauth(serviceName: string, interactive: boolean): Promise<ServiceResult>;

package/dist/commands/fetch-service-usage-with-reauth.js

@@ -1,45 +0,0 @@
-import { fetchServiceUsage } from "./fetch-service-usage.js";
-import { isAuthFailure, runAuthSetup } from "./run-auth-setup.js";
-import { validateService } from "../services/supported-service.js";
-import { chalk } from "../utils/color.js";
-/**
- * Fetch usage for a service, with automatic re-authentication on auth errors.
- * Prompts the user to re-authenticate if the initial fetch fails with an auth error,
- * then retries the fetch. Returns the original result if re-authentication fails.
- */
-export async function fetchServiceUsageWithAutoReauth(serviceName, interactive) {
-    const result = await fetchServiceUsage(serviceName);
-    if (!interactive) {
-        return { service: serviceName, result };
-    }
-    // If auth error, try to re-authenticate and retry
-    if (isAuthFailure(result)) {
-        console.error(chalk.yellow(`⚠ Authentication failed for ${serviceName}. Attempting to re-authenticate...`));
-        try {
-            const service = validateService(serviceName);
-            const authSuccess = await runAuthSetup(service);
-            if (authSuccess) {
-                if (process.stderr.isTTY) {
-                    console.error(chalk.blue(`Retrying ${serviceName} usage fetch...\n`));
-                }
-                const retryResult = await fetchServiceUsage(serviceName);
-                return { service: serviceName, result: retryResult };
-            }
-            else {
-                console.error(chalk.red(`Re-authentication failed for ${serviceName}.`));
-            }
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            // Distinguish validation errors from auth setup errors
-            const isValidationError = errorMessage.includes("Unsupported service") ||
-                errorMessage.includes("Service is required");
-            const prefix = isValidationError
-                ? "Invalid service"
-                : "Failed to re-authenticate";
-            console.error(chalk.red(`${prefix}: ${errorMessage}`));
-        }
-    }
-    // Return original result if re-authentication failed or was not attempted
-    return { service: serviceName, result };
-}

package/dist/services/app-paths.d.ts

@@ -1,9 +0,0 @@
-/**
- * Directory for storing browser authentication contexts
- */
-export declare function getBrowserContextsDirectory(): string;
-/**
- * Ensure a directory exists with restricted permissions (owner-only access).
- * Creates the directory recursively if needed and sets mode 0o700.
- */
-export declare function ensureSecureDirectory(directoryPath: string): Promise<void>;

package/dist/services/app-paths.js

@@ -1,39 +0,0 @@
-import envPaths from "env-paths";
-import path from "node:path";
-import { mkdir, chmod } from "node:fs/promises";
-/**
- * env-paths resolves directories during module initialization, so changes to
- * environment variables (like XDG_DATA_HOME) after the first import will not
- * be picked up without restarting the process.
- */
-const paths = envPaths("axusage", { suffix: "" });
-/**
- * Directory for storing browser authentication contexts
- */
-export function getBrowserContextsDirectory() {
-    return path.join(paths.data, "browser-contexts");
-}
-/**
- * Ensure a directory exists with restricted permissions (owner-only access).
- * Creates the directory recursively if needed and sets mode 0o700.
- */
-export async function ensureSecureDirectory(directoryPath) {
-    try {
-        await mkdir(directoryPath, { recursive: true, mode: 0o700 });
-    }
-    catch (error) {
-        // Only ignore EEXIST; re-throw everything else
-        // mkdir may ignore mode due to umask; we'll enforce via chmod below
-        const isEexist = error instanceof Error && "code" in error && error.code === "EEXIST";
-        if (!isEexist) {
-            throw error;
-        }
-    }
-    try {
-        await chmod(directoryPath, 0o700);
-    }
-    catch {
-        // Best effort: some filesystems (network mounts, containers) may not
-        // support chmod or have different permission models
-    }
-}

package/dist/services/auth-storage-path.d.ts

@@ -1,3 +0,0 @@
-import type { SupportedService } from "./supported-service.js";
-export declare function getStorageStatePathFor(dataDirectory: string, service: SupportedService): string;
-export declare function getAuthMetaPathFor(dataDirectory: string, service: SupportedService): string;

package/dist/services/auth-storage-path.js

@@ -1,7 +0,0 @@
-import path from "node:path";
-export function getStorageStatePathFor(dataDirectory, service) {
-    return path.join(dataDirectory, `${service}-auth.json`);
-}
-export function getAuthMetaPathFor(dataDirectory, service) {
-    return path.join(dataDirectory, `${service}-auth.meta.json`);
-}

package/dist/services/auth-timeouts.d.ts

@@ -1,4 +0,0 @@
-/**
- * Shared authentication-related timeouts.
- */
-export declare const LOGIN_TIMEOUT_MS = 300000;

package/dist/services/auth-timeouts.js

@@ -1,4 +0,0 @@
-/**
- * Shared authentication-related timeouts.
- */
-export const LOGIN_TIMEOUT_MS = 300_000; // 5 minutes

package/dist/services/browser-auth-manager.d.ts

@@ -1,49 +0,0 @@
-import type { BrowserContext } from "playwright";
-import type { SupportedService } from "./supported-service.js";
-/**
- * Configuration for browser authentication manager
- */
-type BrowserAuthConfig = {
-    readonly dataDir?: string;
-    readonly headless?: boolean;
-};
-/**
- * Manages browser contexts for persistent authentication across services
- */
-export declare class BrowserAuthManager {
-    private readonly dataDir;
-    private readonly headless;
-    private browser;
-    private browserPromise;
-    constructor(config?: BrowserAuthConfig);
-    /**
-     * Get the storage state file path for a service
-     */
-    private getStorageStatePath;
-    /**
-     * Check if a service has saved authentication
-     */
-    hasAuth(service: SupportedService): boolean;
-    /**
-     * Ensure a Chromium browser instance is available
-     */
-    private ensureBrowser;
-    private launchAndStoreBrowser;
-    /**
-     * Set up authentication for a service by launching a browser for the user to log in
-     */
-    setupAuth(service: SupportedService): Promise<void>;
-    /**
-     * Get a browser context with saved authentication for a service
-     */
-    getAuthContext(service: SupportedService): Promise<BrowserContext>;
-    /**
-     * Make an authenticated request to a URL using the browser context
-     */
-    makeAuthenticatedRequest(service: SupportedService, url: string): Promise<string>;
-    /**
-     * Close the browser and clean up resources
-     */
-    close(): Promise<void>;
-}
-export {};

package/dist/services/browser-auth-manager.js

@@ -1,113 +0,0 @@
-import { existsSync } from "node:fs";
-import { getServiceAuthConfig } from "./service-auth-configs.js";
-import { launchChromium } from "./launch-chromium.js";
-import { requestService } from "./request-service.js";
-import { doSetupAuth } from "./do-setup-auth.js";
-import { getStorageStatePathFor } from "./auth-storage-path.js";
-import { createAuthContext, loadStoredUserAgent, } from "./create-auth-context.js";
-import { getBrowserContextsDirectory, ensureSecureDirectory, } from "./app-paths.js";
-import { persistStorageState } from "./persist-storage-state.js";
-/**
- * Manages browser contexts for persistent authentication across services
- */
-export class BrowserAuthManager {
-    dataDir;
-    headless;
-    browser = undefined;
-    browserPromise = undefined;
-    constructor(config = {}) {
-        this.dataDir = config.dataDir || getBrowserContextsDirectory();
-        // Default to headless for non-interactive usage flows; auth setup passes headless: false
-        this.headless = config.headless ?? true;
-    }
-    /**
-     * Get the storage state file path for a service
-     */
-    getStorageStatePath(service) {
-        return getStorageStatePathFor(this.dataDir, service);
-    }
-    /**
-     * Check if a service has saved authentication
-     */
-    hasAuth(service) {
-        return existsSync(this.getStorageStatePath(service));
-    }
-    /**
-     * Ensure a Chromium browser instance is available
-     */
-    async ensureBrowser() {
-        if (!this.browserPromise) {
-            this.browserPromise = this.launchAndStoreBrowser();
-        }
-        return this.browserPromise;
-    }
-    async launchAndStoreBrowser() {
-        try {
-            const browser = await launchChromium(this.headless);
-            this.browser = browser;
-            return browser;
-        }
-        catch (error) {
-            // Allow retries on subsequent calls if the launch fails
-            this.browserPromise = undefined;
-            throw error;
-        }
-    }
-    /**
-     * Set up authentication for a service by launching a browser for the user to log in
-     */
-    async setupAuth(service) {
-        const config = getServiceAuthConfig(service);
-        await ensureSecureDirectory(this.dataDir);
-        const browser = await this.ensureBrowser();
-        const storagePath = this.getStorageStatePath(service);
-        // Load existing storage state if available - this gives the browser a chance
-        // to refresh expired cookies/tokens during the login flow
-        const storageState = existsSync(storagePath) ? storagePath : undefined;
-        const userAgent = await loadStoredUserAgent(this.dataDir, service);
-        let context;
-        try {
-            context = await browser.newContext({ storageState, userAgent });
-        }
-        catch {
-            // Corrupted storage state - fall back to fresh context
-            context = await browser.newContext({ userAgent });
-        }
-        try {
-            await doSetupAuth(service, context, this.getStorageStatePath(service), config.instructions);
-        }
-        finally {
-            await context.close();
-        }
-    }
-    /**
-     * Get a browser context with saved authentication for a service
-     */
-    async getAuthContext(service) {
-        const browser = await this.ensureBrowser();
-        return createAuthContext(browser, this.dataDir, service);
-    }
-    /**
-     * Make an authenticated request to a URL using the browser context
-     */
-    async makeAuthenticatedRequest(service, url) {
-        const context = await this.getAuthContext(service);
-        try {
-            return await requestService(service, url, () => Promise.resolve(context));
-        }
-        finally {
-            await persistStorageState(context, this.getStorageStatePath(service));
-            await context.close();
-        }
-    }
-    /**
-     * Close the browser and clean up resources
-     */
-    async close() {
-        if (this.browser) {
-            await this.browser.close();
-            this.browser = undefined;
-            this.browserPromise = undefined;
-        }
-    }
-}

package/dist/services/create-auth-context.d.ts

@@ -1,8 +0,0 @@
-import type { Browser, BrowserContext } from "playwright";
-import type { SupportedService } from "./supported-service.js";
-/**
- * Load the stored userAgent from the auth meta file for a service.
- * Returns undefined if meta file doesn't exist or is invalid.
- */
-export declare function loadStoredUserAgent(dataDirectory: string, service: SupportedService): Promise<string | undefined>;
-export declare function createAuthContext(browser: Browser, dataDirectory: string, service: SupportedService): Promise<BrowserContext>;

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

@@ -1,35 +0,0 @@
-import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { getAuthMetaPathFor, getStorageStatePathFor, } from "./auth-storage-path.js";
-/**
- * Load the stored userAgent from the auth meta file for a service.
- * Returns undefined if meta file doesn't exist or is invalid.
- */
-export async function loadStoredUserAgent(dataDirectory, service) {
-    try {
-        const metaPath = getAuthMetaPathFor(dataDirectory, service);
-        const metaRaw = await readFile(metaPath, "utf8");
-        const meta = JSON.parse(metaRaw);
-        // Validate the parsed structure at runtime
-        if (meta &&
-            typeof meta === "object" &&
-            "userAgent" in meta &&
-            typeof meta.userAgent === "string") {
-            return meta.userAgent;
-        }
-        return undefined;
-    }
-    catch {
-        // Meta file missing, unreadable, or contains invalid JSON
-        return undefined;
-    }
-}
-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} --interactive' first.`);
-    }
-    const userAgent = await loadStoredUserAgent(dataDirectory, service);
-    return browser.newContext({ storageState: storageStatePath, userAgent });
-}

package/dist/services/do-setup-auth.d.ts

@@ -1,3 +0,0 @@
-import type { BrowserContext } from "playwright";
-import type { SupportedService } from "./supported-service.js";
-export declare function doSetupAuth(service: SupportedService, context: BrowserContext, storagePath: string, instructions: string): Promise<void>;

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

@@ -1,19 +0,0 @@
-import { setupAuthInContext } from "./setup-auth-flow.js";
-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");
-    const userAgent = await setupAuthInContext(service, context, storagePath);
-    try {
-        if (userAgent) {
-            const metaPath = getAuthMetaPathFor(path.dirname(storagePath), service);
-            await writeAtomicJson(metaPath, { userAgent }, 0o600);
-        }
-    }
-    catch {
-        // ignore errors when writing meta; not critical
-    }
-    console.error(`\n✓ Authentication saved for ${service}. You can now close the browser.`);
-}

package/dist/services/fetch-json-with-context.d.ts

@@ -1,5 +0,0 @@
-import type { BrowserContext } from "playwright";
-/**
- * Fetch JSON using the page's fetch API so cookies/session are included without navigation.
- */
-export declare function fetchJsonWithContext(context: BrowserContext, url: string): Promise<string>;

package/dist/services/fetch-json-with-context.js

@@ -1,37 +0,0 @@
-/**
- * Fetch JSON using the page's fetch API so cookies/session are included without navigation.
- */
-export async function fetchJsonWithContext(context, url) {
-    const page = await context.newPage();
-    try {
-        const origin = new URL(url).origin;
-        await page.goto(origin + "/", { waitUntil: "domcontentloaded" });
-        const result = await page.evaluate(async (targetUrl) => {
-            const response = await fetch(targetUrl, {
-                credentials: "include",
-                headers: {
-                    Accept: "application/json, text/plain, */*",
-                    "X-Requested-With": "XMLHttpRequest",
-                },
-            });
-            const text = await response.text();
-            return {
-                ok: response.ok,
-                status: response.status,
-                statusText: response.statusText,
-                contentType: response.headers.get("content-type") || "",
-                text,
-            };
-        }, url);
-        if (!result.ok) {
-            throw new Error(`Request failed: ${String(result.status)} ${result.statusText}`);
-        }
-        if (!result.contentType.toLowerCase().startsWith("application/json")) {
-            throw new Error(`Expected JSON response, got ${result.contentType}`);
-        }
-        return result.text;
-    }
-    finally {
-        await page.close();
-    }
-}

package/dist/services/launch-chromium.d.ts

@@ -1,6 +0,0 @@
-import type { Browser } from "playwright";
-/**
- * Launch Chromium with automation indicators disabled to reduce Cloudflare bot detection
- * during the authentication flow.
- */
-export declare function launchChromium(headless: boolean): Promise<Browser>;

package/dist/services/launch-chromium.js

@@ -1,20 +0,0 @@
-import { chromium } from "playwright";
-/**
- * Launch Chromium with automation indicators disabled to reduce Cloudflare bot detection
- * during the authentication flow.
- */
-export async function launchChromium(headless) {
-    try {
-        return await chromium.launch({
-            headless,
-            args: ["--disable-blink-features=AutomationControlled"],
-        });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        if (/Executable doesn't exist|playwright\s+install/iu.test(message)) {
-            throw new Error("Playwright browsers are not installed. This is usually handled automatically by the postinstall script in package.json. Please try reinstalling the package or check if the postinstall script ran successfully. If the problem persists, you can manually run `pnpm exec playwright install chromium` or `npx playwright install chromium`, then retry.");
-        }
-        throw error;
-    }
-}

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

@@ -1,6 +0,0 @@
-import type { BrowserContext } from "playwright";
-/**
- * Persist context storage state to disk with secure permissions (0o600).
- * 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 +0,0 @@
-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 logged as warnings to avoid blocking the main operation.
- */
-export async function persistStorageState(context, storagePath) {
-    try {
-        const state = await context.storageState();
-        await writeAtomicJson(storagePath, state, 0o600);
-    }
-    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/request-service.d.ts

@@ -1,3 +0,0 @@
-import type { BrowserContext } from "playwright";
-import type { SupportedService } from "./supported-service.js";
-export declare function requestService(service: SupportedService, url: string, getContext: () => Promise<BrowserContext>): Promise<string>;

package/dist/services/request-service.js

@@ -1,4 +0,0 @@
-import { fetchJsonWithContext } from "./fetch-json-with-context.js";
-export async function requestService(service, url, getContext) {
-    return await fetchJsonWithContext(await getContext(), url);
-}

package/dist/services/service-auth-configs.d.ts

@@ -1,15 +0,0 @@
-import type { SupportedService } from "./supported-service.js";
-import type { BrowserContext } from "playwright";
-/**
- * Service-specific configuration for authentication
- */
-type ServiceAuthConfig = {
-    readonly url: string;
-    readonly waitForSelector?: string;
-    readonly waitForSelectors?: readonly string[];
-    readonly verifyUrl?: string;
-    readonly verifyFunction?: (context: BrowserContext, url: string) => Promise<boolean>;
-    readonly instructions: string;
-};
-export declare function getServiceAuthConfig(service: SupportedService): ServiceAuthConfig;
-export {};

package/dist/services/service-auth-configs.js

@@ -1,26 +0,0 @@
-const SERVICE_AUTH_CONFIGS = {
-    // Claude uses CLI-based auth via Claude Code credentials
-    claude: {
-        url: "",
-        instructions: "Claude uses Claude Code authentication. Run 'claude' in your terminal to authenticate.",
-    },
-    // ChatGPT uses CLI-based auth via Codex credentials
-    chatgpt: {
-        url: "",
-        instructions: "ChatGPT uses Codex CLI authentication. Run 'codex' in your terminal to authenticate.",
-    },
-    "github-copilot": {
-        url: "https://github.com/login",
-        waitForSelector: 'img[alt*="@"]',
-        verifyUrl: "https://github.com/github-copilot/chat/entitlement",
-        instructions: "Please log in to your GitHub account in the browser window.",
-    },
-    // Gemini uses CLI-based auth, not browser auth. This entry exists only to satisfy the Record type.
-    gemini: {
-        url: "",
-        instructions: "Gemini uses CLI-based authentication. Run 'gemini' in your terminal.",
-    },
-};
-export function getServiceAuthConfig(service) {
-    return SERVICE_AUTH_CONFIGS[service];
-}

package/dist/services/setup-auth-flow.d.ts

@@ -1,3 +0,0 @@
-import type { BrowserContext } from "playwright";
-import type { SupportedService } from "./supported-service.js";
-export declare function setupAuthInContext(service: SupportedService, context: BrowserContext, storagePath: string): Promise<string | undefined>;

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

@@ -1,67 +0,0 @@
-import { getServiceAuthConfig } from "./service-auth-configs.js";
-import { waitForLogin } from "./wait-for-login.js";
-import { verifySessionByFetching } from "./verify-session.js";
-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 {
-        const config = getServiceAuthConfig(service);
-        await page.goto(config.url);
-        const selectors = config.waitForSelectors ??
-            (config.waitForSelector ? [config.waitForSelector] : []);
-        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) {
-                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);
-        const state = await context.storageState();
-        await writeAtomicJson(storagePath, state, 0o600);
-        return userAgent;
-    }
-    finally {
-        await page.close();
-    }
-}
-async function waitForLoginForService(page, selectors) {
-    if (selectors.length > 0) {
-        return waitForLogin(page, selectors);
-    }
-    // When no selectors are configured, skip waiting and rely on verification if available.
-    return "skipped";
-}

package/dist/services/shared-browser-auth-manager.d.ts

@@ -1,4 +0,0 @@
-import { BrowserAuthManager } from "./browser-auth-manager.js";
-export declare function acquireAuthManager(): BrowserAuthManager;
-export declare function releaseAuthManager(): Promise<void>;
-export declare function installAuthManagerCleanup(): void;