axusage 3.1.0 → 3.3.0

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;

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

@@ -1,87 +0,0 @@
-import { BrowserAuthManager } from "./browser-auth-manager.js";
-let manager;
-let references = 0;
-let cleanupInstalled = false;
-let closing = false;
-let exitInitiated = false;
-export function acquireAuthManager() {
-    if (!manager)
-        manager = new BrowserAuthManager();
-    references++;
-    return manager;
-}
-export async function releaseAuthManager() {
-    if (references <= 0) {
-        // Over-release guard: ignore unmatched release
-        if (references === 0) {
-            console.warn("releaseAuthManager() called without a matching acquire; ignoring");
-        }
-        // Avoid closing the manager in an over-release state
-        return;
-    }
-    references -= 1;
-    if (references === 0 && manager) {
-        const closingManager = manager;
-        manager = undefined;
-        try {
-            await closingManager.close();
-        }
-        catch (error) {
-            // Best-effort cleanup: log but don't propagate (prevents masking prior errors in finally blocks)
-            console.warn("Failed to close browser auth manager:", error instanceof Error ? error.message : String(error));
-        }
-    }
-}
-async function forceClose() {
-    if (closing)
-        return;
-    closing = true;
-    references = 0;
-    if (manager) {
-        const closingManager = manager;
-        manager = undefined;
-        try {
-            await closingManager.close();
-        }
-        catch (error) {
-            // Best-effort cleanup: log but don't propagate during shutdown
-            console.warn("Failed to close browser auth manager during shutdown:", error instanceof Error ? error.message : String(error));
-        }
-    }
-}
-export function installAuthManagerCleanup() {
-    if (cleanupInstalled)
-        return;
-    cleanupInstalled = true;
-    /* eslint-disable unicorn/no-process-exit */
-    const safeExit = (code) => {
-        if (exitInitiated)
-            return;
-        exitInitiated = true;
-        process.exit(code);
-    };
-    /* eslint-enable unicorn/no-process-exit */
-    process.on("SIGINT", () => {
-        // Ensure browser is actually closed before exiting
-        void forceClose().finally(() => {
-            safeExit(130);
-        });
-    });
-    process.on("SIGTERM", () => {
-        // Ensure browser is actually closed before exiting
-        void forceClose().finally(() => {
-            safeExit(143);
-        });
-    });
-    process.on("beforeExit", () => {
-        // Best-effort cleanup on natural process exit; ensure we schedule a macrotask
-        // so the event loop stays alive until the async close finishes.
-        if (process.exitCode === undefined)
-            process.exitCode = 0;
-        setImmediate(() => {
-            void forceClose().finally(() => {
-                safeExit(Number(process.exitCode ?? 0));
-            });
-        });
-    });
-}

package/dist/services/verify-session.d.ts

@@ -1,2 +0,0 @@
-import type { BrowserContext } from "playwright";
-export declare function verifySessionByFetching(context: BrowserContext, url: string, maxAttempts?: number, delayMs?: number): Promise<boolean>;

package/dist/services/verify-session.js

@@ -1,27 +0,0 @@
-import { fetchJsonWithContext } from "./fetch-json-with-context.js";
-/**
- * Tries to fetch the given URL within the authenticated context.
- * Returns true if the request succeeds, false if it keeps failing.
- */
-const DEFAULT_MAX_ATTEMPTS = 5;
-const DEFAULT_RETRY_DELAY_MS = 1500;
-export async function verifySessionByFetching(context, url, maxAttempts = DEFAULT_MAX_ATTEMPTS, delayMs = DEFAULT_RETRY_DELAY_MS) {
-    // Try up to `maxAttempts` times; some providers need a brief
-    // delay for session cookies/tokens to settle after login.
-    for (let attempt = 0; attempt < maxAttempts; attempt++) {
-        try {
-            await fetchJsonWithContext(context, url);
-            return true;
-        }
-        catch {
-            // Wait a bit and try again; tokens/cookies may not be settled yet
-            // Skip the delay after the final attempt to avoid unnecessary wait
-            if (attempt < maxAttempts - 1) {
-                await new Promise((resolve) => {
-                    setTimeout(resolve, delayMs);
-                });
-            }
-        }
-    }
-    return false;
-}

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

@@ -1,6 +0,0 @@
-import { type Page } from "playwright";
-/**
- * Waits until one of the selectors appears on the page, or the user presses Enter to continue.
- */
-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,115 +0,0 @@
-import { errors } from "playwright";
-import { LOGIN_TIMEOUT_MS } from "./auth-timeouts.js";
-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 timeoutMs = LOGIN_TIMEOUT_MS;
-    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) {
-                // Stop logging once timeout elapses to avoid confusing "0 minute(s)" spam
-                if (interval)
-                    clearInterval(interval);
-                console.error("Login wait timed out; finishing up...");
-                return;
-            }
-            // Round up to the next minute for clearer UX, ensure at least 1
-            const minutes = Math.max(1, Math.ceil(remaining / 60_000));
-            console.error(`Still waiting for login... ${String(minutes)} minute(s) remaining`);
-        }, 60_000);
-    }
-    try {
-        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);
-        manualController?.abort();
-    }
-}

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

@@ -1,21 +0,0 @@
-import { z } from "zod";
-export declare const GitHubCopilotUsageResponse: z.ZodObject<{
-    licenseType: z.ZodString;
-    quotas: z.ZodObject<{
-        limits: z.ZodObject<{
-            premiumInteractions: z.ZodNumber;
-        }, z.core.$strip>;
-        remaining: z.ZodObject<{
-            premiumInteractions: z.ZodNumber;
-            chatPercentage: z.ZodOptional<z.ZodNumber>;
-            premiumInteractionsPercentage: z.ZodNumber;
-        }, z.core.$strip>;
-        resetDate: z.ZodString;
-        overagesEnabled: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>;
-    plan: z.ZodString;
-    trial: z.ZodOptional<z.ZodObject<{
-        eligible: z.ZodBoolean;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type GitHubCopilotUsageResponse = z.infer<typeof GitHubCopilotUsageResponse>;

package/dist/types/github-copilot.js

@@ -1,27 +0,0 @@
-import { z } from "zod";
-/**
- * GitHub Copilot API response schemas
- */
-const GitHubCopilotQuotaLimits = z.object({
-    premiumInteractions: z.number(),
-});
-const GitHubCopilotQuotaRemaining = z.object({
-    premiumInteractions: z.number(),
-    chatPercentage: z.number().optional(),
-    premiumInteractionsPercentage: z.number(),
-});
-const GitHubCopilotQuotas = z.object({
-    limits: GitHubCopilotQuotaLimits,
-    remaining: GitHubCopilotQuotaRemaining,
-    resetDate: z.string(), // Format: "YYYY-MM-DD"
-    overagesEnabled: z.boolean().optional(),
-});
-const GitHubCopilotTrial = z.object({
-    eligible: z.boolean(),
-});
-export const GitHubCopilotUsageResponse = z.object({
-    licenseType: z.string(),
-    quotas: GitHubCopilotQuotas,
-    plan: z.string(),
-    trial: GitHubCopilotTrial.optional(),
-});

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

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

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

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

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

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

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

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