axusage 2.0.0

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

@@ -0,0 +1,25 @@
+import chalk from "chalk";
+import { existsSync } from "node:fs";
+import { SUPPORTED_SERVICES, validateService, } from "../services/supported-service.js";
+import { getStorageStatePathFor } from "../services/auth-storage-path.js";
+import { getBrowserContextsDirectory } from "../services/app-paths.js";
+export function authStatusCommand(options) {
+    const servicesToCheck = options.service
+        ? [validateService(options.service)]
+        : SUPPORTED_SERVICES;
+    const dataDirectory = getBrowserContextsDirectory();
+    console.log(chalk.blue("\nAuthentication Status:\n"));
+    for (const service of servicesToCheck) {
+        const storagePath = getStorageStatePathFor(dataDirectory, service);
+        const hasAuth = existsSync(storagePath);
+        const status = hasAuth
+            ? chalk.green("✓ Authenticated")
+            : chalk.gray("✗ Not authenticated");
+        console.log(`${chalk.bold(service)}: ${status}`);
+        console.log(`  ${chalk.dim("Storage:")} ${chalk.dim(storagePath)}`);
+    }
+    const allAuthenticated = servicesToCheck.every((s) => existsSync(getStorageStatePathFor(dataDirectory, s)));
+    if (!allAuthenticated) {
+        console.error(chalk.gray(`\nTo set up authentication, run: ${chalk.cyan("axusage auth setup <service>")}`));
+    }
+}

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

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

@@ -0,0 +1,45 @@
+import chalk from "chalk";
+import { fetchServiceUsage } from "./fetch-service-usage.js";
+import { isAuthFailure, runAuthSetup } from "./run-auth-setup.js";
+import { validateService } from "../services/supported-service.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}. Opening browser 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/commands/fetch-service-usage.d.ts

@@ -0,0 +1,8 @@
+import type { ApiError, Result, ServiceUsageData } from "../types/domain.js";
+export type UsageCommandOptions = {
+    readonly service?: string;
+    readonly format?: "text" | "tsv" | "json" | "prometheus";
+    readonly interactive?: boolean;
+};
+export declare function selectServicesToQuery(service?: string): string[];
+export declare function fetchServiceUsage(serviceName: string): Promise<Result<ServiceUsageData, ApiError>>;

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

@@ -0,0 +1,19 @@
+import { ApiError as ApiErrorClass } from "../types/domain.js";
+import { getServiceAdapter } from "../services/service-adapter-registry.js";
+const ALL_SERVICES = ["claude", "chatgpt", "github-copilot", "gemini"];
+export function selectServicesToQuery(service) {
+    const normalized = service?.toLowerCase();
+    if (!service || normalized === "all")
+        return [...ALL_SERVICES];
+    return [service];
+}
+export async function fetchServiceUsage(serviceName) {
+    const adapter = getServiceAdapter(serviceName);
+    if (!adapter) {
+        return {
+            ok: false,
+            error: new ApiErrorClass(`Unknown service "${serviceName}"`),
+        };
+    }
+    return await adapter.fetchUsage();
+}

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

@@ -0,0 +1,29 @@
+import type { SupportedService } from "../services/supported-service.js";
+import type { ApiError, Result, ServiceUsageData } from "../types/domain.js";
+/**
+ * Check if an error message indicates an authentication issue.
+ * Matches common authentication error patterns like "unauthorized", "401",
+ * "authentication failed", etc. with word boundaries to avoid false positives.
+ *
+ * @param message - The error message to check
+ * @returns true if the message indicates an authentication error
+ *
+ * @example
+ * isAuthError("401 Unauthorized") // true
+ * isAuthError("Network timeout") // false
+ */
+export declare function isAuthError(message: string): boolean;
+/**
+ * Check if a fetch result indicates an authentication failure.
+ * Combines the result error check with auth error pattern matching.
+ */
+export declare function isAuthFailure(result: Result<ServiceUsageData, ApiError>): boolean;
+/**
+ * Run auth setup for a service programmatically.
+ * Returns true if auth setup completed successfully.
+ * Times out after 5 minutes to prevent indefinite hangs.
+ *
+ * Note: Gemini uses CLI-based auth and cannot use browser-based re-auth.
+ * This function prints instructions and returns false for Gemini.
+ */
+export declare function runAuthSetup(service: SupportedService): Promise<boolean>;

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

