@foxden-app/foxclaw 0.12.0 → 0.13.0

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;