@foxden-app/foxclaw 0.12.0 → 0.13.0

package/dist/controller/local_usage_service.js

@@ -0,0 +1,62 @@
+import { readCodexLocalUsageSnapshot, readCodexLocalUsageStats, writeCodexLocalUsageSnapshot, } from '../codex_app/local_usage.js';
+import { CODEX_LOCAL_USAGE_REFRESH_MS, CODEX_LOCAL_USAGE_SNAPSHOT_FILENAME } from './state_types.js';
+import path from 'node:path';
+export class CodexLocalUsageService {
+    config;
+    store;
+    closed = false;
+    async stop() { this.closed = true; await this.localUsageRefresh?.catch(() => { }); }
+    localUsageCache = null;
+    localUsageCacheLoaded = false;
+    localUsageRefresh = null;
+    constructor(config, store) {
+        this.config = config;
+        this.store = store;
+    }
+    async readCachedCodexLocalUsageStats() {
+        if (this.localUsageCacheLoaded) {
+            return this.localUsageCache;
+        }
+        this.localUsageCache = await readCodexLocalUsageSnapshot(this.codexLocalUsageSnapshotPath());
+        this.localUsageCacheLoaded = true;
+        return this.localUsageCache;
+    }
+    async refreshCodexLocalUsageIfNeeded(snapshot) {
+        const current = snapshot === undefined ? await this.readCachedCodexLocalUsageStats() : snapshot;
+        if (this.closed)
+            return;
+        if (current && Date.now() - current.computedAtMs < CODEX_LOCAL_USAGE_REFRESH_MS) {
+            return;
+        }
+        if (this.localUsageRefresh) {
+            return;
+        }
+        this.localUsageRefresh = this.refreshCodexLocalUsageStats().finally(() => {
+            this.localUsageRefresh = null;
+        });
+        await this.localUsageRefresh;
+    }
+    async refreshCodexLocalUsageStats() {
+        if (this.closed)
+            return;
+        const stats = await readCodexLocalUsageStats(this.config.codexHome ?? undefined);
+        const snapshot = { computedAtMs: Date.now(), stats };
+        this.localUsageCache = snapshot;
+        this.localUsageCacheLoaded = true;
+        await writeCodexLocalUsageSnapshot(this.codexLocalUsageSnapshotPath(), snapshot);
+        if (this.closed)
+            return;
+        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));
+    }
+    invalidate() { this.localUsageCache = null; }
+    runtimeSnapshotFilename(filename) { return this.config.tgScopeBotId ? filename.replace(/\.json$/, `-${this.config.tgScopeBotId}.json`) : filename; }
+}

package/dist/controller/native_panel_service.d.ts

