@foxden-app/foxclaw 0.10.0 → 0.11.1

package/dist/opencode/adapter.js

@@ -64,6 +64,7 @@ export class OpencodeEngineAdapter {
                         throw new Error(`Failed to create OpenCode session: ${formatSdkError(createRes.error)}`);
                     }
                     sessionId = createRes.data.id;
+                    emitter.emit('conversation', sessionId);
                 }
                 if (cancelled)
                     return;

package/dist/opencode/controller.js

@@ -720,7 +720,7 @@ export class OpencodeBridgeCore {
         const model = index >= 0 ? models[index] : models.find((item) => `${item.providerId}/${item.modelId}` === normalized || item.modelId === normalized || storeModel(item.providerId, item.modelId) === normalized);
         if (!model)
             throw new Error(localize(locale, `未知模型：${raw}`, `Unknown model: ${raw}`));
-        this.store.setChatSettings(scopeId, storeModel(model.providerId, model.modelId), null);
+        this.store.setChatModel(scopeId, storeModel(model.providerId, model.modelId));
         const prefs = readPrefs(this.store.getChatSettings(scopeId));
         if (prefs.variant && !model.variants.includes(prefs.variant))
             this.writePrefs(scopeId, { ...prefs, variant: null });
@@ -1792,7 +1792,7 @@ export class OpencodeBridgeCore {
                 }
                 else {
                     const parsed = parseStoredModel(action.value);
-                    this.store.setChatSettings(event.scopeId, action.value, null);
+                    this.store.setChatModel(event.scopeId, action.value);
                     this.writePrefs(event.scopeId, { ...readPrefs(this.store.getChatSettings(event.scopeId)), variant: null });
                     answer = `${parsed.providerId}/${parsed.modelId}`;
                 }

package/dist/store/database.d.ts

@@ -59,6 +59,7 @@ export declare class BridgeStore {
         scopeId: string;
         chatId: string;
     } | null;
+    migrateTelegramUnnamespacedScope(botId: string, chatId: string): void;
     getBinding(chatId: string): ThreadBinding | null;
     setBinding(chatId: string, threadId: string, cwd: string | null): void;
     listBindings(): ThreadBinding[];
@@ -71,6 +72,8 @@ export declare class BridgeStore {
     }>;
     getChatSettings(chatId: string): ChatSessionSettings | null;
     setChatSettings(chatId: string, model: string | null, reasoningEffort: ReasoningEffortValue | null, locale?: AppLocale | null): void;
+    setChatModel(chatId: string, model: string | null): void;
+    setChatEffort(chatId: string, effort: ReasoningEffortValue | null): void;
     setChatLocale(chatId: string, locale: AppLocale): void;
     setChatAccessPreset(chatId: string, accessPreset: AccessPresetValue | null): void;
     setChatCollaborationMode(chatId: string, collaborationMode: CollaborationModeValue | null): void;

package/dist/store/database.js

@@ -298,6 +298,31 @@ export class BridgeStore {
         const row = this.db.prepare('SELECT scope_id, chat_id FROM telegram_private_scopes WHERE bot_id = ?').get(botId);
         return row ? { scopeId: String(row.scope_id), chatId: String(row.chat_id) } : null;
     }
+    migrateTelegramUnnamespacedScope(botId, chatId) {
+        const legacyScope = `telegram:${chatId}::root`;
+        const namespacedScope = `telegram:${botId}:${chatId}::root`;
+        const existing = this.db.prepare('SELECT chat_id, thread_id, cwd, updated_at FROM chat_bindings WHERE chat_id = ?').get(legacyScope);
+        if (existing) {
+            const target = this.db.prepare('SELECT chat_id, thread_id, cwd, updated_at FROM chat_bindings WHERE chat_id = ?').get(namespacedScope);
+            if (!target) {
+                this.db.prepare('INSERT INTO chat_bindings (chat_id, thread_id, cwd, updated_at) VALUES (?, ?, ?, ?)').run(namespacedScope, existing.thread_id, existing.cwd, existing.updated_at);
+            }
+            else if (Number(existing.updated_at) > Number(target.updated_at)) {
+                this.db.prepare('UPDATE chat_bindings SET thread_id = ?, cwd = ?, updated_at = ? WHERE chat_id = ?').run(existing.thread_id, existing.cwd, existing.updated_at, namespacedScope);
+            }
+        }
+        const legacyBackends = this.db.prepare('SELECT * FROM scope_backend_bindings WHERE scope_id = ?').all(legacyScope);
+        for (const row of legacyBackends) {
+            const backendId = String(row.backend_id);
+            const targetRow = this.db.prepare('SELECT updated_at FROM scope_backend_bindings WHERE scope_id = ? AND backend_id = ?').get(namespacedScope, backendId);
+            if (!targetRow) {
+                this.db.prepare('INSERT INTO scope_backend_bindings (scope_id, backend_id, thread_id, cwd, updated_at, model, reasoning_effort, active_turn_message_mode, service_tier, access_preset) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)').run(namespacedScope, backendId, row.thread_id, row.cwd, row.updated_at, row.model, row.reasoning_effort, row.active_turn_message_mode, row.service_tier, row.access_preset);
+            }
+            else if (Number(row.updated_at) > Number(targetRow.updated_at)) {
+                this.db.prepare('UPDATE scope_backend_bindings SET thread_id = ?, cwd = ?, updated_at = ?, model = ?, reasoning_effort = ?, active_turn_message_mode = ?, service_tier = ?, access_preset = ? WHERE scope_id = ? AND backend_id = ?').run(row.thread_id, row.cwd, row.updated_at, row.model, row.reasoning_effort, row.active_turn_message_mode, row.service_tier, row.access_preset, namespacedScope, backendId);
+            }
+        }
+    }
     getBinding(chatId) {
         const row = this.db.prepare('SELECT chat_id, thread_id, cwd, updated_at FROM chat_bindings WHERE chat_id = ?').get(chatId);
         if (!row)
@@ -370,6 +395,14 @@ export class BridgeStore {
         const nextLocale = locale === undefined ? current?.locale ?? null : locale;
         this.writeChatSettings(chatId, model, reasoningEffort, nextLocale, current?.accessPreset ?? null, current?.collaborationMode ?? null, current?.serviceTier ?? null, current?.activeTurnMessageMode ?? null, current?.activeBackendId ?? null);
     }
+    setChatModel(chatId, model) {
+        const current = this.getChatSettings(chatId);
+        this.setChatSettings(chatId, model, current?.reasoningEffort ?? null);
+    }
+    setChatEffort(chatId, effort) {
+        const current = this.getChatSettings(chatId);
+        this.setChatSettings(chatId, current?.model ?? null, effort);
+    }
     setChatLocale(chatId, locale) {
         const current = this.getChatSettings(chatId);
         this.writeChatSettings(chatId, current?.model ?? null, current?.reasoningEffort ?? null, locale, current?.accessPreset ?? null, current?.collaborationMode ?? null, current?.serviceTier ?? null, current?.activeTurnMessageMode ?? null, current?.activeBackendId ?? null);

package/dist/telegram/api.d.ts

@@ -9,6 +9,7 @@ export interface TelegramRemoteFile {
     file_size?: number;
     file_path?: string;
 }
+export declare function isTransientNetworkError(err: unknown): boolean;
 export declare function callTelegramApi<T>(botToken: string, method: string, body: Record<string, unknown>): Promise<TelegramApiResult<T>>;
 export declare function callTelegramMultipartApi<T>(botToken: string, method: string, fields: Record<string, string>, files: Array<{
     fieldName: string;

package/dist/telegram/api.js

@@ -4,16 +4,28 @@ import https from 'node:https';
 import path from 'node:path';
 import { pipeline } from 'node:stream/promises';
 const DEFAULT_API_BASE_URL = 'https://api.telegram.org';
-function isTransientNetworkError(err) {
+export function isTransientNetworkError(err) {
     if (!err)
         return false;
-    const msg = String(err.message || err);
-    return (msg.includes('Client network socket disconnected') ||
-        msg.includes('ECONNRESET') ||
-        msg.includes('ETIMEDOUT') ||
-        msg.includes('EAI_AGAIN') ||
-        msg.includes('ENOTFOUND') ||
-        msg.includes('socket hang up'));
+    const msg = String(err.message || err).toLowerCase();
+    return (msg.includes('client network socket disconnected') ||
+        msg.includes('econnreset') ||
+        msg.includes('etimedout') ||
+        msg.includes('eai_again') ||
+        msg.includes('enotfound') ||
+        msg.includes('econnrefused') ||
+        msg.includes('socket hang up') ||
+        msg.includes('timed out') ||
+        msg.includes('timeout') ||
+        msg.includes('network socket disconnected') ||
+        msg.includes('network error') ||
+        msg.includes('fetch failed') ||
+        msg.includes('und_err_') ||
+        msg.includes('read tcp') ||
+        msg.includes('connection timed out') ||
+        msg.includes('broken pipe') ||
+        msg.includes('ehostunreach') ||
+        msg.includes('enetunreach'));
 }
 function callTelegramApiOnce(botToken, method, body) {
     const payload = JSON.stringify(body);
@@ -51,7 +63,7 @@ function callTelegramApiOnce(botToken, method, body) {
     });
 }
 export async function callTelegramApi(botToken, method, body) {
-    const maxAttempts = method === 'getUpdates' ? 1 : 3;
+    const maxAttempts = method === 'getUpdates' ? 1 : 4;
     let lastError;
     for (let attempt = 1; attempt <= maxAttempts; attempt++) {
         try {
@@ -60,7 +72,7 @@ export async function callTelegramApi(botToken, method, body) {
         catch (err) {
             lastError = err;
             if (attempt < maxAttempts && isTransientNetworkError(err)) {
-                await new Promise((r) => setTimeout(r, 400 * attempt));
+                await new Promise((r) => setTimeout(r, Math.min(3000, 500 * Math.pow(2, attempt - 1))));
                 continue;
             }
             throw err;
@@ -68,7 +80,7 @@ export async function callTelegramApi(botToken, method, body) {
     }
     throw lastError;
 }
-export async function callTelegramMultipartApi(botToken, method, fields, files) {
+function callTelegramMultipartApiOnce(botToken, method, fields, files) {
     const boundary = `foxclaw-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
     const parts = [];
     for (const [name, value] of Object.entries(fields)) {
@@ -114,6 +126,24 @@ export async function callTelegramMultipartApi(botToken, method, fields, files)
         request.end();
     });
 }
+export async function callTelegramMultipartApi(botToken, method, fields, files) {
+    const maxAttempts = 3;
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            return await callTelegramMultipartApiOnce(botToken, method, fields, files);
+        }
+        catch (err) {
+            lastError = err;
+            if (attempt < maxAttempts && isTransientNetworkError(err)) {
+                await new Promise((r) => setTimeout(r, Math.min(3000, 500 * Math.pow(2, attempt - 1))));
+                continue;
+            }
+            throw err;
+        }
+    }
+    throw lastError;
+}
 export async function getTelegramFile(botToken, fileId) {
     const result = await callTelegramApi(botToken, 'getFile', { file_id: fileId });
     if (!result.ok || !result.result) {
@@ -121,7 +151,7 @@ export async function getTelegramFile(botToken, fileId) {
     }
     return result.result;
 }
-export async function downloadTelegramFile(botToken, remoteFilePath, destinationPath) {
+async function downloadTelegramFileOnce(botToken, remoteFilePath, destinationPath) {
     await fs.promises.mkdir(path.dirname(destinationPath), { recursive: true });
     const tempPath = `${destinationPath}.tmp-${process.pid}-${Date.now()}`;
     let response = null;
@@ -158,6 +188,24 @@ export async function downloadTelegramFile(botToken, remoteFilePath, destination
         response?.destroy();
     }
 }
+export async function downloadTelegramFile(botToken, remoteFilePath, destinationPath) {
+    const maxAttempts = 3;
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            return await downloadTelegramFileOnce(botToken, remoteFilePath, destinationPath);
+        }
+        catch (err) {
+            lastError = err;
+            if (attempt < maxAttempts && isTransientNetworkError(err)) {
+                await new Promise((r) => setTimeout(r, Math.min(3000, 500 * Math.pow(2, attempt - 1))));
+                continue;
+            }
+            throw err;
+        }
+    }
+    throw lastError;
+}
 function escapeMultipartName(value) {
     return value.replaceAll('\\', '\\\\').replaceAll('"', '\\"').replaceAll('\r', '').replaceAll('\n', '');
 }

package/dist/telegram/bot_home.js

@@ -5,16 +5,17 @@ const ID_FILE = '.foxclaw-bot.json';
 export function prepareTelegramBotHome(baseDir, botId, username, sharedHome = null) {
     if (!/^bot\d+$/.test(botId))
         throw new Error('Invalid Telegram bot identity');
-    if (username !== null && !/^[A-Za-z0-9_]{1,64}$/.test(username))
+    const normalizedUsername = username ? username.replace(/^@/, '') : null;
+    if (normalizedUsername !== null && !/^[A-Za-z0-9_]{1,64}$/.test(normalizedUsername))
         throw new Error('Invalid Telegram username for directory');
-    const base = path.resolve(baseDir);
-    fs.mkdirSync(base, { recursive: true, mode: 0o700 });
+    fs.mkdirSync(baseDir, { recursive: true, mode: 0o700 });
+    const base = fs.realpathSync(path.resolve(baseDir));
     const legacy = path.join(base, botId);
     const legacyStat = lstat(legacy);
     const source = legacyStat?.isSymbolicLink() ? fs.realpathSync(legacy) : legacy;
     if (path.dirname(source) !== base)
         throw new Error(`Bot directory points outside its storage root: ${legacy}`);
-    const target = username ? path.join(base, `@${username}`) : source;
+    const target = normalizedUsername ? path.join(base, `@${normalizedUsername}`) : source;
     const sourceStat = lstat(source);
     const targetStat = lstat(target);
     if (sourceStat && !sourceStat.isDirectory())

package/dist/types.d.ts

@@ -403,7 +403,9 @@ export interface RuntimeStatus {
         activeTurns: number;
         runtimeKind?: 'default' | 'isolated';
         currentAuth?: string | null;
+        defaultBackend?: 'codex' | 'antigravity';
         codexHome?: string | null;
+        antigravityHome?: string | null;
         codexAppServer?: RuntimeStatus['codexAppServer'];
     }>;
     weixinRuntime?: {

package/dist/update.js

@@ -33,7 +33,23 @@ export function inferPnpmFallbackPackageFromEntryPoint(entryPoint) {
     return 'pnpm@latest';
 }
 export function resolveSelfUpdateInstaller(entryPoint, nodePath = process.execPath, exists = fs.existsSync, env = process.env) {
-    const pnpmHome = inferPnpmHomeFromEntryPoint(entryPoint);
+    let pnpmHome = inferPnpmHomeFromEntryPoint(entryPoint);
+    const normalizedEntryPoint = entryPoint.replace(/\\/g, '/');
+    const isExplicitNpm = normalizedEntryPoint.includes('/node_modules/@foxden-app/foxclaw/')
+        && !normalizedEntryPoint.includes('/.pnpm/')
+        && !normalizedEntryPoint.includes('/global/');
+    if (!pnpmHome && !isExplicitNpm) {
+        const candidatePnpmHome = env.PNPM_HOME?.trim() || (process.platform === 'win32'
+            ? (env.LOCALAPPDATA ? path.join(env.LOCALAPPDATA, 'pnpm') : null)
+            : path.join(os.homedir(), '.local', 'share', 'pnpm'));
+        if (candidatePnpmHome && exists(candidatePnpmHome)) {
+            const foxclawBin = path.join(candidatePnpmHome, process.platform === 'win32' ? 'foxclaw.cmd' : 'foxclaw');
+            const globalDir = path.join(candidatePnpmHome, 'global');
+            if (exists(foxclawBin) || exists(globalDir)) {
+                pnpmHome = candidatePnpmHome;
+            }
+        }
+    }
     if (pnpmHome) {
         const npmCommandName = process.platform === 'win32' ? 'npm.cmd' : 'npm';
         const npmCommand = executableCandidates(npmCommandName, nodePath, env)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foxden-app/foxclaw",
-  "version": "0.10.0",
+  "version": "0.11.1",
   "description": "Foxden local execution claw for controlling Codex, OpenCode, and Antigravity from trusted chat interfaces.",
   "type": "module",
   "main": "dist/main.js",