@foxden-app/foxclaw 0.7.2 → 0.10.0

package/dist/antigravity/client.d.ts

@@ -0,0 +1,32 @@
+import type { Logger } from '../logger.js';
+import { type AntigravityBridgeEvent } from './events.js';
+export interface AntigravityTurnOptions {
+    prompt: string;
+    conversationId?: string | null;
+    cwd?: string | null;
+    model?: string | null;
+    effort?: string | null;
+    mode?: string | null;
+}
+export interface AntigravityClientEvents {
+    event: [event: AntigravityBridgeEvent];
+    exit: [code: number | null, signal: NodeJS.Signals | null];
+    error: [error: Error];
+}
+export interface AntigravityTurnExecution {
+    conversationId: string | null;
+    cancel(): void;
+    waitForResult(): Promise<AntigravityBridgeEvent | null>;
+    on<E extends keyof AntigravityClientEvents>(event: E, listener: (...args: AntigravityClientEvents[E]) => void): void;
+}
+export declare function normalizeAgyModelId(rawId: string): string;
+export declare class AntigravityAppClient {
+    private readonly cliBin;
+    private readonly logger;
+    private readonly childEnv;
+    private cachedModels;
+    constructor(cliBin: string, logger?: Logger, childEnv?: NodeJS.ProcessEnv | null);
+    get env(): NodeJS.ProcessEnv | null;
+    listModels(): Promise<string[]>;
+    executeTurn(options: AntigravityTurnOptions): AntigravityTurnExecution;
+}

package/dist/antigravity/client.js

