@foxden-app/foxclaw 0.7.2 → 0.10.0

package/dist/controller/controller.js

@@ -2,6 +2,7 @@ import crypto from 'node:crypto';
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
+import { externalWriterControl } from '../codex_app/force_takeover.js';
 import { TELEGRAM_VOICE_MAX_BYTES, TELEGRAM_VOICE_SUPPORTED_EXTENSIONS, telegramVoiceContentType, } from '../voice/files.js';
 import { normalizeLocale, t } from '../i18n.js';
 import { chatGptAuthMetadataMatchesCandidateName, parseChatGptAuthMetadata, readChatGptAuthRecord, readChatGptAuthMetadata, } from '../auth/mirror.js';
@@ -25,6 +26,7 @@ import { normalizeAccessPreset, resolveAccessMode } from './access.js';
 import { diffObservedTurn, findLatestTurn, findLiveTurn } from './observer.js';
 import { applySessionLog, bootstrapSessionLog, splitJsonlChunk, } from './session_observer.js';
 import { renderActiveTurnStatus } from './status.js';
+import { formatMetricTokenCount } from '../store/token_usage.js';
 import { writeRuntimeStatus } from '../runtime.js';
 const AUTH_DELETE_REASON_NEEDS_REPAIR = 'needs_repair';
 const RESTART_PREVIEW_RECOVERY_RETRY_DELAYS_MS = [3000, 7000, 15_000, 30_000, 45_000, 60_000, 60_000, 60_000];
