@foxden-app/foxclaw 0.7.2 → 0.10.0

package/dist/main.js

@@ -7,8 +7,9 @@ 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, buildCodexApiProviderOverrides, DEFAULT_CODEX_TELEGRAM_HOME, DEFAULT_ENV_PATH, DEFAULT_LOG_PATH, DEFAULT_STATUS_PATH, getLoadedEnvPath, loadConfig, loadEnv, } from './config.js';
+import { APP_HOME, buildCodexApiProviderOverrides, DEFAULT_CODEX_TELEGRAM_HOME, DEFAULT_ANTIGRAVITY_TELEGRAM_HOME, DEFAULT_ENV_PATH, DEFAULT_LOG_PATH, DEFAULT_STATUS_PATH, getLoadedEnvPath, loadConfig, loadEnv, } from './config.js';
 import { createAuthRefreshNotificationAggregator, } from './auth/notifications.js';
+import { getAntigravityTelegramCommands } from './i18n.js';
 import { installBundledCodexSkills } from './codex_skills.js';
 import { acquireProcessLock, LockHeldError } from './lock.js';
 import { readRuntimeStatus, writeRuntimeStatus } from './runtime.js';
@@ -18,6 +19,7 @@ import { clearPendingClusterUpdateBroadcast, createSelfUpdateRuntime, inferPnpmH
 import { TELEGRAM_VOICE_MAX_BYTES, TELEGRAM_VOICE_SUPPORTED_EXTENSIONS, telegramVoiceContentType, } from './voice/files.js';
 import { inferTelegramBotId, resolveTelegramVoiceTarget } from './voice/target.js';
 import { shouldShowRuntimeLastUpdate } from './update_status.js';
+import { prepareTelegramBotHome } from './telegram/bot_home.js';
 const rawCommand = process.argv[2];
 const command = rawCommand || 'serve';
 loadEnv();
@@ -225,6 +227,40 @@ async function main() {
         }
         return;
     }