@@ -0,0 +1,55 @@
+import type { AppLocale, CodexSkillsListEntry } from '../types.js';
+import type { TelegramCallbackEvent } from '../telegram/gateway.js';
+import type { AppConfig } from '../config.js';
+import type { BridgeStore } from '../store/database.js';
+import type { Logger } from '../logger.js';
+import type { CodexAppClient } from '../codex_app/client.js';
+import type { ChannelInlineKeyboard } from '../core/channel_port.js';
+export interface NativePanelUi {
+    sendMessage(scopeId: string, text: string, keyboard?: ChannelInlineKeyboard): Promise<number>;
+    editMessage(scopeId: string, messageId: number, text: string, keyboard?: ChannelInlineKeyboard): Promise<void>;
+    scheduleStalePanelDeletion(scopeId: string, messageId: number): void;
+    answerCallback(id: string, text: string): Promise<void>;
+}
+export declare class CodexNativePanelService {
+    private readonly config;
+    private readonly store;
+    private readonly logger;
+    private readonly app;
+    private readonly ui;
+    constructor(config: AppConfig, store: BridgeStore, logger: Logger, app: CodexAppClient, ui: NativePanelUi);
+    handleLoadedCommand(scopeId: string, locale: AppLocale): Promise<void>;
+    handleSkillsCommand(scopeId: string, locale: AppLocale, args: string[]): Promise<void>;
+    handleSkillCommand(scopeId: string, locale: AppLocale, args: string[]): Promise<void>;
+    handleSkillConfigCommand(scopeId: string, locale: AppLocale, args: string[], enabled: boolean): Promise<void>;
+    handleHooksCommand(scopeId: string, locale: AppLocale): Promise<void>;
+    handlePluginsCommand(scopeId: string, locale: AppLocale, args: string[]): Promise<void>;
+    handlePluginCommand(scopeId: string, locale: AppLocale, args: string[]): Promise<void>;
+    handlePluginSkillCommand(scopeId: string, locale: AppLocale, args: string[]): Promise<void>;
+    handleAppsCommand(scopeId: string, locale: AppLocale, args: string[]): Promise<void>;
+    handleFeaturesCommand(scopeId: string, locale: AppLocale): Promise<void>;
+    handleConfigCommand(scopeId: string, locale: AppLocale, args?: string[]): Promise<void>;
+    handleConfigToggleCallback(event: TelegramCallbackEvent, key: 'auth_auto_delete' | 'delete_tool_details', enabled: boolean, locale: AppLocale): Promise<void>;
+    setFoxClawBooleanConfig(key: 'auth_auto_delete' | 'delete_tool_details', enabled: boolean): Promise<{
+        key: 'auth_auto_delete' | 'delete_tool_details';
+        enabled: boolean;
+        envKey: string;
+        envPath: string | null;
+        envUpdated: boolean;
+        envError: string | null;
+    }>;
+    formatConfigToggleUpdate(locale: AppLocale, update: {
+        key: 'auth_auto_delete' | 'delete_tool_details';
+        enabled: boolean;
+        envPath: string | null;
+        envUpdated: boolean;
+        envError: string | null;
+    }): string;
+    handleRequirementsCommand(scopeId: string, locale: AppLocale): Promise<void>;
+    handleProviderCommand(scopeId: string, locale: AppLocale): Promise<void>;
+    handleMcpCommand(scopeId: string, locale: AppLocale, args: string[]): Promise<void>;
+    handleMcpReloadCommand(scopeId: string, locale: AppLocale): Promise<void>;
+    handleMcpLoginCommand(scopeId: string, locale: AppLocale, args: string[]): Promise<void>;
+    handleMcpResourceCommand(scopeId: string, locale: AppLocale, args: string[]): Promise<void>;
+    listSkillsForScope(scopeId: string, forceReload: boolean): Promise<CodexSkillsListEntry[]>;
+}

package/dist/controller/native_panel_service.js

