@foxden-app/foxclaw 0.7.2 → 0.10.0

package/dist/antigravity/conversations.d.ts

@@ -0,0 +1,29 @@
+import type { Logger } from '../logger.js';
+import type { BridgeStore } from '../store/database.js';
+import type { AppLocale } from '../types.js';
+export interface AntigravityConversation {
+    conversationId: string;
+    title: string;
+    preview: string;
+    stepCount: number;
+    lastModifiedTime: string;
+    updatedAt: number;
+    workspaceUris: string[];
+    workspaceDir: string | null;
+    status: string;
+    killed: boolean;
+}
+export declare function parseWorkspaceDir(urisJson: string | null | undefined): string | null;
+export declare function formatAge(timestamp: number, locale?: AppLocale): string;
+export declare class AntigravityConversationManager {
+    readonly dbPath: string;
+    private readonly logger;
+    constructor(appDataDir?: string, logger?: Logger);
+    listConversations(limit?: number, search?: string): AntigravityConversation[];
+    renameConversation(conversationId: string, newTitle: string): boolean;
+    archiveConversation(conversationId: string): boolean;
+    getConversation(conversationId: string): AntigravityConversation | null;
+    resolveConversation(raw: string, scopeId: string, store: BridgeStore): AntigravityConversation | null;
+    getTranscriptPath(conversationId: string): string;
+    hasTranscript(conversationId: string): boolean;
+}

package/dist/antigravity/conversations.js