@@ -64,6 +66,8 @@ const DYNAMIC_HELP_COMMANDS = [
     { key: 'quota', line: '/quota' },
     { key: 'update', line: '/update' },
     { key: 'login_device', line: '/login_device' },
+    { key: 'login_cancel', line: '/login_cancel' },
+    { key: 'cli', line: '/cli' },
     { key: 'threads_archived', line: '/threads archived [query]' },
     { key: 'open', line: '/open <n>' },
     { key: 'goal', line: '/goal [objective|pause|resume|done|budget <tokens|off>|clear confirm]' },
@@ -122,6 +126,9 @@ export class BridgeSessionCore {
     pendingUserInputs = new Map();
     pendingMcpElicitations = new Map();
     pendingLoginsByScope = new Map();
+    externalWriterControl = externalWriterControl;
+    forceTakeoversInProgress = new Set();
+    pendingForceTakeovers = new Map();
     pendingLoginScopesById = new Map();
     pendingAuthAddsByLoginId = new Map();
     latestTurnDiffs = new Map();
@@ -182,9 +189,7 @@ export class BridgeSessionCore {
             this.updateStatus();
         });
         this.bot.on('text', (event) => {
-            void this.withLock(event.scopeId, async () => this.handleText(event)).catch((error) => {
-                void this.handleAsyncError('telegram.text', error, event.scopeId);
-            });
+            this.dispatchInboundLikeTelegramText(event);
         });
         this.bot.on('callback', (event) => {
             void this.handleCallback(event).catch((error) => {
@@ -197,10 +202,23 @@ export class BridgeSessionCore {
      * (used by the Weixin adapter).
      */
     dispatchInboundLikeTelegramText(event) {
-        void this.withLock(event.scopeId, async () => this.handleText(event)).catch((error) => {
+        const command = event.attachments.length === 0 ? parseCommand(event.text) : null;
+        const name = command?.name;
+        // Recovery commands must remain reachable while a normal command is waiting.
+        // handleText still performs normal addressing and authorization checks.
+        const urgent = name && (['status', 'cli', 'login_cancel', 'interrupt'].includes(name)
+            || (name === 'auth' && command?.args[0] === 'sync' && ['status', 'events', 'trace'].includes(command.args[1] ?? 'status')));
+        const task = urgent ? this.handleText(event) : this.withLock(event.scopeId, async () => this.handleText(event));
+        void task.catch((error) => {
             void this.handleAsyncError('channel.text', error, event.scopeId);
         });
     }
+    hasPendingInteraction(scopeId) {
+        return this.pendingThreadRenames.has(scopeId)
+            || this.pendingThreadNewCwds.has(scopeId)
+            || this.pendingUserInputs.has(scopeId)
+            || this.pendingForceTakeovers.has(scopeId);
+    }
     /** Start Codex app-server transport and attach RPC listeners. */
     async startCodexApp() {
         this.stopping = false;
@@ -230,6 +248,15 @@ export class BridgeSessionCore {
             this.attachedThreads.clear();
             this.threadTokenUsageAlerts.clear();
             if (!this.stopping) {
+                if (!this.codexReconnectPending) {
+                    for (const scopeId of new Set([...this.activeTurns.values()].filter(active => !active.isObserved).map(active => active.scopeId))) {
+                        const locale = this.localeForChat(scopeId);
+                        void this.sendMessage(scopeId, locale === 'zh'
+                            ? 'Codex 连接中断，正在重连。任务结果尚未确认，请先用 /status 检查；也可用 /cli 从本机继续。'
+                            : 'Codex disconnected; reconnecting. The task result is unconfirmed. Check /status or use /cli locally.')
+                            .catch(error => this.logger.warn('codex.disconnect_notice_failed', { scopeId, error: toErrorMeta(error) }));
+                    }
+                }
                 this.codexReconnectPending = true;
                 this.pauseAppSnapshotWatchers();
             }
@@ -304,12 +331,13 @@ export class BridgeSessionCore {
         this.updateStatus();
     }
     getRuntimeStatus() {
+        const appServer = typeof this.app.getServerStatus === 'function' ? this.app.getServerStatus() : null;
         return {
             running: true,
-            connected: this.app.isConnected(),
-            userAgent: this.app.getUserAgent(),
+            connected: typeof this.app.isConnected === 'function' ? this.app.isConnected() : false,
+            userAgent: typeof this.app.getUserAgent === 'function' ? this.app.getUserAgent() : null,
             codexHome: this.config.codexHome ?? path.join(os.homedir(), '.codex'),
-            codexAppServer: this.app.getServerStatus(),
+            ...(appServer ? { codexAppServer: appServer } : {}),
             botUsername: this.botUsername,
             currentBindings: this.store.countBindings(),
             pendingApprovals: this.store.countPendingApprovals(),
@@ -539,6 +567,9 @@ export class BridgeSessionCore {
                         if (codexUpdateLine) {
                             lines.push(t(locale, 'status_last_codex_update', { value: codexUpdateLine }));
                         }
+                        if (lastUpdate.agyUpdate) {
+                            lines.push(locale === 'zh' ? `Antigravity CLI：${lastUpdate.agyUpdate}` : `Antigravity CLI: ${lastUpdate.agyUpdate}`);
+                        }
                     }
                     else {
                         lines.push(t(locale, 'status_last_update_none'));
@@ -582,6 +613,20 @@ export class BridgeSessionCore {
                 await this.handleLoginCancelCommand(scopeId, locale, args);
                 return;
             }
+            case 'cli': {
+                const binding = this.store.getBinding(scopeId);
+                const server = this.app.getServerStatus();
+                if (!server.running || !server.port) {
+                    await this.sendMessage(scopeId, locale === 'zh' ? 'Codex 服务不可用，请在本机检查 foxclaw status。' : 'Codex server unavailable. Check foxclaw status locally.');
+                    return;
+                }
+                const threadArg = binding ? ` ${JSON.stringify(binding.threadId)}` : '';
+                await this.sendMessage(scopeId, (locale === 'zh'
+                    ? '在运行桥的这台机器上执行，进入同一个 Codex 服务后可中断或继续会话：\n'
+                    : 'Run on the bridge host to interrupt or continue in the same Codex server:\n')
+                    + `codex resume --remote ws://127.0.0.1:${server.port}${threadArg}`);
+                return;
+            }
             case 'logout': {
                 await this.handleLogoutCommand(scopeId, locale, args);
                 return;
@@ -1072,6 +1117,21 @@ export class BridgeSessionCore {
     async handleCallback(event) {
         const scopeId = event.scopeId;
         const locale = this.localeForChat(scopeId, event.languageCode);
+        if (this.forceTakeoversInProgress.has(scopeId)) {
+            await this.messaging.answerCallback(event.callbackQueryId, t(locale, 'force_takeover_busy'));
+            return;
+        }
+        const forceTakeoverMatch = /^takeover:(confirm|cancel):([a-f0-9]+)$/.exec(event.data);
+        if (forceTakeoverMatch) {
+            await this.handleForceTakeoverCallback(event, locale, forceTakeoverMatch[1], forceTakeoverMatch[2]);
+            return;
+        }
+        const loginCancelMatch = /^login:cancel:(.+)$/.exec(event.data);
+        if (loginCancelMatch) {
+            await this.messaging.answerCallback(event.callbackQueryId, t(locale, 'button_cancel'));
+            await this.handleLoginCancelCommand(scopeId, locale, [loginCancelMatch[1]]);
+            return;
+        }
         const interruptMatch = /^turn:interrupt:(.+)$/.exec(event.data);
         if (interruptMatch) {
             await this.handleTurnInterruptCallback(event, interruptMatch[1], locale);
@@ -3432,7 +3492,9 @@ export class BridgeSessionCore {
             this.coordinator.statusUpdated(status);
             return;
         }
-        writeRuntimeStatus(this.config.statusPath, status);
+        if (this.config.statusPath) {
+            writeRuntimeStatus(this.config.statusPath, status);
+        }
     }
     async sendMessage(scopeId, text, inlineKeyboard) {
         return this.sendRichMarkdownMessage(scopeId, text, inlineKeyboard);
@@ -3654,7 +3716,9 @@ export class BridgeSessionCore {
         if (!scopeId)
             return;
         try {
-            await this.sendMessage(scopeId, t(this.localeForChat(scopeId), 'bridge_error', { error: formatUserError(error) }));
+            const locale = this.localeForChat(scopeId);
+            const hint = isThreadActiveWriterError(error) ? `\n${t(locale, 'force_takeover_hint')}` : '';
+            await this.sendMessage(scopeId, t(locale, 'bridge_error', { error: formatUserError(error) }) + hint);
         }
         catch (notifyError) {
             this.logger.error('telegram.error_notification_failed', { error: toErrorMeta(notifyError), scopeId });
@@ -3887,7 +3951,7 @@ export class BridgeSessionCore {
             }
         }
         for (const active of [...this.activeTurns.values()]) {
-            if (recoveredScopes.has(active.scopeId) || !this.getActiveTurn(active.scopeId, active.turnId)) {
+            if (active.isObserved || recoveredScopes.has(active.scopeId) || !this.getActiveTurn(active.scopeId, active.turnId)) {
                 continue;
             }
             try {
@@ -3900,6 +3964,10 @@ export class BridgeSessionCore {
                     turnId: active.turnId,
                     error: toErrorMeta(error),
                 });
+                await this.sendMessage(active.scopeId, this.localeForChat(active.scopeId) === 'zh'
+                    ? '连接已恢复，但无法确认原任务状态。任务未自动重发，请用 /cli 检查原会话后再继续。'
+                    : 'Connected again, but the original task state could not be confirmed. It was not resent. Use /cli to inspect the session.')
+                    .catch(notifyError => this.logger.warn('codex.recovery_notice_failed', { error: toErrorMeta(notifyError) }));
             }
         }
         await this.recoverQueuedTurns();
@@ -4246,6 +4314,10 @@ export class BridgeSessionCore {
         }
     }
     async handleTakeoverCommand(event, locale, args) {
+        if (args[0] === '--force') {
+            await this.prepareForceTakeover(event, locale, args.slice(1).join(' ').trim());
+            return;
+        }
         const scopeId = event.scopeId;
         const nextPrompt = args.join(' ').trim();
         if (!nextPrompt) {
@@ -4263,10 +4335,113 @@ export class BridgeSessionCore {
                 await this.requestInterrupt(active);
             }
             await this.sendMessage(scopeId, t(locale, 'interrupt_requested_waiting'));
-            await active.completion;
+            let timer;
+            try {
+                await Promise.race([
+                    active.completion,
+                    new Promise((_, reject) => {
+                        timer = setTimeout(() => reject(new Error(locale === 'zh'
+                            ? '等待中断完成超时，尚未发送新任务。请用 /status 检查，或用 /cli 从终端恢复。'
+                            : 'Interrupt confirmation timed out. No replacement task was sent. Check /status or use /cli to recover.')), 30_000);
+                    }),
+                ]);
+            }
+            finally {
+                clearTimeout(timer);
+            }
         }
         await this.startBoundTurnFromEvent(event, locale, nextPrompt);
     }
+    async prepareForceTakeover(event, locale, prompt) {
+        const scopeId = event.scopeId;
+        this.pendingForceTakeovers.delete(scopeId);
+        if (!prompt) {
+            await this.sendMessage(scopeId, t(locale, 'usage_takeover'));
+            return;
+        }
+        if (!scopeId.startsWith('telegram:') || event.userId !== this.config.tgAllowedUserId) {
+            await this.sendMessage(scopeId, t(locale, 'force_takeover_trusted_telegram_only'));
+            return;
+        }
+        const binding = this.store.getBinding(scopeId);
+        if (!binding) {
+            await this.sendMessage(scopeId, t(locale, 'watch_no_thread_bound'));
+            return;
+        }
+        const home = this.config.codexHome ?? process.env.CODEX_HOME ?? path.join(os.homedir(), '.codex');
+        try {
+            const writer = await this.externalWriterControl.inspect(home, binding.threadId);
+            const id = crypto.randomBytes(8).toString('hex');
+            this.pendingForceTakeovers.set(scopeId, {
+                id, expiresAt: Date.now() + 60_000, event, threadId: binding.threadId, home, prompt, writer,
+            });
+            await this.sendMessage(scopeId, t(locale, 'force_takeover_confirm', {
+                threadId: binding.threadId, pid: String(writer.pid), cwd: writer.cwd, prompt,
+            }), [[
+                    { text: t(locale, 'button_force_takeover'), callback_data: `takeover:confirm:${id}` },
+                    { text: t(locale, 'button_cancel'), callback_data: `takeover:cancel:${id}` },
+                ]]);
+        }
+        catch (error) {
+            this.pendingForceTakeovers.delete(scopeId);
+            await this.sendMessage(scopeId, t(locale, 'force_takeover_failed', { error: formatUserError(error) }));
+        }
+    }
+    async handleForceTakeoverCallback(event, locale, action, id) {
+        const scopeId = event.scopeId;
+        const pending = this.pendingForceTakeovers.get(scopeId);
+        if (!pending || pending.id !== id || pending.event.userId !== event.userId
+            || event.userId !== this.config.tgAllowedUserId || pending.expiresAt <= Date.now()) {
+            await this.messaging.answerCallback(event.callbackQueryId, t(locale, 'force_takeover_expired'));
+            return;
+        }
+        // Claim before any await: duplicate callbacks cannot stop or submit twice.
+        this.pendingForceTakeovers.delete(scopeId);
+        await this.messaging.answerCallback(event.callbackQueryId, t(locale, action === 'cancel' ? 'button_cancel' : 'button_force_takeover'));
+        if (action === 'cancel') {
+            await this.sendMessage(scopeId, t(locale, 'force_takeover_cancelled'));
+            return;
+        }
+        await this.withLock(scopeId, async () => {
+            if (pending.expiresAt <= Date.now() || this.store.getBinding(scopeId)?.threadId !== pending.threadId) {
+                await this.sendMessage(scopeId, t(locale, 'force_takeover_expired'));
+                return;
+            }
+            if (this.externalAuthValidationInProgress) {
+                await this.sendMessage(scopeId, t(locale, 'auth_sync_validation_busy'));
+                return;
+            }
+            this.forceTakeoversInProgress.add(scopeId);
+            this.turnStartInProgress += 1;
+            try {
+                try {
+                    await this.sendMessage(scopeId, t(locale, 'force_takeover_stopping', { pid: String(pending.writer.pid) }));
+                    await this.externalWriterControl.stop(pending.home, pending.threadId, pending.writer);
+                    this.logger.warn('codex.external_writer_stopped', { scopeId, threadId: pending.threadId, pid: pending.writer.pid });
+                    await this.stopWatchingScopeThread(scopeId);
+                    this.attachedThreads.delete(attachedThreadKey(scopeId, pending.threadId));
+                    // Never replace a missing thread with an unrelated new conversation.
+                    const binding = this.store.getBinding(scopeId);
+                    if (binding?.threadId !== pending.threadId)
+                        throw new Error(t(locale, 'force_takeover_expired'));
+                    await this.ensureThreadReady(scopeId, binding, { recoverMissingThread: false });
+                }
+                catch (error) {
+                    await this.sendMessage(scopeId, t(locale, 'force_takeover_failed', { error: formatUserError(error) }));
+                    return;
+                }
+                this.store.cancelQueuedTurnInputs(scopeId);
+                await this.sendMessage(scopeId, t(locale, 'force_takeover_acquired', { threadId: pending.threadId }));
+                // Normal turn-start error handling preserves ambiguous submission failures;
+                // do not automatically retry a possibly accepted prompt.
+                await this.startBoundTurnFromEvent(pending.event, locale, pending.prompt);
+            }
+            finally {
+                this.forceTakeoversInProgress.delete(scopeId);
+                this.turnStartInProgress -= 1;
+            }
+        });
+    }
     async handleQueueCommand(event, locale, args) {
         const scopeId = event.scopeId;
         const nextPrompt = args.join(' ').trim();
@@ -4882,6 +5057,9 @@ export class BridgeSessionCore {
             const rows = [
                 ['FoxClaw', `${status.fromVersion} -> ${status.toVersion ?? t(status.locale, 'unknown')}`, status.locale === 'zh' ? '升级完成，服务已重启' : 'Updated; service restarted'],
                 ['Codex CLI', formatSelfUpdateVersionTransition(status.codexFromVersion, status.codexToVersion, status.locale), formatCodexUpdateState(status)],
+                ...(status.agyFromVersion || status.agyUpdate ? [
+                    ['Antigravity (AGY)', formatSelfUpdateVersionTransition(status.agyFromVersion ?? null, status.agyToVersion ?? null, status.locale), status.agyUpdate ?? (status.locale === 'zh' ? '已检查更新' : 'Checked')]
+                ] : []),
                 [status.locale === 'zh' ? '集群广播' : 'Cluster broadcast', status.toVersion ?? t(status.locale, 'unknown'), broadcastLine],
             ];
             const notes = status.releaseNotes?.filter(note => note.trim()) ?? [];
@@ -4899,6 +5077,7 @@ export class BridgeSessionCore {
                 telegramBold(title),
                 escapeTelegramHtml(foxclawResult),
                 escapeTelegramHtml(codexUpdateLine ?? (status.locale === 'zh' ? 'Codex CLI：未执行升级。' : 'Codex CLI: not updated.')),
+                ...(status.agyUpdate ? [escapeTelegramHtml(`Antigravity CLI：${status.agyUpdate}`)] : []),
                 escapeTelegramHtml(broadcastLine),
                 releaseNotes ? escapeTelegramHtml(releaseNotes) : '',
             ].filter(Boolean).join('\n');
@@ -5376,7 +5555,7 @@ export class BridgeSessionCore {
                 t(locale, 'login_code', { value: login.userCode }),
                 t(locale, 'login_id', { value: login.loginId }),
                 t(locale, 'login_cancel_hint', { value: login.loginId }),
-            ].join('\n'));
+            ].join('\n'), this.loginCancelKeyboard(login.loginId, locale));
         }
         catch (error) {
             await this.restoreAuthAfterAddFailure(state.authDir, state.authPath, state.currentTargetPath);
@@ -5419,7 +5598,7 @@ export class BridgeSessionCore {
                 t(locale, 'login_code', { value: login.userCode }),
                 t(locale, 'login_id', { value: login.loginId }),
                 t(locale, 'login_cancel_hint', { value: login.loginId }),
-            ].join('\n'));
+            ].join('\n'), this.loginCancelKeyboard(login.loginId, locale));
         }
         catch (error) {
             await this.restoreAuthAfterAddFailure(state.authDir, state.authPath, state.currentTargetPath);
@@ -5584,6 +5763,11 @@ export class BridgeSessionCore {
         }
     }
     async handleLoginDeviceCommand(scopeId, locale) {
+        const pendingLoginId = this.pendingLoginsByScope.get(scopeId);
+        if (pendingLoginId) {
+            await this.sendMessage(scopeId, t(locale, 'login_cancel_hint', { value: pendingLoginId }), this.loginCancelKeyboard(pendingLoginId, locale));
+            return;
+        }
         const login = await this.app.startDeviceLogin();
         const oldLoginId = this.pendingLoginsByScope.get(scopeId);
         if (oldLoginId) {
@@ -5598,24 +5782,41 @@ export class BridgeSessionCore {
             t(locale, 'login_code', { value: login.userCode }),
             t(locale, 'login_id', { value: login.loginId }),
             t(locale, 'login_cancel_hint', { value: login.loginId }),
-        ].join('\n'));
+        ].join('\n'), this.loginCancelKeyboard(login.loginId, locale));
+    }
+    loginCancelKeyboard(loginId, locale) {
+        return [[{ text: t(locale, 'button_cancel'), callback_data: `login:cancel:${loginId}` }]];
     }
     async handleLoginCancelCommand(scopeId, locale, args) {
         const loginId = args[0]?.trim() || this.pendingLoginsByScope.get(scopeId) || null;
-        if (!loginId) {
+        if (!loginId || this.pendingLoginsByScope.get(scopeId) !== loginId) {
             await this.sendMessage(scopeId, t(locale, 'login_cancel_no_pending'));
             return;
         }
         const pendingAuthAdd = this.pendingAuthAddsByLoginId.get(loginId) ?? null;
-        await this.app.cancelLogin(loginId);
+        // Claim cancellation before awaiting RPC: completion notifications may arrive first.
         this.pendingLoginsByScope.delete(scopeId);
         this.pendingLoginScopesById.delete(loginId);
         this.pendingAuthAddsByLoginId.delete(loginId);
+        let cancelError;
+        try {
+            await this.app.cancelLogin(loginId);
+        }
+        catch (error) {
+            cancelError = error;
+            this.logger.warn('codex.login_cancel_failed', { error: toErrorMeta(error) });
+        }
         if (pendingAuthAdd) {
             await this.restorePendingAuthAdd(pendingAuthAdd);
             await this.sendMessage(scopeId, t(locale, 'auth_add_cancelled'));
             return;
         }
+        if (cancelError) {
+            await this.sendMessage(scopeId, locale === 'zh'
+                ? '已退出本地登录流程，但未能确认服务端取消。请勿继续使用旧验证码；可重新登录或用 /codex_restart 重置登录服务。'
+                : 'Local login flow cleared, but server cancellation is unconfirmed. Do not use the old code; start a new login or use /codex_restart.');
+            return;
+        }
         await this.sendMessage(scopeId, t(locale, 'login_cancelled'));
     }
     async handleLogoutCommand(scopeId, locale, args) {
@@ -6162,6 +6363,20 @@ export class BridgeSessionCore {
             await this.editAuthPanelMessage(event.scopeId, record.messageId, renderAuthListMessage(locale, state, this.authDisplayBotLabel(), parseWeixinBridgeScope(event.scopeId) !== null, record), authChoiceKeyboard(locale, record));
         }
     }
+    async refreshRepairedAuthChoice(event, record, candidateName, locale) {
+        const state = await this.listCodexAuthState();
+        if (state.candidates.find(candidate => candidate.name === candidateName)?.state === 'needs_repair')
+            return false;
+        record.candidates = state.candidates;
+        record.createdAt = Date.now();
+        clampCodexAuthListOffset(record);
+        await this.messaging.answerCallback(event.callbackQueryId, locale === 'zh'
+            ? '授权状态已变化，已刷新面板。' : 'Auth state changed; panel refreshed.');
+        if (record.messageId !== null) {
+            await this.editAuthPanelMessage(event.scopeId, record.messageId, renderAuthListMessage(locale, state, this.authDisplayBotLabel(), parseWeixinBridgeScope(event.scopeId) !== null, record), authChoiceKeyboard(locale, record));
+        }
+        return true;
+    }
     async handleAuthRepairMenuCallback(event, localId, index, locale) {
         const record = this.pendingAuthChoiceLists.get(localId);
         if (!record) {
@@ -6177,6 +6392,8 @@ export class BridgeSessionCore {
             await this.messaging.answerCallback(event.callbackQueryId, t(locale, 'unsupported_action'));
             return;
         }
+        if (await this.refreshRepairedAuthChoice(event, record, candidate.name, locale))
+            return;
         await this.messaging.answerCallback(event.callbackQueryId, t(locale, 'auth_repair_actions_short'));
         if (record.messageId !== null) {
             await this.editAuthPanelMessage(event.scopeId, record.messageId, t(locale, 'auth_repair_actions_message', { value: formatCodexAuthCandidateDisplayName(candidate.name) }), authRepairKeyboard(locale, record, index));
@@ -6197,6 +6414,8 @@ export class BridgeSessionCore {
             await this.messaging.answerCallback(event.callbackQueryId, t(locale, 'unsupported_action'));
             return;
         }
+        if (action !== 'cancel' && await this.refreshRepairedAuthChoice(event, record, candidate.name, locale))
+            return;
         if (action === 'cancel') {
             await this.messaging.answerCallback(event.callbackQueryId, t(locale, 'decision_recorded'));
             const state = await this.listCodexAuthState();
@@ -6847,11 +7066,11 @@ export class BridgeSessionCore {
                     events: formatTokenCount(stats.usageEvents),
                 }),
                 t(locale, 'status_codex_local_tokens', {
-                    total: formatTokenCount(stats.totals.totalTokens),
-                    input: formatTokenCount(stats.totals.inputTokens),
+                    total: formatCodexTokenCountWithMetric(stats.totals.totalTokens),
+                    input: formatCodexTokenCountWithMetric(stats.totals.inputTokens),
                     visible: formatTokenCount(Math.max(0, stats.totals.outputTokens - stats.totals.reasoningOutputTokens)),
-                    output: formatTokenCount(stats.totals.outputTokens),
-                    cached: formatTokenCount(stats.totals.cachedInputTokens),
+                    output: formatCodexTokenCountWithMetric(stats.totals.outputTokens),
+                    cached: formatCodexTokenCountWithMetric(stats.totals.cachedInputTokens),
                     reasoning: formatTokenCount(stats.totals.reasoningOutputTokens),
                 }),
                 ...this.formatCodexLocalResponseThroughputStatusLines(locale, stats),
@@ -6920,6 +7139,13 @@ export class BridgeSessionCore {
         this.localUsageCache = snapshot;
         this.localUsageCacheLoaded = true;
         await writeCodexLocalUsageSnapshot(this.codexLocalUsageSnapshotPath(), snapshot);
+        this.store.setBackendCumulativeTokenUsage({
+            inputTokens: stats.totals.inputTokens,
+            outputTokens: stats.totals.outputTokens,
+            cachedTokens: stats.totals.cachedInputTokens,
+            totalTokens: stats.totals.totalTokens,
+            turnsCount: stats.turns,
+        }, 'codex');
     }
     codexLocalUsageSnapshotPath() {
         return path.join(path.dirname(this.config.statusPath), this.runtimeSnapshotFilename(CODEX_LOCAL_USAGE_SNAPSHOT_FILENAME));
@@ -11829,6 +12055,12 @@ function formatTokenCount(value) {
     }
     return Math.round(value).toLocaleString('en-US');
 }
+function formatCodexTokenCountWithMetric(value) {
+    if (value >= 1_000_000) {
+        return `${formatMetricTokenCount(value)} (${formatTokenCount(value)})`;
+    }
+    return formatTokenCount(value);
+}
 function formatLocalTimestamp(seconds) {
     const date = new Date(seconds * 1000);
     const pad = (value) => String(value).padStart(2, '0');

package/dist/core/attachments.d.ts

@@ -0,0 +1,11 @@
+import type { Logger } from '../logger.js';
+import { type StagedTelegramAttachment, type TelegramInboundAttachment } from '../telegram/media.js';
+export interface TelegramFileDownloader {
+    getFile(fileId: string): Promise<{
+        file_id: string;
+        file_path?: string;
+        file_size?: number;
+    }>;
+    downloadResolvedFile(filePath: string, destination: string): Promise<unknown>;
+}
+export declare function stageInboundAttachments(downloader: TelegramFileDownloader, cwd: string, threadId: string, attachments: readonly TelegramInboundAttachment[], logger?: Logger): Promise<StagedTelegramAttachment[]>;

package/dist/core/attachments.js

@@ -0,0 +1,56 @@
+import fsPromises from 'node:fs/promises';
+import path from 'node:path';
+import { planAttachmentStoragePath, isNativeImageAttachment, TELEGRAM_BOT_API_DOWNLOAD_LIMIT_BYTES, } from '../telegram/media.js';
+export async function stageInboundAttachments(downloader, cwd, threadId, attachments, logger) {
+    const staged = [];
+    for (const attachment of attachments) {
+        try {
+            if (attachment.localPath) {
+                const planned = planAttachmentStoragePath(cwd, threadId, attachment, path.basename(attachment.localPath));
+                await fsPromises.mkdir(path.dirname(planned.localPath), { recursive: true });
+                await fsPromises.copyFile(attachment.localPath, planned.localPath);
+                const stat = await fsPromises.stat(planned.localPath);
+                const resolvedSize = stat.size;
+                staged.push({
+                    ...attachment,
+                    fileName: planned.fileName,
+                    fileSize: resolvedSize,
+                    localPath: planned.localPath,
+                    relativePath: planned.relativePath,
+                    nativeImage: isNativeImageAttachment(attachment),
+                });
+                continue;
+            }
+            const remoteFile = await downloader.getFile(attachment.fileId);
+            const resolvedSize = attachment.fileSize ?? remoteFile.file_size ?? null;
+            if (resolvedSize !== null && resolvedSize > TELEGRAM_BOT_API_DOWNLOAD_LIMIT_BYTES) {
+                logger?.warn('attachments.too_large', {
+                    fileId: attachment.fileId,
+                    size: resolvedSize,
+                });
+                continue;
+            }
+            if (!remoteFile.file_path) {
+                continue;
+            }
+            const planned = planAttachmentStoragePath(cwd, threadId, attachment, remoteFile.file_path);
+            await fsPromises.mkdir(path.dirname(planned.localPath), { recursive: true });
+            await downloader.downloadResolvedFile(remoteFile.file_path, planned.localPath);
+            staged.push({
+                ...attachment,
+                fileName: planned.fileName,
+                fileSize: resolvedSize,
+                localPath: planned.localPath,
+                relativePath: planned.relativePath,
+                nativeImage: isNativeImageAttachment(attachment),
+            });
+        }
+        catch (error) {
+            logger?.warn('attachments.download_failed', {
+                fileId: attachment.fileId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return staged;
+}

package/dist/core/engine_spi.d.ts

@@ -0,0 +1,76 @@
+import type { StagedTelegramAttachment } from '../telegram/media.js';
+import type { AppLocale } from '../types.js';
+export interface EngineModel {
+    id: string;
+    name: string;
+    description?: string | undefined;
+    isDefault?: boolean | undefined;
+}
+export interface EngineTurnRequest {
+    scopeId: string;
+    prompt: string;
+    stagedAttachments?: StagedTelegramAttachment[] | undefined;
+    threadId: string | null;
+    cwd: string;
+    model: string;
+    effort?: string | null | undefined;
+    serviceTier?: string | null | undefined;
+    locale: AppLocale;
+}
+export interface EngineToolEvent {
+    name: string;
+    args?: Record<string, unknown> | string | undefined;
+    output?: string | undefined;
+    status?: 'running' | 'completed' | 'failed' | undefined;
+    stepIndex?: number | undefined;
+    summary?: string | undefined;
+}
+export interface EngineTurnResult {
+    kind: 'result';
+    status: 'SUCCESS' | 'ERROR' | 'INTERRUPTED';
+    response: string;
+    error?: string | undefined;
+    conversationId: string | null;
+    usage?: {
+        inputTokens?: number | undefined;
+        outputTokens?: number | undefined;
+        cachedTokens?: number | undefined;
+        totalTokens?: number | undefined;
+    } | undefined;
+}
+export interface EngineTurnExecution {
+    turnId?: string | undefined;
+    cancel(): void;
+    waitForResult(): Promise<EngineTurnResult | null>;
+    on(event: 'delta', listener: (text: string) => void): void;
+    on(event: 'tool', listener: (tool: EngineToolEvent) => void): void;
+    on(event: 'result', listener: (result: EngineTurnResult) => void): void;
+    on(event: 'error', listener: (error: Error) => void): void;
+    on(event: 'exit', listener: (code: number | null) => void): void;
+}
+export interface EngineTurnErrorContext {
+    error: string;
+    request: EngineTurnRequest;
+    retryCount: number;
+    retryTurn: (retryCount: number) => Promise<void>;
+    sendMessage: (text: string) => Promise<number>;
+    editMessage: (messageId: number, text: string) => Promise<void>;
+}
+export interface IEngineAdapter {
+    readonly id: string;
+    readonly name: string;
+    listModels(): Promise<EngineModel[]>;
+    executeTurn(request: EngineTurnRequest): EngineTurnExecution;
+    preflightTurn?(request: EngineTurnRequest): Promise<void>;
+    handleTurnError?(context: EngineTurnErrorContext): Promise<boolean>;
+}
+export interface BackendDescriptor {
+    id: string;
+    name: string;
+    engineType: string;
+    adapter: IEngineAdapter;
+    account?: string | undefined;
+    details?: string | undefined;
+    isDefault?: boolean | undefined;
+    onSelect?: (scopeId: string) => Promise<void>;
+}

package/dist/core/engine_spi.js

@@ -0,0 +1 @@
+export {};