@foxden-app/foxclaw 0.3.17 → 0.3.19

package/dist/config.d.ts

@@ -7,12 +7,17 @@ export declare const DEFAULT_LOG_PATH: string;
 export declare const DEFAULT_LOCK_PATH: string;
 export declare const DEFAULT_CODEX_APP_SERVER_STATE_PATH: string;
 export declare const DEFAULT_CODEX_APP_SERVER_LOG_PATH: string;
+export declare const DEFAULT_CODEX_TELEGRAM_HOME: string;
 export declare const DEFAULT_ENV_PATH: string;
 export declare function resolveEnvPath(): string;
 export declare function getLoadedEnvPath(): string | null;
 export declare function loadEnv(): void;
 export interface AppConfig {
     tgBotToken: string;
+    tgBotTokens: string[];
+    tgMultiBotMode: boolean;
+    tgScopeBotId: string | null;
+    tgRequireExplicitGroupAddressing: boolean;
     tgAllowedUserId: string;
     tgAllowedChatId: string | null;
     tgAllowedTopicId: number | null;
@@ -21,6 +26,8 @@ export interface AppConfig {
     codexAppLaunchCmd: string;
     codexAppServerStatePath: string;
     codexAppServerLogPath: string;
+    codexAuthDir: string | null;
+    codexHome: string | null;
     codexAppSyncOnOpen: boolean;
     codexAppSyncOnTurnComplete: boolean;
     storePath: string;

package/dist/config.js

@@ -10,6 +10,7 @@ export const DEFAULT_LOG_PATH = path.join(APP_HOME, 'logs', 'service.log');
 export const DEFAULT_LOCK_PATH = path.join(APP_HOME, 'runtime', 'bridge.lock');
 export const DEFAULT_CODEX_APP_SERVER_STATE_PATH = path.join(APP_HOME, 'runtime', 'codex-app-server.json');
 export const DEFAULT_CODEX_APP_SERVER_LOG_PATH = path.join(APP_HOME, 'logs', 'codex-app-server.log');
+export const DEFAULT_CODEX_TELEGRAM_HOME = path.join(APP_HOME, 'codex', 'telegram');
 export const DEFAULT_ENV_PATH = path.join(APP_HOME, '.env');
 let envLoaded = false;
 let loadedEnvPath = null;
@@ -37,8 +38,22 @@ export function loadEnv() {
 }
 export function loadConfig() {
     loadEnv();
+    const configuredTokens = parseCommaSeparatedIds(process.env.TG_BOT_TOKENS);
+    const legacyToken = optional('TG_BOT_TOKEN');
+    const tgBotTokens = configuredTokens.length > 0
+        ? configuredTokens
+        : legacyToken
+            ? [legacyToken]
+            : [];
+    if (tgBotTokens.length === 0) {
+        throw new Error('TG_BOT_TOKENS or TG_BOT_TOKEN is required');
+    }
     const config = {
-        tgBotToken: required('TG_BOT_TOKEN'),
+        tgBotToken: tgBotTokens[0],
+        tgBotTokens,
+        tgMultiBotMode: configuredTokens.length > 0,
+        tgScopeBotId: null,
+        tgRequireExplicitGroupAddressing: configuredTokens.length > 1,
         tgAllowedUserId: required('TG_ALLOWED_USER_ID'),
         tgAllowedChatId: optional('TG_ALLOWED_CHAT_ID'),
         tgAllowedTopicId: nullableIntEnv('TG_ALLOWED_TOPIC_ID'),
@@ -47,6 +62,8 @@ export function loadConfig() {
         codexAppLaunchCmd: process.env.CODEX_APP_LAUNCH_CMD || 'codex app',
         codexAppServerStatePath: process.env.CODEX_APP_SERVER_STATE_PATH || DEFAULT_CODEX_APP_SERVER_STATE_PATH,
         codexAppServerLogPath: process.env.CODEX_APP_SERVER_LOG_PATH || DEFAULT_CODEX_APP_SERVER_LOG_PATH,
+        codexAuthDir: process.env.CODEX_AUTH_DIR?.trim() || null,
+        codexHome: process.env.CODEX_HOME?.trim() || null,
         codexAppSyncOnOpen: boolEnv('CODEX_APP_SYNC_ON_OPEN', true),
         codexAppSyncOnTurnComplete: boolEnv('CODEX_APP_SYNC_ON_TURN_COMPLETE', false),
         storePath: process.env.STORE_PATH || DEFAULT_STORE_PATH,

package/dist/controller/controller.d.ts

@@ -6,6 +6,11 @@ import type { TelegramGateway, TelegramTextEvent } from '../telegram/gateway.js'
 import { BridgeMessagingRouter } from '../channels/bridge_messaging_router.js';
 import type { CodexAppClient } from '../codex_app/client.js';
 import type { SelfUpdateRuntime } from '../update.js';
+export interface CoreCoordinator {
+    canSelfUpdate?: () => boolean;
+    authCandidateUpdated?: (runtimeId: string, candidateName: string) => Promise<void>;
+    statusUpdated?: (status: RuntimeStatus) => void;
+}
 export declare class BridgeSessionCore {
     private readonly config;
     private readonly store;
@@ -13,6 +18,7 @@ export declare class BridgeSessionCore {
     private readonly bot;
     private readonly app;
     private readonly selfUpdater;
+    private readonly coordinator;
     private activeTurns;
     private activeTurnsByTurnId;
     private observedThreadWatchers;
@@ -51,7 +57,7 @@ export declare class BridgeSessionCore {
     /** Last threads-panel pagination state per scope (Telegram inline nav + /open index alignment). */
     private threadListPresentationState;
     private readonly messaging;
-    constructor(config: AppConfig, store: BridgeStore, logger: Logger, bot: TelegramGateway, app: CodexAppClient, outbound: BridgeMessagingRouter, selfUpdater?: SelfUpdateRuntime | null);
+    constructor(config: AppConfig, store: BridgeStore, logger: Logger, bot: TelegramGateway, app: CodexAppClient, outbound: BridgeMessagingRouter, selfUpdater?: SelfUpdateRuntime | null, coordinator?: CoreCoordinator | null);
     /** Wire Telegram inbound events. Call before {@link startCodexApp}. */
     registerTelegramInboundHandlers(): void;
     /**
@@ -140,6 +146,10 @@ export declare class BridgeSessionCore {
     private stageAttachments;
     private registerActiveTurn;
     private createActiveTurnState;
+    isIdleForServiceUpdate(): boolean;
+    private hasLocalBlockingActivity;
+    private authRuntimeId;
+    private ownsScope;
     private setActiveTurn;
     private getActiveTurn;
     private getActiveTurnsForTurn;
@@ -261,13 +271,14 @@ export declare class BridgeSessionCore {
     private retryTurnAfterAuthRotation;
     private selectNextCodexAuthCandidate;
     private listCodexAuthState;
+    private resolveAuthDir;
     private readCodexAuthSwitchLabels;
     private codexAuthSwitchParams;
     private switchCodexAuthAndRestart;
     private buildNativeCollaborationMode;
     private buildCodexUsageStatusLines;
     private buildCodexLocalUsageStatusLines;
-    private formatCodexLocalOutputSpeedStatusLines;
+    private formatCodexLocalResponseThroughputStatusLines;
     private resolveFastStatusLabel;
     private readCachedCodexLocalUsageStats;
     private refreshCodexLocalUsageIfNeeded;
@@ -277,6 +288,7 @@ export declare class BridgeSessionCore {
     private readCodexAuthQuotaSnapshots;
     private writeCodexAuthQuotaSnapshots;
     private codexAuthQuotaSnapshotPath;
+    private runtimeSnapshotFilename;
     private sendThreadContextSummary;
     private handleModelCommand;
     private handleEffortCommand;

package/dist/controller/controller.js

@@ -93,6 +93,7 @@ export class BridgeSessionCore {
     bot;
     app;
     selfUpdater;
+    coordinator;
     activeTurns = new Map();
     activeTurnsByTurnId = new Map();
     observedThreadWatchers = new Map();
@@ -131,13 +132,14 @@ export class BridgeSessionCore {
     /** Last threads-panel pagination state per scope (Telegram inline nav + /open index alignment). */
     threadListPresentationState = new Map();
     messaging;
-    constructor(config, store, logger, bot, app, outbound, selfUpdater = null) {
+    constructor(config, store, logger, bot, app, outbound, selfUpdater = null, coordinator = null) {
         this.config = config;
         this.store = store;
         this.logger = logger;
         this.bot = bot;
         this.app = app;
         this.selfUpdater = selfUpdater;
+        this.coordinator = coordinator;
         this.messaging = outbound;
     }
     /** Wire Telegram inbound events. Call before {@link startCodexApp}. */
@@ -323,6 +325,7 @@ export class BridgeSessionCore {
                 allowedChatId: this.config.tgAllowedChatId,
                 allowedTopicId: this.config.tgAllowedTopicId,
                 topicId: event.topicId,
+                requireExplicitGroupAddressing: this.config.tgRequireExplicitGroupAddressing,
             }),
             replyToBot: event.replyToBot,
         });
@@ -1563,6 +1566,16 @@ export class BridgeSessionCore {
                 return;
             }
             const lines = [t(locale, 'auth_add_done', { value: pendingAuthAdd.name })];
+            try {
+                await this.coordinator?.authCandidateUpdated?.(this.authRuntimeId(), pendingAuthAdd.name);
+            }
+            catch (error) {
+                this.logger.warn('codex.auth_candidate_sync_failed', {
+                    candidate: pendingAuthAdd.name,
+                    runtimeId: this.authRuntimeId(),
+                    error: toErrorMeta(error),
+                });
+            }
             lines.push(...await this.buildCodexUsageStatusLines(locale));
             await this.sendMessage(scopeId, lines.join('\n'));
             return;
@@ -1572,7 +1585,7 @@ export class BridgeSessionCore {
             : t(locale, 'login_failed', { error: params?.error ?? t(locale, 'unknown') }));
     }
     async restorePendingAuthAdd(record) {
-        const state = await listCodexAuthState();
+        const state = await this.listCodexAuthState();
         await this.restoreAuthAfterAddFailure(state.authDir, state.authPath, record.previousTargetPath);
     }
     async restoreAuthAfterAddFailure(authDir, authPath, previousTargetPath) {
@@ -1849,6 +1862,9 @@ export class BridgeSessionCore {
     }
     async restorePendingUserInputs() {
         for (const stored of this.store.listPendingUserInputs()) {
+            if (!this.ownsScope(stored.chatId)) {
+                continue;
+            }
             const record = parseStoredPendingUserInput(stored);
             if (!record) {
                 this.store.markPendingUserInputResolved(stored.localId);
@@ -2535,6 +2551,34 @@ export class BridgeSessionCore {
             resolver,
         };
     }
+    isIdleForServiceUpdate() {
+        return this.activeTurns.size === 0
+            && this.pendingApprovalMessages.size === 0
+            && this.pendingUserInputs.size === 0
+            && this.pendingMcpElicitations.size === 0
+            && this.pendingLoginsByScope.size === 0
+            && !this.authRotationInProgress;
+    }
+    hasLocalBlockingActivity() {
+        return !this.isIdleForServiceUpdate();
+    }
+    authRuntimeId() {
+        return this.config.tgScopeBotId ?? 'default';
+    }
+    ownsScope(scopeId) {
+        if (scopeId.startsWith(BRIDGE_SCOPE_WEIXIN_PREFIX)) {
+            return this.messaging.hasWeixinTransport;
+        }
+        if (!this.config.tgScopeBotId) {
+            return parseTelegramTargetFromBridgeScope(scopeId).botId === null;
+        }
+        try {
+            return parseTelegramTargetFromBridgeScope(scopeId).botId === this.config.tgScopeBotId;
+        }
+        catch {
+            return false;
+        }
+    }
     setActiveTurn(scopeId, turnId, active) {
         const key = activeTurnKey(scopeId, turnId);
         this.activeTurns.set(key, active);
@@ -2785,7 +2829,7 @@ export class BridgeSessionCore {
             }
         }
         for (const scopeId of this.store.findAllChatIdsByThreadId(threadId)) {
-            if (!this.messaging.canSendToScope(scopeId)) {
+            if (!this.ownsScope(scopeId) || !this.messaging.canSendToScope(scopeId)) {
                 continue;
             }
             scopes.add(scopeId);
@@ -2818,7 +2862,12 @@ export class BridgeSessionCore {
         return next;
     }
     updateStatus() {
-        writeRuntimeStatus(this.config.statusPath, this.getRuntimeStatus());
+        const status = this.getRuntimeStatus();
+        if (this.coordinator?.statusUpdated) {
+            this.coordinator.statusUpdated(status);
+            return;
+        }
+        writeRuntimeStatus(this.config.statusPath, status);
     }
     async sendMessage(scopeId, text, inlineKeyboard) {
         return this.messaging.sendPlain(scopeId, text, inlineKeyboard);
@@ -3653,7 +3702,7 @@ export class BridgeSessionCore {
         ].join('\n'));
     }
     async handleAuthReloadCommand(scopeId, locale) {
-        if (this.activeTurns.size > 0 || this.store.countPendingApprovals() > 0 || this.pendingUserInputs.size > 0 || this.pendingMcpElicitations.size > 0) {
+        if (this.hasLocalBlockingActivity()) {
             await this.sendMessage(scopeId, t(locale, 'auth_reload_blocked_active'));
             return;
         }
@@ -3670,7 +3719,7 @@ export class BridgeSessionCore {
             await this.sendMessage(scopeId, t(locale, 'update_unavailable'));
             return;
         }
-        if (this.activeTurns.size > 0 || this.store.countPendingApprovals() > 0 || this.pendingUserInputs.size > 0 || this.pendingMcpElicitations.size > 0) {
+        if (!this.isIdleForServiceUpdate() || this.store.countPendingApprovals() > 0 || this.store.countPendingUserInputs() > 0 || (this.coordinator?.canSelfUpdate && !this.coordinator.canSelfUpdate())) {
             await this.sendMessage(scopeId, t(locale, 'update_blocked_active'));
             return;
         }
@@ -3721,17 +3770,23 @@ export class BridgeSessionCore {
             this.scheduleSelfUpdateStatusPoll();
             return;
         }
+        if (!this.ownsScope(status.scopeId)) {
+            this.scheduleSelfUpdateStatusPoll();
+            return;
+        }
         await this.sendMessage(status.scopeId, this.formatSelfUpdateResult(status));
         await this.selfUpdater?.clearStatus();
     }
     formatSelfUpdateResult(status) {
         if (status.state === 'succeeded') {
-            return t(status.locale, 'update_succeeded', {
+            const result = t(status.locale, 'update_succeeded', {
                 from: status.fromVersion,
                 to: status.toVersion ?? t(status.locale, 'unknown'),
             });
+            return status.codexUpdate ? `${result}\n${status.codexUpdate}` : result;
         }
-        return t(status.locale, 'update_failed', { error: status.error ?? t(status.locale, 'unknown') });
+        const result = t(status.locale, 'update_failed', { error: status.error ?? t(status.locale, 'unknown') });
+        return status.codexUpdate ? `${result}\n${status.codexUpdate}` : result;
     }
     async handleAuthCommand(scopeId, locale, args) {
         const action = args[0]?.toLowerCase() ?? 'list';
@@ -3769,7 +3824,7 @@ export class BridgeSessionCore {
         record.messageId = messageId;
     }
     async handleAuthUseCommand(scopeId, locale, args) {
-        if (this.activeTurns.size > 0 || this.store.countPendingApprovals() > 0 || this.pendingUserInputs.size > 0 || this.pendingMcpElicitations.size > 0) {
+        if (this.hasLocalBlockingActivity()) {
             await this.sendMessage(scopeId, t(locale, 'auth_reload_blocked_active'));
             return;
         }
@@ -3807,7 +3862,7 @@ export class BridgeSessionCore {
             await this.sendMessage(scopeId, renderAuthListMessage(locale, state, parseWeixinBridgeScope(scopeId) !== null));
             return;
         }
-        this.store.setCodexAuthCandidateDisabled(candidate.name, disabled);
+        this.store.setCodexAuthCandidateDisabled(candidate.name, disabled, this.authRuntimeId());
         await this.sendMessage(scopeId, t(locale, disabled ? 'auth_candidate_disabled' : 'auth_candidate_enabled', {
             value: candidate.name,
         }));
@@ -3825,7 +3880,7 @@ export class BridgeSessionCore {
         return latest;
     }
     async handleAuthAddCommand(scopeId, locale, args) {
-        if (this.activeTurns.size > 0 || this.store.countPendingApprovals() > 0 || this.pendingUserInputs.size > 0 || this.pendingMcpElicitations.size > 0) {
+        if (this.hasLocalBlockingActivity()) {
             await this.sendMessage(scopeId, t(locale, 'auth_reload_blocked_active'));
             return;
         }
@@ -4259,7 +4314,7 @@ export class BridgeSessionCore {
             return;
         }
         const disabled = !candidate.disabled;
-        this.store.setCodexAuthCandidateDisabled(candidate.name, disabled);
+        this.store.setCodexAuthCandidateDisabled(candidate.name, disabled, this.authRuntimeId());
         const state = await this.listCodexAuthState();
         record.candidates = state.candidates;
         await this.messaging.answerCallback(event.callbackQueryId, t(locale, disabled ? 'auth_candidate_disabled_short' : 'auth_candidate_enabled_short'));
@@ -4277,7 +4332,7 @@ export class BridgeSessionCore {
             await this.messaging.answerCallback(event.callbackQueryId, t(locale, 'auth_choice_mismatch'));
             return;
         }
-        if (this.activeTurns.size > 0 || this.store.countPendingApprovals() > 0 || this.pendingUserInputs.size > 0 || this.pendingMcpElicitations.size > 0) {
+        if (this.hasLocalBlockingActivity()) {
             await this.messaging.answerCallback(event.callbackQueryId, t(locale, 'auth_reload_blocked_active'));
             return;
         }
@@ -4299,7 +4354,7 @@ export class BridgeSessionCore {
         if (!this.pendingAuthRotation || this.authRotationInProgress) {
             return false;
         }
-        if (this.activeTurns.size > 0 || this.store.countPendingApprovals() > 0 || this.pendingUserInputs.size > 0 || this.pendingMcpElicitations.size > 0) {
+        if (this.hasLocalBlockingActivity()) {
             return false;
         }
         const rotation = this.pendingAuthRotation;
@@ -4398,13 +4453,19 @@ export class BridgeSessionCore {
         return candidate ? { candidate, fromLabel: state.currentLabel, toLabel: await authPathDisplayLabel(candidate.path) } : null;
     }
     async listCodexAuthState() {
-        const state = await listCodexAuthState(this.store.listDisabledCodexAuthCandidateNames());
+        const state = await listCodexAuthState(this.store.listDisabledCodexAuthCandidateNames(this.authRuntimeId()), this.resolveAuthDir());
         const snapshots = await this.readCodexAuthQuotaSnapshots();
         state.candidates.forEach((candidate) => {
             candidate.quota = snapshots[candidate.name] ?? null;
         });
         return state;
     }
+    resolveAuthDir() {
+        return this.config.codexAuthDir
+            ?? (this.config.tgMultiBotMode ? this.config.codexHome : null)
+            ?? process.env.CODEX_AUTH_DIR
+            ?? path.join(os.homedir(), '.codex');
+    }
     async readCodexAuthSwitchLabels(candidate) {
         const state = await this.listCodexAuthState();
         return {
@@ -4419,7 +4480,7 @@ export class BridgeSessionCore {
         };
     }
     async switchCodexAuthAndRestart(scopeId, locale, candidate, automatic) {
-        const result = await switchCodexAuth(candidate.path);
+        const result = await switchCodexAuth(candidate.path, this.resolveAuthDir());
         this.authRotationFailedTargets.delete(candidate.path);
         this.pendingTurnErrors.clear();
         this.attachedThreads.clear();
@@ -4544,11 +4605,12 @@ export class BridgeSessionCore {
                 t(locale, 'status_codex_local_tokens', {
                     total: formatTokenCount(stats.totals.totalTokens),
                     input: formatTokenCount(stats.totals.inputTokens),
+                    visible: formatTokenCount(Math.max(0, stats.totals.outputTokens - stats.totals.reasoningOutputTokens)),
                     output: formatTokenCount(stats.totals.outputTokens),
                     cached: formatTokenCount(stats.totals.cachedInputTokens),
                     reasoning: formatTokenCount(stats.totals.reasoningOutputTokens),
                 }),
-                ...this.formatCodexLocalOutputSpeedStatusLines(locale, stats),
+                ...this.formatCodexLocalResponseThroughputStatusLines(locale, stats),
                 t(locale, 'status_codex_local_snapshot_at', {
                     value: formatLocalTimestamp(snapshot.computedAtMs / 1000),
                 }),
@@ -4559,16 +4621,21 @@ export class BridgeSessionCore {
             return [t(locale, 'status_codex_local_usage_unavailable', { error: formatShortStatusError(error) })];
         }
     }
-    formatCodexLocalOutputSpeedStatusLines(locale, stats) {
-        const speed = stats.outputSpeed;
-        if (speed.samples === 0 || speed.outputTokens <= 0 || speed.seconds <= 0) {
+    formatCodexLocalResponseThroughputStatusLines(locale, stats) {
+        const throughput = stats.responseThroughput;
+        if (throughput.completedTurns === 0
+            || throughput.visibleOutputTokens <= 0
+            || throughput.seconds <= 0
+            || throughput.recentCompletedTurns === 0
+            || throughput.recentVisibleOutputTokens <= 0
+            || throughput.recentSeconds <= 0) {
             return [];
         }
-        const avg = speed.outputTokens / speed.seconds;
-        return [t(locale, 'status_codex_local_speed', {
-                avg: formatCompactNumber(avg),
-                latest: speed.latestTokensPerSecond === null ? t(locale, 'unknown') : formatCompactNumber(speed.latestTokensPerSecond),
-                samples: formatTokenCount(speed.samples),
+        return [t(locale, 'status_codex_local_throughput', {
+                overall: formatCompactNumber(throughput.visibleOutputTokens / throughput.seconds),
+                recent: formatCompactNumber(throughput.recentVisibleOutputTokens / throughput.recentSeconds),
+                recentTurns: formatTokenCount(throughput.recentCompletedTurns),
+                turns: formatTokenCount(throughput.completedTurns),
             })];
     }
     async resolveFastStatusLabel(locale, settings) {
@@ -4604,14 +4671,14 @@ export class BridgeSessionCore {
         await this.localUsageRefresh;
     }
     async refreshCodexLocalUsageStats() {
-        const stats = await readCodexLocalUsageStats();
+        const stats = await readCodexLocalUsageStats(this.config.codexHome ?? undefined);
         const snapshot = { computedAtMs: Date.now(), stats };
         this.localUsageCache = snapshot;
         this.localUsageCacheLoaded = true;
         await writeCodexLocalUsageSnapshot(this.codexLocalUsageSnapshotPath(), snapshot);
     }
     codexLocalUsageSnapshotPath() {
-        return path.join(path.dirname(this.config.statusPath), CODEX_LOCAL_USAGE_SNAPSHOT_FILENAME);
+        return path.join(path.dirname(this.config.statusPath), this.runtimeSnapshotFilename(CODEX_LOCAL_USAGE_SNAPSHOT_FILENAME));
     }
     async refreshCurrentCodexAuthQuota(state) {
         const candidate = state.candidates.find(entry => entry.isCurrent);
@@ -4663,7 +4730,13 @@ export class BridgeSessionCore {
         await fs.rename(temporaryPath, snapshotPath);
     }
     codexAuthQuotaSnapshotPath() {
-        return path.join(path.dirname(this.config.statusPath), CODEX_AUTH_QUOTA_SNAPSHOT_FILENAME);
+        return path.join(path.dirname(this.config.statusPath), this.runtimeSnapshotFilename(CODEX_AUTH_QUOTA_SNAPSHOT_FILENAME));
+    }
+    runtimeSnapshotFilename(filename) {
+        if (!this.config.tgScopeBotId) {
+            return filename;
+        }
+        return filename.replace(/\.json$/, `-${this.config.tgScopeBotId}.json`);
     }
     async sendThreadContextSummary(scopeId, locale, threadId) {
         try {
@@ -5582,6 +5655,9 @@ export class BridgeSessionCore {
     }
     async cleanupStaleTurnPreviews() {
         for (const preview of this.store.listActiveTurnPreviews()) {
+            if (!this.ownsScope(preview.scopeId)) {
+                continue;
+            }
             if (!this.messaging.canSendToScope(preview.scopeId)) {
                 this.store.removeActiveTurnPreview(preview.turnId);
                 this.logger.info('telegram.preview_dropped_disabled_channel', {
@@ -7113,11 +7189,11 @@ function parseActiveTurnKey(key) {
         turnId: decodeURIComponent(key.slice(split + 1)),
     };
 }
-function codexAuthDir() {
-    return process.env.CODEX_AUTH_DIR || path.join(os.homedir(), '.codex');
+function codexAuthDir(explicitAuthDir = null) {
+    return explicitAuthDir || process.env.CODEX_AUTH_DIR || path.join(os.homedir(), '.codex');
 }
-async function listCodexAuthState(disabledNames = new Set()) {
-    const authDir = codexAuthDir();
+async function listCodexAuthState(disabledNames = new Set(), explicitAuthDir = null) {
+    const authDir = codexAuthDir(explicitAuthDir);
     const authPath = path.join(authDir, 'auth.json');
     const currentTargetPath = await resolveCurrentAuthTarget(authDir, authPath);
     const candidates = [];
@@ -7216,8 +7292,8 @@ async function pointCodexAuthAtTarget(authDir, authPath, targetPath) {
         throw error;
     }
 }
-async function switchCodexAuth(targetPath) {
-    const state = await listCodexAuthState();
+async function switchCodexAuth(targetPath, explicitAuthDir = null) {
+    const state = await listCodexAuthState(new Set(), explicitAuthDir);
     const candidate = state.candidates.find(entry => entry.path === targetPath);
     if (!candidate) {
         throw new Error(`Auth candidate is no longer available: ${path.basename(targetPath)}`);

package/dist/core/bridge_scope.d.ts

@@ -7,12 +7,15 @@ export interface WeixinBridgeScope {
     accountId: string;
     fromUserId: string;
 }
+export interface TelegramBridgeTarget extends TelegramScope {
+    botId: string | null;
+}
 export declare function isBridgeScopedKey(key: string): boolean;
 /** Wrap legacy Telegram inner scope (`chat::topic`) for storage and routing. */
-export declare function toTelegramBridgeScopeId(telegramInnerScopeId: string): string;
+export declare function toTelegramBridgeScopeId(telegramInnerScopeId: string, botId?: string | null): string;
 /** Strip `telegram:` prefix; returns `null` if not a Telegram bridge scope. */
 export declare function telegramInnerScopeFromBridge(bridgeScopeId: string): string | null;
-export declare function parseTelegramTargetFromBridgeScope(bridgeScopeId: string): TelegramScope;
+export declare function parseTelegramTargetFromBridgeScope(bridgeScopeId: string): TelegramBridgeTarget;
 /** Parse `weixin:<accountId>:<from_user_id>`; returns `null` if not a Weixin scope. */
 export declare function parseWeixinBridgeScope(bridgeScopeId: string): WeixinBridgeScope | null;
 export declare function toWeixinBridgeScopeId(accountId: string, fromUserId: string): string;

package/dist/core/bridge_scope.js

@@ -7,8 +7,8 @@ export function isBridgeScopedKey(key) {
     return key.startsWith(BRIDGE_SCOPE_TELEGRAM_PREFIX) || key.startsWith(BRIDGE_SCOPE_WEIXIN_PREFIX);
 }
 /** Wrap legacy Telegram inner scope (`chat::topic`) for storage and routing. */
-export function toTelegramBridgeScopeId(telegramInnerScopeId) {
-    return `${BRIDGE_SCOPE_TELEGRAM_PREFIX}${telegramInnerScopeId}`;
+export function toTelegramBridgeScopeId(telegramInnerScopeId, botId = null) {
+    return `${BRIDGE_SCOPE_TELEGRAM_PREFIX}${botId ? `${botId}:` : ''}${telegramInnerScopeId}`;
 }
 /** Strip `telegram:` prefix; returns `null` if not a Telegram bridge scope. */
 export function telegramInnerScopeFromBridge(bridgeScopeId) {
@@ -22,7 +22,11 @@ export function parseTelegramTargetFromBridgeScope(bridgeScopeId) {
     if (inner === null) {
         throw new Error(`Expected ${BRIDGE_SCOPE_TELEGRAM_PREFIX} scope, got: ${bridgeScopeId}`);
     }
-    return parseTelegramScopeId(inner);
+    const namespaced = /^(bot\d+):(.*)$/.exec(inner);
+    if (!namespaced) {
+        return { ...parseTelegramScopeId(inner), botId: null };
+    }
+    return { ...parseTelegramScopeId(namespaced[2]), botId: namespaced[1] };
 }
 /** Parse `weixin:<accountId>:<from_user_id>`; returns `null` if not a Weixin scope. */
 export function parseWeixinBridgeScope(bridgeScopeId) {

package/dist/i18n.d.ts

@@ -111,8 +111,8 @@ declare const MESSAGES: {
         readonly status_codex_usage_reset: ", resets {value}";
         readonly status_codex_usage_unavailable: "Codex usage: unavailable ({error})";
         readonly status_codex_local_history: "Codex local history: {sessions} sessions, {turns} turns, {events} usage records";
-        readonly status_codex_local_tokens: "Codex local tokens: total {total}; input {input}, output {output}, cached input {cached}, reasoning output {reasoning}";
-        readonly status_codex_local_speed: "Codex local output speed: avg {avg} token/s, latest {latest} token/s ({samples} samples)";
+        readonly status_codex_local_tokens: "Codex local tokens: total {total}; input {input}, visible output {visible}, reasoning output {reasoning}, total output {output}, cached input {cached}";
+        readonly status_codex_local_throughput: "Codex visible reply throughput (end-to-end, excluding reasoning): overall {overall} token/s, last {recentTurns} completed turns {recent} token/s ({turns} completed turns sampled)";
         readonly status_codex_local_snapshot_at: "Codex local stats snapshot: {value}";
         readonly status_codex_local_usage_refreshing: "Codex local history: building snapshot in background";
         readonly status_codex_local_usage_unavailable: "Codex local history: unavailable ({error})";
@@ -675,8 +675,8 @@ declare const MESSAGES: {
         readonly status_codex_usage_reset: "，重置时间 {value}";
         readonly status_codex_usage_unavailable: "Codex 用量：无法获取（{error}）";
         readonly status_codex_local_history: "Codex 本地历史：{sessions} 个会话，{turns} 轮，{events} 条用量记录";
-        readonly status_codex_local_tokens: "Codex 本地 Token：总计 {total}；输入 {input}，输出 {output}，缓存输入 {cached}，推理输出 {reasoning}";
-        readonly status_codex_local_speed: "Codex 本地输出速度：平均 {avg} token/s，最近 {latest} token/s（{samples} 个样本）";
+        readonly status_codex_local_tokens: "Codex 本地 Token：总计 {total}；输入 {input}，可见输出 {visible}，推理输出 {reasoning}，总输出 {output}，缓存输入 {cached}";
+        readonly status_codex_local_throughput: "Codex 可见答复吞吐（端到端，排除推理 token）：整体 {overall} token/s，最近 {recentTurns} 个完成轮次 {recent} token/s（{turns} 个完成轮次样本）";
         readonly status_codex_local_snapshot_at: "Codex 本地统计快照：{value}";
         readonly status_codex_local_usage_refreshing: "Codex 本地历史：正在后台生成统计快照";
         readonly status_codex_local_usage_unavailable: "Codex 本地历史：无法获取（{error}）";

package/dist/i18n.js

@@ -109,8 +109,8 @@ const MESSAGES = {
         status_codex_usage_reset: ', resets {value}',
         status_codex_usage_unavailable: 'Codex usage: unavailable ({error})',
         status_codex_local_history: 'Codex local history: {sessions} sessions, {turns} turns, {events} usage records',
-        status_codex_local_tokens: 'Codex local tokens: total {total}; input {input}, output {output}, cached input {cached}, reasoning output {reasoning}',
-        status_codex_local_speed: 'Codex local output speed: avg {avg} token/s, latest {latest} token/s ({samples} samples)',
+        status_codex_local_tokens: 'Codex local tokens: total {total}; input {input}, visible output {visible}, reasoning output {reasoning}, total output {output}, cached input {cached}',
+        status_codex_local_throughput: 'Codex visible reply throughput (end-to-end, excluding reasoning): overall {overall} token/s, last {recentTurns} completed turns {recent} token/s ({turns} completed turns sampled)',
         status_codex_local_snapshot_at: 'Codex local stats snapshot: {value}',
         status_codex_local_usage_refreshing: 'Codex local history: building snapshot in background',
         status_codex_local_usage_unavailable: 'Codex local history: unavailable ({error})',
@@ -673,8 +673,8 @@ const MESSAGES = {
         status_codex_usage_reset: '，重置时间 {value}',
         status_codex_usage_unavailable: 'Codex 用量：无法获取（{error}）',
         status_codex_local_history: 'Codex 本地历史：{sessions} 个会话，{turns} 轮，{events} 条用量记录',
-        status_codex_local_tokens: 'Codex 本地 Token：总计 {total}；输入 {input}，输出 {output}，缓存输入 {cached}，推理输出 {reasoning}',
-        status_codex_local_speed: 'Codex 本地输出速度：平均 {avg} token/s，最近 {latest} token/s（{samples} 个样本）',
+        status_codex_local_tokens: 'Codex 本地 Token：总计 {total}；输入 {input}，可见输出 {visible}，推理输出 {reasoning}，总输出 {output}，缓存输入 {cached}',
+        status_codex_local_throughput: 'Codex 可见答复吞吐（端到端，排除推理 token）：整体 {overall} token/s，最近 {recentTurns} 个完成轮次 {recent} token/s（{turns} 个完成轮次样本）',
         status_codex_local_snapshot_at: 'Codex 本地统计快照：{value}',
         status_codex_local_usage_refreshing: 'Codex 本地历史：正在后台生成统计快照',
         status_codex_local_usage_unavailable: 'Codex 本地历史：无法获取（{error}）',