axusage 3.1.0 → 3.2.0

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;
-    }
-}