@@ -0,0 +1,214 @@
+import { formatLoadedThreadsMessage, formatSkillsMessage, findSkill, formatSkillDetailMessage, formatHooksMessage, formatPluginsMessage, formatPluginDetailMessage, formatPluginSkillMessage, formatAppsMessage, formatFeaturesMessage, parseConfigBooleanArg, formatConfigMessage, configKeyboard, writeEnvBoolean, formatRequirementsMessage, formatProviderMessage, formatMcpStatusMessage, formatMcpResourceMessage, } from './native_panels.js';
+import { t } from '../i18n.js';
+import { toErrorMeta, formatUserError } from './shared_helpers.js';
+export class CodexNativePanelService {
+    config;
+    store;
+    logger;
+    app;
+    ui;
+    constructor(config, store, logger, app, ui) {
+        this.config = config;
+        this.store = store;
+        this.logger = logger;
+        this.app = app;
+        this.ui = ui;
+    }
+    async handleLoadedCommand(scopeId, locale) {
+        const threadIds = await this.app.listLoadedThreads();
+        await this.ui.sendMessage(scopeId, formatLoadedThreadsMessage(locale, threadIds));
+    }
+    async handleSkillsCommand(scopeId, locale, args) {
+        const forceReload = args[0]?.toLowerCase() === 'reload';
+        const query = (forceReload ? args.slice(1) : args).join(' ').trim();
+        const entries = await this.listSkillsForScope(scopeId, forceReload);
+        await this.ui.sendMessage(scopeId, formatSkillsMessage(locale, entries, query || null, forceReload));
+    }
+    async handleSkillCommand(scopeId, locale, args) {
+        const name = args.join(' ').trim();
+        if (!name) {
+            await this.ui.sendMessage(scopeId, t(locale, 'usage_skill'));
+            return;
+        }
+        const skill = findSkill(await this.listSkillsForScope(scopeId, false), name);
+        if (!skill) {
+            await this.ui.sendMessage(scopeId, t(locale, 'skill_not_found', { name }));
+            return;
+        }
+        await this.ui.sendMessage(scopeId, formatSkillDetailMessage(locale, skill));
+    }
+    async handleSkillConfigCommand(scopeId, locale, args, enabled) {
+        const name = args.join(' ').trim();
+        if (!name) {
+            await this.ui.sendMessage(scopeId, enabled ? t(locale, 'usage_skill_enable') : t(locale, 'usage_skill_disable'));
+            return;
+        }
+        await this.app.writeSkillConfig({ name }, enabled);
+        await this.ui.sendMessage(scopeId, t(locale, enabled ? 'skill_enabled' : 'skill_disabled', { name }));
+    }
+    async handleHooksCommand(scopeId, locale) {
+        const binding = this.store.getBinding(scopeId);
+        const entries = await this.app.listHooks(binding?.cwd ?? this.config.defaultCwd);
+        await this.ui.sendMessage(scopeId, formatHooksMessage(locale, entries));
+    }
+    async handlePluginsCommand(scopeId, locale, args) {
+        const query = args.join(' ').trim() || null;
+        const binding = this.store.getBinding(scopeId);
+        const marketplaces = await this.app.listPlugins(binding?.cwd ?? this.config.defaultCwd);
+        await this.ui.sendMessage(scopeId, formatPluginsMessage(locale, marketplaces, query));
+    }
+    async handlePluginCommand(scopeId, locale, args) {
+        const name = args.join(' ').trim();
+        if (!name) {
+            await this.ui.sendMessage(scopeId, t(locale, 'usage_plugin'));
+            return;
+        }
+        const plugin = await this.app.readPlugin(name);
+        if (!plugin) {
+            await this.ui.sendMessage(scopeId, t(locale, 'plugin_not_found', { name }));
+            return;
+        }
+        await this.ui.sendMessage(scopeId, formatPluginDetailMessage(locale, plugin));
+    }
+    async handlePluginSkillCommand(scopeId, locale, args) {
+        const [marketplace, plugin, ...skillParts] = args;
+        const skill = skillParts.join(' ').trim();
+        if (!marketplace || !plugin || !skill) {
+            await this.ui.sendMessage(scopeId, t(locale, 'usage_plugin_skill'));
+            return;
+        }
+        const contents = await this.app.readPluginSkill(marketplace, plugin, skill);
+        await this.ui.sendMessage(scopeId, formatPluginSkillMessage(locale, marketplace, plugin, skill, contents));
+    }
+    async handleAppsCommand(scopeId, locale, args) {
+        const forceRefetch = args[0]?.toLowerCase() === 'reload';
+        const binding = this.store.getBinding(scopeId);
+        const apps = await this.app.listApps(binding?.threadId ?? null, forceRefetch);
+        await this.ui.sendMessage(scopeId, formatAppsMessage(locale, apps, forceRefetch));
+    }
+    async handleFeaturesCommand(scopeId, locale) {
+        const features = await this.app.listExperimentalFeatures();
+        await this.ui.sendMessage(scopeId, formatFeaturesMessage(locale, features));
+    }
+    async handleConfigCommand(scopeId, locale, args = []) {
+        const action = args[0]?.toLowerCase() ?? '';
+        if (['auth_auto_delete', 'auth-auto-delete', 'auto_delete_needs_repair', 'auto-delete-needs-repair'].includes(action)) {
+            const enabled = parseConfigBooleanArg(args[1]);
+            if (enabled === null) {
+                await this.ui.sendMessage(scopeId, t(locale, 'config_auth_auto_delete_usage'));
+                return;
+            }
+            const update = await this.setFoxClawBooleanConfig('auth_auto_delete', enabled);
+            const binding = this.store.getBinding(scopeId);
+            const result = await this.app.readConfig(binding?.cwd ?? this.config.defaultCwd, true);
+            const sentMessageId = await this.ui.sendMessage(scopeId, `${this.formatConfigToggleUpdate(locale, update)}\n\n${formatConfigMessage(locale, result, this.config, this.store.getCodexAuthPoolStats())}`, configKeyboard(locale, this.config));
+            this.ui.scheduleStalePanelDeletion(scopeId, sentMessageId);
+            return;
+        }
+        if (['delete_tool_details', 'delete-tool-details', 'tool_details', 'tool-details'].includes(action)) {
+            const enabled = parseConfigBooleanArg(args[1]);
+            if (enabled === null) {
+                await this.ui.sendMessage(scopeId, t(locale, 'config_delete_tool_details_usage'));
+                return;
+            }
+            const update = await this.setFoxClawBooleanConfig('delete_tool_details', enabled);
+            const binding = this.store.getBinding(scopeId);
+            const result = await this.app.readConfig(binding?.cwd ?? this.config.defaultCwd, true);
+            const sentMessageId = await this.ui.sendMessage(scopeId, `${this.formatConfigToggleUpdate(locale, update)}\n\n${formatConfigMessage(locale, result, this.config, this.store.getCodexAuthPoolStats())}`, configKeyboard(locale, this.config));
+            this.ui.scheduleStalePanelDeletion(scopeId, sentMessageId);
+            return;
+        }
+        const binding = this.store.getBinding(scopeId);
+        const result = await this.app.readConfig(binding?.cwd ?? this.config.defaultCwd, true);
+        const sentMessageId = await this.ui.sendMessage(scopeId, formatConfigMessage(locale, result, this.config, this.store.getCodexAuthPoolStats()), configKeyboard(locale, this.config));
+        this.ui.scheduleStalePanelDeletion(scopeId, sentMessageId);
+    }
+    async handleConfigToggleCallback(event, key, enabled, locale) {
+        const update = await this.setFoxClawBooleanConfig(key, enabled);
+        await this.ui.answerCallback(event.callbackQueryId, t(locale, 'decision_recorded'));
+        const binding = this.store.getBinding(event.scopeId);
+        const result = await this.app.readConfig(binding?.cwd ?? this.config.defaultCwd, true);
+        const message = `${this.formatConfigToggleUpdate(locale, update)}\n\n${formatConfigMessage(locale, result, this.config, this.store.getCodexAuthPoolStats())}`;
+        if (event.messageId !== null) {
+            await this.ui.editMessage(event.scopeId, event.messageId, message, configKeyboard(locale, this.config));
+            this.ui.scheduleStalePanelDeletion(event.scopeId, event.messageId);
+        }
+        else {
+            const sentMessageId = await this.ui.sendMessage(event.scopeId, message, configKeyboard(locale, this.config));
+            this.ui.scheduleStalePanelDeletion(event.scopeId, sentMessageId);
+        }
+    }
+    async setFoxClawBooleanConfig(key, enabled) {
+        const envKey = key === 'auth_auto_delete'
+            ? 'AUTH_AUTO_DELETE_NEEDS_REPAIR'
+            : 'TELEGRAM_DELETE_TOOL_DETAILS_AFTER_FINAL';
+        if (key === 'auth_auto_delete') {
+            this.config.authAutoDeleteNeedsRepair = enabled;
+        }
+        else {
+            this.config.telegramDeleteToolDetailsAfterFinal = enabled;
+        }
+        const envPath = this.config.envPath;
+        if (!envPath) {
+            return { key, enabled, envKey, envPath: null, envUpdated: false, envError: null };
+        }
+        try {
+            await writeEnvBoolean(envPath, envKey, enabled);
+            return { key, enabled, envKey, envPath, envUpdated: true, envError: null };
+        }
+        catch (error) {
+            this.logger.warn('config.env_update_failed', { key: envKey, envPath, error: toErrorMeta(error) });
+            return { key, enabled, envKey, envPath, envUpdated: false, envError: formatUserError(error) };
+        }
+    }
+    formatConfigToggleUpdate(locale, update) {
+        const lines = [t(locale, update.key === 'auth_auto_delete' ? 'config_auth_auto_delete_updated' : 'config_delete_tool_details_updated', {
+                value: t(locale, update.enabled ? 'yes' : 'no'),
+            })];
+        if (update.envError) {
+            lines.push(t(locale, 'config_env_update_failed', { value: update.envPath ?? t(locale, 'unknown'), error: update.envError }));
+        }
+        return lines.join('\n');
+    }
+    async handleRequirementsCommand(scopeId, locale) {
+        const requirements = await this.app.readConfigRequirements();
+        await this.ui.sendMessage(scopeId, formatRequirementsMessage(locale, requirements));
+    }
+    async handleProviderCommand(scopeId, locale) {
+        const capabilities = await this.app.readModelProviderCapabilities();
+        await this.ui.sendMessage(scopeId, formatProviderMessage(locale, capabilities));
+    }
+    async handleMcpCommand(scopeId, locale, args) {
+        const detail = args[0]?.toLowerCase() === 'brief' ? 'toolsAndAuthOnly' : 'full';
+        const statuses = await this.app.listMcpServerStatus(detail);
+        await this.ui.sendMessage(scopeId, formatMcpStatusMessage(locale, statuses));
+    }
+    async handleMcpReloadCommand(scopeId, locale) {
+        await this.app.reloadMcpServers();
+        await this.ui.sendMessage(scopeId, t(locale, 'mcp_reload_done'));
+    }
+    async handleMcpLoginCommand(scopeId, locale, args) {
+        const name = args.join(' ').trim();
+        if (!name) {
+            await this.ui.sendMessage(scopeId, t(locale, 'usage_mcp_login'));
+            return;
+        }
+        const url = await this.app.loginMcpServer(name);
+        await this.ui.sendMessage(scopeId, t(locale, 'mcp_login_started', { name, url: url || t(locale, 'unknown') }));
+    }
+    async handleMcpResourceCommand(scopeId, locale, args) {
+        const [server, ...uriParts] = args;
+        const uri = uriParts.join(' ').trim();
+        if (!server || !uri) {
+            await this.ui.sendMessage(scopeId, t(locale, 'usage_mcp_resource'));
+            return;
+        }
+        const binding = this.store.getBinding(scopeId);
+        const contents = await this.app.readMcpResource(server, uri, binding?.threadId ?? null);
+        await this.ui.sendMessage(scopeId, formatMcpResourceMessage(locale, server, uri, contents));
+    }
+    async listSkillsForScope(scopeId, forceReload) {
+        const binding = this.store.getBinding(scopeId);
+        return this.app.listSkills(binding?.cwd ?? this.config.defaultCwd, forceReload);
+    }
+}

