@foxden-app/foxclaw 0.12.0 → 0.13.1

package/dist/controller/access.d.ts

@@ -1,11 +1 @@
-import type { AppConfig } from '../config.js';
-import type { AccessPresetValue, ApprovalPolicyValue, ChatSessionSettings, SandboxModeValue } from '../types.js';
-export interface ResolvedAccessMode {
-    preset: AccessPresetValue;
-    approvalPolicy: ApprovalPolicyValue;
-    sandboxMode: SandboxModeValue;
-}
-export declare const ACCESS_PRESETS: AccessPresetValue[];
-export declare function normalizeAccessPreset(value: string | null | undefined): AccessPresetValue | null;
-export declare function resolveConfiguredAccessPreset(settings: Pick<ChatSessionSettings, 'accessPreset'> | null | undefined): AccessPresetValue;
-export declare function resolveAccessMode(config: Pick<AppConfig, 'defaultApprovalPolicy' | 'defaultSandboxMode'>, settings: Pick<ChatSessionSettings, 'accessPreset'> | null | undefined): ResolvedAccessMode;
+export * from '../core/access.js';

package/dist/controller/access.js

@@ -1,33 +1 @@
-export const ACCESS_PRESETS = ['read-only', 'default', 'full-access'];
-export function normalizeAccessPreset(value) {
-    if (value === 'read-only' || value === 'default' || value === 'full-access') {
-        return value;
-    }
-    return null;
-}
-export function resolveConfiguredAccessPreset(settings) {
-    return settings?.accessPreset ?? 'default';
-}
-export function resolveAccessMode(config, settings) {
-    const preset = resolveConfiguredAccessPreset(settings);
-    switch (preset) {
-        case 'read-only':
-            return {
-                preset,
-                approvalPolicy: 'on-request',
-                sandboxMode: 'read-only',
-            };
-        case 'full-access':
-            return {
-                preset,
-                approvalPolicy: 'never',
-                sandboxMode: 'danger-full-access',
-            };
-        default:
-            return {
-                preset: 'default',
-                approvalPolicy: config.defaultApprovalPolicy,
-                sandboxMode: config.defaultSandboxMode,
-            };
-    }
-}
+export * from '../core/access.js';

package/dist/controller/activity.d.ts

@@ -1,62 +1 @@
-import type { JsonRpcNotification } from '../codex_app/client.js';
-export interface RawExecCommandEvent {
-    callId: string;
-    turnId: string;
-    command: string[];
-    cwd: string | null;
-    parsedCmd: any[];
-}
-export type TurnActivityState = 'thinking' | 'reading' | 'searching' | 'editing' | 'running_command' | 'approval_waiting' | 'completed' | 'interrupted';
-export type TurnOutputKind = 'commentary' | 'final_answer' | 'tool_summary' | 'error';
-export type TurnActivityEvent = {
-    kind: 'user_message';
-    turnId: string;
-    text: string;
-} | {
-    kind: 'agent_message_started';
-    turnId: string;
-    itemId: string;
-    phase: string | null;
-    outputKind: TurnOutputKind;
-    isPlan?: boolean;
-} | {
-    kind: 'agent_message_delta';
-    turnId: string;
-    itemId: string;
-    delta: string;
-    outputKind: TurnOutputKind;
-    isPlan?: boolean;
-} | {
-    kind: 'agent_message_completed';
-    turnId: string;
-    itemId: string;
-    phase: string | null;
-    text: string | null;
-    outputKind: TurnOutputKind;
-    isPlan?: boolean;
-} | {
-    kind: 'reasoning_started';
-    turnId: string;
-    state: 'thinking';
-} | {
-    kind: 'reasoning_completed';
-    turnId: string;
-    state: 'thinking';
-} | {
-    kind: 'tool_started';
-    turnId: string;
-    exec: RawExecCommandEvent;
-    state: TurnActivityState;
-} | {
-    kind: 'tool_completed';
-    turnId: string;
-    exec: RawExecCommandEvent;
-    state: TurnActivityState;
-} | {
-    kind: 'turn_completed';
-    turnId: string;
-    state: 'completed' | 'interrupted';
-};
-export declare function normalizeTurnActivityEvent(notification: JsonRpcNotification): TurnActivityEvent | null;
-export declare function classifyAgentOutput(phase: string | null, completed: boolean): TurnOutputKind;
-export declare function inferToolActivityState(event: RawExecCommandEvent): TurnActivityState;
+export * from '../codex_app/activity.js';

package/dist/controller/activity.js

