@foxden-app/foxclaw 0.7.2 → 0.10.0

package/dist/channels/telegram/telegram_channel_adapter.d.ts

@@ -1,12 +1,19 @@
 import type { BridgeSessionCore } from '../../controller/controller.js';
+export interface ITelegramBridgeCore {
+    registerTelegramInboundHandlers(): void;
+    startCodexApp(): Promise<void>;
+    startTelegramPolling(): Promise<void>;
+    stop(): Promise<void>;
+}
 /**
- * Telegram channel: inbound subscription + transport startup ordering for {@link BridgeSessionCore}.
+ * Telegram channel: inbound subscription + transport startup ordering for {@link BridgeSessionCore}
+ * or {@link UnifiedBridgeCore}.
  * Additional channels (e.g. Weixin) can compose the same core with their own adapters.
  */
 export declare class TelegramChannelAdapter {
     private readonly core;
-    constructor(core: BridgeSessionCore);
+    constructor(core: BridgeSessionCore | ITelegramBridgeCore);
     start(): Promise<void>;
     stop(): Promise<void>;
-    get sessionCore(): BridgeSessionCore;
+    get sessionCore(): BridgeSessionCore | ITelegramBridgeCore;
 }

package/dist/channels/telegram/telegram_channel_adapter.js

@@ -1,5 +1,6 @@
 /**
- * Telegram channel: inbound subscription + transport startup ordering for {@link BridgeSessionCore}.
+ * Telegram channel: inbound subscription + transport startup ordering for {@link BridgeSessionCore}
+ * or {@link UnifiedBridgeCore}.
  * Additional channels (e.g. Weixin) can compose the same core with their own adapters.
  */
 export class TelegramChannelAdapter {

package/dist/channels/weixin/weixin_channel_adapter.d.ts

@@ -2,6 +2,10 @@ import type { AppConfig } from '../../config.js';
 import type { BridgeSessionCore } from '../../controller/controller.js';
 import type { Logger } from '../../logger.js';
 import type { BridgeStore } from '../../store/database.js';
+import type { TelegramTextEvent } from '../../telegram/gateway.js';
+export interface IWeixinBridgeCore {
+    dispatchInboundLikeTelegramText(event: TelegramTextEvent): void;
+}
 export declare class WeixinChannelAdapter {
     private readonly core;
     private readonly store;
@@ -9,7 +13,7 @@ export declare class WeixinChannelAdapter {
     private readonly logger;
     private readonly abort;
     private loops;
-    constructor(core: BridgeSessionCore, store: BridgeStore, config: AppConfig, logger: Logger);
+    constructor(core: BridgeSessionCore | IWeixinBridgeCore, store: BridgeStore, config: AppConfig, logger: Logger);
     start(): Promise<void>;
     stop(): Promise<void>;
     private listAccounts;

package/dist/codex_app/adapter.d.ts

@@ -0,0 +1,20 @@
+import type { IEngineAdapter, EngineModel, EngineTurnRequest, EngineTurnExecution } from '../core/engine_spi.js';
+import type { CodexAppClient } from './client.js';
+import type { SandboxModeValue } from '../types.js';
+export declare class CodexEngineAdapter implements IEngineAdapter {
+    private readonly client;
+    readonly id: string;
+    readonly name: string;
+    private readonly defaultModel;
+    private readonly defaultApprovalPolicy;
+    private readonly defaultSandboxMode;
+    constructor(client: CodexAppClient, options?: {
+        id?: string;
+        name?: string;
+        defaultModel?: string | undefined;
+        defaultApprovalPolicy?: string;
+        defaultSandboxMode?: SandboxModeValue;
+    });
+    listModels(): Promise<EngineModel[]>;
+    executeTurn(request: EngineTurnRequest): EngineTurnExecution;
+}

package/dist/codex_app/adapter.js

@@ -0,0 +1,213 @@
+import { EventEmitter } from 'node:events';
+import { normalizeTurnActivityEvent } from '../controller/activity.js';
+import { buildAttachmentPrompt } from '../telegram/media.js';
+export class CodexEngineAdapter {
+    client;
+    id;
+    name;
+    defaultModel;
+    defaultApprovalPolicy;
+    defaultSandboxMode;
+    constructor(client, options = {}) {
+        this.client = client;
+        this.id = options.id ?? 'codex';
+        this.name = options.name ?? 'OpenAI Codex (App Server)';
+        this.defaultModel = options.defaultModel;
+        this.defaultApprovalPolicy = options.defaultApprovalPolicy ?? 'on-request';
+        this.defaultSandboxMode = options.defaultSandboxMode ?? 'workspace-write';
+    }
+    async listModels() {
+        try {
+            const models = await this.client.listModels();
+            const list = models.map((m) => ({
+                id: m.id,
+                name: m.displayName || m.id,
+                description: m.description,
+                isDefault: m.isDefault || m.id === this.defaultModel,
+            }));
+            if (!list.some((m) => m.id === 'gpt-6-sol')) {
+                list.push({
+                    id: 'gpt-6-sol',
+                    name: 'GPT-6-Sol',
+                    description: 'Next-generation flagship model with deep reasoning',
+                    isDefault: false,
+                });
+            }
+            return list;
+        }
+        catch {
+            return [];
+        }
+    }
+    executeTurn(request) {
+        const emitter = new EventEmitter();
+        let threadId = request.threadId;
+        let turnId = null;
+        let cancelled = false;
+        let promptText = request.prompt;
+        if (request.stagedAttachments && request.stagedAttachments.length > 0 && !request.prompt.includes('Telegram attachments:')) {
+            promptText = buildAttachmentPrompt(request.prompt, request.stagedAttachments);
+        }
+        let accumulatedResponse = '';
+        let finalResult = null;
+        let turnError = null;
+        const resultWaiters = [];
+        const resolveWaiters = (res) => {
+            while (resultWaiters.length > 0) {
+                resultWaiters.shift()(res);
+            }
+        };
+        const onNotification = (msg) => {
+            try {
+                const ev = normalizeTurnActivityEvent(msg);
+                if (!ev)
+                    return;
+                if (ev.turnId && turnId && ev.turnId !== turnId)
+                    return;
+                if (ev.kind === 'agent_message_delta') {
+                    accumulatedResponse += ev.delta;
+                    emitter.emit('delta', ev.delta);
+                }
+                else if (ev.kind === 'tool_started') {
+                    const cmdName = Array.isArray(ev.exec?.command) ? ev.exec.command.join(' ') : 'command';
+                    emitter.emit('tool', {
+                        name: cmdName,
+                        status: 'running',
+                    });
+                }
+                else if (ev.kind === 'tool_completed') {
+                    const cmdName = Array.isArray(ev.exec?.command) ? ev.exec.command.join(' ') : 'command';
+                    emitter.emit('tool', {
+                        name: cmdName,
+                        status: 'completed',
+                    });
+                }
+                else if (ev.kind === 'turn_completed') {
+                    cleanup();
+                    finalResult = {
+                        kind: 'result',
+                        status: ev.state === 'interrupted' ? 'INTERRUPTED' : 'SUCCESS',
+                        response: accumulatedResponse,
+                        conversationId: threadId,
+                    };
+                    emitter.emit('result', finalResult);
+                    resolveWaiters(finalResult);
+                }
+            }
+            catch {
+                // Ignore parsing errors for unrelated notifications
+            }
+        };
+        const cleanup = () => {
+            this.client.off('notification', onNotification);
+        };
+        this.client.on('notification', onNotification);
+        const effectiveModel = request.model && request.model !== 'default'
+            ? request.model
+            : (this.defaultModel && this.defaultModel !== 'default' ? this.defaultModel : null);
+        const run = async () => {
+            try {
+                if (!threadId) {
+                    const session = await this.client.startThread({
+                        cwd: request.cwd,
+                        model: effectiveModel,
+                        approvalPolicy: this.defaultApprovalPolicy,
+                        sandboxMode: this.defaultSandboxMode,
+                    });
+                    threadId = session.thread.threadId;
+                }
+                else {
+                    try {
+                        await this.client.resumeThread({
+                            threadId,
+                            cwd: request.cwd,
+                            approvalPolicy: this.defaultApprovalPolicy,
+                        });
+                    }
+                    catch {
+                        // thread might already be active on server
+                    }
+                }
+                if (cancelled) {
+                    cleanup();
+                    return;
+                }
+                if (!threadId) {
+                    throw new Error('Failed to resolve or create Codex thread for turn');
+                }
+                let turn;
+                try {
+                    turn = await this.client.startTurn({
+                        threadId,
+                        input: [{ type: 'text', text: promptText, text_elements: [] }],
+                        cwd: request.cwd,
+                        model: effectiveModel,
+                        effort: request.effort ?? null,
+                        serviceTier: request.serviceTier ?? undefined,
+                        collaborationMode: null,
+                        approvalPolicy: this.defaultApprovalPolicy,
+                        sandboxMode: this.defaultSandboxMode,
+                    });
+                }
+                catch (turnErr) {
+                    const errMsg = String(turnErr);
+                    if (errMsg.includes('not found') ||
+                        errMsg.includes('No thread') ||
+                        errMsg.includes('stale') ||
+                        errMsg.includes('invalid thread')) {
+                        const session = await this.client.startThread({
+                            cwd: request.cwd,
+                            model: effectiveModel,
+                            approvalPolicy: this.defaultApprovalPolicy,
+                            sandboxMode: this.defaultSandboxMode,
+                        });
+                        threadId = session.thread.threadId;
+                        turn = await this.client.startTurn({
+                            threadId,
+                            input: [{ type: 'text', text: promptText, text_elements: [] }],
+                            cwd: request.cwd,
+                            model: effectiveModel,
+                            effort: request.effort ?? null,
+                            serviceTier: request.serviceTier ?? undefined,
+                            collaborationMode: null,
+                            approvalPolicy: this.defaultApprovalPolicy,
+                            sandboxMode: this.defaultSandboxMode,
+                        });
+                    }
+                    else {
+                        throw turnErr;
+                    }
+                }
+                turnId = turn.id;
+            }
+            catch (err) {
+                cleanup();
+                turnError = err instanceof Error ? err : new Error(String(err));
+                emitter.emit('error', turnError);
+                resolveWaiters(null);
+            }
+        };
+        void run();
+        return {
+            turnId: turnId ?? undefined,
+            cancel: () => {
+                cancelled = true;
+                if (threadId && turnId) {
+                    void this.client.interruptTurn(threadId, turnId).catch(() => { });
+                }
+            },
+            waitForResult: async () => {
+                if (finalResult)
+                    return finalResult;
+                if (turnError)
+                    return null;
+                return new Promise((resolve) => {
+                    resultWaiters.push(resolve);
+                });
+            },
+            on: (event, listener) => {
+                emitter.on(event, listener);
+            },
+        };
+    }
+}

package/dist/codex_app/client.d.ts

@@ -49,7 +49,7 @@ interface StartTurnOptions {
     serviceTier?: string | null | undefined;
     collaborationMode: CodexCollaborationMode | null;
 }
-interface CodexAppServerRuntimeStatus {
+export interface CodexAppServerRuntimeStatus {
     pid: number | null;
     port: number | null;
     running: boolean;
@@ -78,6 +78,7 @@ export declare class CodexAppClient extends EventEmitter {
     private port;
     private connected;
     private userAgent;
+    private readonly requestTimeoutMs;
     constructor(codexCliBin: string, launchCommand: string, autolaunch: boolean, serverStatePath: string, serverLogPath: string, logger: Logger, childEnv?: NodeJS.ProcessEnv | null, appServerConfigOverrides?: readonly string[]);
     isConnected(): boolean;
     getUserAgent(): string | null;

package/dist/codex_app/client.js

@@ -33,6 +33,7 @@ export class CodexAppClient extends EventEmitter {
     port = null;
     connected = false;
     userAgent = null;
+    requestTimeoutMs = 30_000;
     constructor(codexCliBin, launchCommand, autolaunch, serverStatePath, serverLogPath, logger, childEnv = null, appServerConfigOverrides = []) {
         super();
         this.codexCliBin = codexCliBin;
@@ -283,6 +284,18 @@ export class CodexAppClient extends EventEmitter {
             models.push(...rows.map(mapModel));
             cursor = typeof result.nextCursor === 'string' ? result.nextCursor : null;
         } while (cursor);
+        if (!models.some((m) => m.id === 'gpt-6-sol' || m.model === 'gpt-6-sol')) {
+            models.push({
+                id: 'gpt-6-sol',
+                model: 'gpt-6-sol',
+                displayName: 'GPT-6-Sol',
+                description: 'Next-generation flagship model with deep reasoning',
+                isDefault: false,
+                supportedReasoningEfforts: ['low', 'medium', 'high', 'xhigh', 'max'],
+                defaultReasoningEffort: 'medium',
+                serviceTiers: [],
+            });
+        }
         return models;
     }
     async readAccount(refreshToken = false) {
@@ -577,6 +590,9 @@ export class CodexAppClient extends EventEmitter {
                 port: state.port,
                 error: error instanceof Error ? error.message : String(error),
             });
+            if (isProcessAlive(state.pid)) {
+                throw new Error(`Managed Codex app-server pid ${state.pid} is alive but unreachable; retry the connection or explicitly restart it.`, { cause: error });
+            }
             this.clearServerStateForPid(state.pid);
             return false;
         }
@@ -588,11 +604,18 @@ export class CodexAppClient extends EventEmitter {
             try {
                 await new Promise((resolve, reject) => {
                     const ws = new WebSocket(url);
+                    const timer = setTimeout(() => {
+                        ws.close();
+                        reject(new Error('WebSocket handshake timed out'));
+                    }, 2000);
                     const onError = (event) => {
+                        clearTimeout(timer);
                         ws.close();
                         reject(new Error(`WebSocket connect failed: ${String(event.type)}`));
                     };
                     ws.addEventListener('open', () => {
+                        clearTimeout(timer);
+                        ws.removeEventListener('error', onError);
                         this.socket = ws;
                         this.connected = true;
                         ws.addEventListener('message', message => this.handleMessage(String(message.data)));
@@ -608,7 +631,12 @@ export class CodexAppClient extends EventEmitter {
                             });
                         });
                         ws.addEventListener('error', err => {
-                            this.logger.warn('codex.ws.error', String(err.message ?? 'unknown'));
+                            this.logger.warn('codex.ws.error', { message: err.message || 'WebSocket transport error', port: this.port });
+                            if (this.socket === ws) {
+                                this.socket = null;
+                                ws.close();
+                                this.handleDisconnect({ source: 'websocket-error', port: this.port });
+                            }
                         });
                         resolve();
                     }, { once: true });
@@ -649,8 +677,22 @@ export class CodexAppClient extends EventEmitter {
         }
         const id = String(++this.requestId);
         return new Promise((resolve, reject) => {
-            this.pending.set(id, { resolve, reject });
-            this.send({ jsonrpc: '2.0', id, method, params });
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                this.logger.warn('codex.request_timeout', { method, timeoutMs: this.requestTimeoutMs });
+                reject(new Error(`Codex request timed out: ${method}. The result is unknown; check /status or use foxclaw resume before retrying.`));
+            }, this.requestTimeoutMs);
+            this.pending.set(id, {
+                resolve: (value) => { clearTimeout(timer); resolve(value); },
+                reject: (error) => { clearTimeout(timer); reject(error); },
+            });
+            try {
+                this.send({ jsonrpc: '2.0', id, method, params });
+            }
+            catch (error) {
+                this.pending.get(id)?.reject(error);
+                this.pending.delete(id);
+            }
         });
     }
     send(payload) {
@@ -690,6 +732,7 @@ export class CodexAppClient extends EventEmitter {
         }
     }
     handleDisconnect(meta) {
+        this.logger.warn('codex.disconnected', meta);
         if (this.connected) {
             this.connected = false;
         }
@@ -711,7 +754,7 @@ export class CodexAppClient extends EventEmitter {
         this.reconnectTimer = setTimeout(async () => {
             this.reconnectTimer = null;
             try {
-                await this.startServer();
+                await this.start();
             }
             catch (error) {
                 this.logger.error('codex.reconnect_failed', { error: String(error) });

package/dist/codex_app/force_takeover.d.ts

@@ -0,0 +1,12 @@
+export interface ExternalWriterIdentity {
+    pid: number;
+    startTime: string;
+    exe: string;
+    lockDevice: string;
+    lockInode: string;
+    cwd: string;
+}
+export declare const externalWriterControl: {
+    inspect(home: string, threadId: string): Promise<ExternalWriterIdentity>;
+    stop(home: string, threadId: string, expected: ExternalWriterIdentity): Promise<void>;
+};

package/dist/codex_app/force_takeover.js

@@ -0,0 +1,27 @@
+import { execFile } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+const helper = fileURLToPath(new URL('../../scripts/force-takeover.py', import.meta.url));
+async function runHelper(home, threadId, expected) {
+    if (process.platform !== 'linux')
+        throw new Error('Force takeover requires Linux/WSL with pidfd support');
+    const args = [helper, home, threadId];
+    if (expected)
+        args.push(JSON.stringify(expected));
+    const { stdout } = await execFileAsync('python3', args, { timeout: 12_000, maxBuffer: 16_384 });
+    const response = JSON.parse(stdout);
+    if (!response.ok)
+        throw new Error(response.error ?? 'External writer inspection failed');
+    return response.result;
+}
+export const externalWriterControl = {
+    async inspect(home, threadId) {
+        return await runHelper(home, threadId);
+    },
+    async stop(home, threadId, expected) {
+        const result = await runHelper(home, threadId, expected);
+        if (result.stopped !== true)
+            throw new Error('CLI stop was not confirmed');
+    },
+};

package/dist/config.d.ts

@@ -9,7 +9,9 @@ export declare const DEFAULT_CODEX_APP_SERVER_STATE_PATH: string;
 export declare const DEFAULT_CODEX_APP_SERVER_LOG_PATH: string;
 export declare const DEFAULT_OPENCODE_SERVER_STATE_PATH: string;
 export declare const DEFAULT_OPENCODE_SERVER_LOG_PATH: string;
+export declare const DEFAULT_ANTIGRAVITY_AUTH_DIR: string;
 export declare const DEFAULT_CODEX_TELEGRAM_HOME: string;
+export declare const DEFAULT_ANTIGRAVITY_TELEGRAM_HOME: string;
 export declare const DEFAULT_AUTH_SYNC_STATE_PATH: string;
 export declare const DEFAULT_AUTH_SYNC_TEMP_DIR: string;
 export declare const DEFAULT_ENV_PATH: string;
@@ -42,6 +44,14 @@ export interface AppConfig {
     opencodeServerPassword: string | null;
     opencodeServerStatePath: string;
     opencodeServerLogPath: string;
+    antigravityBotToken: string | null;
+    antigravityBotTokens: string[];
+    antigravityMultiBotMode: boolean;
+    antigravityDefaultRuntimeBotToken: string | null;
+    antigravityHome: string | null;
+    antigravityCliBin: string;
+    antigravityAuthDir: string;
+    antigravityDefaultModel: string;
     storePath: string;
     logLevel: LogLevel;
     defaultCwd: string;
@@ -101,6 +111,8 @@ export interface CodexApiProviderConfig {
 export declare function loadConfig(): AppConfig;
 export declare function buildCodexApiProviderOverrides(providers: readonly CodexApiProviderConfig[], defaultProviderId?: string | null): string[];
 export declare function validateOpencodeBotToken(token: string | null, codexTokens: readonly string[]): void;
+export declare function validateAntigravityBotTokens(tokens: readonly string[], codexTokens: readonly string[], opencodeToken: string | null): void;
+export declare function validateAntigravityBotToken(token: string | null, codexTokens: readonly string[], opencodeToken: string | null): void;
 export declare function parseCodexApiProviders(raw: string | undefined): CodexApiProviderConfig[];
 export declare function selectDefaultRuntimeBotToken(configuredTokens: string[], legacyToken: string | null): string | null;
 export declare function ensureAppDirs(config: AppConfig): void;

package/dist/config.js

@@ -12,7 +12,9 @@ export const DEFAULT_CODEX_APP_SERVER_STATE_PATH = path.join(APP_HOME, 'runtime'
 export const DEFAULT_CODEX_APP_SERVER_LOG_PATH = path.join(APP_HOME, 'logs', 'codex-app-server.log');
 export const DEFAULT_OPENCODE_SERVER_STATE_PATH = path.join(APP_HOME, 'runtime', 'opencode-server.json');
 export const DEFAULT_OPENCODE_SERVER_LOG_PATH = path.join(APP_HOME, 'logs', 'opencode-server.log');
+export const DEFAULT_ANTIGRAVITY_AUTH_DIR = path.join(os.homedir(), '.gemini', 'antigravity-cli');
 export const DEFAULT_CODEX_TELEGRAM_HOME = path.join(APP_HOME, 'codex', 'telegram');
+export const DEFAULT_ANTIGRAVITY_TELEGRAM_HOME = path.join(APP_HOME, 'antigravity', 'telegram');
 export const DEFAULT_AUTH_SYNC_STATE_PATH = path.join(APP_HOME, 'runtime', 'auth-sync.json');
 export const DEFAULT_AUTH_SYNC_TEMP_DIR = path.join(APP_HOME, 'runtime', 'auth-sync');
 export const DEFAULT_ENV_PATH = path.join(APP_HOME, '.env');
@@ -55,6 +57,16 @@ export function loadConfig() {
     }
     const opencodeBotToken = optional('OPENCODE_BOT_TOKEN');
     validateOpencodeBotToken(opencodeBotToken, tgBotTokens);
+    const configuredAntigravityTokens = parseCommaSeparatedIds(process.env.ANTIGRAVITY_BOT_TOKENS);
+    const legacyAntigravityToken = optional('ANTIGRAVITY_BOT_TOKEN');
+    const antigravityDefaultRuntimeBotToken = selectDefaultRuntimeBotToken(configuredAntigravityTokens, legacyAntigravityToken);
+    const antigravityBotTokens = configuredAntigravityTokens.length > 0
+        ? configuredAntigravityTokens
+        : legacyAntigravityToken
+            ? [legacyAntigravityToken]
+            : [];
+    const antigravityBotToken = antigravityBotTokens[0] || null;
+    validateAntigravityBotTokens(antigravityBotTokens, tgBotTokens, opencodeBotToken);
     const config = {
         tgBotToken: tgBotTokens[0],
         tgBotTokens,
@@ -81,6 +93,14 @@ export function loadConfig() {
         opencodeServerPassword: optional('OPENCODE_SERVER_PASSWORD'),
         opencodeServerStatePath: process.env.OPENCODE_SERVER_STATE_PATH || DEFAULT_OPENCODE_SERVER_STATE_PATH,
         opencodeServerLogPath: process.env.OPENCODE_SERVER_LOG_PATH || DEFAULT_OPENCODE_SERVER_LOG_PATH,
+        antigravityBotToken,
+        antigravityBotTokens,
+        antigravityMultiBotMode: configuredAntigravityTokens.length > 0,
+        antigravityDefaultRuntimeBotToken,
+        antigravityHome: process.env.ANTIGRAVITY_HOME?.trim() || null,
+        antigravityCliBin: process.env.ANTIGRAVITY_CLI_BIN || resolveCommand('agy') || '/home/wuya/.local/bin/agy',
+        antigravityAuthDir: process.env.ANTIGRAVITY_AUTH_DIR?.trim() || DEFAULT_ANTIGRAVITY_AUTH_DIR,
+        antigravityDefaultModel: process.env.ANTIGRAVITY_DEFAULT_MODEL?.trim() || 'gemini-3.8-flash-high',
         storePath: process.env.STORE_PATH || DEFAULT_STORE_PATH,
         logLevel: parseLogLevel(process.env.LOG_LEVEL || 'info'),
         defaultCwd: process.env.DEFAULT_CWD || process.cwd(),
@@ -156,6 +176,28 @@ export function validateOpencodeBotToken(token, codexTokens) {
         throw new Error('OPENCODE_BOT_TOKEN must use a different bot from TG_BOT_TOKENS/TG_BOT_TOKEN');
     }
 }
+export function validateAntigravityBotTokens(tokens, codexTokens, opencodeToken) {
+    if (tokens.length === 0)
+        return;
+    const seen = new Set();
+    for (const token of tokens) {
+        if (seen.has(token)) {
+            throw new Error(`ANTIGRAVITY_BOT_TOKENS contains duplicate Telegram bot token: ${token}`);
+        }
+        seen.add(token);
+        if (codexTokens.includes(token)) {
+            throw new Error('ANTIGRAVITY_BOT_TOKENS/ANTIGRAVITY_BOT_TOKEN must use a different bot from TG_BOT_TOKENS/TG_BOT_TOKEN');
+        }
+        if (opencodeToken && token === opencodeToken) {
+            throw new Error('ANTIGRAVITY_BOT_TOKENS/ANTIGRAVITY_BOT_TOKEN must use a different bot from OPENCODE_BOT_TOKEN');
+        }
+    }
+}
+export function validateAntigravityBotToken(token, codexTokens, opencodeToken) {
+    if (!token)
+        return;
+    validateAntigravityBotTokens([token], codexTokens, opencodeToken);
+}
 export function parseCodexApiProviders(raw) {
     if (!raw?.trim())
         return [];

package/dist/controller/controller.d.ts

@@ -2,8 +2,8 @@ import type { AppConfig } from '../config.js';
 import type { Logger } from '../logger.js';
 import type { BridgeStore } from '../store/database.js';
 import { type AuthSyncClusterAuditResult } from '../auth/cross_node_sync.js';
-import type { RuntimeStatus } from '../types.js';
-import type { TelegramGateway, TelegramTextEvent } from '../telegram/gateway.js';
+import type { AppLocale, RuntimeStatus } from '../types.js';
+import type { TelegramGateway, TelegramTextEvent, TelegramCallbackEvent } from '../telegram/gateway.js';
 import { BridgeMessagingRouter } from '../channels/bridge_messaging_router.js';
 import type { CodexAppClient } from '../codex_app/client.js';
 import type { SelfUpdateRuntime, SelfUpdateStatus } from '../update.js';
@@ -66,6 +66,9 @@ export declare class BridgeSessionCore {
     private pendingUserInputs;
     private pendingMcpElicitations;
     private pendingLoginsByScope;
+    private externalWriterControl;
+    private forceTakeoversInProgress;
+    private pendingForceTakeovers;
     private pendingLoginScopesById;
     private pendingAuthAddsByLoginId;
     private latestTurnDiffs;
@@ -116,6 +119,7 @@ export declare class BridgeSessionCore {
      * (used by the Weixin adapter).
      */
     dispatchInboundLikeTelegramText(event: TelegramTextEvent): void;
+    hasPendingInteraction(scopeId: string): boolean;
     /** Start Codex app-server transport and attach RPC listeners. */
     startCodexApp(): Promise<void>;
     /** Begin Telegram Bot API long-polling after handlers and Codex are ready. */
@@ -132,7 +136,7 @@ export declare class BridgeSessionCore {
     private handleWatchCommand;
     private handleThreadArchiveIndexCommand;
     private handleThreadRenameIndexCommand;
-    private handleCallback;
+    handleCallback(event: TelegramCallbackEvent): Promise<void>;
     private handleApprovalTextCommand;
     private handleNotification;
     private handleServerRequest;
@@ -287,6 +291,8 @@ export declare class BridgeSessionCore {
     private applyObservedSessionEvents;
     private applyObservedTurnSnapshot;
     private handleTakeoverCommand;
+    private prepareForceTakeover;
+    private handleForceTakeoverCallback;
     private handleQueueCommand;
     private handleActiveTurnInboundMessage;
     private queueObservedThreadMessage;
@@ -322,7 +328,7 @@ export declare class BridgeSessionCore {
     private clearProactiveAuthRefreshTimer;
     private runProactiveAuthRefresh;
     private recordProactiveAuthRefreshStatus;
-    private handleAuthCommand;
+    handleAuthCommand(scopeId: string, locale: AppLocale, args: string[]): Promise<void>;
     private handleAuthSyncCommand;
     private runAuthSafeSyncAll;
     private runAuthClusterAudit;
@@ -341,6 +347,7 @@ export declare class BridgeSessionCore {
     private handleVoiceCallback;
     private sendVoiceForText;
     private handleLoginDeviceCommand;
+    private loginCancelKeyboard;
     private handleLoginCancelCommand;
     private handleLogoutCommand;
     private handleSteerCommand;
@@ -377,6 +384,7 @@ export declare class BridgeSessionCore {
     private requireReadyBinding;
     private handleAuthPanelActionCallback;
     private handleAuthListViewCallback;
+    private refreshRepairedAuthChoice;
     private handleAuthRepairMenuCallback;
     private handleAuthRepairActionCallback;
     private handleAuthToggleCallback;
@@ -437,7 +445,9 @@ export declare class BridgeSessionCore {
     private handleNavigationCallback;
     private showWherePanel;
     private handleThreadListNavigationCallback;
-    private showThreadsPanel;
+    showThreadsPanel(scopeId: string, messageId?: number, searchTerm?: string | null, locale?: AppLocale, options?: {
+        offset?: number;
+    }, archived?: boolean): Promise<void>;
     private showModelSettingsPanel;
     private showSetupPanel;
     private showAccessSettingsPanel;