@@ -0,0 +1,91 @@
+import chalk from "chalk";
+import { BrowserAuthManager } from "../services/browser-auth-manager.js";
+/** Timeout for authentication setup (5 minutes) */
+const AUTH_SETUP_TIMEOUT_MS = 300_000;
+/**
+ * Check if an error message indicates an authentication issue.
+ * Matches common authentication error patterns like "unauthorized", "401",
+ * "authentication failed", etc. with word boundaries to avoid false positives.
+ *
+ * @param message - The error message to check
+ * @returns true if the message indicates an authentication error
+ *
+ * @example
+ * isAuthError("401 Unauthorized") // true
+ * isAuthError("Network timeout") // false
+ */
+export function isAuthError(message) {
+    const authPatterns = [
+        /\bauthentication\s+failed\b/iu,
+        /\bno\s+saved\s+authentication\b/iu,
+        /\b401\b/u,
+        /\bunauthorized\b/iu,
+        /\bsession\s+expired\b/iu,
+        /\blogin\s+required\b/iu,
+        /\bcredentials?\s+(expired|invalid)\b/iu,
+    ];
+    return authPatterns.some((pattern) => pattern.test(message));
+}
+/**
+ * Check if a fetch result indicates an authentication failure.
+ * Combines the result error check with auth error pattern matching.
+ */
+export function isAuthFailure(result) {
+    return (!result.ok &&
+        Boolean(result.error.message) &&
+        isAuthError(result.error.message));
+}
+/**
+ * Run auth setup for a service programmatically.
+ * Returns true if auth setup completed successfully.
+ * Times out after 5 minutes to prevent indefinite hangs.
+ *
+ * Note: Gemini uses CLI-based auth and cannot use browser-based re-auth.
+ * This function prints instructions and returns false for Gemini.
+ */
+export async function runAuthSetup(service) {
+    // CLI-based auth cannot use browser auth flow
+    if (service === "gemini") {
+        console.error(chalk.yellow("\nGemini uses CLI-based authentication managed by the Gemini CLI."));
+        console.error(chalk.gray("\nTo re-authenticate, run:"));
+        console.error(chalk.cyan("  gemini"));
+        console.error(chalk.gray("\nThe Gemini CLI will guide you through the OAuth login process.\n"));
+        return false;
+    }
+    if (service === "claude") {
+        console.error(chalk.yellow("\nClaude uses CLI-based authentication managed by Claude Code."));
+        console.error(chalk.gray("\nTo re-authenticate, run:"));
+        console.error(chalk.cyan("  claude"));
+        console.error(chalk.gray("\nClaude Code will guide you through authentication.\n"));
+        return false;
+    }
+    if (service === "chatgpt") {
+        console.error(chalk.yellow("\nChatGPT uses CLI-based authentication managed by Codex."));
+        console.error(chalk.gray("\nTo re-authenticate, run:"));
+        console.error(chalk.cyan("  codex"));
+        console.error(chalk.gray("\nCodex will guide you through authentication.\n"));
+        return false;
+    }
+    const manager = new BrowserAuthManager({ headless: false });
+    let timeoutId;
+    try {
+        console.error(chalk.blue(`\nOpening browser for ${service} authentication...\n`));
+        const setupPromise = manager.setupAuth(service);
+        const timeoutPromise = new Promise((_, reject) => {
+            timeoutId = setTimeout(() => {
+                reject(new Error("Authentication setup timed out after 5 minutes"));
+            }, AUTH_SETUP_TIMEOUT_MS);
+        });
+        await Promise.race([setupPromise, timeoutPromise]);
+        console.error(chalk.green(`\n✓ Authentication for ${service} is complete!\n`));
+        return true;
+    }
+    catch (error) {
+        console.error(chalk.red(`\n✗ Failed to set up authentication: ${error instanceof Error ? error.message : String(error)}`));
+        return false;
+    }
+    finally {
+        clearTimeout(timeoutId);
+        await manager.close();
+    }
+}

package/dist/commands/usage-command.d.ts

@@ -0,0 +1,15 @@
+import type { ServiceResult } from "../types/domain.js";
+import type { UsageCommandOptions } from "./fetch-service-usage.js";
+/**
+ * Fetches usage for services using hybrid strategy:
+ * 1. Try all services in parallel first (fast path for valid credentials)
+ * 2. If any service fails with auth error, retry those sequentially with re-auth
+ *
+ * This maintains ~2s response time when credentials are valid while gracefully
+ * handling authentication failures that require interactive prompts.
+ */
+export declare function fetchServicesWithHybridStrategy(servicesToQuery: string[], interactive: boolean): Promise<ServiceResult[]>;
+/**
+ * Executes the usage command
+ */
+export declare function usageCommand(options: UsageCommandOptions): Promise<void>;

package/dist/commands/usage-command.js