@@ -0,0 +1,289 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { DatabaseSync } from 'node:sqlite';
+export function parseWorkspaceDir(urisJson) {
+    if (!urisJson)
+        return null;
+    try {
+        const list = JSON.parse(urisJson);
+        if (Array.isArray(list) && list.length > 0 && typeof list[0] === 'string') {
+            const uri = list[0];
+            if (uri.startsWith('file://')) {
+                return uri.replace(/^file:\/\//, '');
+            }
+            return uri;
+        }
+    }
+    catch {
+        // If it's a plain string
+        if (typeof urisJson === 'string' && urisJson.startsWith('/')) {
+            return urisJson;
+        }
+    }
+    return null;
+}
+export function formatAge(timestamp, locale = 'zh') {
+    if (!timestamp)
+        return '—';
+    const seconds = Math.max(0, Math.round((Date.now() - timestamp) / 1000));
+    if (seconds < 60)
+        return locale === 'zh' ? `${seconds} 秒前` : `${seconds}s ago`;
+    const minutes = Math.round(seconds / 60);
+    if (minutes < 60)
+        return locale === 'zh' ? `${minutes} 分钟前` : `${minutes}m ago`;
+    const hours = Math.round(minutes / 60);
+    if (hours < 48)
+        return locale === 'zh' ? `${hours} 小时前` : `${hours}h ago`;
+    const days = Math.round(hours / 24);
+    return locale === 'zh' ? `${days} 天前` : `${days}d ago`;
+}
+export class AntigravityConversationManager {
+    dbPath;
+    logger;
+    constructor(appDataDir, logger) {
+        const baseDir = appDataDir || path.join(os.homedir(), '.gemini', 'antigravity-cli');
+        this.dbPath = path.join(baseDir, 'conversation_summaries.db');
+        this.logger = logger;
+    }
+    listConversations(limit = 15, search) {
+        try {
+            if (!fs.existsSync(this.dbPath)) {
+                return [];
+            }
+            const db = new DatabaseSync(this.dbPath, { readOnly: true });
+            let rows = [];
+            try {
+                db.exec('PRAGMA busy_timeout = 3000;');
+                let query = `
+          SELECT conversation_id, title, preview, step_count, last_modified_time, workspace_uris, status, killed
+          FROM conversation_summaries
+          WHERE killed = 0
+        `;
+                const params = [];
+                if (search && search.trim()) {
+                    query += ` AND (title LIKE ? OR preview LIKE ? OR workspace_uris LIKE ?)`;
+                    const term = `%${search.trim()}%`;
+                    params.push(term, term, term);
+                }
+                query += ` ORDER BY last_modified_time DESC LIMIT ?`;
+                params.push(limit);
+                rows = db.prepare(query).all(...params);
+            }
+            finally {
+                db.close();
+            }
+            return rows.map((r) => {
+                const id = String(r.conversation_id);
+                const title = String(r.title || r.preview || 'Untitled');
+                const preview = String(r.preview || '');
+                const stepCount = Number(r.step_count || 0);
+                const lastModifiedTime = String(r.last_modified_time || '');
+                const timeMs = lastModifiedTime ? new Date(lastModifiedTime).getTime() : 0;
+                const workspaceDir = parseWorkspaceDir(r.workspace_uris);
+                return {
+                    conversationId: id,
+                    title,
+                    preview,
+                    stepCount,
+                    lastModifiedTime,
+                    updatedAt: Number.isNaN(timeMs) ? 0 : timeMs,
+                    workspaceUris: r.workspace_uris ? [String(r.workspace_uris)] : [],
+                    workspaceDir,
+                    status: String(r.status || ''),
+                    killed: Boolean(r.killed),
+                };
+            });
+        }
+        catch (err) {
+            this.logger?.warn('antigravity.conversations.list_error', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+            return [];
+        }
+    }
+    renameConversation(conversationId, newTitle) {
+        try {
+            if (!fs.existsSync(this.dbPath))
+                return false;
+            const db = new DatabaseSync(this.dbPath);
+            try {
+                db.exec('PRAGMA busy_timeout = 3000;');
+                db.prepare('UPDATE conversation_summaries SET title = ? WHERE conversation_id = ?').run(newTitle, conversationId);
+                return true;
+            }
+            finally {
+                db.close();
+            }
+        }
+        catch (err) {
+            this.logger?.warn('antigravity.conversations.rename_error', { error: String(err) });
+            return false;
+        }
+    }
+    archiveConversation(conversationId) {
+        try {
+            if (!fs.existsSync(this.dbPath))
+                return false;
+            const db = new DatabaseSync(this.dbPath);
+            try {
+                db.exec('PRAGMA busy_timeout = 3000;');
+                db.prepare('UPDATE conversation_summaries SET killed = 1 WHERE conversation_id = ?').run(conversationId);
+                return true;
+            }
+            finally {
+                db.close();
+            }
+        }
+        catch (err) {
+            this.logger?.warn('antigravity.conversations.archive_error', { error: String(err) });
+            return false;
+        }
+    }
+    getConversation(conversationId) {
+        try {
+            if (!fs.existsSync(this.dbPath))
+                return null;
+            const db = new DatabaseSync(this.dbPath, { readOnly: true });
+            let row;
+            try {
+                db.exec('PRAGMA busy_timeout = 3000;');
+                row = db.prepare(`
+          SELECT conversation_id, title, preview, step_count, last_modified_time, workspace_uris, status, killed
+          FROM conversation_summaries
+          WHERE conversation_id = ?
+        `).get(conversationId);
+            }
+            finally {
+                db.close();
+            }
+            if (!row)
+                return null;
+            const timeMs = row.last_modified_time ? new Date(String(row.last_modified_time)).getTime() : 0;
+            return {
+                conversationId: String(row.conversation_id),
+                title: String(row.title || row.preview || 'Untitled'),
+                preview: String(row.preview || ''),
+                stepCount: Number(row.step_count || 0),
+                lastModifiedTime: String(row.last_modified_time || ''),
+                updatedAt: Number.isNaN(timeMs) ? 0 : timeMs,
+                workspaceUris: row.workspace_uris ? [String(row.workspace_uris)] : [],
+                workspaceDir: parseWorkspaceDir(row.workspace_uris),
+                status: String(row.status || ''),
+                killed: Boolean(row.killed),
+            };
+        }
+        catch (err) {
+            this.logger?.warn('antigravity.conversations.get_error', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+            return null;
+        }
+    }
+    resolveConversation(raw, scopeId, store) {
+        const value = raw.trim();
+        if (!value)
+            return null;
+        // 1. Check numeric index in store cache
+        if (/^\d+$/.test(value)) {
+            const index = Number.parseInt(value, 10);
+            if (index > 0) {
+                const cached = store.getCachedThread(scopeId, index);
+                if (cached) {
+                    const direct = this.getConversation(cached.threadId);
+                    if (direct)
+                        return direct;
+                    return {
+                        conversationId: cached.threadId,
+                        title: cached.name || cached.preview || cached.threadId.slice(0, 8),
+                        preview: cached.preview,
+                        stepCount: 0,
+                        lastModifiedTime: new Date(cached.updatedAt).toISOString(),
+                        updatedAt: cached.updatedAt,
+                        workspaceUris: cached.cwd ? [cached.cwd] : [],
+                        workspaceDir: cached.cwd,
+                        status: 'idle',
+                        killed: false,
+                    };
+                }
+            }
+        }
+        // 2. Check store cached threads by exact ID or prefix
+        const cachedList = store.listCachedThreads(scopeId);
+        const cachedMatch = cachedList.find((c) => c.threadId === value || c.threadId.startsWith(value));
+        if (cachedMatch) {
+            const direct = this.getConversation(cachedMatch.threadId);
+            if (direct)
+                return direct;
+            return {
+                conversationId: cachedMatch.threadId,
+                title: cachedMatch.name || cachedMatch.preview || cachedMatch.threadId.slice(0, 8),
+                preview: cachedMatch.preview,
+                stepCount: 0,
+                lastModifiedTime: new Date(cachedMatch.updatedAt).toISOString(),
+                updatedAt: cachedMatch.updatedAt,
+                workspaceUris: cachedMatch.cwd ? [cachedMatch.cwd] : [],
+                workspaceDir: cachedMatch.cwd,
+                status: 'idle',
+                killed: false,
+            };
+        }
+        // 3. Direct exact or prefix lookup in SQLite
+        const direct = this.getConversation(value);
+        if (direct)
+            return direct;
+        const list = this.listConversations(50);
+        const matches = list.filter((c) => c.conversationId === value || c.conversationId.startsWith(value));
+        if (matches.length === 1) {
+            return matches[0];
+        }
+        // 4. Fallback to on-disk brain directory & transcript.jsonl
+        if (this.hasTranscript(value)) {
+            return {
+                conversationId: value,
+                title: value.slice(0, 8),
+                preview: '',
+                stepCount: 0,
+                lastModifiedTime: new Date().toISOString(),
+                updatedAt: Date.now(),
+                workspaceUris: [],
+                workspaceDir: null,
+                status: 'idle',
+                killed: false,
+            };
+        }
+        const brainDir = path.join(path.dirname(this.dbPath), 'brain');
+        if (fs.existsSync(brainDir)) {
+            try {
+                const entries = fs.readdirSync(brainDir);
+                const brainMatches = entries.filter((e) => e === value || e.startsWith(value));
+                if (brainMatches.length === 1) {
+                    const matchedId = brainMatches[0];
+                    return {
+                        conversationId: matchedId,
+                        title: matchedId.slice(0, 8),
+                        preview: '',
+                        stepCount: 0,
+                        lastModifiedTime: new Date().toISOString(),
+                        updatedAt: Date.now(),
+                        workspaceUris: [],
+                        workspaceDir: null,
+                        status: 'idle',
+                        killed: false,
+                    };
+                }
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        return null;
+    }
+    getTranscriptPath(conversationId) {
+        const baseDir = path.dirname(this.dbPath);
+        return path.join(baseDir, 'brain', conversationId, '.system_generated', 'logs', 'transcript.jsonl');
+    }
+    hasTranscript(conversationId) {
+        return fs.existsSync(this.getTranscriptPath(conversationId));
+    }
+}

package/dist/antigravity/events.d.ts

@@ -0,0 +1,101 @@
+export interface AgInitPayload {
+    cwd: string;
+    tools?: string[];
+    permission_mode?: string;
+}
+export interface AgInitEvent {
+    event: 'init';
+    conversation_id: string;
+    init: AgInitPayload;
+}
+export interface AgStepUsage {
+    input_tokens: number;
+    output_tokens: number;
+    thinking_tokens: number;
+    cache_read_tokens: number;
+    total_tokens: number;
+}
+export interface AgToolInfo {
+    name: string;
+    parameters: Record<string, unknown>;
+    output?: string;
+}
+export interface AgStepUpdatePayload {
+    conversation_id: string;
+    step_index: number;
+    state: 'ACTIVE' | 'DONE' | 'ERROR';
+    step_type: 'user_input' | 'system_message' | 'agent_response' | 'tool';
+    text_delta?: string;
+    tool_name?: string;
+    tool_info?: AgToolInfo;
+    duration_seconds?: number;
+    usage?: AgStepUsage;
+}
+export interface AgStepUpdateEvent {
+    event: 'step_update';
+    step_update: AgStepUpdatePayload;
+}
+export interface AgResultPayload {
+    conversation_id: string;
+    status: 'SUCCESS' | 'ERROR';
+    response: string;
+    error?: string;
+    duration_seconds: number;
+    num_turns: number;
+    usage?: AgStepUsage;
+}
+export interface AgResultEvent {
+    event: 'result';
+    result: AgResultPayload;
+}
+export type AgRawEvent = AgInitEvent | AgStepUpdateEvent | AgResultEvent;
+export interface AgInitBridgeEvent {
+    kind: 'init';
+    conversationId: string;
+    cwd: string;
+    tools: string[];
+}
+export interface AgTextEvent {
+    kind: 'text';
+    conversationId: string;
+    stepIndex: number;
+    delta: string;
+    accumulatedText: string;
+}
+export interface AgToolEvent {
+    kind: 'tool';
+    conversationId: string;
+    stepIndex: number;
+    state: 'ACTIVE' | 'DONE' | 'ERROR';
+    toolName: string;
+    parameters: Record<string, unknown>;
+    output?: string | undefined;
+}
+export interface AgResultBridgeEvent {
+    kind: 'result';
+    conversationId: string;
+    status: 'SUCCESS' | 'ERROR';
+    response: string;
+    error?: string | undefined;
+    usage?: AgStepUsage | undefined;
+    durationSeconds: number;
+}
+export interface AgErrorBridgeEvent {
+    kind: 'error';
+    conversationId: string | null;
+    message: string;
+    isQuotaError: boolean;
+}
+export type AntigravityBridgeEvent = AgInitBridgeEvent | AgTextEvent | AgToolEvent | AgResultBridgeEvent | AgErrorBridgeEvent;
+export declare function isVerificationError(errorMessage: string): boolean;
+export declare function isQuotaOrAuthError(errorMessage: string): boolean;
+export declare function isCapacityOrUnavailableError(errorMessage: string): boolean;
+/**
+ * Normalizes raw NDJSON stream events from `agy` into clean bridge events.
+ */
+export declare class AntigravityEventNormalizer {
+    private accumulatedTextByStep;
+    private lastSeenUsage;
+    reset(): void;
+    accept(raw: AgRawEvent): AntigravityBridgeEvent[];
+}

package/dist/antigravity/events.js

@@ -0,0 +1,114 @@
+export function isVerificationError(errorMessage) {
+    const lower = errorMessage.toLowerCase();
+    return (lower.includes('verification required') ||
+        lower.includes('verification. please complete') ||
+        lower.includes('eligibility check failed'));
+}
+export function isQuotaOrAuthError(errorMessage) {
+    const lower = errorMessage.toLowerCase();
+    return (lower.includes('resourceexhausted') ||
+        lower.includes('resource_exhausted') ||
+        lower.includes('429') ||
+        lower.includes('quota') ||
+        lower.includes('rate limit') ||
+        lower.includes('token expired') ||
+        lower.includes('not authenticated') ||
+        lower.includes('unauthenticated') ||
+        lower.includes('invalid_grant') ||
+        lower.includes('verification required') ||
+        lower.includes('verification. please complete') ||
+        lower.includes('eligibility check failed') ||
+        lower.includes('precondition required'));
+}
+export function isCapacityOrUnavailableError(errorMessage) {
+    const lower = errorMessage.toLowerCase();
+    return (lower.includes('unavailable') ||
+        lower.includes('503') ||
+        lower.includes('no capacity available') ||
+        lower.includes('overloaded') ||
+        lower.includes('high load'));
+}
+/**
+ * Normalizes raw NDJSON stream events from `agy` into clean bridge events.
+ */
+export class AntigravityEventNormalizer {
+    accumulatedTextByStep = new Map();
+    lastSeenUsage;
+    reset() {
+        this.accumulatedTextByStep.clear();
+        this.lastSeenUsage = undefined;
+    }
+    accept(raw) {
+        switch (raw.event) {
+            case 'init':
+                return [
+                    {
+                        kind: 'init',
+                        conversationId: raw.conversation_id,
+                        cwd: raw.init.cwd,
+                        tools: raw.init.tools ?? [],
+                    },
+                ];
+            case 'step_update': {
+                const payload = raw.step_update;
+                if (payload.usage) {
+                    this.lastSeenUsage = payload.usage;
+                }
+                if (payload.step_type === 'agent_response' && payload.text_delta) {
+                    const current = this.accumulatedTextByStep.get(payload.step_index) ?? '';
+                    const next = current + payload.text_delta;
+                    this.accumulatedTextByStep.set(payload.step_index, next);
+                    return [
+                        {
+                            kind: 'text',
+                            conversationId: payload.conversation_id,
+                            stepIndex: payload.step_index,
+                            delta: payload.text_delta,
+                            accumulatedText: next,
+                        },
+                    ];
+                }
+                if (payload.step_type === 'tool' && payload.tool_name) {
+                    return [
+                        {
+                            kind: 'tool',
+                            conversationId: payload.conversation_id,
+                            stepIndex: payload.step_index,
+                            state: payload.state,
+                            toolName: payload.tool_name,
+                            parameters: payload.tool_info?.parameters ?? {},
+                            output: payload.tool_info?.output,
+                        },
+                    ];
+                }
+                return [];
+            }
+            case 'result': {
+                const res = raw.result;
+                const usage = res.usage ?? this.lastSeenUsage;
+                const events = [
+                    {
+                        kind: 'result',
+                        conversationId: res.conversation_id,
+                        status: res.status,
+                        response: res.response,
+                        error: res.error,
+                        usage,
+                        durationSeconds: res.duration_seconds,
+                    },
+                ];
+                if (res.status === 'ERROR' && res.error) {
+                    events.push({
+                        kind: 'error',
+                        conversationId: res.conversation_id,
+                        message: res.error,
+                        isQuotaError: isQuotaOrAuthError(res.error),
+                    });
+                }
+                return events;
+            }
+            default:
+                return [];
+        }
+    }
+}

package/dist/antigravity/runtime.d.ts

@@ -0,0 +1,47 @@
+import type { AppConfig } from '../config.js';
+import type { Logger } from '../logger.js';
+import type { BridgeStore } from '../store/database.js';
+import { TelegramGateway } from '../telegram/gateway.js';
+import { AntigravityAppClient } from './client.js';
+import { AntigravityAuthManager } from './auth.js';
+import { AntigravityBridgeCore } from './controller.js';
+import type { CodexAppClient } from '../codex_app/client.js';
+export interface AntigravityRuntimeOptions {
+    botToken?: string | undefined;
+    botId?: string | undefined;
+    botUsername?: string | undefined;
+    sharedDefaultRuntime?: boolean | undefined;
+    home?: string | undefined;
+    authDir?: string | undefined;
+    codexApp?: CodexAppClient | undefined;
+    app?: AntigravityAppClient | undefined;
+    auth?: AntigravityAuthManager | undefined;
+}
+/** Keeps the optional Antigravity Telegram bot lifecycle decoupled from Codex and OpenCode runtimes. */
+export declare class AntigravityTelegramRuntime {
+    private readonly bot;
+    private readonly app;
+    private readonly auth;
+    private readonly core;
+    private readonly botId;
+    private readonly configuredUsername;
+    private readonly sharedDefaultRuntime;
+    private readonly home;
+    private readonly authDir;
+    constructor(config: AppConfig, store: BridgeStore, logger: Logger, options?: AntigravityRuntimeOptions);
+    get id(): string;
+    get username(): string | null;
+    get isSharedDefaultRuntime(): boolean;
+    get botHome(): string;
+    get authDirectory(): string;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getRuntimeStatus(): ReturnType<AntigravityBridgeCore['getRuntimeStatus']> & {
+        id?: string;
+        botHome?: string;
+        authDir?: string;
+        sharedDefaultRuntime?: boolean;
+    };
+    get botGateway(): TelegramGateway;
+    get bridgeCore(): AntigravityBridgeCore;
+}

package/dist/antigravity/runtime.js

@@ -0,0 +1,82 @@
+import os from 'node:os';
+import { TelegramMessagingPort } from '../channels/telegram/telegram_messaging_port.js';
+import { getAntigravityTelegramCommands } from '../i18n.js';
+import { TelegramGateway } from '../telegram/gateway.js';
+import { AntigravityAppClient } from './client.js';
+import { AntigravityAuthManager } from './auth.js';
+import { AntigravityBridgeCore } from './controller.js';
+/** Keeps the optional Antigravity Telegram bot lifecycle decoupled from Codex and OpenCode runtimes. */
+export class AntigravityTelegramRuntime {
+    bot;
+    app;
+    auth;
+    core;
+    botId;
+    configuredUsername;
+    sharedDefaultRuntime;
+    home;
+    authDir;
+    constructor(config, store, logger, options) {
+        const token = options?.botToken ?? config.antigravityBotToken;
+        if (!token) {
+            throw new Error('ANTIGRAVITY_BOT_TOKEN or ANTIGRAVITY_BOT_TOKENS is required for the Antigravity runtime');
+        }
+        this.bot = new TelegramGateway(token, config.tgAllowedUserId, config.tgAllowedChatId, config.telegramPollIntervalMs, store, logger, true, getAntigravityTelegramCommands);
+        this.botId = options?.botId ?? null;
+        this.configuredUsername = options?.botUsername ?? null;
+        this.home = options?.home ?? os.homedir();
+        this.authDir = options?.authDir ?? config.antigravityAuthDir;
+        this.sharedDefaultRuntime =
+            options?.sharedDefaultRuntime ??
+                (config.antigravityDefaultRuntimeBotToken
+                    ? config.antigravityDefaultRuntimeBotToken === token
+                    : true);
+        this.auth = options?.auth ?? new AntigravityAuthManager(this.authDir, logger);
+        const childEnv = options?.home && !this.sharedDefaultRuntime ? { HOME: options.home } : null;
+        this.app = options?.app ?? new AntigravityAppClient(config.antigravityCliBin, logger, childEnv);
+        this.core = new AntigravityBridgeCore(config, store, logger, this.bot, this.app, this.auth, new TelegramMessagingPort(this.bot), {
+            ...options,
+            defaultBackendId: 'antigravity',
+        });
+        this.core.registerInboundHandlers();
+    }
+    get id() {
+        return this.botId ?? this.bot.identity ?? 'unknown';
+    }
+    get username() {
+        return this.bot.username ?? this.configuredUsername;
+    }
+    get isSharedDefaultRuntime() {
+        return this.sharedDefaultRuntime;
+    }
+    get botHome() {
+        return this.home;
+    }
+    get authDirectory() {
+        return this.authDir;
+    }
+    async start() {
+        await this.bot.initializeIdentity().catch(() => { });
+        await this.bot.resolveUsername().catch(() => { });
+        await this.core.start();
+    }
+    async stop() {
+        await this.core.stop();
+    }
+    getRuntimeStatus() {
+        const status = this.core.getRuntimeStatus();
+        return {
+            ...status,
+            id: this.id,
+            botHome: this.home,
+            authDir: this.authDir,
+            sharedDefaultRuntime: this.sharedDefaultRuntime,
+        };
+    }
+    get botGateway() {
+        return this.bot;
+    }
+    get bridgeCore() {
+        return this.core;
+    }
+}

package/dist/auth/cross_node_sync.js

@@ -776,11 +776,11 @@ export class CrossNodeAuthSync {
         this.recordEvent({
             direction: 'local',
             kind: 'audit.state',
-            stage: message.state,
+            stage: applied ? message.state : 'skipped',
             peer: null,
             requestId: message.requestId,
             candidateName: message.candidateName,
-            detail: null,
+            detail: applied ? null : 'local candidate did not match the audited identity or refresh timestamp',
         });
     }
     async buildAuditReport() {