@foxden-app/foxclaw 0.7.3 → 0.11.0

package/dist/controller/controller.js

@@ -26,6 +26,7 @@ import { normalizeAccessPreset, resolveAccessMode } from './access.js';
 import { diffObservedTurn, findLatestTurn, findLiveTurn } from './observer.js';
 import { applySessionLog, bootstrapSessionLog, splitJsonlChunk, } from './session_observer.js';
 import { renderActiveTurnStatus } from './status.js';
+import { formatMetricTokenCount } from '../store/token_usage.js';
 import { writeRuntimeStatus } from '../runtime.js';
 const AUTH_DELETE_REASON_NEEDS_REPAIR = 'needs_repair';
 const RESTART_PREVIEW_RECOVERY_RETRY_DELAYS_MS = [3000, 7000, 15_000, 30_000, 45_000, 60_000, 60_000, 60_000];
@@ -130,6 +131,7 @@ export class BridgeSessionCore {
     pendingForceTakeovers = new Map();
     pendingLoginScopesById = new Map();
     pendingAuthAddsByLoginId = new Map();
+    authLoginRecoveryTimers = new Map();
     latestTurnDiffs = new Map();
     threadTokenUsageAlerts = new Map();
     pendingAuthChoiceLists = new Map();
@@ -212,6 +214,12 @@ export class BridgeSessionCore {
             void this.handleAsyncError('channel.text', error, event.scopeId);
         });
     }
