@foxden-app/foxclaw 0.11.1 → 0.13.0

package/dist/controller/auth_errors.js

@@ -0,0 +1,124 @@
+import { stringOrNull } from './shared_helpers.js';
+export function classifyCodexAuthRotationError(params) {
+    const collected = collectCodexErrorText(params);
+    if (isChatGptBackendAccessBlocked(collected)) {
+        return null;
+    }
+    const code = stringOrNull(params?.error?.codexErrorInfo) ?? stringOrNull(params?.error?.code);
+    const message = stringOrNull(params?.error?.message) ?? '';
+    const text = `${code ?? ''}\n${message}\n${collected}`;
+    if (isCodexAuthInvalidError(text)) {
+        return 'auth_invalid';
+    }
+    if (isCodexQuotaLimitError(text)) {
+        return 'quota_limited';
+    }
+    if (code && /auth|unauthorized|forbidden|login/i.test(code)) {
+        return 'auth_invalid';
+    }
+    return /(not authenticated|unauthorized|forbidden|sign in|log in|login|auth)/i.test(message)
+        ? 'auth_invalid'
+        : null;
+}
+export function isCodexAuthInvalidError(text) {
+    return /token[_\s-]?invalidated/i.test(text)
+        || /authentication token has been invalidated/i.test(text)
+        || /\b401\s+unauthorized\b/i.test(text)
+        || /\bunauthorized\b/i.test(text)
+        || /\bnot authenticated\b/i.test(text)
+        || /\bsign in again\b/i.test(text)
+        || /\blog in again\b/i.test(text);
+}
+export function isCodexQuotaLimitError(text) {
+    return /usageLimitExceeded/i.test(text)
+        || /you['’]?ve hit your usage limit/i.test(text)
+        || /\busage limit(?:s)?\b/i.test(text)
+        || /\brate limit(?:ed|s)?\b/i.test(text)
+        || /\btoo many requests\b/i.test(text)
+        || /\binsufficient[_\s-]?quota\b/i.test(text)
+        || /\bquota exceeded\b/i.test(text)
+        || /\bbilling hard limit\b/i.test(text)
+        || /\bcredits? exhausted\b/i.test(text)
+        || /\bout of credits?\b/i.test(text)
+        || /\bcredits? limit\b/i.test(text);
+}
+export function formatCodexNotificationError(params) {
+    const collected = collectCodexErrorText(params);
+    const known = formatKnownCodexAccessError(collected);
+    if (known) {
+        return known;
+    }
+    const message = stringOrNull(params?.error?.message);
+    if (message) {
+        return clipUserFacingError(cleanUserFacingError(message));
+    }
+    const code = stringOrNull(params?.error?.codexErrorInfo) ?? stringOrNull(params?.error?.code);
+    if (code) {
+        return clipUserFacingError(cleanUserFacingError(code));
+    }
+    return clipUserFacingError(cleanUserFacingError(JSON.stringify(params?.error ?? params ?? {})));
+}
+export function isRetryableCodexTransportError(params) {
+    if (params?.willRetry !== true) {
+        return false;
+    }
+    const errorInfo = params?.error?.codexErrorInfo;
+    return Boolean(errorInfo && typeof errorInfo === 'object' && 'responseStreamDisconnected' in errorInfo);
+}
+export function collectCodexErrorText(params) {
+    const parts = [
+        stringOrNull(params?.error?.message),
+        stringOrNull(params?.error?.additionalDetails),
+        stringOrNull(params?.additionalDetails),
+        stringOrNull(params?.error?.codexErrorInfo),
+        stringOrNull(params?.error?.code),
+    ].filter((part) => part !== null);
+    if (parts.length > 0) {
+        return parts.join(' ');
+    }
+    try {
+        return JSON.stringify(params?.error ?? params ?? {});
+    }
+    catch {
+        return String(params?.error ?? params ?? '');
+    }
+}
+export function formatKnownCodexAccessError(raw) {
+    if (!isChatGptBackendAccessBlocked(raw)) {
+        return null;
+    }
+    const ray = raw.match(/\bcf-ray:\s*([A-Za-z0-9-]+)/i)?.[1]
+        ?? raw.match(/\bRay ID:\s*([A-Za-z0-9-]+)/i)?.[1]
+        ?? null;
+    return `ChatGPT backend 403 Forbidden: service network/proxy/IP is blocked, not necessarily auth.json invalid. Check HTTP_PROXY/HTTPS_PROXY in the FoxClaw env file and restart FoxClaw${ray ? ` (cf-ray: ${ray})` : ''}.`;
+}
+export function isChatGptBackendAccessBlocked(raw) {
+    const value = raw.toLowerCase();
+    const targetsChatGptBackend = value.includes('chatgpt.com/backend-api')
+        || value.includes('wss://chatgpt.com/backend-api');
+    const isForbidden = value.includes('403 forbidden')
+        || value.includes('status 403')
+        || value.includes('httpstatuscode":403')
+        || value.includes('httpstatuscode:403');
+    const looksLikeHtmlBlock = value.includes('<html')
+        || value.includes('text/html')
+        || value.includes('cf-ray')
+        || value.includes('unable to load site')
+        || value.includes('if you are using a vpn');
+    return targetsChatGptBackend && isForbidden && looksLikeHtmlBlock;
+}
+export function cleanUserFacingError(raw) {
+    return raw
+        .replace(/<script\b[\s\S]*?<\/script>/gi, ' ')
+        .replace(/<style\b[\s\S]*?<\/style>/gi, ' ')
+        .replace(/<[^>]+>/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+export function clipUserFacingError(raw, limit = 900) {
+    const cleaned = raw.trim();
+    if (cleaned.length <= limit) {
+        return cleaned;
+    }
+    return `${cleaned.slice(0, limit - 3)}...`;
+}

package/dist/controller/auth_files.d.ts

@@ -0,0 +1,13 @@
+import type { CodexAuthCandidateState } from '../store/database.js';
+import { CodexAuthState, CodexAuthSwitchResult } from './state_types.js';
+export declare function codexAuthDir(explicitAuthDir?: string | null): string;
+export declare function listCodexAuthState(disabledNames?: Set<string>, candidateStates?: Map<string, CodexAuthCandidateState>, explicitAuthDir?: string | null): Promise<CodexAuthState>;
+export declare function isCodexAuthCandidateName(name: string): boolean;
+export declare function isCodexApiKeyAuthCandidate(candidatePath: string): Promise<boolean>;
+export declare function codexAuthCandidateNameFromAddName(raw: string): string | null;
+export declare function resolveCurrentAuthTarget(authDir: string, authPath: string): Promise<string | null>;
+export declare function resolveAuthFinalTargetPath(startPath: string): Promise<string>;
+export declare function authPathDisplayLabel(authPath: string): Promise<string>;
+export declare function pointCodexAuthAtTarget(authDir: string, authPath: string, targetPath: string): Promise<void>;
+export declare function restoreCodexAuthTarget(authDir: string, authPath: string, targetPath: string | null, regularAuthContents: string | null): Promise<void>;
+export declare function switchCodexAuth(targetPath: string, explicitAuthDir?: string | null): Promise<CodexAuthSwitchResult>;

package/dist/controller/auth_files.js

@@ -0,0 +1,156 @@
+import path from 'node:path';
+import os from 'node:os';
+import fs from 'node:fs/promises';
+import { isFileMissingError } from './shared_helpers.js';
+export function codexAuthDir(explicitAuthDir = null) {
+    return explicitAuthDir || process.env.CODEX_AUTH_DIR || path.join(os.homedir(), '.codex');
+}
+export async function listCodexAuthState(disabledNames = new Set(), candidateStates = new Map(), explicitAuthDir = null) {
+    const authDir = codexAuthDir(explicitAuthDir);
+    const authPath = path.join(authDir, 'auth.json');
+    const currentTargetPath = await resolveCurrentAuthTarget(authDir, authPath);
+    const candidates = [];
+    const entries = await fs.readdir(authDir, { withFileTypes: true }).catch((error) => {
+        if (isFileMissingError(error)) {
+            return [];
+        }
+        throw error;
+    });
+    for (const entry of entries) {
+        if (!isCodexAuthCandidateName(entry.name)) {
+            continue;
+        }
+        const candidatePath = path.join(authDir, entry.name);
+        const stat = await fs.stat(candidatePath).catch(() => null);
+        if (!stat?.isFile()) {
+            continue;
+        }
+        candidates.push({
+            name: entry.name,
+            path: candidatePath,
+            isCurrent: currentTargetPath === candidatePath,
+            disabled: disabledNames.has(entry.name),
+            state: candidateStates.get(entry.name) ?? 'active',
+            mtimeMs: stat.mtimeMs,
+            credentialKind: 'invalid',
+            credentialLastRefreshMs: null,
+            credentialExpiresAtMs: null,
+            quota: null,
+        });
+    }
+    candidates.sort((left, right) => left.name.localeCompare(right.name, undefined, { numeric: true }));
+    return {
+        authDir,
+        authPath,
+        currentTargetPath,
+        currentLabel: currentTargetPath ? await authPathDisplayLabel(currentTargetPath) : null,
+        candidates,
+    };
+}
+export function isCodexAuthCandidateName(name) {
+    if (name === 'auth.json' || name.startsWith('.auth.json.')) {
+        return false;
+    }
+    return name.startsWith('auth.json_') || name.startsWith('auth.json.') || name.startsWith('auth.json-');
+}
+export async function isCodexApiKeyAuthCandidate(candidatePath) {
+    try {
+        const parsed = JSON.parse(await fs.readFile(candidatePath, 'utf8'));
+        return typeof parsed.openai_api_key === 'string' && parsed.openai_api_key.trim().length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+export function codexAuthCandidateNameFromAddName(raw) {
+    const normalized = raw.trim();
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(normalized)) {
+        return null;
+    }
+    const name = normalized.startsWith('auth.json_')
+        || normalized.startsWith('auth.json.')
+        || normalized.startsWith('auth.json-')
+        ? normalized
+        : `auth.json_${normalized}`;
+    return isCodexAuthCandidateName(name) ? name : null;
+}
+export async function resolveCurrentAuthTarget(authDir, authPath) {
+    const stat = await fs.lstat(authPath).catch(() => null);
+    if (!stat) {
+        return null;
+    }
+    if (stat.isSymbolicLink()) {
+        const target = await fs.readlink(authPath);
+        return path.resolve(authDir, target);
+    }
+    return authPath;
+}
+export async function resolveAuthFinalTargetPath(startPath) {
+    let currentPath = startPath;
+    const seen = new Set();
+    for (let depth = 0; depth < 20; depth += 1) {
+        const absolutePath = path.resolve(currentPath);
+        if (seen.has(absolutePath)) {
+            return currentPath;
+        }
+        seen.add(absolutePath);
+        const stat = await fs.lstat(currentPath).catch(() => null);
+        if (!stat?.isSymbolicLink()) {
+            return currentPath;
+        }
+        const target = await fs.readlink(currentPath);
+        currentPath = path.resolve(path.dirname(currentPath), target);
+    }
+    return currentPath;
+}
+export async function authPathDisplayLabel(authPath) {
+    return path.basename(await resolveAuthFinalTargetPath(authPath));
+}
+export async function pointCodexAuthAtTarget(authDir, authPath, targetPath) {
+    await fs.mkdir(authDir, { recursive: true });
+    const tempLink = path.join(authDir, `.auth.json.${process.pid}.${Date.now()}.tmp`);
+    try {
+        await fs.symlink(targetPath, tempLink);
+        await fs.rename(tempLink, authPath);
+    }
+    catch (error) {
+        await fs.unlink(tempLink).catch(() => { });
+        throw error;
+    }
+}
+export async function restoreCodexAuthTarget(authDir, authPath, targetPath, regularAuthContents) {
+    if (regularAuthContents !== null) {
+        await fs.mkdir(authDir, { recursive: true });
+        const temporary = path.join(authDir, `.auth.json.${process.pid}.${Date.now()}.restore`);
+        try {
+            await fs.writeFile(temporary, regularAuthContents, { mode: 0o600 });
+            await fs.rename(temporary, authPath);
+        }
+        catch (error) {
+            await fs.unlink(temporary).catch(() => undefined);
+            throw error;
+        }
+        return;
+    }
+    if (targetPath) {
+        await pointCodexAuthAtTarget(authDir, authPath, targetPath);
+        return;
+    }
+    await fs.unlink(authPath).catch((error) => {
+        if (!isFileMissingError(error)) {
+            throw error;
+        }
+    });
+}
+export async function switchCodexAuth(targetPath, explicitAuthDir = null) {
+    const state = await listCodexAuthState(new Set(), new Map(), explicitAuthDir);
+    const candidate = state.candidates.find(entry => entry.path === targetPath);
+    if (!candidate) {
+        throw new Error(`Auth candidate is no longer available: ${path.basename(targetPath)}`);
+    }
+    await pointCodexAuthAtTarget(state.authDir, state.authPath, candidate.path);
+    return {
+        fromLabel: state.currentLabel,
+        toLabel: await authPathDisplayLabel(candidate.path),
+    };
+}

package/dist/controller/auth_presentation.d.ts

@@ -0,0 +1,77 @@
+import type { AppLocale, CodexAccountInfo, CodexAccountRateLimits, CodexRateLimitSnapshot, CodexRateLimitWindow, RuntimeStatus } from '../types.js';
+import type { CodexAuthQuotaSnapshotRecord } from '../store/database.js';
+import { type ChatGptAuthMetadata } from '../auth/mirror.js';
+import { CodexAuthListView, CodexAuthCandidate, PendingAuthChoiceList, CodexAuthListFilter, CodexAuthState, CodexAuthCandidateHealth, CodexAuthRefreshAllResult, CodexAuthClusterAuditOutcome, AuthProactiveRefreshStatus, AuthSyncRuntimeEvent, CodexAuthQuotaSnapshot } from './state_types.js';
+export declare function parseCodexAuthListRequest(action: string, args: string[]): Partial<CodexAuthListView> | null;
+export declare function createPendingAuthChoiceList(chatId: string, candidates: CodexAuthCandidate[], view?: Partial<CodexAuthListView>): PendingAuthChoiceList;
+export declare function clampCodexAuthListOffset(view: PendingAuthChoiceList): void;
+export declare function codexAuthListPage(candidates: CodexAuthCandidate[], view: CodexAuthListView | null): {
+    visible: Array<{
+        candidate: CodexAuthCandidate;
+        index: number;
+    }>;
+    filteredCount: number;
+    offset: number;
+    pageIndex: number;
+    pageCount: number;
+    filter: CodexAuthListFilter;
+    searchTerm: string | null;
+};
+export declare function filterCodexAuthCandidates(candidates: CodexAuthCandidate[], view: Pick<CodexAuthListView, 'filter' | 'searchTerm'>): Array<{
+    candidate: CodexAuthCandidate;
+    index: number;
+}>;
+export declare function renderAuthListMessage(locale: AppLocale, state: CodexAuthState, botLabel?: string | null, includeWeixinCopyPaste?: boolean, view?: CodexAuthListView | null): string;
+export declare function authChoiceKeyboard(locale: AppLocale, record: PendingAuthChoiceList): Array<Array<{
+    text: string;
+    callback_data: string;
+}>>;
+export declare function formatCodexAuthCandidateDisplayName(name: string): string;
+export declare function authFilterButton(locale: AppLocale, record: PendingAuthChoiceList, filter: CodexAuthListFilter): {
+    text: string;
+    callback_data: string;
+};
+export declare function codexAuthCandidateHealth(candidate: CodexAuthCandidate): CodexAuthCandidateHealth;
+export declare function codexAuthCandidateNeedsAttention(candidate: CodexAuthCandidate): boolean;
+export declare function formatCodexAuthCandidateStatus(locale: AppLocale, candidate: CodexAuthCandidate): string;
+export declare function formatCodexAuthFilter(locale: AppLocale, filter: CodexAuthListFilter): string;
+export declare function authRefreshAllConfirmKeyboard(locale: AppLocale, record: PendingAuthChoiceList): Array<Array<{
+    text: string;
+    callback_data: string;
+}>>;
+export declare function authRepairKeyboard(locale: AppLocale, record: PendingAuthChoiceList, index: number): Array<Array<{
+    text: string;
+    callback_data: string;
+}>>;
+export declare function formatAuthRefreshAllResult(locale: AppLocale, result: CodexAuthRefreshAllResult, mode?: 'manual' | 'proactive'): string;
+export declare function formatAuthClusterAuditResult(locale: AppLocale, outcome: CodexAuthClusterAuditOutcome): string;
+export declare function formatAuthSyncStatus(locale: AppLocale, status: RuntimeStatus['authSync'], proactiveRefresh?: AuthProactiveRefreshStatus | null): string;
+export declare function formatAuthProactiveRefreshStatus(locale: AppLocale, status: AuthProactiveRefreshStatus): string;
+export declare function formatAuthProactiveRefreshState(locale: AppLocale, state: AuthProactiveRefreshStatus['state']): string;
+export declare function formatLimitedList(values: readonly string[], limit: number): string;
+export declare function formatAuthSyncEvents(locale: AppLocale, status: RuntimeStatus['authSync'], filter: string | null): string;
+export declare function formatAuthSyncTrace(locale: AppLocale, status: RuntimeStatus['authSync'], requestId: string): string;
+export declare function filterAuthSyncEvents(events: AuthSyncRuntimeEvent[], filter: string | null): AuthSyncRuntimeEvent[];
+export declare function formatAuthSyncEventLine(event: AuthSyncRuntimeEvent): string;
+export declare function selectCodexRateLimitSnapshot(limits: CodexAccountRateLimits | null): CodexRateLimitSnapshot | null;
+export declare function formatCodexAccountLabel(account: CodexAccountInfo): string;
+export declare function formatPlanTypeLabel(value: string): string;
+export declare function formatRateLimitWindowLabel(locale: AppLocale, window: CodexRateLimitWindow, fallback: 'primary' | 'secondary'): string;
+export declare function formatCompactRateLimitWindowLabel(locale: AppLocale, minutes: number | null, fallback: 'primary' | 'secondary'): string;
+export declare function formatCompactAge(locale: AppLocale, ageMs: number): string;
+export declare function formatUtcDateTime(timestampMs: number): string;
+export declare function formatUsagePercent(value: number): string;
+export declare function formatRemainingUsagePercent(usedPercent: number): string;
+export declare function authQuotaSnapshotFromRateLimit(snapshot: CodexRateLimitSnapshot, accountId?: string | null, quotaIdentityId?: string | null): CodexAuthQuotaSnapshot;
+export declare function codexAuthQuotaSnapshotFromRecord(record: CodexAuthQuotaSnapshotRecord): CodexAuthQuotaSnapshot;
+export declare function mergeCodexAuthQuotaSnapshots(current: CodexAuthQuotaSnapshot | null, incoming: CodexAuthQuotaSnapshot | null): CodexAuthQuotaSnapshot | null;
+export declare function isFiniteCodexAuthQuotaSnapshotRecord(record: CodexAuthQuotaSnapshotRecord): boolean;
+export declare function remainingUsagePercent(usedPercent: number): number | null;
+export declare function formatAuthQuotaPrefix(locale: AppLocale, snapshot: CodexAuthQuotaSnapshot | null): string;
+export declare function formatAuthQuotaButtonPrefix(snapshot: CodexAuthQuotaSnapshot | null): string;
+export declare function formatAuthQuotaButtonValue(value: number | null): string;
+export declare function isCodexAuthQuotaSnapshot(value: unknown): value is CodexAuthQuotaSnapshot;
+export declare function normalizeCodexAuthQuotaSnapshot(snapshot: CodexAuthQuotaSnapshot): CodexAuthQuotaSnapshot;
+export declare function chatGptAuthMetadataCompatible(left: Pick<ChatGptAuthMetadata, 'accountId' | 'quotaIdentityId'>, right: Pick<ChatGptAuthMetadata, 'accountId' | 'quotaIdentityId'>): boolean;
+export declare function isNullableFiniteNumber(value: unknown): value is number | null;
+export declare function isNullableString(value: unknown): value is string | null;