+    if (command === 'resume') {
+        const args = process.argv.slice(3);
+        const botIndex = args.indexOf('--bot-id');
+        const botId = botIndex >= 0 ? args[botIndex + 1] : null;
+        if (botIndex >= 0)
+            args.splice(botIndex, 2);
+        if ((botIndex >= 0 && !botId) || args.length > 1 || args[0]?.startsWith('-')) {
+            throw new Error('Usage: foxclaw resume [thread-id] [--bot-id <bot-id>]');
+        }
+        const status = readRuntimeStatus(process.env.STATUS_PATH || DEFAULT_STATUS_PATH);
+        const runtime = botId ? status?.bots?.find(bot => bot.id === botId) : status;
+        if (!runtime)
+            throw new Error('No matching runtime status. Check foxclaw status.');
+        if (!botId && new Set(status?.bots?.map(bot => bot.codexAppServer?.port).filter(Boolean)).size > 1) {
+            throw new Error('Multiple Codex servers found. Select one with --bot-id from foxclaw status --json.');
+        }
+        const server = runtime.codexAppServer;
+        if (!server?.running || !server.pid || !server.port) {
+            throw new Error('Codex app-server is not running. Check foxclaw status.');
+        }
+        try {
+            process.kill(server.pid, 0);
+        }
+        catch {
+            throw new Error('Codex app-server status is stale; the process has exited.');
+        }
+        const result = spawnSync(process.env.CODEX_CLI_BIN || 'codex', [
+            'resume', '--remote', `ws://127.0.0.1:${server.port}`, ...args,
+        ], { stdio: 'inherit' });
+        if (result.error)
+            throw result.error;
+        process.exitCode = result.status ?? 1;
+        return;
+    }
     if (command === 'doctor') {
         const failed = !runDoctorChecks();
         process.exit(failed ? 1 : 0);
@@ -278,6 +314,7 @@ Usage:
   foxclaw init
   foxclaw doctor
   foxclaw status
+  foxclaw resume [thread-id] [--bot-id <bot-id>]
   foxclaw start|restart|stop
   foxclaw update
   foxclaw send-voice <path> [caption]
@@ -552,7 +589,7 @@ function truncateStatusLine(value, maxLength) {
     return normalized.length <= maxLength ? normalized : `${normalized.slice(0, Math.max(0, maxLength - 1))}…`;
 }
 async function runServeCli() {
-    const [{ BridgeMessagingRouter }, { TelegramMessagingPort }, { WeixinChannelAdapter }, { WeixinMessagingPort }, { attachIlinkRuntimeFromBridgeLogger }, { loadWeixinAccount }, { Logger }, { BridgeStore }, { TelegramGateway }, { CodexAppClient }, { BridgeSessionCore }, { TelegramChannelAdapter }, { AuthCandidateMirror }, { CrossNodeAuthSync }, { OpencodeTelegramRuntime },] = await Promise.all([
+    const [{ BridgeMessagingRouter }, { TelegramMessagingPort }, { WeixinChannelAdapter }, { WeixinMessagingPort }, { attachIlinkRuntimeFromBridgeLogger }, { loadWeixinAccount }, { Logger }, { BridgeStore }, { TelegramGateway }, { CodexAppClient }, { BridgeSessionCore }, { TelegramChannelAdapter }, { AuthCandidateMirror }, { CrossNodeAuthSync }, { OpencodeTelegramRuntime }, { AntigravityTelegramRuntime }, { UnifiedBridgeCore }, { AntigravityAppClient }, { AntigravityAuthManager },] = await Promise.all([
         import('./channels/bridge_messaging_router.js'),
         import('./channels/telegram/telegram_messaging_port.js'),
         import('./channels/weixin/weixin_channel_adapter.js'),
@@ -568,6 +605,10 @@ async function runServeCli() {
         import('./auth/mirror.js'),
         import('./auth/cross_node_sync.js'),
         import('./opencode/runtime.js'),
+        import('./antigravity/runtime.js'),
+        import('./antigravity/controller.js'),
+        import('./antigravity/client.js'),
+        import('./antigravity/auth.js'),
     ]);
     const config = loadConfig();
     const logger = new Logger(config.logLevel, config.logPath);
@@ -583,26 +624,85 @@ async function runServeCli() {
     let activeAuthMirror = null;
     let activeAuthSync = null;
     let activeOpencodeRuntime = null;
+    const activeAntigravityRuntimes = [];
+    let sharedCodexApp = null;
+    let sharedAntigravityApp = null;
+    let sharedAntigravityAuth = null;
     try {
         store = new BridgeStore(config.storePath);
+        sharedAntigravityAuth = new AntigravityAuthManager(config.antigravityAuthDir, logger);
+        sharedAntigravityApp = new AntigravityAppClient(config.antigravityCliBin, logger);
+        if (config.codexCliBin) {
+            sharedCodexApp = new CodexAppClient(config.codexCliBin, config.codexAppLaunchCmd, config.codexAppAutolaunch, config.codexAppServerStatePath, config.codexAppServerLogPath, logger, config.codexHome ? { CODEX_HOME: config.codexHome } : null, codexApiProviderOverrides);
+        }
         if (config.opencodeBotToken) {
             activeOpencodeRuntime = new OpencodeTelegramRuntime(config, store, logger);
             await activeOpencodeRuntime.start();
             logger.info('opencode.bridge.started', activeOpencodeRuntime.getRuntimeStatus());
         }
+        if (config.antigravityBotTokens.length > 0) {
+            for (const token of config.antigravityBotTokens) {
+                const bot = new TelegramGateway(token, config.tgAllowedUserId, config.tgAllowedChatId, config.telegramPollIntervalMs, store, logger, true, getAntigravityTelegramCommands);
+                const id = await bot.initializeIdentity();
+                const username = await bot.resolveUsername();
+                const sharedDefaultRuntime = config.antigravityDefaultRuntimeBotToken
+                    ? config.antigravityDefaultRuntimeBotToken === token
+                    : (token === config.antigravityBotTokens[0]);
+                let home;
+                let authDir;
+                let app;
+                let auth;
+                if (sharedDefaultRuntime) {
+                    home = os.homedir();
+                    authDir = config.antigravityAuthDir;
+                    app = sharedAntigravityApp;
+                    auth = sharedAntigravityAuth;
+                }
+                else {
+                    home = prepareTelegramBotHome(DEFAULT_ANTIGRAVITY_TELEGRAM_HOME, id, username, null);
+                    authDir = path.join(home, '.gemini', 'antigravity-cli');
+                    fs.mkdirSync(authDir, { recursive: true, mode: 0o700 });
+                    app = new AntigravityAppClient(config.antigravityCliBin, logger, { HOME: home });
+                    auth = new AntigravityAuthManager(authDir, logger);
+                }
+                const runtimeConfig = {
+                    ...config,
+                    antigravityBotToken: token,
+                    antigravityBotTokens: [token],
+                    tgScopeBotId: id,
+                    antigravityAuthDir: authDir,
+                };
+                const runtime = new AntigravityTelegramRuntime(runtimeConfig, store, logger, {
+                    botToken: token,
+                    botId: id,
+                    botUsername: username ?? undefined,
+                    sharedDefaultRuntime,
+                    home,
+                    authDir,
+                    codexApp: sharedCodexApp ?? undefined,
+                    app,
+                    auth,
+                });
+                await runtime.start();
+                activeAntigravityRuntimes.push(runtime);
+                logger.info('antigravity.bridge.started', runtime.getRuntimeStatus());
+            }
+        }
         if (config.tgMultiBotMode) {
             const seeds = [];
             const canonicalAuthDir = config.codexAuthDir ?? config.codexHome ?? path.join(os.homedir(), '.codex');
-            for (const token of config.tgBotTokens) {
+            const identities = await Promise.all(config.tgBotTokens.map(async (token) => {
                 const bot = new TelegramGateway(token, config.tgAllowedUserId, config.tgAllowedChatId, config.telegramPollIntervalMs, store, logger, true);
                 const id = await bot.initializeIdentity();
+                const username = await bot.resolveUsername();
+                return { token, bot, id, username };
+            }));
+            for (const { token, bot, id, username } of identities) {
                 if (seeds.some((runtime) => runtime.id === id)) {
                     throw new Error(`TG_BOT_TOKENS contains duplicate Telegram bot identity: ${id}`);
                 }
                 const sharedDefaultRuntime = config.tgDefaultRuntimeBotToken === token;
-                const home = sharedDefaultRuntime
-                    ? (config.codexHome ?? path.join(os.homedir(), '.codex'))
-                    : path.join(DEFAULT_CODEX_TELEGRAM_HOME, id, 'home');
+                const home = prepareTelegramBotHome(DEFAULT_CODEX_TELEGRAM_HOME, id, username, sharedDefaultRuntime ? (config.codexHome ?? path.join(os.homedir(), '.codex')) : null);
                 const authDir = sharedDefaultRuntime ? canonicalAuthDir : home;
                 if (!sharedDefaultRuntime) {
                     fs.mkdirSync(home, { recursive: true, mode: 0o700 });
@@ -614,7 +714,7 @@ async function runServeCli() {
                     tgBotTokens: [token],
                     tgScopeBotId: id,
                     codexAuthDir: sharedDefaultRuntime ? config.codexAuthDir : home,
-                    codexHome: sharedDefaultRuntime ? config.codexHome : home,
+                    codexHome: home,
                     codexAppAutolaunch: sharedDefaultRuntime ? config.codexAppAutolaunch : false,
                     codexAppServerStatePath: sharedDefaultRuntime
                         ? config.codexAppServerStatePath
@@ -623,9 +723,7 @@ async function runServeCli() {
                         ? config.codexAppServerLogPath
                         : path.join(APP_HOME, 'logs', `codex-app-server-${id}.log`),
                 };
-                const childEnv = sharedDefaultRuntime
-                    ? (config.codexHome ? { CODEX_HOME: config.codexHome } : null)
-                    : { CODEX_HOME: home };
+                const childEnv = { CODEX_HOME: home };
                 const app = new CodexAppClient(runtimeConfig.codexCliBin, runtimeConfig.codexAppLaunchCmd, runtimeConfig.codexAppAutolaunch, runtimeConfig.codexAppServerStatePath, runtimeConfig.codexAppServerLogPath, logger, childEnv, [
                     ...codexApiProviderOverrides,
                     ...(sharedDefaultRuntime ? [] : ['cli_auth_credentials_store="file"']),
@@ -661,6 +759,7 @@ async function runServeCli() {
                 statusPath: config.statusPath,
                 logPath: path.join(APP_HOME, 'logs', 'update.log'),
                 codexCliBin: config.codexCliBin,
+                agyCliBin: config.antigravityCliBin,
             });
             const lastSelfUpdatePath = path.join(APP_HOME, 'runtime', 'last-self-update.json');
             let lastSelfUpdate = readSelfUpdateStatus(lastSelfUpdatePath);
@@ -707,6 +806,20 @@ async function runServeCli() {
                             ...(weixinStatus.codexAppServer ? { codexAppServer: weixinStatus.codexAppServer } : {}),
                         },
                     } : {}),
+                    ...(activeAntigravityRuntimes.length > 0 ? {
+                        antigravityBots: activeAntigravityRuntimes.map((runtime) => {
+                            const status = runtime.getRuntimeStatus();
+                            return {
+                                id: runtime.id,
+                                username: status.botUsername ?? runtime.botGateway.username,
+                                connected: running && Boolean(status.connected),
+                                activeTurns: running ? (status.activeTurns ?? 0) : 0,
+                                runtimeKind: runtime.isSharedDefaultRuntime ? 'default' : 'isolated',
+                                home: runtime.botHome,
+                                authDir: runtime.authDirectory,
+                            };
+                        }),
+                    } : {}),
                     authMirror: mirror.getStatus(),
                     authSync: authSync?.getStatus() ?? null,
                     authProactiveRefresh,
@@ -803,7 +916,14 @@ async function runServeCli() {
             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);
+                const codexCore = new BridgeSessionCore(seed.config, store, logger, seed.bot, seed.app, outbound, selfUpdater, coordinator, false);
+                const core = new UnifiedBridgeCore(seed.config, store, logger, seed.bot, sharedAntigravityApp ?? undefined, sharedAntigravityAuth ?? undefined, telegramMessaging, {
+                    codexApp: seed.app,
+                    codexCore,
+                    antigravityApp: sharedAntigravityApp ?? undefined,
+                    antigravityAuth: sharedAntigravityAuth ?? undefined,
+                    defaultBackendId: 'codex',
+                });
                 runtimes.push({ ...seed, core, telegram: new TelegramChannelAdapter(core) });
             }
             if (config.wxEnabled) {
@@ -889,8 +1009,10 @@ async function runServeCli() {
                 await activeWeixinCore?.stop();
                 await Promise.all(runtimes.map((runtime) => runtime.telegram.stop()));
                 await activeOpencodeRuntime?.stop();
+                await Promise.all(activeAntigravityRuntimes.map((runtime) => runtime.stop().catch(() => { })));
                 writeAggregateStatus(false);
-                await Promise.all(managedApps.map((app) => app.stop({ terminateServer: true }).catch((error) => {
+                const allManaged = [...managedApps, ...(sharedCodexApp ? [sharedCodexApp] : [])];
+                await Promise.all(allManaged.map((app) => app.stop({ terminateServer: true }).catch((error) => {
                     logger.warn('codex.app-server.stop_failed', { error: serializeError(error) });
                 })));
                 store?.close();
@@ -904,12 +1026,13 @@ async function runServeCli() {
         const singleCodexHome = config.codexHome ?? path.join(os.homedir(), '.codex');
         installBundledCodexSkills(packageRoot, singleCodexHome);
         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, config.codexHome ? { CODEX_HOME: config.codexHome } : null, codexApiProviderOverrides);
+        const app = sharedCodexApp ?? new CodexAppClient(config.codexCliBin, config.codexAppLaunchCmd, config.codexAppAutolaunch, config.codexAppServerStatePath, config.codexAppServerLogPath, logger, config.codexHome ? { CODEX_HOME: config.codexHome } : null, codexApiProviderOverrides);
         const telegramMessaging = new TelegramMessagingPort(bot);
         const weixinMessaging = config.wxEnabled
             ? new WeixinMessagingPort(store, (id) => loadWeixinAccount(config.weixinAccountsDir, id))
             : null;
         const outbound = new BridgeMessagingRouter(telegramMessaging, weixinMessaging);
+        void outbound;
         const selfUpdater = createSelfUpdateRuntime({
             entryPoint,
             nodePath: process.execPath,
@@ -917,10 +1040,32 @@ async function runServeCli() {
             statusPath: config.statusPath,
             logPath: path.join(APP_HOME, 'logs', 'update.log'),
             codexCliBin: config.codexCliBin,
+            agyCliBin: config.antigravityCliBin,
         });
         let singleAuthSync = null;
         let singleMirror = null;
         let core = null;
+        const writeSingleStatus = (running = true) => {
+            const coreStatus = core?.getRuntimeStatus();
+            writeRuntimeStatus(config.statusPath, {
+                running,
+                connected: running && Boolean(coreStatus?.connected),
+                userAgent: coreStatus?.userAgent ?? app.getUserAgent(),
+                codexHome: coreStatus?.codexHome ?? singleCodexHome,
+                ...(coreStatus?.codexAppServer ? { codexAppServer: coreStatus.codexAppServer } : app.getServerStatus() ? { codexAppServer: app.getServerStatus() } : {}),
+                botUsername: coreStatus?.botUsername ?? bot.username,
+                currentBindings: store?.countBindings() ?? 0,
+                pendingApprovals: store?.countPendingApprovals() ?? 0,
+                pendingUserInputs: store?.countPendingUserInputs() ?? 0,
+                queuedTurns: store?.countQueuedTurnInputs() ?? 0,
+                activeTurns: coreStatus?.activeTurns ?? 0,
+                lastError: null,
+                updatedAt: new Date().toISOString(),
+                channels: { telegram: running, weixin: running && config.wxEnabled },
+                authMirror: singleMirror?.getStatus() ?? null,
+                authSync: singleAuthSync?.getStatus() ?? null,
+            });
+        };
         const singleAuthDir = config.codexAuthDir ?? config.codexHome ?? process.env.CODEX_AUTH_DIR ?? path.join(os.homedir(), '.codex');
         const singleLocalAuthRefreshLease = createLocalAuthRefreshLease();
         const singleAuthSyncLocalIdle = () => Boolean(core?.isIdleForServiceUpdate())
@@ -973,12 +1118,9 @@ async function runServeCli() {
             authSyncPushAll: () => singleAuthSync?.pushAll() ?? Promise.resolve({ sent: 0, skipped: 0 }),
             authSyncTest: () => singleAuthSync?.testPeers() ?? Promise.resolve({ sent: 0, replied: 0, missing: [] }),
             authSyncAudit: () => singleAuthSync?.auditCluster() ?? Promise.resolve(null),
-            statusUpdated: (status) => {
-                writeRuntimeStatus(config.statusPath, {
-                    ...status,
-                    authMirror: singleMirror?.getStatus() ?? null,
-                    authSync: singleAuthSync?.getStatus() ?? null,
-                });
+            statusUpdated: (_status) => {
+                void _status;
+                writeSingleStatus(true);
             },
         } : null;
         if (config.authSyncEnabled) {
@@ -1002,7 +1144,15 @@ async function runServeCli() {
             await singleMirror.initialize();
             activeAuthMirror = singleMirror;
         }
-        core = new BridgeSessionCore(config, store, logger, bot, app, outbound, selfUpdater, singleCoordinator);
+        const singleOutbound = new BridgeMessagingRouter(telegramMessaging, null);
+        const singleCodexCore = new BridgeSessionCore(config, store, logger, bot, app, singleOutbound, selfUpdater, singleCoordinator, false);
+        core = new UnifiedBridgeCore(config, store, logger, bot, sharedAntigravityApp ?? undefined, sharedAntigravityAuth ?? undefined, telegramMessaging, {
+            codexApp: app,
+            codexCore: singleCodexCore,
+            antigravityApp: sharedAntigravityApp ?? undefined,
+            antigravityAuth: sharedAntigravityAuth ?? undefined,
+            defaultBackendId: 'codex',
+        });
         if (config.authSyncEnabled && singleMirror) {
             await bot.initializeIdentity();
             singleAuthSync = new CrossNodeAuthSync(buildAuthSyncConfig(config, bot.username ? `@${bot.username}` : 'default'), logger, {
@@ -1060,6 +1210,7 @@ async function runServeCli() {
         if (weixinAdapter) {
             await weixinAdapter.start();
         }
+        writeSingleStatus(true);
         logger.info('bridge.started', core.getRuntimeStatus());
         const shutdown = async (signal) => {
             logger.info('bridge.shutting_down', { signal });
@@ -1069,6 +1220,7 @@ async function runServeCli() {
             await weixinAdapter?.stop();
             await telegram.stop();
             await activeOpencodeRuntime?.stop();
+            await Promise.all(activeAntigravityRuntimes.map((runtime) => runtime.stop().catch(() => { })));
             writeRuntimeStatus(config.statusPath, {
                 running: false,
                 connected: false,
@@ -1103,6 +1255,7 @@ async function runServeCli() {
         await activeWeixinCore?.stop().catch(() => { });
         await Promise.allSettled(activeTelegramAdapters.map((adapter) => adapter.stop()));
         await activeOpencodeRuntime?.stop().catch(() => { });
+        await Promise.allSettled(activeAntigravityRuntimes.map((runtime) => runtime.stop()));
         await Promise.allSettled(managedApps.map((app) => app.stop({ terminateServer: true })));
         store?.close();
         processLock.release();
@@ -1797,6 +1950,23 @@ function runDoctorChecks() {
         ].map((value) => value.trim()).filter(Boolean);
         checks.push(['OpenCode uses an independent Telegram bot', !codexTokens.includes(process.env.OPENCODE_BOT_TOKEN.trim())]);
     }
+    const antigravityTokens = [
+        ...(process.env.ANTIGRAVITY_BOT_TOKENS ?? '').split(','),
+        process.env.ANTIGRAVITY_BOT_TOKEN ?? '',
+    ].map((value) => value.trim()).filter(Boolean);
+    if (antigravityTokens.length > 0) {
+        const configuredAgyBin = process.env.ANTIGRAVITY_CLI_BIN;
+        checks.push(['antigravity (agy) cli available', hasConfiguredCommand(configuredAgyBin, 'agy')]);
+        const codexTokens = [
+            ...(process.env.TG_BOT_TOKENS ?? '').split(','),
+            process.env.TG_BOT_TOKEN ?? '',
+        ].map((value) => value.trim()).filter(Boolean);
+        const hasConflict = antigravityTokens.some((t) => codexTokens.includes(t));
+        checks.push(['Antigravity uses independent Telegram bot(s)', !hasConflict]);
+        const authDir = process.env.ANTIGRAVITY_AUTH_DIR || path.join(os.homedir(), '.gemini', 'antigravity-cli');
+        const hasAuth = fs.existsSync(path.join(authDir, 'antigravity-oauth-token'));
+        checks.push(['antigravity oauth token available', hasAuth]);
+    }
     if (process.env.WX_ENABLED === 'true' || process.env.WX_ENABLED === '1') {
         const accountsDir = process.env.WEIXIN_ACCOUNTS_DIR || path.join(APP_HOME, 'weixin', 'accounts');
         let hasAccounts = false;

package/dist/opencode/adapter.d.ts

@@ -0,0 +1,11 @@
+import type { IEngineAdapter, EngineModel, EngineTurnRequest, EngineTurnExecution } from '../core/engine_spi.js';
+import type { OpencodeAppClient } from './client.js';
+export declare class OpencodeEngineAdapter implements IEngineAdapter {
+    private readonly client;
+    private readonly defaultModel?;
+    readonly id = "opencode";
+    readonly name = "OpenCode (SDK)";
+    constructor(client: OpencodeAppClient, defaultModel?: string | undefined);
+    listModels(): Promise<EngineModel[]>;
+    executeTurn(request: EngineTurnRequest): EngineTurnExecution;
+}

package/dist/opencode/adapter.js

@@ -0,0 +1,168 @@
+import { EventEmitter } from 'node:events';
+import { formatSdkError } from './client.js';
+import { buildAttachmentPrompt } from '../telegram/media.js';
+export class OpencodeEngineAdapter {
+    client;
+    defaultModel;
+    id = 'opencode';
+    name = 'OpenCode (SDK)';
+    constructor(client, defaultModel) {
+        this.client = client;
+        this.defaultModel = defaultModel;
+    }
+    async listModels() {
+        if (!this.client.isConnected())
+            return [];
+        try {
+            const response = await this.client.getClient().provider.list();
+            if (response.error || !response.data)
+                return [];
+            const { all, connected, default: defaultMap } = response.data;
+            const models = [];
+            for (const providerId of connected) {
+                const provider = all.find((p) => p.id === providerId);
+                if (!provider)
+                    continue;
+                const defaultForProvider = defaultMap[providerId];
+                for (const m of Object.values(provider.models)) {
+                    const modelFullId = `${providerId}/${m.id}`;
+                    models.push({
+                        id: modelFullId,
+                        name: `${provider.name} - ${m.name}`,
+                        isDefault: m.id === defaultForProvider,
+                    });
+                }
+            }
+            return models;
+        }
+        catch {
+            return [];
+        }
+    }
+    executeTurn(request) {
+        const emitter = new EventEmitter();
+        let sessionId = request.threadId;
+        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 finalResult = null;
+        let turnError = null;
+        const resultWaiters = [];
+        const resolveWaiters = (res) => {
+            while (resultWaiters.length > 0) {
+                resultWaiters.shift()(res);
+            }
+        };
+        const run = async () => {
+            try {
+                const sdk = this.client.getClient();
+                if (!sessionId) {
+                    const createRes = await sdk.session.create({ directory: request.cwd });
+                    if (createRes.error || !createRes.data) {
+                        throw new Error(`Failed to create OpenCode session: ${formatSdkError(createRes.error)}`);
+                    }
+                    sessionId = createRes.data.id;
+                }
+                if (cancelled)
+                    return;
+                let accumulatedResponse = '';
+                const onEvent = (ev) => {
+                    if ('sessionId' in ev && ev.sessionId === sessionId) {
+                        if (ev.kind === 'text') {
+                            if (ev.delta) {
+                                accumulatedResponse += ev.delta;
+                                emitter.emit('delta', ev.delta);
+                            }
+                        }
+                        else if (ev.kind === 'tool') {
+                            emitter.emit('tool', {
+                                name: ev.tool,
+                                args: undefined,
+                                output: undefined,
+                                status: ev.status === 'running' ? 'running' : ev.status === 'error' ? 'failed' : 'completed',
+                            });
+                        }
+                        else if (ev.kind === 'idle') {
+                            cleanup();
+                            finalResult = {
+                                kind: 'result',
+                                status: 'SUCCESS',
+                                response: accumulatedResponse,
+                                conversationId: sessionId,
+                            };
+                            emitter.emit('result', finalResult);
+                            resolveWaiters(finalResult);
+                        }
+                        else if (ev.kind === 'error') {
+                            cleanup();
+                            turnError = new Error(ev.message);
+                            finalResult = {
+                                kind: 'result',
+                                status: 'ERROR',
+                                response: ev.message,
+                                conversationId: sessionId,
+                            };
+                            emitter.emit('result', finalResult);
+                            emitter.emit('error', turnError);
+                            resolveWaiters(finalResult);
+                        }
+                    }
+                };
+                const cleanup = () => {
+                    this.client.off('event', onEvent);
+                };
+                this.client.on('event', onEvent);
+                let modelParam;
+                const targetModel = request.model || this.defaultModel;
+                if (targetModel && targetModel.includes('/')) {
+                    const [pId, ...mRest] = targetModel.split('/');
+                    modelParam = { providerID: pId, modelID: mRest.join('/') };
+                }
+                const promptRes = await sdk.session.promptAsync({
+                    sessionID: sessionId,
+                    directory: request.cwd,
+                    parts: [{ type: 'text', text: promptText }],
+                    ...(modelParam ? { model: modelParam } : {}),
+                });
+                if (promptRes.error) {
+                    cleanup();
+                    turnError = new Error(formatSdkError(promptRes.error));
+                    emitter.emit('error', turnError);
+                    resolveWaiters(null);
+                }
+                else {
+                    this.client.watchSessionUntilIdle(sessionId, request.cwd);
+                }
+            }
+            catch (err) {
+                turnError = err instanceof Error ? err : new Error(String(err));
+                emitter.emit('error', turnError);
+                resolveWaiters(null);
+            }
+        };
+        void run();
+        return {
+            turnId: sessionId ?? undefined,
+            cancel: () => {
+                cancelled = true;
+                if (sessionId) {
+                    void this.client.getClient().session.abort({ sessionID: sessionId }).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/store/database.d.ts

@@ -1,4 +1,5 @@
 import type { AccessPresetValue, ActiveTurnMessageMode, AppLocale, CachedThread, ChatSessionSettings, CollaborationModeValue, GuidedPlanSessionRecord, GuidedPlanSessionState, PendingAttachmentBatchRecord, PendingAttachmentBatchStatus, PendingApprovalRecord, QueuedTurnInputRecord, QueuedTurnInputStatus, ReasoningEffortValue, ThreadBinding } from '../types.js';
+import type { CumulativeTokenTotals, CumulativeTokenUsageRecord, TokenUsageDelta } from './token_usage.js';
 export interface ActiveTurnPreviewRecord {
     turnId: string;
     scopeId: string;
@@ -62,6 +63,12 @@ export declare class BridgeStore {
     setBinding(chatId: string, threadId: string, cwd: string | null): void;
     listBindings(): ThreadBinding[];
     clearBinding(chatId: string): void;
+    getWatchedThread(chatId: string): string | null;
+    setWatchedThread(chatId: string, threadId: string | null): void;
+    listWatchedThreads(): Array<{
+        scopeId: string;
+        threadId: string;
+    }>;
     getChatSettings(chatId: string): ChatSessionSettings | null;
     setChatSettings(chatId: string, model: string | null, reasoningEffort: ReasoningEffortValue | null, locale?: AppLocale | null): void;
     setChatLocale(chatId: string, locale: AppLocale): void;
@@ -69,6 +76,30 @@ export declare class BridgeStore {
     setChatCollaborationMode(chatId: string, collaborationMode: CollaborationModeValue | null): void;
     setChatServiceTier(chatId: string, serviceTier: string | null): void;
     setChatActiveTurnMessageMode(chatId: string, activeTurnMessageMode: ActiveTurnMessageMode | null): void;
+    getActiveBackend(chatId: string): string | null;
+    setActiveBackend(chatId: string, backendId: string | null): void;
+    getScopeBackendBinding(scopeId: string, backendId: string): {
+        threadId: string;
+        cwd: string | null;
+        model?: string | null;
+        reasoningEffort?: string | null;
+        activeTurnMessageMode?: string | null;
+        serviceTier?: string | null;
+        accessPreset?: string | null;
+    } | null;
+    setScopeBackendBinding(scopeId: string, backendId: string, threadId: string, cwd: string | null, settings?: {
+        model?: string | null;
+        reasoningEffort?: string | null;
+        activeTurnMessageMode?: string | null;
+        serviceTier?: string | null;
+        accessPreset?: string | null;
+    } | null): void;
+    listScopeBackendBindings(scopeId: string): Array<{
+        backendId: string;
+        threadId: string;
+        cwd: string | null;
+        updatedAt: number;
+    }>;
     findChatIdByThreadId(threadId: string): string | null;
     findAllChatIdsByThreadId(threadId: string): string[];
     countBindings(): number;
@@ -141,5 +172,15 @@ export declare class BridgeStore {
     getCodexAuthPoolStats(): CodexAuthPoolStats;
     setCodexAuthQuotaSnapshot(runtimeId: string, candidateName: string, accountId: string, quotaIdentityId: string, snapshot: Pick<CodexAuthQuotaSnapshotRecord, 'capturedAtMs' | 'planType' | 'primaryWindowDurationMins' | 'primaryRemainingPercent' | 'secondaryWindowDurationMins' | 'secondaryRemainingPercent'> & Partial<Pick<CodexAuthQuotaSnapshotRecord, 'primaryResetsAt' | 'secondaryResetsAt'>>): void;
     listCodexAuthQuotaSnapshots(quotaIdentityIds: string[]): CodexAuthQuotaSnapshotRecord[];
+    recordTokenUsage(delta: TokenUsageDelta, backendId?: string): void;
+    setBackendCumulativeTokenUsage(usage: {
+        inputTokens: number;
+        outputTokens: number;
+        cachedTokens?: number;
+        totalTokens?: number;
+        turnsCount?: number;
+    }, backendId: string): void;
+    getCumulativeTokenUsage(backendId?: string): CumulativeTokenTotals;
+    getAllBackendTokenUsages(): CumulativeTokenUsageRecord[];
     private ensureColumn;
 }