@foxden-app/foxclaw 0.3.18 → 0.4.0

package/dist/i18n.js

@@ -116,18 +116,27 @@ const MESSAGES = {
         status_codex_local_usage_unavailable: 'Codex local history: unavailable ({error})',
         status_codex_credits: 'Codex credits: {value}',
         status_codex_limit_reached: 'Codex limit: {value}',
+        status_runtime_overview: 'Telegram bot runtimes:',
+        status_runtime_bot: '- {bot}: connected {connected}, auth {auth}, active turns {turns}',
+        status_runtime_weixin: '- Weixin default runtime: connected {connected}, active turns {turns}',
+        status_auth_mirror_none: 'Last auth mirror: none recorded',
+        status_auth_mirror_synced: 'Last auth mirror: {candidate} from {source} at {time}',
+        status_last_update_none: 'Last service update: none recorded',
+        status_last_update: 'Last service update: {from} -> {to} at {time}',
+        status_last_codex_update: 'Last Codex update: {value}',
         update_started: 'FoxClaw update started. I will report here after installation, checks, and service restart complete.',
         update_succeeded: 'FoxClaw updated and restarted: {from} -> {to}.',
         update_failed: 'FoxClaw update failed: {error}\nRun foxclaw update in a terminal for details.',
         update_unavailable: 'Self-update is unavailable in this runtime. Run foxclaw update in a terminal.',
         update_already_running: 'A FoxClaw update is already running. I will report here when it finishes.',
-        update_blocked_active: 'Cannot update FoxClaw while a turn, approval, or question is active. Wait or use /interrupt first.',
+        update_blocked_active: 'Cannot update FoxClaw while a runtime activity or auth mirror write is active. Wait or use /interrupt first.',
         auth_reload_restarting: 'Restarting Codex app-server to reload auth...',
         auth_reload_done: 'Codex app-server restarted. Current auth has been reloaded.',
         auth_reload_blocked_active: 'Cannot reload Codex auth while a turn, approval, or question is active. Wait or use /interrupt first.',
         usage_auth: 'Usage: /auth [list|use <n>|enable <n>|disable <n>|reload|add <name>]',
         usage_auth_add: 'Usage: /auth add <name>. Use letters, numbers, dot, dash, or underscore.',
         auth_list_title: 'Codex auth files:',
+        auth_bot: 'Bot runtime: {value}',
         auth_current: 'Current auth: {value}',
         auth_dir: 'Auth dir: {value}',
         auth_candidate_count: 'Candidates: {value}',
@@ -680,18 +689,27 @@ const MESSAGES = {
         status_codex_local_usage_unavailable: 'Codex 本地历史：无法获取（{error}）',
         status_codex_credits: 'Codex 额度：{value}',
         status_codex_limit_reached: 'Codex 限制：{value}',
+        status_runtime_overview: 'Telegram bot 运行时：',
+        status_runtime_bot: '- {bot}：连接 {connected}，auth {auth}，进行中回复 {turns}',
+        status_runtime_weixin: '- 微信默认运行时：连接 {connected}，进行中回复 {turns}',
+        status_auth_mirror_none: '最近 auth 镜像：暂无记录',
+        status_auth_mirror_synced: '最近 auth 镜像：{candidate} 由 {source} 于 {time} 同步',
+        status_last_update_none: '最近服务升级：暂无记录',
+        status_last_update: '最近服务升级：{from} -> {to}（{time}）',
+        status_last_codex_update: '最近 Codex 升级：{value}',
         update_started: '已开始升级 FoxClaw。安装、自检和服务重启完成后，我会在这里回报结果。',
         update_succeeded: 'FoxClaw 已升级并重启：{from} -> {to}。',
         update_failed: 'FoxClaw 升级失败：{error}\n请在终端运行 foxclaw update 查看详情。',
         update_unavailable: '当前运行方式不支持自升级，请在终端运行 foxclaw update。',
         update_already_running: 'FoxClaw 升级已经在进行中，结束后我会在这里回报结果。',
-        update_blocked_active: '当前有回复、审批或问题在进行中，不能升级 FoxClaw。请先等待，或使用 /interrupt。',
+        update_blocked_active: '当前有 runtime 操作或 auth 镜像写入在进行中，不能升级 FoxClaw。请先等待，或使用 /interrupt。',
         auth_reload_restarting: '正在重启 Codex app-server 以重新读取 auth...',
         auth_reload_done: 'Codex app-server 已重启，当前 auth 已重新读取。',
         auth_reload_blocked_active: '当前有回复、审批或问题在进行中，不能重载 Codex auth。请先等待，或使用 /interrupt。',
         usage_auth: '用法：/auth [list|use <编号>|enable <编号>|disable <编号>|reload|add <名称>]',
         usage_auth_add: '用法：/auth add <名称>。名称只能包含字母、数字、点、短横线或下划线。',
         auth_list_title: 'Codex auth 文件：',
+        auth_bot: 'Bot runtime：{value}',
         auth_current: '当前 auth：{value}',
         auth_dir: 'Auth 目录：{value}',
         auth_candidate_count: '候选数量：{value}',

package/dist/main.js

@@ -1,15 +1,16 @@
 #!/usr/bin/env node
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import process from 'node:process';
 import { createInterface } from 'node:readline/promises';
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-import { APP_HOME, DEFAULT_ENV_PATH, DEFAULT_LOG_PATH, DEFAULT_STATUS_PATH, getLoadedEnvPath, loadConfig, loadEnv, } from './config.js';
+import { APP_HOME, DEFAULT_CODEX_TELEGRAM_HOME, DEFAULT_ENV_PATH, DEFAULT_LOG_PATH, DEFAULT_STATUS_PATH, getLoadedEnvPath, loadConfig, loadEnv, } from './config.js';
 import { acquireProcessLock, LockHeldError } from './lock.js';
 import { readRuntimeStatus, writeRuntimeStatus } from './runtime.js';
 import { refreshFoxclawExecStartDropIns, removeFoxclawExecStartDropIns } from './systemd.js';
-import { createSelfUpdateRuntime, inferPnpmHomeFromEntryPoint, performSelfUpdate } from './update.js';
+import { createSelfUpdateRuntime, inferPnpmHomeFromEntryPoint, performSelfUpdate, readSelfUpdateStatus, writeSelfUpdateStatus, } from './update.js';
 const rawCommand = process.argv[2];
 const command = rawCommand || 'serve';
 loadEnv();
@@ -61,6 +62,9 @@ async function main() {
             entryPoint,
             nodePath: process.execPath,
             version: readPackageVersion(),
+            ...(process.env.CODEX_CLI_BIN || resolveCommand('codex')
+                ? { codexCliBin: process.env.CODEX_CLI_BIN || resolveCommand('codex') }
+                : {}),
             ...(notificationFile ? { notificationFile } : {}),
         };
         const outcome = performSelfUpdate(options);
@@ -137,7 +141,7 @@ Usage:
   foxclaw --help`);
 }
 async function runServeCli() {
-    const [{ BridgeMessagingRouter }, { TelegramMessagingPort }, { WeixinChannelAdapter }, { WeixinMessagingPort }, { attachIlinkRuntimeFromBridgeLogger }, { loadWeixinAccount }, { Logger }, { BridgeStore }, { TelegramGateway }, { CodexAppClient }, { BridgeSessionCore }, { TelegramChannelAdapter },] = await Promise.all([
+    const [{ BridgeMessagingRouter }, { TelegramMessagingPort }, { WeixinChannelAdapter }, { WeixinMessagingPort }, { attachIlinkRuntimeFromBridgeLogger }, { loadWeixinAccount }, { Logger }, { BridgeStore }, { TelegramGateway }, { CodexAppClient }, { BridgeSessionCore }, { TelegramChannelAdapter }, { AuthCandidateMirror },] = await Promise.all([
         import('./channels/bridge_messaging_router.js'),
         import('./channels/telegram/telegram_messaging_port.js'),
         import('./channels/weixin/weixin_channel_adapter.js'),
@@ -150,6 +154,7 @@ async function runServeCli() {
         import('./codex_app/client.js'),
         import('./controller/controller.js'),
         import('./channels/telegram/telegram_channel_adapter.js'),
+        import('./auth/mirror.js'),
     ]);
     const config = loadConfig();
     const logger = new Logger(config.logLevel, config.logPath);
@@ -157,8 +162,184 @@ async function runServeCli() {
     const processLock = acquireProcessLock(config.lockPath);
     let store = null;
     let weixinAdapter = null;
+    let activeWeixinCore = null;
+    let activeTelegramAdapters = [];
+    let managedApps = [];
+    let activeAuthMirror = null;
     try {
         store = new BridgeStore(config.storePath);
+        if (config.tgMultiBotMode) {
+            const seeds = [];
+            for (const token of config.tgBotTokens) {
+                const bot = new TelegramGateway(token, config.tgAllowedUserId, config.tgAllowedChatId, config.telegramPollIntervalMs, store, logger, true);
+                const id = await bot.initializeIdentity();
+                if (seeds.some((runtime) => runtime.id === id)) {
+                    throw new Error(`TG_BOT_TOKENS contains duplicate Telegram bot identity: ${id}`);
+                }
+                const home = path.join(DEFAULT_CODEX_TELEGRAM_HOME, id, 'home');
+                fs.mkdirSync(home, { recursive: true, mode: 0o700 });
+                const runtimeConfig = {
+                    ...config,
+                    tgBotToken: token,
+                    tgBotTokens: [token],
+                    tgScopeBotId: id,
+                    codexAuthDir: home,
+                    codexHome: home,
+                    codexAppAutolaunch: false,
+                    codexAppServerStatePath: path.join(APP_HOME, 'runtime', `codex-app-server-${id}.json`),
+                    codexAppServerLogPath: path.join(APP_HOME, 'logs', `codex-app-server-${id}.log`),
+                };
+                const app = new CodexAppClient(runtimeConfig.codexCliBin, runtimeConfig.codexAppLaunchCmd, runtimeConfig.codexAppAutolaunch, runtimeConfig.codexAppServerStatePath, runtimeConfig.codexAppServerLogPath, logger, { CODEX_HOME: home }, ['cli_auth_credentials_store="file"']);
+                seeds.push({ id, home, config: runtimeConfig, bot, app });
+            }
+            const canonicalAuthDir = config.codexAuthDir ?? config.codexHome ?? path.join(os.homedir(), '.codex');
+            const mirror = new AuthCandidateMirror(canonicalAuthDir, seeds.map((runtime) => ({
+                id: runtime.id,
+                label: runtime.bot.username ? `@${runtime.bot.username}` : runtime.id,
+                authDir: runtime.home,
+                notify: async (message) => {
+                    const chatId = store.getTelegramPrivateChatId(runtime.id);
+                    if (chatId) {
+                        await runtime.bot.sendMessage(chatId, message);
+                    }
+                },
+            })), logger, path.join(APP_HOME, 'runtime', 'auth-mirror.json'));
+            await mirror.initialize();
+            mirror.start();
+            activeAuthMirror = mirror;
+            managedApps = seeds.map((runtime) => runtime.app);
+            const selfUpdater = createSelfUpdateRuntime({
+                entryPoint,
+                nodePath: process.execPath,
+                version: readPackageVersion(),
+                statusPath: config.statusPath,
+                logPath: path.join(APP_HOME, 'logs', 'update.log'),
+                codexCliBin: config.codexCliBin,
+            });
+            const lastSelfUpdatePath = path.join(APP_HOME, 'runtime', 'last-self-update.json');
+            let lastSelfUpdate = readSelfUpdateStatus(lastSelfUpdatePath);
+            const runtimes = [];
+            const writeAggregateStatus = (running = true) => {
+                const statuses = runtimes.map((runtime) => runtime.core.getRuntimeStatus());
+                const weixinStatus = activeWeixinCore?.getRuntimeStatus() ?? null;
+                const first = statuses[0] ?? null;
+                writeRuntimeStatus(config.statusPath, {
+                    running,
+                    connected: running
+                        && statuses.every((status) => status.connected)
+                        && (!weixinStatus || weixinStatus.connected),
+                    userAgent: first?.userAgent ?? null,
+                    ...(first?.codexAppServer ? { codexAppServer: first.codexAppServer } : {}),
+                    botUsername: first?.botUsername ?? null,
+                    currentBindings: store.countBindings(),
+                    pendingApprovals: store.countPendingApprovals(),
+                    pendingUserInputs: store.countPendingUserInputs(),
+                    activeTurns: statuses.reduce((sum, status) => sum + status.activeTurns, 0)
+                        + (weixinStatus?.activeTurns ?? 0),
+                    lastError: statuses.find((status) => status.lastError)?.lastError
+                        ?? weixinStatus?.lastError
+                        ?? null,
+                    updatedAt: new Date().toISOString(),
+                    channels: { telegram: running, weixin: running && config.wxEnabled },
+                    bots: runtimes.map((runtime, index) => ({
+                        id: runtime.id,
+                        username: statuses[index]?.botUsername ?? runtime.bot.username,
+                        connected: running && Boolean(statuses[index]?.connected),
+                        activeTurns: running ? (statuses[index]?.activeTurns ?? 0) : 0,
+                        ...(statuses[index]?.codexAppServer ? { codexAppServer: statuses[index].codexAppServer } : {}),
+                    })),
+                    ...(weixinStatus ? {
+                        weixinRuntime: {
+                            connected: running && weixinStatus.connected,
+                            activeTurns: running ? weixinStatus.activeTurns : 0,
+                            ...(weixinStatus.codexAppServer ? { codexAppServer: weixinStatus.codexAppServer } : {}),
+                        },
+                    } : {}),
+                    authMirror: mirror.getStatus(),
+                    lastUpdate: lastSelfUpdate,
+                });
+            };
+            const coordinator = {
+                canSelfUpdate: () => runtimes.every((runtime) => runtime.core.isIdleForServiceUpdate())
+                    && (!activeWeixinCore || activeWeixinCore.isIdleForServiceUpdate())
+                    && mirror.isIdle(),
+                authCandidateUpdated: (runtimeId, candidateName) => mirror.syncRuntimeCandidate(runtimeId, candidateName).then(() => undefined),
+                statusUpdated: () => writeAggregateStatus(),
+                getServiceStatus: async () => ({
+                    bots: await Promise.all(runtimes.map(async (runtime) => {
+                        const status = runtime.core.getRuntimeStatus();
+                        return {
+                            id: runtime.id,
+                            username: status.botUsername ?? runtime.bot.username,
+                            connected: status.connected,
+                            activeTurns: status.activeTurns,
+                            currentAuth: await runtime.core.getCurrentAuthLabel().catch(() => null),
+                            ...(status.codexAppServer ? { codexAppServer: status.codexAppServer } : {}),
+                        };
+                    })),
+                    ...(activeWeixinCore ? {
+                        weixinRuntime: {
+                            connected: activeWeixinCore.getRuntimeStatus().connected,
+                            activeTurns: activeWeixinCore.getRuntimeStatus().activeTurns,
+                            codexAppServer: activeWeixinCore.getRuntimeStatus().codexAppServer,
+                        },
+                    } : {}),
+                    authMirror: mirror.getStatus(),
+                    lastUpdate: lastSelfUpdate,
+                }),
+                selfUpdateCompleted: (status) => {
+                    lastSelfUpdate = status;
+                    writeSelfUpdateStatus(lastSelfUpdatePath, status);
+                    writeAggregateStatus();
+                },
+            };
+            for (const seed of seeds) {
+                const telegramMessaging = new TelegramMessagingPort(seed.bot);
+                const outbound = new BridgeMessagingRouter(telegramMessaging, null);
+                const core = new BridgeSessionCore(seed.config, store, logger, seed.bot, seed.app, outbound, selfUpdater, coordinator);
+                runtimes.push({ ...seed, core, telegram: new TelegramChannelAdapter(core) });
+            }
+            if (config.wxEnabled) {
+                const weixinApp = new CodexAppClient(config.codexCliBin, config.codexAppLaunchCmd, config.codexAppAutolaunch, config.codexAppServerStatePath, config.codexAppServerLogPath, logger);
+                const outbound = new BridgeMessagingRouter(new TelegramMessagingPort(seeds[0].bot), new WeixinMessagingPort(store, (id) => loadWeixinAccount(config.weixinAccountsDir, id)));
+                activeWeixinCore = new BridgeSessionCore(config, store, logger, seeds[0].bot, weixinApp, outbound, selfUpdater, coordinator, false);
+                managedApps.push(weixinApp);
+                weixinAdapter = new WeixinChannelAdapter(activeWeixinCore, store, config, logger);
+            }
+            activeTelegramAdapters = runtimes.map((runtime) => runtime.telegram);
+            process.on('unhandledRejection', (error) => {
+                logger.error('process.unhandled_rejection', { error: serializeError(error) });
+            });
+            process.on('uncaughtException', (error) => {
+                logger.error('process.uncaught_exception', { error: serializeError(error) });
+            });
+            for (const runtime of runtimes) {
+                await runtime.telegram.start();
+            }
+            if (weixinAdapter) {
+                await activeWeixinCore.startCodexApp();
+                await weixinAdapter.start();
+            }
+            writeAggregateStatus();
+            logger.info('bridge.started', { bots: runtimes.map((runtime) => runtime.id) });
+            const shutdown = async (signal) => {
+                logger.info('bridge.shutting_down', { signal });
+                mirror.stop();
+                await weixinAdapter?.stop();
+                await activeWeixinCore?.stop();
+                await Promise.all(runtimes.map((runtime) => runtime.telegram.stop()));
+                writeAggregateStatus(false);
+                await Promise.all(managedApps.map((app) => app.stop({ terminateServer: true }).catch((error) => {
+                    logger.warn('codex.app-server.stop_failed', { error: serializeError(error) });
+                })));
+                store?.close();
+                processLock.release();
+                process.exit(0);
+            };
+            process.on('SIGINT', () => void shutdown('SIGINT'));
+            process.on('SIGTERM', () => void shutdown('SIGTERM'));
+            return;
+        }
         const bot = new TelegramGateway(config.tgBotToken, config.tgAllowedUserId, config.tgAllowedChatId, config.telegramPollIntervalMs, store, logger);
         const app = new CodexAppClient(config.codexCliBin, config.codexAppLaunchCmd, config.codexAppAutolaunch, config.codexAppServerStatePath, config.codexAppServerLogPath, logger);
         const telegramMessaging = new TelegramMessagingPort(bot);
@@ -172,9 +353,12 @@ async function runServeCli() {
             version: readPackageVersion(),
             statusPath: config.statusPath,
             logPath: path.join(APP_HOME, 'logs', 'update.log'),
+            codexCliBin: config.codexCliBin,
         });
         const core = new BridgeSessionCore(config, store, logger, bot, app, outbound, selfUpdater);
         const telegram = new TelegramChannelAdapter(core);
+        managedApps = [app];
+        activeTelegramAdapters = [telegram];
         if (config.wxEnabled) {
             weixinAdapter = new WeixinChannelAdapter(core, store, config, logger);
         }
@@ -218,7 +402,11 @@ async function runServeCli() {
         process.on('SIGTERM', () => void shutdown('SIGTERM'));
     }
     catch (error) {
+        activeAuthMirror?.stop();
         await weixinAdapter?.stop().catch(() => { });
+        await activeWeixinCore?.stop().catch(() => { });
+        await Promise.allSettled(activeTelegramAdapters.map((adapter) => adapter.stop()));
+        await Promise.allSettled(managedApps.map((app) => app.stop({ terminateServer: true })));
         store?.close();
         processLock.release();
         throw error;
@@ -264,15 +452,15 @@ async function configureEnvInteractively(envPath, existed) {
         const skipped = [];
         const warnings = [];
         Object.assign(updates, await maybeSaveProxyEnvFromShell(rl, envPath));
-        const token = sanitizeEnvInput(await rl.question('Telegram bot token (TG_BOT_TOKEN): '));
-        if (token) {
-            updates.TG_BOT_TOKEN = token;
-            if (!/^\d+:[A-Za-z0-9_-]+$/.test(token)) {
-                warnings.push('TG_BOT_TOKEN does not look like a standard Telegram bot token.');
+        const tokens = sanitizeEnvInput(await rl.question('Telegram bot token(s), comma-separated (TG_BOT_TOKENS): '));
+        if (tokens) {
+            updates.TG_BOT_TOKENS = tokens;
+            if (tokens.split(',').map((token) => token.trim()).some((token) => !/^\d+:[A-Za-z0-9_-]+$/.test(token))) {
+                warnings.push('One or more TG_BOT_TOKENS values do not look like standard Telegram bot tokens.');
             }
         }
         else {
-            skipped.push('TG_BOT_TOKEN');
+            skipped.push('TG_BOT_TOKENS');
         }
         const userId = sanitizeEnvInput(await rl.question('Telegram numeric user ID (TG_ALLOWED_USER_ID): '));
         if (userId) {
@@ -486,7 +674,7 @@ function runDoctorChecks() {
     const checks = [
         ['node >= 24', Number(process.versions.node.split('.')[0]) >= 24],
         ['codex cli available', hasConfiguredCodexBin(configuredCodexBin) || hasCommand('codex')],
-        ['telegram bot token configured', Boolean(process.env.TG_BOT_TOKEN)],
+        ['telegram bot token(s) configured', Boolean(process.env.TG_BOT_TOKENS?.trim() || process.env.TG_BOT_TOKEN?.trim())],
         ['telegram allowed user configured', Boolean(process.env.TG_ALLOWED_USER_ID)],
     ];
     if (process.env.WX_ENABLED === 'true' || process.env.WX_ENABLED === '1') {

package/dist/store/database.d.ts

@@ -29,6 +29,8 @@ export declare class BridgeStore {
     constructor(dbPath: string);
     getTelegramOffset(botKey: string): number;
     setTelegramOffset(botKey: string, updateId: number): void;
+    rememberTelegramPrivateScope(botId: string, scopeId: string, chatId: string): void;
+    getTelegramPrivateChatId(botId: string): string | null;
     getBinding(chatId: string): ThreadBinding | null;
     setBinding(chatId: string, threadId: string, cwd: string | null): void;
     clearBinding(chatId: string): void;
@@ -73,7 +75,7 @@ export declare class BridgeStore {
     private writeChatSettings;
     getWeixinContextToken(scopeId: string): string | null;
     setWeixinContextToken(scopeId: string, contextToken: string): void;
-    listDisabledCodexAuthCandidateNames(): Set<string>;
-    setCodexAuthCandidateDisabled(name: string, disabled: boolean): void;
+    listDisabledCodexAuthCandidateNames(runtimeId?: string): Set<string>;
+    setCodexAuthCandidateDisabled(name: string, disabled: boolean, runtimeId?: string): void;
     private ensureColumn;
 }

package/dist/store/database.js

@@ -8,10 +8,16 @@ export class BridgeStore {
         fs.mkdirSync(path.dirname(dbPath), { recursive: true });
         this.db = new DatabaseSync(dbPath);
         this.db.exec(`
-      CREATE TABLE IF NOT EXISTS telegram_offsets (
-        bot_key TEXT PRIMARY KEY,
-        update_id INTEGER NOT NULL
-      );
+      CREATE TABLE IF NOT EXISTS telegram_offsets (
+        bot_key TEXT PRIMARY KEY,
+        update_id INTEGER NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS telegram_private_scopes (
+        bot_id TEXT PRIMARY KEY,
+        scope_id TEXT NOT NULL,
+        chat_id TEXT NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
       CREATE TABLE IF NOT EXISTS chat_bindings (
         chat_id TEXT PRIMARY KEY,
         thread_id TEXT NOT NULL,
@@ -110,6 +116,13 @@ export class BridgeStore {
         disabled INTEGER NOT NULL DEFAULT 0,
         updated_at INTEGER NOT NULL
       );
+      CREATE TABLE IF NOT EXISTS codex_auth_candidate_runtime (
+        runtime_id TEXT NOT NULL,
+        name TEXT NOT NULL,
+        disabled INTEGER NOT NULL DEFAULT 0,
+        updated_at INTEGER NOT NULL,
+        PRIMARY KEY (runtime_id, name)
+      );
     `);
         this.ensureColumn('thread_cache', 'name', 'TEXT');
         this.ensureColumn('thread_cache', 'model_provider', 'TEXT');
@@ -136,6 +149,17 @@ export class BridgeStore {
       ON CONFLICT(bot_key) DO UPDATE SET update_id = excluded.update_id
     `).run(botKey, updateId);
     }
+    rememberTelegramPrivateScope(botId, scopeId, chatId) {
+        this.db.prepare(`
+      INSERT INTO telegram_private_scopes (bot_id, scope_id, chat_id, updated_at)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(bot_id) DO UPDATE SET scope_id = excluded.scope_id, chat_id = excluded.chat_id, updated_at = excluded.updated_at
+    `).run(botId, scopeId, chatId, Date.now());
+    }
+    getTelegramPrivateChatId(botId) {
+        const row = this.db.prepare('SELECT chat_id FROM telegram_private_scopes WHERE bot_id = ?').get(botId);
+        return row ? String(row.chat_id) : null;
+    }
     getBinding(chatId) {
         const row = this.db.prepare('SELECT chat_id, thread_id, cwd, updated_at FROM chat_bindings WHERE chat_id = ?').get(chatId);
         if (!row)
@@ -462,11 +486,23 @@ export class BridgeStore {
       ON CONFLICT(scope_id) DO UPDATE SET context_token = excluded.context_token, updated_at = excluded.updated_at
     `).run(scopeId, contextToken, Date.now());
     }
-    listDisabledCodexAuthCandidateNames() {
+    listDisabledCodexAuthCandidateNames(runtimeId = 'default') {
+        if (runtimeId !== 'default') {
+            const runtimeRows = this.db.prepare('SELECT name FROM codex_auth_candidate_runtime WHERE runtime_id = ? AND disabled = 1').all(runtimeId);
+            return new Set(runtimeRows.map(row => String(row.name)));
+        }
         const rows = this.db.prepare('SELECT name FROM codex_auth_candidates WHERE disabled = 1').all();
         return new Set(rows.map(row => String(row.name)));
     }
-    setCodexAuthCandidateDisabled(name, disabled) {
+    setCodexAuthCandidateDisabled(name, disabled, runtimeId = 'default') {
+        if (runtimeId !== 'default') {
+            this.db.prepare(`
+        INSERT INTO codex_auth_candidate_runtime (runtime_id, name, disabled, updated_at)
+        VALUES (?, ?, ?, ?)
+        ON CONFLICT(runtime_id, name) DO UPDATE SET disabled = excluded.disabled, updated_at = excluded.updated_at
+      `).run(runtimeId, name, disabled ? 1 : 0, Date.now());
+            return;
+        }
         this.db.prepare(`
       INSERT INTO codex_auth_candidates (name, disabled, updated_at)
       VALUES (?, ?, ?)

package/dist/telegram/addressing.d.ts

@@ -27,6 +27,7 @@ interface DefaultScopeParams {
     allowedChatId: string | null;
     allowedTopicId: number | null;
     topicId: number | null;
+    requireExplicitGroupAddressing?: boolean;
 }
 export declare function resolveTelegramAddressing(params: ResolveTelegramAddressingParams): TelegramAddressingDecision;
 export declare function isDefaultTelegramScope(params: DefaultScopeParams): boolean;

package/dist/telegram/addressing.js

@@ -21,6 +21,9 @@ export function isDefaultTelegramScope(params) {
     if (params.chatType === 'private') {
         return true;
     }
+    if (params.requireExplicitGroupAddressing) {
+        return false;
+    }
     if (params.allowedChatId === null) {
         return false;
     }

package/dist/telegram/gateway.d.ts

@@ -34,12 +34,15 @@ export declare class TelegramGateway extends EventEmitter {
     private readonly pollIntervalMs;
     private readonly store;
     private readonly logger;
+    private readonly namespacedScopes;
     private running;
     private botKey;
     private botUsername;
     private botUserId;
-    constructor(botToken: string, allowedUserId: string, allowedChatId: string | null, pollIntervalMs: number, store: BridgeStore, logger: Logger);
+    constructor(botToken: string, allowedUserId: string, allowedChatId: string | null, pollIntervalMs: number, store: BridgeStore, logger: Logger, namespacedScopes?: boolean);
     get username(): string | null;
+    get identity(): string | null;
+    initializeIdentity(): Promise<string>;
     start(): Promise<void>;
     stop(): void;
     sendMessage(chatId: string, text: string, inlineKeyboard?: Array<Array<{

package/dist/telegram/gateway.js

@@ -11,11 +11,12 @@ export class TelegramGateway extends EventEmitter {
     pollIntervalMs;
     store;
     logger;
+    namespacedScopes;
     running = false;
     botKey;
     botUsername = null;
     botUserId = null;
-    constructor(botToken, allowedUserId, allowedChatId, pollIntervalMs, store, logger) {
+    constructor(botToken, allowedUserId, allowedChatId, pollIntervalMs, store, logger, namespacedScopes = false) {
         super();
         this.botToken = botToken;
         this.allowedUserId = allowedUserId;
@@ -23,16 +24,26 @@ export class TelegramGateway extends EventEmitter {
         this.pollIntervalMs = pollIntervalMs;
         this.store = store;
         this.logger = logger;
+        this.namespacedScopes = namespacedScopes;
         this.botKey = `telegram:${crypto.createHash('sha256').update(this.botToken).digest('hex').slice(0, 8)}`;
     }
     get username() {
         return this.botUsername;
     }
+    get identity() {
+        return this.botUserId === null ? null : `bot${this.botUserId}`;
+    }
+    async initializeIdentity() {
+        await this.resolveBotIdentity(true);
+        return this.identity;
+    }
     async start() {
         if (this.running)
             return;
         this.running = true;
-        await this.resolveBotIdentity();
+        if (this.botUserId === null) {
+            await this.resolveBotIdentity(this.namespacedScopes);
+        }
         await this.registerCommands();
         void this.pollLoop();
     }
@@ -134,12 +145,16 @@ export class TelegramGateway extends EventEmitter {
     async downloadResolvedFile(remoteFilePath, destinationPath) {
         return downloadTelegramFile(this.botToken, remoteFilePath, destinationPath);
     }
-    async resolveBotIdentity() {
+    async resolveBotIdentity(required = false) {
         const result = await callTelegramApi(this.botToken, 'getMe', {});
         if (result.ok && result.result) {
             this.botKey = `telegram:bot${result.result.id}`;
             this.botUserId = result.result.id;
             this.botUsername = result.result.username ?? null;
+            return;
+        }
+        if (required) {
+            throw new Error(result.description || 'Failed to resolve Telegram bot identity');
         }
     }
     async registerCommands() {
@@ -187,7 +202,7 @@ export class TelegramGateway extends EventEmitter {
             const attachments = extractAttachments(update.message);
             const text = update.message.text ?? update.message.caption ?? '';
             const topicId = update.message.message_thread_id ?? null;
-            const scopeId = toTelegramBridgeScopeId(createTelegramScopeId(String(update.message.chat.id), topicId));
+            const scopeId = toTelegramBridgeScopeId(createTelegramScopeId(String(update.message.chat.id), topicId), this.namespacedScopes ? this.identity : null);
             const entities = update.message.text ? (update.message.entities ?? []) : (update.message.caption_entities ?? []);
             const replyToBot = this.botUserId !== null && update.message.reply_to_message?.from?.id === this.botUserId;
             if (text || attachments.length > 0) {
@@ -204,6 +219,9 @@ export class TelegramGateway extends EventEmitter {
                     replyToBot,
                     ...(update.message.from.language_code ? { languageCode: update.message.from.language_code } : {}),
                 });
+                if (update.message.chat.type === 'private' && this.identity) {
+                    this.store.rememberTelegramPrivateScope(this.identity, scopeId, String(update.message.chat.id));
+                }
                 return;
             }
         }
@@ -216,7 +234,7 @@ export class TelegramGateway extends EventEmitter {
             this.emit('callback', {
                 chatId: String(update.callback_query.message.chat.id),
                 topicId,
-                scopeId: toTelegramBridgeScopeId(createTelegramScopeId(String(update.callback_query.message.chat.id), topicId)),
+                scopeId: toTelegramBridgeScopeId(createTelegramScopeId(String(update.callback_query.message.chat.id), topicId), this.namespacedScopes ? this.identity : null),
                 userId: String(update.callback_query.from.id),
                 data: update.callback_query.data,
                 callbackQueryId: update.callback_query.id,

package/dist/types.d.ts

@@ -340,4 +340,30 @@ export interface RuntimeStatus {
         telegram: boolean;
         weixin: boolean;
     };
+    bots?: Array<{
+        id: string;
+        username: string | null;
+        connected: boolean;
+        activeTurns: number;
+        currentAuth?: string | null;
+        codexAppServer?: RuntimeStatus['codexAppServer'];
+    }>;
+    weixinRuntime?: {
+        connected: boolean;
+        activeTurns: number;
+        codexAppServer?: RuntimeStatus['codexAppServer'];
+    };
+    authMirror?: {
+        candidateName: string;
+        sourceRuntimeId: string;
+        sourceLabel: string;
+        syncedAt: string;
+    } | null;
+    lastUpdate?: {
+        state: string;
+        fromVersion: string;
+        toVersion: string | null;
+        codexUpdate?: string | null;
+        updatedAt: string;
+    } | null;
 }

package/dist/update.d.ts

@@ -6,6 +6,7 @@ export interface SelfUpdateStatus {
     locale: AppLocale;
     fromVersion: string;
     toVersion: string | null;
+    codexUpdate?: string | null;
     error: string | null;
     updatedAt: string;
 }
@@ -19,6 +20,7 @@ export interface SelfUpdateInstaller {
     command: string;
     installArgs: string[];
     rootArgs: string[];
+    pnpmHome?: string;
 }
 interface CreateSelfUpdateRuntimeOptions {
     entryPoint: string;
@@ -26,12 +28,14 @@ interface CreateSelfUpdateRuntimeOptions {
     version: string;
     statusPath: string;
     logPath: string;
+    codexCliBin?: string;
 }
 interface PerformSelfUpdateOptions {
     entryPoint: string;
     nodePath: string;
     version: string;
     notificationFile?: string;
+    codexCliBin?: string;
     env?: NodeJS.ProcessEnv;
 }
 export interface SelfUpdateOutcome {
@@ -43,6 +47,7 @@ export interface SelfUpdateOutcome {
 export declare function selfUpdateStatusPath(statusPath: string): string;
 export declare function inferPnpmHomeFromEntryPoint(entryPoint: string): string | null;
 export declare function resolveSelfUpdateInstaller(entryPoint: string, nodePath?: string, exists?: (target: string) => boolean, env?: NodeJS.ProcessEnv): SelfUpdateInstaller;
+export declare function resolveCodexUpdateInstaller(codexCliBin: string, nodePath?: string, exists?: (target: string) => boolean, env?: NodeJS.ProcessEnv, realpath?: (target: string) => string, readText?: (target: string) => string): SelfUpdateInstaller | null;
 export declare function readSelfUpdateStatus(statusFile: string): SelfUpdateStatus | null;
 export declare function writeSelfUpdateStatus(statusFile: string, status: SelfUpdateStatus): void;
 export declare function createSelfUpdateRuntime(options: CreateSelfUpdateRuntimeOptions): SelfUpdateRuntime;