@@ -0,0 +1,238 @@
+import { spawn } from 'node:child_process';
+import readline from 'node:readline';
+import { EventEmitter } from 'node:events';
+import { AntigravityEventNormalizer, } from './events.js';
+export function normalizeAgyModelId(rawId) {
+    return rawId
+        .replace(/-(high|medium|low)$/, '')
+        .replace(/-thinking$/, '');
+}
+export class AntigravityAppClient {
+    cliBin;
+    logger;
+    childEnv;
+    cachedModels = null;
+    constructor(cliBin, logger, childEnv) {
+        this.cliBin = cliBin;
+        this.logger = logger;
+        this.childEnv = childEnv ?? null;
+    }
+    get env() {
+        return this.childEnv;
+    }
+    async listModels() {
+        if (this.cachedModels && this.cachedModels.length > 0) {
+            return this.cachedModels;
+        }
+        try {
+            const child = spawn(this.cliBin, ['models'], {
+                stdio: ['ignore', 'pipe', 'pipe'],
+                env: this.childEnv ? { ...process.env, ...this.childEnv } : process.env,
+            });
+            let output = '';
+            child.stdout.on('data', (d) => {
+                output += d.toString('utf8');
+            });
+            await new Promise((resolve, reject) => {
+                child.on('close', (code) => {
+                    if (code === 0)
+                        resolve();
+                    else
+                        reject(new Error(`agy models exited with code ${code}`));
+                });
+                child.on('error', reject);
+            });
+            const lines = output.split('\n');
+            const seen = new Set();
+            const models = [];
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith('⠋') || trimmed.startsWith('Fetching'))
+                    continue;
+                const parts = trimmed.split(/\s+/);
+                if (parts[0]) {
+                    const cleanId = normalizeAgyModelId(parts[0]);
+                    if (!seen.has(cleanId)) {
+                        seen.add(cleanId);
+                        models.push(cleanId);
+                    }
+                }
+            }
+            if (models.length > 0) {
+                this.cachedModels = models;
+                return models;
+            }
+        }
+        catch (err) {
+            this.logger?.warn('antigravity.list_models_failed', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+        // Fallback to standard known models
+        return [
+            'gemini-3.8-flash',
+            'gemini-3.7-flash',
+            'gemini-3.6-flash',
+            'gemini-3.1-pro',
+            'claude-sonnet-4-6',
+            'claude-opus-4-6',
+            'gpt-oss-120b',
+        ];
+    }
+    executeTurn(options) {
+        const emitter = new EventEmitter();
+        const normalizer = new AntigravityEventNormalizer();
+        const args = [
+            '-p',
+            '',
+            '--input-format',
+            'stream-json',
+            '--output-format',
+            'stream-json',
+            '--dangerously-skip-permissions',
+        ];
+        if (options.conversationId) {
+            args.push('--conversation', options.conversationId);
+        }
+        const requestedModel = (!options.model || options.model === 'default') ? 'gemini-3.8-flash' : options.model;
+        const baseModel = normalizeAgyModelId(requestedModel);
+        let cliModel = baseModel;
+        if (baseModel === 'claude-opus-4-6') {
+            cliModel = 'claude-opus-4-6-thinking';
+        }
+        else if (baseModel === 'gpt-oss-120b') {
+            cliModel = 'gpt-oss-120b-medium';
+        }
+        args.push('--model', cliModel);
+        // Effort is only passed for models that accept it (Gemini models)
+        if (baseModel.startsWith('gemini-')) {
+            let effort = options.effort || 'high';
+            if (effort === 'xhigh' || effort === 'max' || effort === 'ultra') {
+                effort = 'high';
+            }
+            else if (effort !== 'low' && effort !== 'medium' && effort !== 'high') {
+                effort = 'high';
+            }
+            args.push('--effort', effort);
+        }
+        if (options.mode) {
+            args.push('--mode', options.mode);
+        }
+        const workingDir = options.cwd || process.cwd();
+        this.logger?.info('antigravity.turn.starting', {
+            cwd: workingDir,
+            conversationId: options.conversationId ?? null,
+            model: cliModel,
+        });
+        let child = spawn(this.cliBin, args, {
+            cwd: workingDir,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: this.childEnv ? { ...process.env, ...this.childEnv } : { ...process.env },
+        });
+        let activeConversationId = options.conversationId ?? null;
+        let finalResultEvent = null;
+        if (!child.stdin || !child.stdout) {
+            throw new Error('Failed to create stdio pipes for Antigravity CLI process');
+        }
+        // Feed user prompt via stdin
+        const inputMsg = JSON.stringify({
+            event: 'user',
+            message: {
+                content: options.prompt,
+            },
+        });
+        child.stdin.write(inputMsg + '\n');
+        child.stdin.end();
+        const rl = readline.createInterface({
+            input: child.stdout,
+            crlfDelay: Infinity,
+        });
+        rl.on('line', (line) => {
+            const trimmed = line.trim();
+            if (!trimmed || !trimmed.startsWith('{'))
+                return;
+            try {
+                const parsed = JSON.parse(trimmed);
+                if (parsed.event === 'init') {
+                    activeConversationId = parsed.conversation_id;
+                }
+                const bridgeEvents = normalizer.accept(parsed);
+                for (const ev of bridgeEvents) {
+                    if (ev.kind === 'result') {
+                        finalResultEvent = ev;
+                    }
+                    emitter.emit('event', ev);
+                }
+            }
+            catch (e) {
+                this.logger?.debug('antigravity.ndjson_parse_error', { line, error: String(e) });
+            }
+        });
+        let stderrBuffer = '';
+        child.stderr?.on('data', (data) => {
+            stderrBuffer += data.toString('utf8');
+        });
+        child.on('error', (err) => {
+            this.logger?.error('antigravity.process.error', { error: err.message });
+            emitter.emit('error', err);
+        });
+        child.on('close', (code, signal) => {
+            this.logger?.info('antigravity.process.exit', {
+                code,
+                signal,
+                conversationId: activeConversationId,
+                stderr: stderrBuffer ? stderrBuffer.slice(-200) : undefined,
+            });
+            if (!finalResultEvent && code !== 0) {
+                const errorMsg = stderrBuffer.trim() || `Process exited with code ${code}${signal ? ` (${signal})` : ''}`;
+                const errResult = {
+                    kind: 'result',
+                    conversationId: activeConversationId || '',
+                    status: 'ERROR',
+                    response: errorMsg,
+                    error: errorMsg,
+                    durationSeconds: 0,
+                };
+                finalResultEvent = errResult;
+                emitter.emit('event', errResult);
+            }
+            emitter.emit('exit', code, signal);
+            child = null;
+        });
+        const execution = {
+            get conversationId() {
+                return activeConversationId;
+            },
+            cancel() {
+                if (child && !child.killed) {
+                    child.kill('SIGINT');
+                    setTimeout(() => {
+                        if (child && !child.killed) {
+                            child.kill('SIGKILL');
+                        }
+                    }, 2000).unref();
+                }
+            },
+            waitForResult() {
+                return new Promise((resolve) => {
+                    if (finalResultEvent) {
+                        resolve(finalResultEvent);
+                        return;
+                    }
+                    emitter.on('event', (ev) => {
+                        if (ev.kind === 'result') {
+                            resolve(ev);
+                        }
+                    });
+                    emitter.on('exit', () => {
+                        resolve(finalResultEvent);
+                    });
+                });
+            },
+            on(event, listener) {
+                emitter.on(event, listener);
+            },
+        };
+        return execution;
+    }
+}

package/dist/antigravity/controller.d.ts