+    hasPendingInteraction(scopeId) {
+        return this.pendingThreadRenames.has(scopeId)
+            || this.pendingThreadNewCwds.has(scopeId)
+            || this.pendingUserInputs.has(scopeId)
+            || this.pendingForceTakeovers.has(scopeId);
+    }
     /** Start Codex app-server transport and attach RPC listeners. */
     async startCodexApp() {
         this.stopping = false;
@@ -291,6 +299,9 @@ export class BridgeSessionCore {
         this.pendingLoginsByScope.clear();
         this.pendingLoginScopesById.clear();
         this.pendingAuthAddsByLoginId.clear();
+        for (const timer of this.authLoginRecoveryTimers.values())
+            clearTimeout(timer);
+        this.authLoginRecoveryTimers.clear();
         this.latestTurnDiffs.clear();
         this.threadTokenUsageAlerts.clear();
         this.pendingAuthChoiceLists.clear();
@@ -324,12 +335,13 @@ export class BridgeSessionCore {
         this.updateStatus();
     }
     getRuntimeStatus() {
+        const appServer = typeof this.app.getServerStatus === 'function' ? this.app.getServerStatus() : null;
         return {
             running: true,
-            connected: this.app.isConnected(),
-            userAgent: this.app.getUserAgent(),
+            connected: typeof this.app.isConnected === 'function' ? this.app.isConnected() : false,
+            userAgent: typeof this.app.getUserAgent === 'function' ? this.app.getUserAgent() : null,
             codexHome: this.config.codexHome ?? path.join(os.homedir(), '.codex'),
-            codexAppServer: this.app.getServerStatus(),
+            ...(appServer ? { codexAppServer: appServer } : {}),
             botUsername: this.botUsername,
             currentBindings: this.store.countBindings(),
             pendingApprovals: this.store.countPendingApprovals(),
@@ -559,6 +571,9 @@ export class BridgeSessionCore {
                         if (codexUpdateLine) {
                             lines.push(t(locale, 'status_last_codex_update', { value: codexUpdateLine }));
                         }
+                        if (lastUpdate.agyUpdate) {
+                            lines.push(locale === 'zh' ? `Antigravity CLI：${lastUpdate.agyUpdate}` : `Antigravity CLI: ${lastUpdate.agyUpdate}`);
+                        }
                     }
                     else {
                         lines.push(t(locale, 'status_last_update_none'));
@@ -1801,6 +1816,15 @@ export class BridgeSessionCore {
             return;
         }
         const pendingAuthAdd = loginId ? this.pendingAuthAddsByLoginId.get(loginId) ?? null : null;
+        if (params?.success && pendingAuthAdd)
+            await this.reconcileAuthLoginCredential(pendingAuthAdd);
+        // A recovery check and the server notification may complete concurrently.
+        if (this.pendingLoginScopesById.get(loginId) !== scopeId)
+            return;
+        const timer = this.authLoginRecoveryTimers.get(loginId);
+        if (timer)
+            clearTimeout(timer);
+        this.authLoginRecoveryTimers.delete(loginId);
         this.pendingLoginScopesById.delete(loginId);
         if (this.pendingLoginsByScope.get(scopeId) === loginId) {
             this.pendingLoginsByScope.delete(scopeId);
@@ -1875,6 +1899,62 @@ export class BridgeSessionCore {
         const state = await this.listCodexAuthState();
         await this.restoreAuthAfterAddFailure(state.authDir, state.authPath, record.previousTargetPath);
     }
+    scheduleAuthLoginRecovery(loginId) {
+        const timer = setTimeout(() => {
+            this.authLoginRecoveryTimers.delete(loginId);
+            void this.recoverAuthLogin(loginId).catch(error => {
+                this.logger.warn('codex.auth_login_recovery_failed', { error: toErrorMeta(error) });
+            }).finally(() => {
+                if (!this.stopping && this.pendingAuthAddsByLoginId.has(loginId)) {
+                    this.scheduleAuthLoginRecovery(loginId);
+                }
+            });
+        }, 5_000);
+        timer.unref();
+        this.authLoginRecoveryTimers.set(loginId, timer);
+    }
+    async recoverAuthLogin(loginId) {
+        const record = this.pendingAuthAddsByLoginId.get(loginId);
+        if (!record)
+            return;
+        if (Date.now() - record.createdAt >= 15 * 60_000) {
+            await this.handleAccountLoginCompleted({ loginId, success: false, error: 'Device login timed out; completion was not confirmed.' });
+            return;
+        }
+        await this.reconcileAuthLoginCredential(record);
+        const metadata = await readChatGptAuthMetadata(record.path);
+        if (!metadata || metadata.lastRefreshMs < record.createdAt
+            || !chatGptAuthMetadataMatchesCandidateName(record.name, metadata))
+            return;
+        const account = await this.app.readAccount(true);
+        const limits = await this.app.readAccountRateLimits();
+        if (!account || !limits || !selectCodexRateLimitSnapshot(limits)
+            || (metadata.email && account.email !== metadata.email))
+            return;
+        if (!this.pendingAuthAddsByLoginId.has(loginId))
+            return;
+        this.logger.info('codex.auth_login_recovered', { candidate: record.name });
+        await this.handleAccountLoginCompleted({ loginId, success: true });
+    }
+    async reconcileAuthLoginCredential(record) {
+        const authPath = path.join(this.resolveAuthDir(), 'auth.json');
+        const [target, current] = await Promise.all([
+            readChatGptAuthRecord(record.path), readChatGptAuthRecord(authPath),
+        ]);
+        // Codex can replace auth.json atomically, breaking our candidate symlink.
+        // Only adopt a newly written credential for the same account identity.
+        if (target && current && current.lastRefreshMs >= record.createdAt
+            && current.quotaIdentityId === target.quotaIdentityId
+            && current.lastRefreshMs > target.lastRefreshMs
+            && chatGptAuthMetadataMatchesCandidateName(record.name, current)) {
+            if (!this.pendingAuthAddsByLoginId.has(record.loginId))
+                return;
+            const temporary = `${record.path}.${process.pid}.tmp`;
+            await fs.writeFile(temporary, current.raw, { mode: 0o600 });
+            await fs.rename(temporary, record.path);
+            await pointCodexAuthAtTarget(this.resolveAuthDir(), authPath, record.path);
+        }
+    }
     async restoreAuthAfterAddFailure(authDir, authPath, previousTargetPath) {
         if (previousTargetPath) {
             await pointCodexAuthAtTarget(authDir, authPath, previousTargetPath);
@@ -3481,7 +3561,9 @@ export class BridgeSessionCore {
             this.coordinator.statusUpdated(status);
             return;
         }
-        writeRuntimeStatus(this.config.statusPath, status);
+        if (this.config.statusPath) {
+            writeRuntimeStatus(this.config.statusPath, status);
+        }
     }
     async sendMessage(scopeId, text, inlineKeyboard) {
         return this.sendRichMarkdownMessage(scopeId, text, inlineKeyboard);
@@ -5044,6 +5126,9 @@ export class BridgeSessionCore {
             const rows = [
                 ['FoxClaw', `${status.fromVersion} -> ${status.toVersion ?? t(status.locale, 'unknown')}`, status.locale === 'zh' ? '升级完成，服务已重启' : 'Updated; service restarted'],
                 ['Codex CLI', formatSelfUpdateVersionTransition(status.codexFromVersion, status.codexToVersion, status.locale), formatCodexUpdateState(status)],
+                ...(status.agyFromVersion || status.agyUpdate ? [
+                    ['Antigravity (AGY)', formatSelfUpdateVersionTransition(status.agyFromVersion ?? null, status.agyToVersion ?? null, status.locale), status.agyUpdate ?? (status.locale === 'zh' ? '已检查更新' : 'Checked')]
+                ] : []),
                 [status.locale === 'zh' ? '集群广播' : 'Cluster broadcast', status.toVersion ?? t(status.locale, 'unknown'), broadcastLine],
             ];
             const notes = status.releaseNotes?.filter(note => note.trim()) ?? [];
@@ -5061,6 +5146,7 @@ export class BridgeSessionCore {
                 telegramBold(title),
                 escapeTelegramHtml(foxclawResult),
                 escapeTelegramHtml(codexUpdateLine ?? (status.locale === 'zh' ? 'Codex CLI：未执行升级。' : 'Codex CLI: not updated.')),
+                ...(status.agyUpdate ? [escapeTelegramHtml(`Antigravity CLI：${status.agyUpdate}`)] : []),
                 escapeTelegramHtml(broadcastLine),
                 releaseNotes ? escapeTelegramHtml(releaseNotes) : '',
             ].filter(Boolean).join('\n');
@@ -5531,6 +5617,7 @@ export class BridgeSessionCore {
                 mode: 'add',
                 createdAt: Date.now(),
             });
+            this.scheduleAuthLoginRecovery(login.loginId);
             await this.sendMessage(scopeId, [
                 t(locale, 'auth_add_started', { value: candidateName }),
                 t(locale, 'login_device_prereq'),
@@ -5574,6 +5661,7 @@ export class BridgeSessionCore {
                 mode: 'repair',
                 createdAt: Date.now(),
             });
+            this.scheduleAuthLoginRecovery(login.loginId);
             await this.sendMessage(scopeId, [
                 t(locale, 'auth_repair_started', { value: target.name }),
                 t(locale, 'login_device_prereq'),
@@ -7049,11 +7137,11 @@ export class BridgeSessionCore {
                     events: formatTokenCount(stats.usageEvents),
                 }),
                 t(locale, 'status_codex_local_tokens', {
-                    total: formatTokenCount(stats.totals.totalTokens),
-                    input: formatTokenCount(stats.totals.inputTokens),
+                    total: formatCodexTokenCountWithMetric(stats.totals.totalTokens),
+                    input: formatCodexTokenCountWithMetric(stats.totals.inputTokens),
                     visible: formatTokenCount(Math.max(0, stats.totals.outputTokens - stats.totals.reasoningOutputTokens)),
-                    output: formatTokenCount(stats.totals.outputTokens),
-                    cached: formatTokenCount(stats.totals.cachedInputTokens),
+                    output: formatCodexTokenCountWithMetric(stats.totals.outputTokens),
+                    cached: formatCodexTokenCountWithMetric(stats.totals.cachedInputTokens),
                     reasoning: formatTokenCount(stats.totals.reasoningOutputTokens),
                 }),
                 ...this.formatCodexLocalResponseThroughputStatusLines(locale, stats),
@@ -7122,6 +7210,13 @@ export class BridgeSessionCore {
         this.localUsageCache = snapshot;
         this.localUsageCacheLoaded = true;
         await writeCodexLocalUsageSnapshot(this.codexLocalUsageSnapshotPath(), snapshot);
+        this.store.setBackendCumulativeTokenUsage({
+            inputTokens: stats.totals.inputTokens,
+            outputTokens: stats.totals.outputTokens,
+            cachedTokens: stats.totals.cachedInputTokens,
+            totalTokens: stats.totals.totalTokens,
+            turnsCount: stats.turns,
+        }, 'codex');
     }
     codexLocalUsageSnapshotPath() {
         return path.join(path.dirname(this.config.statusPath), this.runtimeSnapshotFilename(CODEX_LOCAL_USAGE_SNAPSHOT_FILENAME));
@@ -12031,6 +12126,12 @@ function formatTokenCount(value) {
     }
     return Math.round(value).toLocaleString('en-US');
 }
+function formatCodexTokenCountWithMetric(value) {
+    if (value >= 1_000_000) {
+        return `${formatMetricTokenCount(value)} (${formatTokenCount(value)})`;
+    }
+    return formatTokenCount(value);
+}
 function formatLocalTimestamp(seconds) {
     const date = new Date(seconds * 1000);
     const pad = (value) => String(value).padStart(2, '0');

package/dist/core/attachments.d.ts

@@ -0,0 +1,11 @@
+import type { Logger } from '../logger.js';
+import { type StagedTelegramAttachment, type TelegramInboundAttachment } from '../telegram/media.js';
+export interface TelegramFileDownloader {
+    getFile(fileId: string): Promise<{
+        file_id: string;
+        file_path?: string;
+        file_size?: number;
+    }>;
+    downloadResolvedFile(filePath: string, destination: string): Promise<unknown>;
+}
+export declare function stageInboundAttachments(downloader: TelegramFileDownloader, cwd: string, threadId: string, attachments: readonly TelegramInboundAttachment[], logger?: Logger): Promise<StagedTelegramAttachment[]>;

package/dist/core/attachments.js

@@ -0,0 +1,56 @@
+import fsPromises from 'node:fs/promises';
+import path from 'node:path';
+import { planAttachmentStoragePath, isNativeImageAttachment, TELEGRAM_BOT_API_DOWNLOAD_LIMIT_BYTES, } from '../telegram/media.js';
+export async function stageInboundAttachments(downloader, cwd, threadId, attachments, logger) {
+    const staged = [];
+    for (const attachment of attachments) {
+        try {
+            if (attachment.localPath) {
+                const planned = planAttachmentStoragePath(cwd, threadId, attachment, path.basename(attachment.localPath));
+                await fsPromises.mkdir(path.dirname(planned.localPath), { recursive: true });
+                await fsPromises.copyFile(attachment.localPath, planned.localPath);
+                const stat = await fsPromises.stat(planned.localPath);
+                const resolvedSize = stat.size;
+                staged.push({
+                    ...attachment,
+                    fileName: planned.fileName,
+                    fileSize: resolvedSize,
+                    localPath: planned.localPath,
+                    relativePath: planned.relativePath,
+                    nativeImage: isNativeImageAttachment(attachment),
+                });
+                continue;
+            }
+            const remoteFile = await downloader.getFile(attachment.fileId);
+            const resolvedSize = attachment.fileSize ?? remoteFile.file_size ?? null;
+            if (resolvedSize !== null && resolvedSize > TELEGRAM_BOT_API_DOWNLOAD_LIMIT_BYTES) {
+                logger?.warn('attachments.too_large', {
+                    fileId: attachment.fileId,
+                    size: resolvedSize,
+                });
+                continue;
+            }
+            if (!remoteFile.file_path) {
+                continue;
+            }
+            const planned = planAttachmentStoragePath(cwd, threadId, attachment, remoteFile.file_path);
+            await fsPromises.mkdir(path.dirname(planned.localPath), { recursive: true });
+            await downloader.downloadResolvedFile(remoteFile.file_path, planned.localPath);
+            staged.push({
+                ...attachment,
+                fileName: planned.fileName,
+                fileSize: resolvedSize,
+                localPath: planned.localPath,
+                relativePath: planned.relativePath,
+                nativeImage: isNativeImageAttachment(attachment),
+            });
+        }
+        catch (error) {
+            logger?.warn('attachments.download_failed', {
+                fileId: attachment.fileId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return staged;
+}

package/dist/core/engine_spi.d.ts

@@ -0,0 +1,77 @@
+import type { StagedTelegramAttachment } from '../telegram/media.js';
+import type { AppLocale } from '../types.js';
+export interface EngineModel {
+    id: string;
+    name: string;
+    description?: string | undefined;
+    isDefault?: boolean | undefined;
+}
+export interface EngineTurnRequest {
+    scopeId: string;
+    prompt: string;
+    stagedAttachments?: StagedTelegramAttachment[] | undefined;
+    threadId: string | null;
+    cwd: string;
+    model: string;
+    effort?: string | null | undefined;
+    serviceTier?: string | null | undefined;
+    locale: AppLocale;
+}
+export interface EngineToolEvent {
+    name: string;
+    args?: Record<string, unknown> | string | undefined;
+    output?: string | undefined;
+    status?: 'running' | 'completed' | 'failed' | undefined;
+    stepIndex?: number | undefined;
+    summary?: string | undefined;
+}
+export interface EngineTurnResult {
+    kind: 'result';
+    status: 'SUCCESS' | 'ERROR' | 'INTERRUPTED';
+    response: string;
+    error?: string | undefined;
+    conversationId: string | null;
+    usage?: {
+        inputTokens?: number | undefined;
+        outputTokens?: number | undefined;
+        cachedTokens?: number | undefined;
+        totalTokens?: number | undefined;
+    } | undefined;
+}
+export interface EngineTurnExecution {
+    turnId?: string | undefined;
+    cancel(): void;
+    waitForResult(): Promise<EngineTurnResult | null>;
+    on(event: 'delta', listener: (text: string) => void): void;
+    on(event: 'tool', listener: (tool: EngineToolEvent) => void): void;
+    on(event: 'result', listener: (result: EngineTurnResult) => void): void;
+    on(event: 'error', listener: (error: Error) => void): void;
+    on(event: 'exit', listener: (code: number | null) => void): void;
+    on(event: 'conversation', listener: (conversationId: string) => void): void;
+}
+export interface EngineTurnErrorContext {
+    error: string;
+    request: EngineTurnRequest;
+    retryCount: number;
+    retryTurn: (retryCount: number) => Promise<void>;
+    sendMessage: (text: string) => Promise<number>;
+    editMessage: (messageId: number, text: string) => Promise<void>;
+}
+export interface IEngineAdapter {
+    readonly id: string;
+    readonly name: string;
+    listModels(): Promise<EngineModel[]>;
+    executeTurn(request: EngineTurnRequest): EngineTurnExecution;
+    preflightTurn?(request: EngineTurnRequest): Promise<void>;
+    handleTurnError?(context: EngineTurnErrorContext): Promise<boolean>;
+}
+export interface BackendDescriptor {
+    id: string;
+    name: string;
+    engineType: string;
+    adapter: IEngineAdapter;
+    account?: string | undefined;
+    details?: string | undefined;
+    isDefault?: boolean | undefined;
+    onSelect?: (scopeId: string) => Promise<void>;
+}

package/dist/core/engine_spi.js

@@ -0,0 +1 @@
+export {};

package/dist/core/orchestrator.d.ts

@@ -0,0 +1,106 @@
+import type { AppConfig } from '../config.js';
+import type { BridgeStore } from '../store/database.js';
+import type { Logger } from '../logger.js';
+import type { AppLocale } from '../types.js';
+import type { TelegramGateway, TelegramTextEvent, TelegramCallbackEvent } from '../telegram/gateway.js';
+import type { TelegramMessagingPort, InlineKeyboard } from '../channels/telegram/telegram_messaging_port.js';
+import { TurnQueueManager } from './turn_queue.js';
+import type { IEngineAdapter, EngineTurnExecution, BackendDescriptor } from './engine_spi.js';
+export declare const STREAM_THROTTLE_MS = 700;
+export declare const TYPING_INTERVAL_MS = 4000;
+export interface UnifiedActiveTurn {
+    scopeId: string;
+    messageId: number;
+    threadId: string | null;
+    execution: EngineTurnExecution;
+    accumulatedText: string;
+    toolLines: string[];
+    flushTimer: NodeJS.Timeout | null;
+    lastFlushTime: number;
+    typingTimer: NodeJS.Timeout | null;
+    stepIndex?: number;
+    toolCount: number;
+    currentTool?: string | null;
+    startTime: number;
+}
+export interface EngineCustomUiHook {
+    renderCustomStatus?(scopeId: string, locale: AppLocale): Promise<string | null>;
+    renderCustomSetupRows?(scopeId: string, locale: AppLocale): Promise<InlineKeyboard>;
+    handleCustomCallback?(scopeId: string, data: string, locale: AppLocale, messageId?: number, event?: TelegramCallbackEvent): Promise<boolean>;
+    handleCustomCommand?(scopeId: string, command: string, args: string, locale: AppLocale, event?: TelegramTextEvent): Promise<boolean>;
+    handleCustomInbound?(event: TelegramTextEvent, locale: AppLocale): Promise<boolean>;
+}
+export declare class UnifiedChannelOrchestrator {
+    readonly config: AppConfig;
+    readonly store: BridgeStore;
+    readonly logger: Logger;
+    readonly bot: TelegramGateway;
+    readonly messaging: TelegramMessagingPort;
+    readonly queueManager: TurnQueueManager;
+    readonly customUi?: EngineCustomUiHook | undefined;
+    private readonly backends;
+    private readonly defaultBackendId;
+    private readonly activeTurns;
+    private readonly stalePanelDeleteTimers;
+    private readonly backendProvider?;
+    get adapter(): IEngineAdapter;
+    constructor(options: {
+        config: AppConfig;
+        store: BridgeStore;
+        logger: Logger;
+        bot: TelegramGateway;
+        adapter?: IEngineAdapter;
+        adapters?: Map<string, IEngineAdapter> | IEngineAdapter[];
+        backends?: BackendDescriptor[];
+        backendProvider?: (() => Promise<BackendDescriptor[]> | BackendDescriptor[]) | undefined;
+        defaultBackendId?: string;
+        messaging: TelegramMessagingPort;
+        customUi?: EngineCustomUiHook | undefined;
+    });
+    getAdapterForScope(scopeId: string): IEngineAdapter;
+    getBackendDescriptorForScope(scopeId: string): BackendDescriptor;
+    getAdapterForBackend(backendId: string): IEngineAdapter;
+    registerBackend(desc: BackendDescriptor): void;
+    listBackends(): Promise<BackendDescriptor[]>;
+    resolveBackendDescriptor(backendId: string): Promise<BackendDescriptor | null>;
+    syncCurrentBackendSettings(scopeId: string): void;
+    scheduleStalePanelDeletion(scopeId: string, messageId: number): void;
+    switchBackend(scopeId: string, targetBackendId: string, locale: AppLocale): Promise<{
+        previousBackendId: string;
+        newBackendId: string;
+        restoredThreadId: string | null;
+        cwd: string | null;
+    }>;
+    registerInboundHandlers(): void;
+    dispatchInboundLikeTelegramText(event: TelegramTextEvent): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getActiveTurnsCount(): number;
+    hasActiveTurn(scopeId: string): boolean;
+    sendMessage(scopeId: string, text: string, keyboard?: InlineKeyboard): Promise<number>;
+    editMessage(scopeId: string, messageId: number, text: string, keyboard?: InlineKeyboard): Promise<void>;
+    private safeDeliverChunks;
+    private safeDeliverMessage;
+    handleText(event: TelegramTextEvent): Promise<void>;
+    handleCallback(event: TelegramCallbackEvent): Promise<void>;
+    startPromptTurn(event: TelegramTextEvent, prompt: string, locale: AppLocale, options?: {
+        reuseMessageId?: number | undefined;
+        forcedThreadId?: string | undefined;
+    }): Promise<void>;
+    private enqueuePromptTurn;
+    private drainNextQueuedTurn;
+    private executeTurn;
+    private handleEffortCommand;
+    private handleBoostCommand;
+    private handleActiveCommand;
+    private handleQueueCommand;
+    private handleSteerCommand;
+    handleInterrupt(scopeId: string, locale: AppLocale): Promise<void>;
+    handleNewSession(scopeId: string, locale: AppLocale, targetCwdInput?: string): Promise<void>;
+    sendStatus(scopeId: string, locale: AppLocale): Promise<void>;
+    sendSetupMenu(scopeId: string, locale: AppLocale, editMessageId?: number): Promise<void>;
+    sendModelsMenu(scopeId: string, locale: AppLocale, editMessageId?: number): Promise<void>;
+    sendHelp(scopeId: string, locale: AppLocale): Promise<void>;
+    sendBackendMenu(scopeId: string, locale: AppLocale, editMessageId?: number): Promise<void>;
+    handleBackendCommand(scopeId: string, argsString: string, locale: AppLocale): Promise<void>;
+}