@@ -0,0 +1,146 @@
+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";
+/**
+ * Fetches usage for services using hybrid strategy:
+ * 1. Try all services in parallel first (fast path for valid credentials)
+ * 2. If any service fails with auth error, retry those sequentially with re-auth
+ *
+ * This maintains ~2s response time when credentials are valid while gracefully
+ * handling authentication failures that require interactive prompts.
+ */
+export async function fetchServicesWithHybridStrategy(servicesToQuery, interactive) {
+    // First attempt: fetch all services in parallel
+    const parallelResults = await Promise.all(servicesToQuery.map(async (serviceName) => {
+        const result = await fetchServiceUsage(serviceName);
+        return { service: serviceName, result };
+    }));
+    // Check for auth errors
+    const authFailures = parallelResults.filter(({ result }) => isAuthFailure(result));
+    // If no auth failures, return parallel results
+    if (authFailures.length === 0 || !interactive) {
+        return parallelResults;
+    }
+    const shouldShowProgress = process.stderr.isTTY;
+    // Retry auth failures sequentially with re-authentication
+    const retryResults = [];
+    for (const [index, { service }] of authFailures.entries()) {
+        if (shouldShowProgress) {
+            console.error(chalk.dim(`[${String(index + 1)}/${String(authFailures.length)}] Re-authenticating ${service}...`));
+        }
+        const result = await fetchServiceUsageWithAutoReauth(service, interactive);
+        retryResults.push(result);
+    }
+    if (shouldShowProgress) {
+        console.error(chalk.green(`✓ Completed ${String(retryResults.length)} re-authentication${retryResults.length === 1 ? "" : "s"}\n`));
+    }
+    // Merge results: keep successful parallel results, replace auth failures with retries
+    // Build a map for O(1) lookups instead of O(n²) find() calls
+    const retryMap = new Map(retryResults.map((r) => [r.service, r]));
+    return parallelResults.map((parallelResult) => retryMap.get(parallelResult.service) ?? parallelResult);
+}
+/**
+ * Executes the usage command
+ */
+export async function usageCommand(options) {
+    const servicesToQuery = selectServicesToQuery(options.service);
+    const interactive = options.interactive ?? false;
+    // Fetch usage data using hybrid parallel/sequential strategy
+    const results = await fetchServicesWithHybridStrategy(servicesToQuery, interactive);
+    // Collect successful results and errors
+    const successes = [];
+    const errors = [];
+    const authFailureServices = new Set();
+    for (const { service, result } of results) {
+        if (result.ok) {
+            successes.push(result.value);
+        }
+        else {
+            errors.push({ service, error: result.error });
+            if (isAuthFailure(result))
+                authFailureServices.add(service);
+        }
+    }
+    // Display errors if any (but don't exit if we have at least one success)
+    if (errors.length > 0) {
+        for (const { service, error } of errors) {
+            console.error(chalk.yellow(`⚠ Warning: Failed to fetch ${service} usage:`));
+            console.error(chalk.gray(`  ${error.message}`));
+            if (error.status) {
+                console.error(chalk.gray(`  Status: ${String(error.status)}`));
+            }
+        }
+        if (successes.length > 0) {
+            console.error(); // Empty line for spacing
+        }
+    }
+    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.`));
+        if (successes.length > 0) {
+            console.error();
+        }
+    }
+    // Exit if no services succeeded
+    if (successes.length === 0) {
+        console.error(chalk.red("\nNo services could be queried successfully."));
+        process.exitCode = 1;
+        return;
+    }
+    // Display results
+    const hasPartialFailures = errors.length > 0;
+    const format = options.format ?? "text";
+    switch (format) {
+        case "tsv": {
+            console.log(formatServiceUsageAsTsv(successes));
+            break;
+        }
+        case "json": {
+            const [singleSuccess] = successes;
+            if (successes.length === 1 && !hasPartialFailures && singleSuccess) {
+                console.log(formatServiceUsageDataAsJson(singleSuccess));
+            }
+            else {
+                const payload = successes.length === 1 && singleSuccess
+                    ? toJsonObject(singleSuccess)
+                    : successes.map((data) => toJsonObject(data));
+                const output = hasPartialFailures
+                    ? {
+                        results: payload,
+                        errors: errors.map(({ service, error }) => ({
+                            service,
+                            message: error.message,
+                            status: error.status,
+                        })),
+                    }
+                    : payload;
+                // eslint-disable-next-line unicorn/no-null -- JSON.stringify requires null for no replacer
+                console.log(JSON.stringify(output, null, 2));
+            }
+            break;
+        }
+        case "prometheus": {
+            // Emit Prometheus text metrics using prom-client
+            const output = await formatPrometheusMetrics(successes);
+            process.stdout.write(output);
+            break;
+        }
+        case "text": {
+            // For human-readable output, display each service's results
+            for (const data of successes) {
+                const index = successes.indexOf(data);
+                if (index > 0) {
+                    console.log(); // Add spacing between services
+                }
+                console.log(formatServiceUsageData(data));
+            }
+            break;
+        }
+    }
+    if (hasPartialFailures) {
+        process.exitCode = 2;
+    }
+}

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

@@ -0,0 +1,9 @@
+/**
+ * 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

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

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

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

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

package/dist/services/auth-timeouts.js

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

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

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

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

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