@@ -0,0 +1,96 @@
+import type { AppConfig } from '../config.js';
+import { TelegramMessagingPort } from '../channels/telegram/telegram_messaging_port.js';
+import type { Logger } from '../logger.js';
+import type { BridgeStore } from '../store/database.js';
+import type { RuntimeStatus } from '../types.js';
+import type { TelegramGateway, TelegramTextEvent } from '../telegram/gateway.js';
+import { AntigravityAppClient } from './client.js';
+import { AntigravityAuthManager } from './auth.js';
+import { AntigravityEngineAdapter } from './adapter.js';
+import { CodexEngineAdapter } from '../codex_app/adapter.js';
+import type { CodexAppClient, CodexAppServerRuntimeStatus } from '../codex_app/client.js';
+import { OpencodeEngineAdapter } from '../opencode/adapter.js';
+import type { OpencodeAppClient } from '../opencode/client.js';
+import { BridgeSessionCore } from '../controller/controller.js';
+export interface UnifiedBridgeRuntimeStatus {
+    running: boolean;
+    connected: boolean;
+    activeTurns: number;
+    botUsername: string | null;
+    codexHome: string;
+    codexAppServer?: CodexAppServerRuntimeStatus | undefined;
+    userAgent: string | null;
+    authProactiveRefresh?: RuntimeStatus['authProactiveRefresh'];
+    lastError?: string | null | undefined;
+}
+export interface UnifiedBridgeCoreOptions {
+    codexApp?: CodexAppClient | undefined;
+    codexAdapter?: CodexEngineAdapter | undefined;
+    codexCore?: BridgeSessionCore | undefined;
+    antigravityApp?: AntigravityAppClient | undefined;
+    antigravityAuth?: AntigravityAuthManager | undefined;
+    antigravityAdapter?: AntigravityEngineAdapter | undefined;
+    opencodeApp?: OpencodeAppClient | undefined;
+    opencodeAdapter?: OpencodeEngineAdapter | undefined;
+    defaultBackendId?: 'antigravity' | 'codex' | 'opencode' | string | undefined;
+}
+export declare class UnifiedBridgeCore {
+    private readonly config;
+    private readonly store;
+    private readonly logger;
+    private readonly bot;
+    private readonly app;
+    private readonly auth;
+    private readonly conversations;
+    private readonly messaging;
+    private readonly adapter;
+    private readonly codexAdapter?;
+    private readonly codexApp?;
+    readonly codexCore?: BridgeSessionCore | undefined;
+    private readonly opencodeAdapter?;
+    private readonly defaultBackendId;
+    private readonly orchestrator;
+    private readonly watchers;
+    private readonly pendingAgyRenames;
+    private readonly stalePanelDeleteTimers;
+    constructor(config: AppConfig, store: BridgeStore, logger: Logger, bot: TelegramGateway, app?: AntigravityAppClient | undefined, auth?: AntigravityAuthManager | undefined, messaging?: TelegramMessagingPort | undefined, options?: UnifiedBridgeCoreOptions);
+    private getBackendDescriptors;
+    registerInboundHandlers(): void;
+    registerTelegramInboundHandlers(): void;
+    dispatchInboundLikeTelegramText(event: TelegramTextEvent): void;
+    startCodexApp(): Promise<void>;
+    startTelegramPolling(): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getRuntimeStatus(): UnifiedBridgeRuntimeStatus;
+    isIdleForServiceUpdate(): boolean;
+    getCurrentAuthLabel(): Promise<string | null>;
+    handleExternalCodexAuthCandidateDeleted(candidateName: string, _reason?: string | null): Promise<void>;
+    validateExternalCodexAuthCandidate(_candidateName: string, _rawAuth: string, _expectedAccountId: string): Promise<{
+        ok: boolean;
+        reason?: string | null;
+    }>;
+    private sendMessage;
+    private editMessage;
+    scheduleStalePanelDeletion(scopeId: string, messageId: number): void;
+    private renderCustomStatus;
+    private renderCustomSetupRows;
+    private handleCustomInbound;
+    private handleCustomCommand;
+    private handleCustomCallback;
+    private sendThreadsPanel;
+    private openThread;
+    private sendCodexAuthMenu;
+    private switchCodexAccount;
+    private sendCodexThreadsMenu;
+    private openCodexThread;
+    private watchConversation;
+    private unwatchConversation;
+    private scheduleWatcherPoll;
+    private pollWatcher;
+    private handleWatcherTranscriptEntry;
+    private sendAuthMenu;
+    private startLoginFlow;
+    private sendEffortMenu;
+}
+export { UnifiedBridgeCore as AntigravityBridgeCore };