@@ -1,418 +1,2 @@
-export function normalizeTurnActivityEvent(notification) {
-    switch (notification.method) {
-        case 'item/started':
-            return normalizeStartedEvent(notification.params);
-        case 'item/agentMessage/delta':
-            return normalizeAgentDeltaEvent(notification.params);
-        case 'item/plan/delta':
-            return normalizePlanDeltaEvent(notification.params);
-        case 'item/completed':
-            return normalizeCompletedEvent(notification.params);
-        case 'turn/plan/updated':
-            return normalizePlanUpdatedEvent(notification.params);
-        case 'codex/event/exec_command_begin':
-            return normalizeToolEvent(notification.params, 'tool_started');
-        case 'codex/event/exec_command_end':
-            return normalizeToolEvent(notification.params, 'tool_completed');
-        case 'turn/completed': {
-            const turnId = extractTurnId(notification.params);
-            if (!turnId)
-                return null;
-            return {
-                kind: 'turn_completed',
-                turnId,
-                state: 'completed',
-            };
-        }
-        case 'turn/interrupted':
-        case 'turn/aborted': {
-            const turnId = extractTurnId(notification.params);
-            if (!turnId)
-                return null;
-            return {
-                kind: 'turn_completed',
-                turnId,
-                state: 'interrupted',
-            };
-        }
-        default:
-            return null;
-    }
-}
-function normalizeStartedEvent(params) {
-    const turnId = extractTurnId(params);
-    if (!turnId)
-        return null;
-    const item = params?.item;
-    const itemType = normalizeEventItemType(item);
-    if (itemType === 'reasoning') {
-        return {
-            kind: 'reasoning_started',
-            turnId,
-            state: 'thinking',
-        };
-    }
-    const toolEvent = normalizeThreadItemToolEvent(params, 'tool_started');
-    if (toolEvent) {
-        return toolEvent;
-    }
-    if (!isRelayableTextItemType(itemType)) {
-        return null;
-    }
-    const itemId = extractItemId(item);
-    if (!itemId)
-        return null;
-    const phase = itemType === 'plan' ? 'commentary' : extractAgentPhase(item);
-    return {
-        kind: 'agent_message_started',
-        turnId,
-        itemId,
-        phase,
-        outputKind: outputKindForItemType(itemType, phase, false),
-        isPlan: itemType === 'plan',
-    };
-}
-function normalizeAgentDeltaEvent(params) {
-    const turnId = extractTurnId(params);
-    const delta = extractAgentDeltaText(params);
-    const itemId = extractItemId(params);
-    if (!turnId || !delta || !itemId) {
-        return null;
-    }
-    const phase = extractAgentPhase(params);
-    return {
-        kind: 'agent_message_delta',
-        turnId,
-        itemId,
-        delta,
-        outputKind: classifyAgentOutput(phase, false),
-    };
-}
-function normalizePlanDeltaEvent(params) {
-    const turnId = extractTurnId(params);
-    const delta = extractAgentDeltaText(params);
-    const itemId = extractItemId(params);
-    if (!turnId || !delta || !itemId) {
-        return null;
-    }
-    return {
-        kind: 'agent_message_delta',
-        turnId,
-        itemId,
-        delta,
-        outputKind: 'commentary',
-        isPlan: true,
-    };
-}
-function normalizeCompletedEvent(params) {
-    const turnId = extractTurnId(params);
-    if (!turnId)
-        return null;
-    const item = params?.item;
-    const itemType = normalizeEventItemType(item);
-    if (itemType === 'reasoning') {
-        return {
-            kind: 'reasoning_completed',
-            turnId,
-            state: 'thinking',
-        };
-    }
-    const toolEvent = normalizeThreadItemToolEvent(params, 'tool_completed');
-    if (toolEvent) {
-        return toolEvent;
-    }
-    if (!isRelayableTextItemType(itemType)) {
-        return null;
-    }
-    const itemId = extractItemId(item);
-    if (!itemId)
-        return null;
-    const phase = itemType === 'plan' ? 'commentary' : extractAgentPhase(item);
-    return {
-        kind: 'agent_message_completed',
-        turnId,
-        itemId,
-        phase,
-        text: extractCompletedAgentText(params),
-        outputKind: outputKindForItemType(itemType, phase, true),
-        isPlan: itemType === 'plan',
-    };
-}
-function normalizePlanUpdatedEvent(params) {
-    const turnId = extractTurnId(params);
-    if (!turnId) {
-        return null;
-    }
-    const text = formatPlanUpdateText(params);
-    if (!text) {
-        return null;
-    }
-    return {
-        kind: 'agent_message_completed',
-        turnId,
-        itemId: `${turnId}:plan`,
-        phase: 'commentary',
-        text,
-        outputKind: 'commentary',
-        isPlan: true,
-    };
-}
-function normalizeToolEvent(params, kind) {
-    const exec = extractRawExecCommandEvent(params);
-    if (!exec) {
-        return null;
-    }
-    return {
-        kind,
-        turnId: exec.turnId,
-        exec,
-        state: inferToolActivityState(exec),
-    };
-}
-function normalizeThreadItemToolEvent(params, kind) {
-    const turnId = extractTurnId(params);
-    const item = params?.item;
-    const itemId = extractItemId(item);
-    const itemType = normalizeEventItemType(item);
-    if (!turnId || !itemId || !itemType) {
-        return null;
-    }
-    let command = [];
-    let cwd = null;
-    let parsedCmd = [];
-    switch (itemType) {
-        case 'commandexecution':
-            command = typeof item.command === 'string' ? [item.command] : [];
-            cwd = typeof item.cwd === 'string' ? item.cwd : null;
-            parsedCmd = normalizeCommandActions(item.commandActions);
-            break;
-        case 'filechange':
-            parsedCmd = normalizeFileChanges(item.changes);
-            break;
-        case 'websearch':
-            parsedCmd = [{
-                    type: 'search',
-                    query: typeof item.query === 'string' ? item.query : '',
-                    path: null,
-                }];
-            break;
-        case 'imageview':
-            parsedCmd = [{ type: 'read', path: typeof item.path === 'string' ? item.path : null }];
-            break;
-        case 'mcptoolcall':
-            command = [`MCP ${String(item.server ?? 'server')}/${String(item.tool ?? 'tool')}`];
-            break;
-        case 'dynamictoolcall':
-            command = [`Tool ${item.namespace ? `${String(item.namespace)}/` : ''}${String(item.tool ?? 'tool')}`];
-            break;
-        case 'collabagenttoolcall':
-            command = [`Agent ${String(item.tool ?? 'operation')}`];
-            break;
-        case 'imagegeneration':
-            command = ['Image generation'];
-            break;
-        default:
-            return null;
-    }
-    const exec = {
-        callId: itemId,
-        turnId,
-        command,
-        cwd,
-        parsedCmd,
-    };
-    return {
-        kind,
-        turnId,
-        exec,
-        state: inferToolActivityState(exec),
-    };
-}
-function normalizeCommandActions(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    return value.map((entry) => {
-        const type = typeof entry?.type === 'string' ? entry.type : '';
-        if (type === 'listFiles') {
-            return { ...entry, type: 'list_files' };
-        }
-        return entry;
-    });
-}
-function normalizeFileChanges(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    return value.map((entry) => ({
-        type: 'apply_patch',
-        path: typeof entry?.path === 'string' ? entry.path : null,
-    }));
-}
-export function classifyAgentOutput(phase, completed) {
-    if (!phase) {
-        return completed ? 'final_answer' : 'commentary';
-    }
-    const normalized = phase.replace(/[^a-z]/gi, '').toLowerCase();
-    if (normalized === 'final' || normalized === 'finalanswer' || normalized === 'answer' || normalized === 'response') {
-        return 'final_answer';
-    }
-    return 'commentary';
-}
-export function inferToolActivityState(event) {
-    const parsedTypes = (event.parsedCmd ?? [])
-        .map((entry) => (typeof entry?.type === 'string' ? entry.type : ''))
-        .filter(Boolean);
-    if (parsedTypes.includes('search')) {
-        return 'searching';
-    }
-    if (parsedTypes.includes('read') || parsedTypes.includes('list_files')) {
-        return 'reading';
-    }
-    if (parsedTypes.some(type => ['write', 'edit', 'apply_patch', 'move', 'copy', 'delete', 'mkdir'].includes(type))) {
-        return 'editing';
-    }
-    return 'running_command';
-}
-function extractRawExecCommandEvent(params) {
-    const msg = params?.msg;
-    if (!msg || typeof msg !== 'object') {
-        return null;
-    }
-    const callId = typeof msg.call_id === 'string' ? msg.call_id : null;
-    const turnId = typeof msg.turn_id === 'string' ? msg.turn_id : null;
-    if (!callId || !turnId) {
-        return null;
-    }
-    return {
-        callId,
-        turnId,
-        command: Array.isArray(msg.command) ? msg.command.map((entry) => String(entry)) : [],
-        cwd: msg.cwd ? String(msg.cwd) : null,
-        parsedCmd: Array.isArray(msg.parsed_cmd) ? msg.parsed_cmd : [],
-    };
-}
-function extractTurnId(params) {
-    const candidates = [
-        params?.turnId,
-        params?.turn_id,
-        params?.turn?.id,
-        params?.turn?.turnId,
-        params?.item?.turnId,
-        params?.item?.turn_id,
-    ];
-    for (const candidate of candidates) {
-        if (candidate !== null && candidate !== undefined && String(candidate).trim()) {
-            return String(candidate);
-        }
-    }
-    return null;
-}
-function extractItemId(value) {
-    const candidates = [
-        value?.itemId,
-        value?.item_id,
-        value?.id,
-        value?.item?.id,
-    ];
-    for (const candidate of candidates) {
-        if (candidate !== null && candidate !== undefined && String(candidate).trim()) {
-            return String(candidate);
-        }
-    }
-    return null;
-}
-function extractAgentPhase(value) {
-    const phase = value?.phase ?? value?.item?.phase ?? null;
-    return typeof phase === 'string' && phase.trim() ? phase : null;
-}
-function extractAgentDeltaText(params) {
-    const candidates = [
-        params?.delta,
-        params?.textDelta,
-        params?.contentDelta,
-        params?.text,
-    ];
-    for (const candidate of candidates) {
-        const text = extractTextCandidate(candidate);
-        if (text) {
-            return text;
-        }
-    }
-    return null;
-}
-function extractCompletedAgentText(params) {
-    const itemType = normalizeEventItemType(params?.item ?? params);
-    if (!isRelayableTextItemType(itemType)) {
-        return null;
-    }
-    const item = params?.item ?? params;
-    const directText = extractTextCandidate(item?.text)
-        ?? extractTextCandidate(item?.content)
-        ?? extractTextCandidate(item?.value);
-    if (directText !== null) {
-        return directText;
-    }
-    return '';
-}
-function isRelayableTextItemType(itemType) {
-    return itemType === 'agentmessage' || itemType === 'assistantmessage' || itemType === 'plan';
-}
-function outputKindForItemType(itemType, phase, completed) {
-    if (itemType === 'plan') {
-        return 'commentary';
-    }
-    return classifyAgentOutput(phase, completed);
-}
-function formatPlanUpdateText(params) {
-    const lines = [];
-    const explanation = extractTextCandidate(params?.explanation);
-    if (explanation) {
-        lines.push(explanation);
-    }
-    const plan = Array.isArray(params?.plan) ? params.plan : [];
-    for (const entry of plan) {
-        const step = extractTextCandidate(entry?.step);
-        if (!step) {
-            continue;
-        }
-        const status = typeof entry?.status === 'string' && entry.status ? ` [${entry.status}]` : '';
-        lines.push(`- ${step}${status}`);
-    }
-    return lines.join('\n').trim() || null;
-}
-function normalizeEventItemType(value) {
-    const raw = value?.type ?? value?.itemType ?? value?.item_type ?? value?.kind;
-    if (typeof raw !== 'string') {
-        return null;
-    }
-    return raw.replace(/[^a-z]/gi, '').toLowerCase();
-}
-function extractTextCandidate(value) {
-    if (typeof value === 'string') {
-        return value;
-    }
-    if (!value || typeof value !== 'object') {
-        return null;
-    }
-    for (const key of ['text', 'delta', 'content', 'value']) {
-        const candidate = value[key];
-        if (typeof candidate === 'string') {
-            return candidate;
-        }
-    }
-    for (const key of ['parts', 'segments', 'content']) {
-        const candidate = value[key];
-        if (!Array.isArray(candidate)) {
-            continue;
-        }
-        const text = candidate
-            .map((entry) => extractTextCandidate(entry))
-            .filter((entry) => entry !== null)
-            .join('');
-        if (text) {
-            return text;
-        }
-    }
-    return null;
-}
+// Compatibility export for existing control-plane consumers.
+export * from '../codex_app/activity.js';

package/dist/controller/auth_errors.d.ts

@@ -0,0 +1,11 @@
+import { CodexAuthRotationReason } from './state_types.js';
+export declare function classifyCodexAuthRotationError(params: any): CodexAuthRotationReason | null;
+export declare function isCodexAuthInvalidError(text: string): boolean;
+export declare function isCodexQuotaLimitError(text: string): boolean;
+export declare function formatCodexNotificationError(params: any): string;
+export declare function isRetryableCodexTransportError(params: any): boolean;
+export declare function collectCodexErrorText(params: any): string;
+export declare function formatKnownCodexAccessError(raw: string): string | null;
+export declare function isChatGptBackendAccessBlocked(raw: string): boolean;
+export declare function cleanUserFacingError(raw: string): string;
+export declare function clipUserFacingError(raw: string, limit?: number): string;

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