@foxden-app/foxclaw 0.5.19 → 0.5.21

package/dist/controller/controller.js

@@ -19,6 +19,7 @@ import { diffObservedTurn, findLatestTurn, findLiveTurn } from './observer.js';
 import { applySessionLog, bootstrapSessionLog, splitJsonlChunk, } from './session_observer.js';
 import { renderActiveTurnStatus } from './status.js';
 import { writeRuntimeStatus } from '../runtime.js';
+const AUTH_DELETE_REASON_NEEDS_REPAIR = 'needs_repair';
 class UserFacingError extends Error {
 }
 const OBSERVED_THREAD_POLL_MS = 1500;
@@ -119,6 +120,8 @@ export class BridgeSessionCore {
     pendingAuthRotation = null;
     authRotationInProgress = false;
     authRefreshAllInProgress = false;
+    externalAuthValidationInProgress = false;
+    turnStartInProgress = 0;
     authRotationFailedTargets = new Set();
     localUsageCache = null;
     localUsageCacheLoaded = false;
@@ -245,6 +248,8 @@ export class BridgeSessionCore {
         this.commandUsageSequence = 0;
         this.pendingAuthRotation = null;
         this.authRefreshAllInProgress = false;
+        this.externalAuthValidationInProgress = false;
+        this.turnStartInProgress = 0;
         this.clearObservedThreadWatchers();
         this.releaseActiveTurnsForBridgeShutdown();
         this.bot.stop();
@@ -311,6 +316,10 @@ export class BridgeSessionCore {
                 await this.handleActiveTurnInboundMessage(event, locale, event.text.trim());
                 return;
             }
+            if (this.externalAuthValidationInProgress) {
+                await this.sendMessage(scopeId, t(locale, 'auth_sync_validation_busy'));
+                return;
+            }
             await this.startBoundTurnFromEvent(event, locale, event.text.trim());
             return;
         }
@@ -365,6 +374,10 @@ export class BridgeSessionCore {
             await this.handleActiveTurnInboundMessage(event, locale, decision.text);
             return;
         }
+        if (this.externalAuthValidationInProgress) {
+            await this.sendMessage(scopeId, t(locale, 'auth_sync_validation_busy'));
+            return;
+        }
         await this.startBoundTurnFromEvent(event, locale, decision.text);
     }
     async handleCommand(event, locale, name, args) {
@@ -420,6 +433,7 @@ export class BridgeSessionCore {
                     t(locale, 'status_pending_user_inputs', { value: this.store.countPendingUserInputs() }),
                     t(locale, 'status_queued_turns', { value: this.store.countQueuedTurnInputs(scopeId) }),
                     t(locale, 'status_active_turns', { value: this.activeTurns.size }),
+                    formatCodexAuthPoolSummary(locale, this.store.getCodexAuthPoolStats()),
                 ];
                 if (serviceStatus) {
                     lines.push('', t(locale, 'status_runtime_overview'));
@@ -743,7 +757,7 @@ export class BridgeSessionCore {
                 return;
             }
             case 'config': {
-                await this.handleConfigCommand(scopeId, locale);
+                await this.handleConfigCommand(scopeId, locale, args);
                 return;
             }
             case 'requirements': {
@@ -1041,6 +1055,11 @@ export class BridgeSessionCore {
             await this.handleSetupCallback(event, setupMatch[1], setupMatch[2], locale);
             return;
         }
+        const configMatch = /^config:auth_auto_delete:(on|off)$/.exec(event.data);
+        if (configMatch) {
+            await this.handleConfigToggleCallback(event, configMatch[1] === 'on', locale);
+            return;
+        }
         const settingsMatch = /^settings:(model|effort|access):(.+)$/.exec(event.data);
         if (settingsMatch) {
             await this.handleSettingsCallback(event, settingsMatch[1], settingsMatch[2], locale);
@@ -2919,53 +2938,75 @@ export class BridgeSessionCore {
     async getCurrentAuthLabel() {
         return (await this.listCodexAuthState()).currentLabel;
     }
+    async handleExternalCodexAuthCandidateDeleted(candidateName, reason = null) {
+        this.store.deleteCodexAuthCandidate(candidateName);
+        if (isInvalidCodexAuthDeleteReason(reason)) {
+            this.store.recordCodexAuthCandidateInvalidDelete(candidateName, reason);
+        }
+        else {
+            this.store.recordCodexAuthCandidateRemoved(candidateName, reason);
+        }
+        this.authRotationFailedTargets.delete(path.join(this.resolveAuthDir(), candidateName));
+        this.pendingTurnErrors.clear();
+        this.attachedThreads.clear();
+        await this.app.restart();
+    }
     async validateExternalCodexAuthCandidate(candidateName, rawAuth, expectedAccountId) {
-        if (!this.isIdleForServiceUpdate()) {
+        if (this.externalAuthValidationInProgress) {
             return { ok: false, reason: 'runtime is not idle' };
         }
-        const metadata = parseChatGptAuthMetadata(rawAuth);
-        if (!metadata || metadata.accountId !== expectedAccountId) {
-            return { ok: false, reason: 'remote auth account id mismatch' };
-        }
-        const state = await this.listCodexAuthState();
-        const existing = state.candidates.find(candidate => candidate.name === candidateName) ?? null;
-        if (existing) {
-            const existingMetadata = await readChatGptAuthMetadata(existing.path);
-            if (existingMetadata && existingMetadata.accountId !== expectedAccountId) {
-                return { ok: false, reason: 'same candidate belongs to a different account' };
-            }
+        if (!this.isIdleForServiceUpdate()) {
+            return { ok: false, reason: 'runtime is not idle' };
         }
-        const authStat = await fs.lstat(state.authPath).catch(() => null);
-        const originalRegularAuth = authStat?.isFile()
-            ? await fs.readFile(state.authPath, 'utf8').catch(() => null)
-            : null;
-        const tempPath = path.join(state.authDir, `.auth-sync-validate-${process.pid}-${Date.now()}.json`);
+        this.externalAuthValidationInProgress = true;
         try {
-            await fs.writeFile(tempPath, rawAuth, { encoding: 'utf8', mode: 0o600 });
-            await pointCodexAuthAtTarget(state.authDir, state.authPath, tempPath);
-            this.pendingTurnErrors.clear();
-            this.attachedThreads.clear();
-            await this.app.restart();
-            const account = await this.app.readAccount(false);
-            const rateLimits = await this.app.readAccountRateLimits();
-            if (!account || !rateLimits || !selectCodexRateLimitSnapshot(rateLimits)) {
-                return { ok: false, reason: 'Codex did not validate ChatGPT usage for remote auth' };
+            const metadata = parseChatGptAuthMetadata(rawAuth);
+            if (!metadata || metadata.accountId !== expectedAccountId) {
+                return { ok: false, reason: 'remote auth account id mismatch' };
+            }
+            const state = await this.listCodexAuthState();
+            const existing = state.candidates.find(candidate => candidate.name === candidateName) ?? null;
+            if (existing) {
+                const existingMetadata = await readChatGptAuthMetadata(existing.path);
+                if (existingMetadata && existingMetadata.accountId !== expectedAccountId) {
+                    return { ok: false, reason: 'same candidate belongs to a different account' };
+                }
+            }
+            const authStat = await fs.lstat(state.authPath).catch(() => null);
+            const originalRegularAuth = authStat?.isFile()
+                ? await fs.readFile(state.authPath, 'utf8').catch(() => null)
+                : null;
+            const tempPath = path.join(state.authDir, `.auth-sync-validate-${process.pid}-${Date.now()}.json`);
+            try {
+                await fs.writeFile(tempPath, rawAuth, { encoding: 'utf8', mode: 0o600 });
+                await pointCodexAuthAtTarget(state.authDir, state.authPath, tempPath);
+                this.pendingTurnErrors.clear();
+                this.attachedThreads.clear();
+                await this.app.restart();
+                const account = await this.app.readAccount(false);
+                const rateLimits = await this.app.readAccountRateLimits();
+                if (!account || !rateLimits || !selectCodexRateLimitSnapshot(rateLimits)) {
+                    return { ok: false, reason: 'Codex did not validate ChatGPT usage for remote auth' };
+                }
+                return { ok: true };
+            }
+            catch (error) {
+                return { ok: false, reason: formatUserError(error) };
+            }
+            finally {
+                await restoreCodexAuthTarget(state.authDir, state.authPath, state.currentTargetPath, originalRegularAuth).catch((error) => {
+                    this.logger.warn('codex.auth_sync_restore_failed', { error: toErrorMeta(error) });
+                });
+                await fs.rm(tempPath, { force: true }).catch(() => undefined);
+                this.pendingTurnErrors.clear();
+                this.attachedThreads.clear();
+                await this.app.restart().catch((error) => {
+                    this.logger.warn('codex.auth_sync_restart_restore_failed', { error: toErrorMeta(error) });
+                });
             }
-            return { ok: true };
-        }
-        catch (error) {
-            return { ok: false, reason: formatUserError(error) };
         }
         finally {
-            await restoreCodexAuthTarget(state.authDir, state.authPath, state.currentTargetPath, originalRegularAuth).catch((error) => {
-                this.logger.warn('codex.auth_sync_restore_failed', { error: toErrorMeta(error) });
-            });
-            await fs.rm(tempPath, { force: true }).catch(() => undefined);
-            this.pendingTurnErrors.clear();
-            this.attachedThreads.clear();
-            await this.app.restart().catch((error) => {
-                this.logger.warn('codex.auth_sync_restart_restore_failed', { error: toErrorMeta(error) });
-            });
+            this.externalAuthValidationInProgress = false;
         }
     }
     isIdleForServiceUpdate() {
@@ -2975,7 +3016,9 @@ export class BridgeSessionCore {
             && this.pendingMcpElicitations.size === 0
             && this.pendingLoginsByScope.size === 0
             && !this.authRotationInProgress
-            && !this.authRefreshAllInProgress;
+            && !this.authRefreshAllInProgress
+            && !this.externalAuthValidationInProgress
+            && this.turnStartInProgress === 0;
     }
     hasLocalBlockingActivity() {
         return !this.isIdleForServiceUpdate();
@@ -4738,13 +4781,13 @@ export class BridgeSessionCore {
             throw error;
         }
     }
-    async deleteCodexAuthCandidate(candidate) {
+    async deleteCodexAuthCandidate(candidate, reason = null) {
         const wasCurrent = candidate.isCurrent;
         const authDir = this.resolveAuthDir();
         const authPath = path.join(authDir, 'auth.json');
         let deletedByCoordinator = false;
         try {
-            await this.coordinator?.authCandidateDeleted?.(this.authRuntimeId(), candidate.name);
+            await this.coordinator?.authCandidateDeleted?.(this.authRuntimeId(), candidate.name, reason);
             deletedByCoordinator = Boolean(this.coordinator?.authCandidateDeleted);
         }
         catch (error) {
@@ -4761,6 +4804,12 @@ export class BridgeSessionCore {
             }
         }
         this.store.deleteCodexAuthCandidate(candidate.name);
+        if (isInvalidCodexAuthDeleteReason(reason)) {
+            this.store.recordCodexAuthCandidateInvalidDelete(candidate.name, reason);
+        }
+        else {
+            this.store.recordCodexAuthCandidateRemoved(candidate.name, reason);
+        }
         this.authRotationFailedTargets.delete(candidate.path);
         const snapshots = await this.readCodexAuthQuotaSnapshots();
         if (Object.prototype.hasOwnProperty.call(snapshots, candidate.name)) {
@@ -5069,10 +5118,58 @@ export class BridgeSessionCore {
         const features = await this.app.listExperimentalFeatures();
         await this.sendMessage(scopeId, formatFeaturesMessage(locale, features));
     }
-    async handleConfigCommand(scopeId, locale) {
+    async handleConfigCommand(scopeId, locale, args = []) {
+        const action = args[0]?.toLowerCase() ?? '';
+        if (['auth_auto_delete', 'auth-auto-delete', 'auto_delete_needs_repair', 'auto-delete-needs-repair'].includes(action)) {
+            const enabled = parseConfigBooleanArg(args[1]);
+            if (enabled === null) {
+                await this.sendMessage(scopeId, t(locale, 'config_auth_auto_delete_usage'));
+                return;
+            }
+            const update = await this.setAuthAutoDeleteNeedsRepair(enabled);
+            const binding = this.store.getBinding(scopeId);
+            const result = await this.app.readConfig(binding?.cwd ?? this.config.defaultCwd, true);
+            await this.sendMessage(scopeId, `${this.formatConfigToggleUpdate(locale, update)}\n\n${formatConfigMessage(locale, result, this.config, this.store.getCodexAuthPoolStats())}`, configKeyboard(locale, this.config));
+            return;
+        }
         const binding = this.store.getBinding(scopeId);
         const result = await this.app.readConfig(binding?.cwd ?? this.config.defaultCwd, true);
-        await this.sendMessage(scopeId, formatConfigMessage(locale, result));
+        await this.sendMessage(scopeId, formatConfigMessage(locale, result, this.config, this.store.getCodexAuthPoolStats()), configKeyboard(locale, this.config));
+    }
+    async handleConfigToggleCallback(event, enabled, locale) {
+        const update = await this.setAuthAutoDeleteNeedsRepair(enabled);
+        await this.messaging.answerCallback(event.callbackQueryId, t(locale, 'decision_recorded'));
+        const binding = this.store.getBinding(event.scopeId);
+        const result = await this.app.readConfig(binding?.cwd ?? this.config.defaultCwd, true);
+        const message = `${this.formatConfigToggleUpdate(locale, update)}\n\n${formatConfigMessage(locale, result, this.config, this.store.getCodexAuthPoolStats())}`;
+        if (event.messageId !== null) {
+            await this.editMessage(event.scopeId, event.messageId, message, configKeyboard(locale, this.config));
+        }
+        else {
+            await this.sendMessage(event.scopeId, message, configKeyboard(locale, this.config));
+        }
+    }
+    async setAuthAutoDeleteNeedsRepair(enabled) {
+        this.config.authAutoDeleteNeedsRepair = enabled;
+        const envPath = this.config.envPath;
+        if (!envPath) {
+            return { enabled, envPath: null, envUpdated: false, envError: null };
+        }
+        try {
+            await writeEnvBoolean(envPath, 'AUTH_AUTO_DELETE_NEEDS_REPAIR', enabled);
+            return { enabled, envPath, envUpdated: true, envError: null };
+        }
+        catch (error) {
+            this.logger.warn('config.env_update_failed', { key: 'AUTH_AUTO_DELETE_NEEDS_REPAIR', envPath, error: toErrorMeta(error) });
+            return { enabled, envPath, envUpdated: false, envError: formatUserError(error) };
+        }
+    }
+    formatConfigToggleUpdate(locale, update) {
+        const lines = [t(locale, 'config_auth_auto_delete_updated', { value: t(locale, update.enabled ? 'yes' : 'no') })];
+        if (update.envError) {
+            lines.push(t(locale, 'config_env_update_failed', { value: update.envPath ?? t(locale, 'unknown'), error: update.envError }));
+        }
+        return lines.join('\n');
     }
     async handleRequirementsCommand(scopeId, locale) {
         const requirements = await this.app.readConfigRequirements();
@@ -5424,7 +5521,10 @@ export class BridgeSessionCore {
                     }
                     return false;
                 }
-                this.markCodexAuthCandidateNeedsRepair(current.name);
+                const disposition = await this.markCodexAuthCandidateNeedsRepair(current.name);
+                if (disposition.deleted) {
+                    await this.sendMessage(rotation.scopeId, formatCodexAuthPoolSummary(locale, this.store.getCodexAuthPoolStats()));
+                }
             }
             const selection = await this.selectNextCodexAuthCandidate(failedTargets);
             if (!selection) {
@@ -5434,10 +5534,12 @@ export class BridgeSessionCore {
                 return false;
             }
             const { candidate, fromLabel, toLabel } = selection;
-            await this.sendMessage(rotation.scopeId, t(locale, 'auth_auto_switching', {
-                ...this.codexAuthSwitchParams(locale, fromLabel, toLabel),
-                error: formatShortStatusError(rotation.reason),
-            }));
+            await this.sendMessage(rotation.scopeId, this.config.authAutoDeleteNeedsRepair
+                ? t(locale, 'auth_auto_switching_quiet', { error: formatShortStatusError(rotation.reason) })
+                : t(locale, 'auth_auto_switching', {
+                    ...this.codexAuthSwitchParams(locale, fromLabel, toLabel),
+                    error: formatShortStatusError(rotation.reason),
+                }));
             const outcome = await this.switchCodexAuthAndRestart(rotation.scopeId, locale, candidate, true);
             if (!outcome.ok) {
                 return false;
@@ -5525,6 +5627,7 @@ export class BridgeSessionCore {
     }
     async listCodexAuthState() {
         const state = await listCodexAuthState(this.store.listDisabledCodexAuthCandidateNames(this.authRuntimeId()), this.store.listCodexAuthCandidateStates(this.authRuntimeId()), this.resolveAuthDir());
+        this.store.recordCodexAuthPoolInventory(state.candidates.map(candidate => candidate.name));
         const snapshots = await this.readCodexAuthQuotaSnapshots();
         const candidateQuotaIdentities = await this.readCodexAuthCandidateQuotaIdentities(state.candidates);
         state.candidates.forEach((candidate) => {
@@ -5571,7 +5674,6 @@ export class BridgeSessionCore {
         await this.app.restart();
         const validation = await this.validateCurrentCodexAuthCandidate(candidate);
         if (!validation.ok) {
-            this.markCodexAuthCandidateNeedsRepair(candidate.name);
             let restoredPrevious = false;
             try {
                 await restoreCodexAuthTarget(initialState.authDir, initialState.authPath, initialState.currentTargetPath, originalRegularAuth);
@@ -5586,6 +5688,7 @@ export class BridgeSessionCore {
                     error: toErrorMeta(error),
                 });
             }
+            const repairDisposition = await this.markCodexAuthCandidateNeedsRepair(candidate.name);
             const outcome = {
                 ...result,
                 ok: false,
@@ -5593,6 +5696,8 @@ export class BridgeSessionCore {
                 recovered,
                 error: validation.error,
                 restoredPrevious,
+                autoDeleted: repairDisposition.deleted,
+                deleteRestarted: repairDisposition.restarted,
             };
             if (sendResult) {
                 const lines = this.formatAuthSwitchValidationLines(locale, outcome);
@@ -5609,11 +5714,15 @@ export class BridgeSessionCore {
             recovered,
             error: null,
             restoredPrevious: false,
+            autoDeleted: false,
+            deleteRestarted: false,
         };
         if (!sendResult) {
             return outcome;
         }
-        const lines = [t(locale, automatic ? 'auth_auto_done' : 'auth_switch_done', this.codexAuthSwitchParams(locale, result.fromLabel, result.toLabel))];
+        const lines = [automatic && this.config.authAutoDeleteNeedsRepair
+                ? t(locale, 'auth_auto_done_quiet')
+                : t(locale, automatic ? 'auth_auto_done' : 'auth_switch_done', this.codexAuthSwitchParams(locale, result.fromLabel, result.toLabel))];
         if (recovered) {
             lines.push(t(locale, 'auth_recovered_newer_candidate', { value: candidate.name }));
         }
@@ -5662,12 +5771,19 @@ export class BridgeSessionCore {
         if (outcome.ok) {
             return [];
         }
+        const validationKey = outcome.autoDeleted && this.config.authAutoDeleteNeedsRepair
+            ? 'auth_switch_validation_auto_deleted_quiet'
+            : outcome.autoDeleted
+                ? 'auth_switch_validation_auto_deleted'
+                : 'auth_switch_validation_failed';
         return [
-            t(locale, 'auth_switch_validation_failed', {
+            t(locale, validationKey, {
                 value: outcome.candidateName,
                 error: outcome.error ?? t(locale, 'unknown'),
             }),
             outcome.restoredPrevious ? t(locale, 'auth_switch_validation_reverted') : '',
+            outcome.deleteRestarted ? t(locale, 'auth_delete_current_restarted') : '',
+            outcome.autoDeleted ? formatCodexAuthPoolSummary(locale, this.store.getCodexAuthPoolStats()) : '',
         ].filter(Boolean);
     }
     async recoverCodexAuthCandidate(candidateName, options = { crossNode: true }) {
@@ -5686,8 +5802,23 @@ export class BridgeSessionCore {
             return false;
         }
     }
-    markCodexAuthCandidateNeedsRepair(candidateName) {
+    async markCodexAuthCandidateNeedsRepair(candidateName) {
+        if (this.config.authAutoDeleteNeedsRepair) {
+            const candidate = (await this.listCodexAuthState()).candidates.find(entry => entry.name === candidateName) ?? null;
+            if (!candidate) {
+                this.store.deleteCodexAuthCandidate(candidateName);
+                this.store.recordCodexAuthCandidateInvalidDelete(candidateName, AUTH_DELETE_REASON_NEEDS_REPAIR);
+                return { deleted: true, restarted: false };
+            }
+            const restarted = await this.deleteCodexAuthCandidate(candidate, AUTH_DELETE_REASON_NEEDS_REPAIR);
+            this.logger.warn('codex.auth_candidate_auto_deleted', {
+                candidate: candidateName,
+                runtimeId: this.authRuntimeId(),
+            });
+            return { deleted: true, restarted };
+        }
         this.store.setCodexAuthCandidateState(candidateName, 'needs_repair');
+        return { deleted: false, restarted: false };
     }
     markCodexAuthCandidateActive(candidateName) {
         this.store.setCodexAuthCandidateState(candidateName, 'active');
@@ -6913,36 +7044,46 @@ export class BridgeSessionCore {
     }
     async startBoundTurnFromEvent(event, locale, text) {
         const scopeId = event.scopeId;
-        this.clearPlanImplementationPromptsForScope(scopeId);
-        await this.stopWatchingScopeThread(scopeId);
-        const existingBinding = this.store.getBinding(scopeId);
-        const binding = existingBinding
-            ? await this.ensureThreadReady(scopeId, existingBinding)
-            : await this.createBinding(scopeId, null);
-        await this.sendTyping(scopeId);
-        const previewMessageId = 0;
+        if (this.externalAuthValidationInProgress) {
+            await this.sendMessage(scopeId, t(locale, 'auth_sync_validation_busy'));
+            return;
+        }
+        this.turnStartInProgress += 1;
         try {
-            const input = await this.buildTurnInput(binding, { ...event, text }, locale);
-            const turnState = await this.startTurnWithRecovery(scopeId, binding, input);
-            if (turnState.collaborationMode === 'plan') {
-                this.store.setChatCollaborationMode(scopeId, DEFAULT_COLLABORATION_MODE);
+            this.clearPlanImplementationPromptsForScope(scopeId);
+            await this.stopWatchingScopeThread(scopeId);
+            const existingBinding = this.store.getBinding(scopeId);
+            const binding = existingBinding
+                ? await this.ensureThreadReady(scopeId, existingBinding)
+                : await this.createBinding(scopeId, null);
+            await this.sendTyping(scopeId);
+            const previewMessageId = 0;
+            try {
+                const input = await this.buildTurnInput(binding, { ...event, text }, locale);
+                const turnState = await this.startTurnWithRecovery(scopeId, binding, input);
+                if (turnState.collaborationMode === 'plan') {
+                    this.store.setChatCollaborationMode(scopeId, DEFAULT_COLLABORATION_MODE);
+                }
+                await this.registerActiveTurn(scopeId, event.chatId, event.chatType, event.topicId, turnState.threadId, turnState.turnId, previewMessageId, {
+                    input,
+                    threadId: turnState.threadId,
+                    cwd: this.store.getBinding(scopeId)?.cwd ?? binding.cwd ?? this.config.defaultCwd,
+                    chatId: event.chatId,
+                    chatType: event.chatType,
+                    topicId: event.topicId,
+                    collaborationMode: turnState.collaborationMode,
+                    failedAuthTargets: new Set(),
+                }, turnState.collaborationMode);
             }
-            await this.registerActiveTurn(scopeId, event.chatId, event.chatType, event.topicId, turnState.threadId, turnState.turnId, previewMessageId, {
-                input,
-                threadId: turnState.threadId,
-                cwd: this.store.getBinding(scopeId)?.cwd ?? binding.cwd ?? this.config.defaultCwd,
-                chatId: event.chatId,
-                chatType: event.chatType,
-                topicId: event.topicId,
-                collaborationMode: turnState.collaborationMode,
-                failedAuthTargets: new Set(),
-            }, turnState.collaborationMode);
-        }
-        catch (error) {
-            if (previewMessageId > 0) {
-                await this.cleanupTransientPreview(scopeId, previewMessageId);
+            catch (error) {
+                if (previewMessageId > 0) {
+                    await this.cleanupTransientPreview(scopeId, previewMessageId);
+                }
+                throw error;
             }
-            throw error;
+        }
+        finally {
+            this.turnStartInProgress -= 1;
         }
     }
     async requestInterrupt(active) {
@@ -8045,7 +8186,7 @@ function formatFeaturesMessage(locale, features) {
     }
     return lines.join('\n');
 }
-function formatConfigMessage(locale, result) {
+function formatConfigMessage(locale, result, appConfig, authPoolStats) {
     const config = result.config && typeof result.config === 'object' ? result.config : {};
     const layers = Array.isArray(result.layers) ? result.layers : [];
     const keys = ['model', 'model_provider', 'approval_policy', 'sandbox_mode', 'web_search', 'service_tier', 'profile', 'review_model'];
@@ -8055,8 +8196,62 @@ function formatConfigMessage(locale, result) {
         lines.push(`${key}: ${value === null || value === undefined ? '-' : formatConfigValue(value)}`);
     }
     lines.push(t(locale, 'config_layers', { count: layers.length }));
+    lines.push('');
+    lines.push(t(locale, 'config_foxclaw_title'));
+    lines.push(t(locale, 'config_auth_auto_delete_needs_repair', {
+        value: t(locale, appConfig.authAutoDeleteNeedsRepair ? 'yes' : 'no'),
+    }));
+    lines.push(`AUTH_AUTO_DELETE_NEEDS_REPAIR=${appConfig.authAutoDeleteNeedsRepair ? 'true' : 'false'}`);
+    lines.push(formatCodexAuthPoolSummary(locale, authPoolStats));
     return lines.join('\n');
 }
+function formatCodexAuthPoolSummary(locale, stats) {
+    return t(locale, 'auth_pool_summary', {
+        total: stats.totalSeen,
+        alive: stats.alive,
+        deleted: stats.deletedInvalid,
+    });
+}
+function isInvalidCodexAuthDeleteReason(reason) {
+    return reason === AUTH_DELETE_REASON_NEEDS_REPAIR;
+}
+function configKeyboard(locale, appConfig) {
+    const enabled = appConfig.authAutoDeleteNeedsRepair;
+    return [[{
+                text: t(locale, enabled ? 'button_config_auth_auto_delete_off' : 'button_config_auth_auto_delete_on'),
+                callback_data: `config:auth_auto_delete:${enabled ? 'off' : 'on'}`,
+            }]];
+}
+function parseConfigBooleanArg(value) {
+    const normalized = value?.trim().toLowerCase();
+    if (!normalized)
+        return null;
+    if (['1', 'true', 'yes', 'on', 'enable', 'enabled'].includes(normalized))
+        return true;
+    if (['0', 'false', 'no', 'off', 'disable', 'disabled'].includes(normalized))
+        return false;
+    return null;
+}
+async function writeEnvBoolean(envPath, key, enabled) {
+    await fs.mkdir(path.dirname(envPath), { recursive: true });
+    const nextLine = `${key}=${enabled ? 'true' : 'false'}`;
+    let contents = '';
+    try {
+        contents = await fs.readFile(envPath, 'utf8');
+    }
+    catch {
+        await fs.writeFile(envPath, `${nextLine}\n`, { encoding: 'utf8', mode: 0o600 });
+        return;
+    }
+    const pattern = new RegExp(`(^|\\n)[ \\t#]*${escapeRegExp(key)}\\s*=.*(?=\\r?\\n|$)`);
+    const nextContents = pattern.test(contents)
+        ? contents.replace(pattern, (_match, prefix) => `${prefix}${nextLine}`)
+        : `${contents}${contents.endsWith('\n') || contents.length === 0 ? '' : '\n'}${nextLine}\n`;
+    await fs.writeFile(envPath, nextContents, { encoding: 'utf8', mode: 0o600 });
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
 function formatRequirementsMessage(locale, requirements) {
     const lines = [t(locale, 'requirements_title')];
     if (!requirements) {