@foxden-app/foxclaw 0.7.3 → 0.11.0

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;

package/dist/codex_app/client.js

@@ -284,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) {

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;
@@ -17,6 +19,8 @@ export declare function resolveEnvPath(): string;
 export declare function getLoadedEnvPath(): string | null;
 export declare function loadEnv(): void;
 export interface AppConfig {
+    codexBotTokens: string[];
+    antigravityBotTokens: string[];
     tgBotToken: string;
     tgBotTokens: string[];
     tgMultiBotMode: boolean;
@@ -42,6 +46,13 @@ export interface AppConfig {
     opencodeServerPassword: string | null;
     opencodeServerStatePath: string;
     opencodeServerLogPath: string;
+    antigravityBotToken: string | null;
+    antigravityMultiBotMode: boolean;
+    antigravityDefaultRuntimeBotToken: string | null;
+    antigravityHome: string | null;
+    antigravityCliBin: string;
+    antigravityAuthDir: string;
+    antigravityDefaultModel: string;
     storePath: string;
     logLevel: LogLevel;
     defaultCwd: string;
@@ -100,7 +111,10 @@ export interface CodexApiProviderConfig {
 }
 export declare function loadConfig(): AppConfig;
 export declare function buildCodexApiProviderOverrides(providers: readonly CodexApiProviderConfig[], defaultProviderId?: string | null): string[];
+export declare function validateCodexBotTokens(tokens: readonly string[]): void;
 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');
@@ -42,26 +44,35 @@ export function loadEnv() {
 }
 export function loadConfig() {
     loadEnv();
-    const configuredTokens = parseCommaSeparatedIds(process.env.TG_BOT_TOKENS);
-    const legacyToken = optional('TG_BOT_TOKEN');
-    const tgDefaultRuntimeBotToken = selectDefaultRuntimeBotToken(configuredTokens, legacyToken);
-    const tgBotTokens = configuredTokens.length > 0
-        ? configuredTokens
-        : legacyToken
-            ? [legacyToken]
-            : [];
-    if (tgBotTokens.length === 0) {
-        throw new Error('TG_BOT_TOKENS or TG_BOT_TOKEN is required');
+    if (process.env.TG_BOT_TOKEN?.trim() || process.env.TG_BOT_TOKENS?.trim()) {
+        throw new Error('Configuration error: TG_BOT_TOKEN and TG_BOT_TOKENS have been removed. Please update .env to use CODEX_BOT_TOKENS and/or ANTIGRAVITY_BOT_TOKENS.');
     }
+    const codexBotTokens = parseCommaSeparatedIds(process.env.CODEX_BOT_TOKENS || process.env.CODEX_BOT_TOKEN);
+    const antigravityBotTokens = parseCommaSeparatedIds(process.env.ANTIGRAVITY_BOT_TOKENS || process.env.ANTIGRAVITY_BOT_TOKEN);
     const opencodeBotToken = optional('OPENCODE_BOT_TOKEN');
-    validateOpencodeBotToken(opencodeBotToken, tgBotTokens);
+    if (codexBotTokens.length === 0 && antigravityBotTokens.length === 0) {
+        throw new Error('At least one Telegram bot token must be configured via CODEX_BOT_TOKENS or ANTIGRAVITY_BOT_TOKENS');
+    }
+    validateCodexBotTokens(codexBotTokens);
+    validateAntigravityBotTokens(antigravityBotTokens, codexBotTokens, opencodeBotToken);
+    validateOpencodeBotToken(opencodeBotToken, [...codexBotTokens, ...antigravityBotTokens]);
+    const codexDefaultRuntimeBotToken = selectDefaultRuntimeBotToken(codexBotTokens, optional('CODEX_DEFAULT_RUNTIME_BOT_TOKEN')) || codexBotTokens[0] || null;
+    const antigravityDefaultRuntimeBotToken = selectDefaultRuntimeBotToken(antigravityBotTokens, optional('ANTIGRAVITY_DEFAULT_RUNTIME_BOT_TOKEN')) ||
+        antigravityBotTokens[0] ||
+        null;
+    const totalBots = codexBotTokens.length + antigravityBotTokens.length;
+    const tgBotTokens = codexBotTokens.length > 0 ? codexBotTokens : antigravityBotTokens;
+    const tgBotToken = (codexBotTokens[0] || antigravityBotTokens[0]);
+    const antigravityBotToken = antigravityBotTokens[0] || null;
     const config = {
-        tgBotToken: tgBotTokens[0],
+        codexBotTokens,
+        antigravityBotTokens,
+        tgBotToken,
         tgBotTokens,
-        tgMultiBotMode: configuredTokens.length > 0,
-        tgDefaultRuntimeBotToken,
+        tgMultiBotMode: totalBots > 1,
+        tgDefaultRuntimeBotToken: codexDefaultRuntimeBotToken,
         tgScopeBotId: null,
-        tgRequireExplicitGroupAddressing: configuredTokens.length > 1,
+        tgRequireExplicitGroupAddressing: totalBots > 1,
         tgAllowedUserId: required('TG_ALLOWED_USER_ID'),
         tgAllowedChatId: optional('TG_ALLOWED_CHAT_ID'),
         tgAllowedTopicId: nullableIntEnv('TG_ALLOWED_TOPIC_ID'),
@@ -81,6 +92,13 @@ 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,
+        antigravityMultiBotMode: antigravityBotTokens.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(),
@@ -149,13 +167,44 @@ export function buildCodexApiProviderOverrides(providers, defaultProviderId = nu
     }
     return overrides;
 }
+export function validateCodexBotTokens(tokens) {
+    const seen = new Set();
+    for (const token of tokens) {
+        if (seen.has(token)) {
+            throw new Error(`CODEX_BOT_TOKENS contains duplicate Telegram bot token: ${token}`);
+        }
+        seen.add(token);
+    }
+}
 export function validateOpencodeBotToken(token, codexTokens) {
     if (!token)
         return;
     if (codexTokens.includes(token)) {
-        throw new Error('OPENCODE_BOT_TOKEN must use a different bot from TG_BOT_TOKENS/TG_BOT_TOKEN');
+        throw new Error('OPENCODE_BOT_TOKEN must use a different bot from CODEX_BOT_TOKENS');
     }
 }
+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 must use a different bot from CODEX_BOT_TOKENS');
+        }
+        if (opencodeToken && token === opencodeToken) {
+            throw new Error('ANTIGRAVITY_BOT_TOKENS 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';
@@ -71,6 +71,7 @@ export declare class BridgeSessionCore {
     private pendingForceTakeovers;
     private pendingLoginScopesById;
     private pendingAuthAddsByLoginId;
+    private authLoginRecoveryTimers;
     private latestTurnDiffs;
     private threadTokenUsageAlerts;
     private pendingAuthChoiceLists;
@@ -119,6 +120,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. */
@@ -135,7 +137,7 @@ export declare class BridgeSessionCore {
     private handleWatchCommand;
     private handleThreadArchiveIndexCommand;
     private handleThreadRenameIndexCommand;
-    private handleCallback;
+    handleCallback(event: TelegramCallbackEvent): Promise<void>;
     private handleApprovalTextCommand;
     private handleNotification;
     private handleServerRequest;
@@ -155,6 +157,9 @@ export declare class BridgeSessionCore {
     private handleServerRequestResolved;
     private handleAccountLoginCompleted;
     private restorePendingAuthAdd;
+    private scheduleAuthLoginRecovery;
+    private recoverAuthLogin;
+    private reconcileAuthLoginCredential;
     private restoreAuthAfterAddFailure;
     private handleAccountUpdated;
     private handleRateLimitsUpdated;
@@ -327,7 +332,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;
@@ -444,7 +449,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;