package/dist/controller/native_panels.d.ts

@@ -0,0 +1,61 @@
+import type { AppLocale, CodexAppInfo, CodexConfigRequirements, CodexExperimentalFeature, CodexFuzzyFileResult, CodexHooksListEntry, CodexMcpResourceContent, CodexMcpServerStatus, CodexModelProviderCapabilities, CodexPluginDetail, CodexPluginMarketplace, CodexSkillMetadata, CodexSkillsListEntry, CodexThreadGoal, AppTurnSnapshot, ThreadGoalStatusValue } from '../types.js';
+import type { SelfUpdateStatus } from '../update.js';
+import type { AppConfig } from '../config.js';
+import type { CodexAuthPoolStats } from '../store/database.js';
+import { RichAuthCandidateRow, SelfUpdateBroadcastSummary, RemoteControlStatusState } from './state_types.js';
+export declare function findSkill(entries: CodexSkillsListEntry[], name: string): CodexSkillMetadata | null;
+export declare function formatSkillsMessage(locale: AppLocale, entries: CodexSkillsListEntry[], query: string | null, forceReload: boolean): string;
+export declare function formatSkillDetailMessage(locale: AppLocale, skill: CodexSkillMetadata): string;
+export declare function formatMcpStatusMessage(locale: AppLocale, statuses: CodexMcpServerStatus[]): string;
+export declare function formatMcpResourceMessage(locale: AppLocale, server: string, uri: string, contents: CodexMcpResourceContent[]): string;
+export declare function formatDiffMessage(locale: AppLocale, diff: string): string;
+export declare function formatRichDiffMessage(locale: AppLocale, diff: string): string;
+export declare function formatRichDemoMessage(locale: AppLocale): string;
+export declare function formatRichDemoFallbackMessage(locale: AppLocale): string;
+export declare function formatRichInternalMessage(title: string, text: string): string;
+export declare function splitRichInternalSections(text: string): string[][];
+export declare function formatRichInternalSection(lines: string[]): string;
+export declare function formatRichInternalSectionWithoutCandidates(lines: string[]): string;
+export declare function parseRichAuthCandidateRow(line: string): RichAuthCandidateRow | null;
+export declare function formatRichAuthCandidateTable(rows: RichAuthCandidateRow[]): string;
+export declare function splitRichAuthStatus(status: string): Pick<RichAuthCandidateRow, 'plan' | 'health' | 'refresh' | 'expiry' | 'risk'>;
+export declare function formatRichAuthRisk(health: string): string;
+export declare function parseRichAuthQuotaCell(value: string): {
+    value: string;
+    reset: string;
+};
+export declare function formatRichAuthCommandCell(row: RichAuthCandidateRow): string;
+export declare function formatRichAuthCommandLink(command: string, label: string): string;
+export declare function parseRichInternalKeyValue(line: string): [string, string] | null;
+export declare function formatRichInternalValue(value: string): string;
+export declare function renderTelegramTable(headers: string[], rows: string[][]): string;
+export declare function formatSelfUpdateVersionTransition(fromVersion: string | null | undefined, toVersion: string | null | undefined, locale: AppLocale): string;
+export declare function formatCodexUpdateState(status: SelfUpdateStatus): string;
+export declare function formatSelfUpdateBroadcastLine(locale: AppLocale, targetVersion: string | null, broadcast: SelfUpdateBroadcastSummary): string;
+export declare function clipRichMessageText(value: string, limit: number): string;
+export declare function formatLoadedThreadsMessage(locale: AppLocale, threadIds: string[]): string;
+export declare function formatHooksMessage(locale: AppLocale, entries: CodexHooksListEntry[]): string;
+export declare function formatPluginsMessage(locale: AppLocale, marketplaces: CodexPluginMarketplace[], query: string | null): string;
+export declare function formatPluginDetailMessage(locale: AppLocale, plugin: CodexPluginDetail): string;
+export declare function formatPluginSkillMessage(locale: AppLocale, marketplace: string, plugin: string, skill: string, contents: string | null): string;
+export declare function formatAppsMessage(locale: AppLocale, apps: CodexAppInfo[], forceRefetch: boolean): string;
+export declare function formatFeaturesMessage(locale: AppLocale, features: CodexExperimentalFeature[]): string;
+export declare function formatConfigMessage(locale: AppLocale, result: Record<string, unknown>, appConfig: AppConfig, authPoolStats: CodexAuthPoolStats): string;
+export declare function formatCodexApiProviderConfigLines(locale: AppLocale, appConfig: AppConfig): string[];
+export declare function formatCodexAuthPoolSummary(locale: AppLocale, stats: CodexAuthPoolStats): string;
+export declare function isInvalidCodexAuthDeleteReason(reason: string | null | undefined): boolean;
+export declare function configKeyboard(locale: AppLocale, appConfig: AppConfig): Array<Array<{
+    text: string;
+    callback_data: string;
+}>>;
+export declare function formatDurationMs(locale: AppLocale, value: number): string;
+export declare function parseConfigBooleanArg(value: string | undefined): boolean | null;
+export declare function writeEnvBoolean(envPath: string, key: string, enabled: boolean): Promise<void>;
+export declare function escapeRegExp(value: string): string;
+export declare function formatRequirementsMessage(locale: AppLocale, requirements: CodexConfigRequirements | null): string;
+export declare function formatProviderMessage(locale: AppLocale, capabilities: CodexModelProviderCapabilities): string;
+export declare function formatGoalMessage(locale: AppLocale, goal: CodexThreadGoal | null, prefix?: string): string;
+export declare function formatHistoryMessage(locale: AppLocale, threadId: string, turns: AppTurnSnapshot[]): string;
+export declare function formatFuzzyFilesMessage(locale: AppLocale, query: string, root: string, files: CodexFuzzyFileResult[]): string;
+export declare function formatRemoteStatusMessage(locale: AppLocale, status: RemoteControlStatusState | null): string;
+export declare function formatGoalStatus(locale: AppLocale, status: ThreadGoalStatusValue): string;