@foxden-app/foxclaw 0.11.1 → 0.13.0

package/dist/dsh/ui.js

@@ -0,0 +1,342 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { randomBytes } from 'node:crypto';
+import { DshClient } from './client.js';
+import { DshEngineAdapter } from './adapter.js';
+/** DSH controls shared by the unified bot and the optional dedicated bot. */
+export class DshUi {
+    config;
+    store;
+    logger;
+    messaging;
+    actions = new Map();
+    approvals = new Map();
+    adapter;
+    get pendingApprovals() { return this.approvals.size; }
+    constructor(config, store, logger, messaging) {
+        this.config = config;
+        this.store = store;
+        this.logger = logger;
+        this.messaging = messaging;
+        if (!config.dsh)
+            throw new Error('DSH backend is not configured');
+        const dsh = config.dsh;
+        this.adapter = new DshEngineAdapter({
+            createClient: scopeId => {
+                const client = new DshClient(dsh, scopeId, logger);
+                client.permissionHandler = (request, signal) => this.requestPermission(scopeId, request, signal);
+                client.cancelPermissions = () => {
+                    for (const pending of this.approvals.values())
+                        if (pending.scopeId === scopeId)
+                            pending.resolve({ outcome: { outcome: 'cancelled' } });
+                };
+                return client;
+            },
+            preferences: scopeId => {
+                const binding = store.getBinding(scopeId);
+                const settings = store.getChatSettings(scopeId);
+                return { cwd: binding?.cwd || config.defaultCwd, threadId: binding?.threadId || null, model: settings?.model ?? null, effort: settings?.reasoningEffort ?? null, access: settings?.accessPreset ?? this.defaultAccess() };
+            },
+            bind: (scopeId, id, cwd) => {
+                store.setBinding(scopeId, id, cwd);
+                const settings = store.getChatSettings(scopeId);
+                store.setScopeBackendBinding(scopeId, 'dsh', id, cwd, { model: settings?.model ?? null, reasoningEffort: settings?.reasoningEffort ?? null, accessPreset: settings?.accessPreset ?? this.defaultAccess() });
+            },
+        });
+    }
+    defaultAccess() { return this.config.defaultSandboxMode === 'danger-full-access' ? 'full-access' : this.config.defaultSandboxMode === 'read-only' ? 'read-only' : 'default'; }
+    copy(locale, zh, en) { return locale === 'zh' ? zh : en; }
+    status(scopeId, locale) {
+        const settings = this.store.getChatSettings(scopeId);
+        return `• **${this.copy(locale, '推理档位', 'Reasoning')}**: \`${settings?.reasoningEffort ?? 'default'}\`\n• **${this.copy(locale, 'DSH 权限', 'DSH access')}**: \`${settings?.accessPreset ?? this.defaultAccess()}\`\n• **${this.copy(locale, '配置', 'Settings')}**: \`/setup\` · \`/plugins\``;
+    }
+    button(scopeId, kind, value, text, cwd) {
+        for (const [key, action] of this.actions)
+            if (action.expires < Date.now())
+                this.actions.delete(key);
+        const key = randomBytes(6).toString('hex');
+        this.actions.set(key, { scopeId, kind, value, ...(cwd ? { cwd } : {}), expires: Date.now() + Math.max(this.config.telegramPanelTtlMs, 300000) });
+        return { text, callback_data: `dsh:a:${key}` };
+    }
+    async panel(scopeId, text, keyboard, orchestrator, messageId) {
+        if (messageId)
+            await orchestrator.editMessage(scopeId, messageId, text, keyboard);
+        else
+            messageId = await orchestrator.sendMessage(scopeId, text, keyboard);
+        orchestrator.scheduleStalePanelDeletion(scopeId, messageId);
+    }
+    async setup(scopeId, locale, orchestrator, messageId) {
+        const settings = this.store.getChatSettings(scopeId);
+        const binding = this.store.getBinding(scopeId);
+        const access = settings?.accessPreset ?? this.defaultAccess();
+        const mode = settings?.activeTurnMessageMode ?? 'queue';
+        const rows = [
+            [{ text: this.copy(locale, '🎯 模型', '🎯 Model'), callback_data: 'dsh:models' }, { text: this.copy(locale, '🧠 推理档位', '🧠 Reasoning'), callback_data: 'dsh:efforts' }],
+            ['read-only', 'default', 'full-access'].map(value => this.button(scopeId, 'access', value, `${access === value ? '✓ ' : ''}${this.copy(locale, value === 'read-only' ? '只读' : value === 'default' ? '工作区写入' : '完全访问', value)}`)),
+            [{ text: this.copy(locale, '📁 会话', '📁 Sessions'), callback_data: 'dsh:threads' }, { text: this.copy(locale, '🧩 插件配置', '🧩 Plugins'), callback_data: 'dsh:plugins' }],
+            [{ text: mode === 'queue' ? this.copy(locale, '⏳ 排队', '⏳ Queue') : this.copy(locale, '⚡ 中断接管', '⚡ Interrupt & steer'), callback_data: 'engine:setup:active_mode' }],
+            [{ text: this.copy(locale, '✨ 新建会话', '✨ New session'), callback_data: 'engine:setup:new' }, { text: this.copy(locale, '🔌 切换后端', '🔌 Backend'), callback_data: 'engine:setup:backend' }],
+            [{ text: this.copy(locale, '🔄 刷新', '🔄 Refresh'), callback_data: 'engine:setup:main' }],
+        ];
+        await this.panel(scopeId, `⚙️ **DeepSeek Harness**\n\n${this.copy(locale, '模型', 'Model')}: \`${settings?.model ?? 'default'}\`\n${this.copy(locale, '推理档位', 'Reasoning')}: \`${settings?.reasoningEffort ?? 'default'}\`\n${this.copy(locale, '权限', 'Access')}: \`${access}\`\n${this.copy(locale, '会话', 'Session')}: \`${binding?.threadId || 'new'}\`\n${this.copy(locale, '工作目录', 'Directory')}: \`${binding?.cwd || this.config.defaultCwd}\``, rows, orchestrator, messageId);
+    }
+    async models(scopeId, locale, orchestrator, messageId) {
+        const models = await this.adapter.listModels(scopeId);
+        const current = this.store.getChatSettings(scopeId)?.model;
+        const buttons = [this.button(scopeId, 'model', '', this.copy(locale, '默认模型', 'Default model')), ...models.map(model => this.button(scopeId, 'model', model.id, `${model.id === current ? '✓ ' : ''}${model.name}`))];
+        const rows = [];
+        for (let index = 0; index < buttons.length; index += 2)
+            rows.push(buttons.slice(index, index + 2));
+        rows.push([{ text: this.copy(locale, '返回设置', 'Back'), callback_data: 'engine:setup:main' }]);
+        await this.panel(scopeId, this.copy(locale, '🎯 **DSH 模型**', '🎯 **DSH models**'), rows, orchestrator, messageId);
+    }
+    async efforts(scopeId, locale, orchestrator, messageId) {
+        const choices = await this.adapter.listEfforts(scopeId);
+        const rows = [[this.button(scopeId, 'effort', '', this.copy(locale, '默认档位', 'Default effort'))]];
+        for (const choice of choices)
+            rows.push([this.button(scopeId, 'effort', choice.value, choice.name)]);
+        rows.push([{ text: this.copy(locale, '返回设置', 'Back'), callback_data: 'engine:setup:main' }]);
+        await this.panel(scopeId, choices.length ? this.copy(locale, '🧠 **当前模型的推理档位**', '🧠 **Reasoning for this model**') : this.copy(locale, '当前模型未提供可切换的推理档位。', 'This model exposes no reasoning selector.'), rows, orchestrator, messageId);
+    }
+    async selectModel(scopeId, value, orchestrator) {
+        await this.adapter.selectModel(scopeId, value || null);
+        this.store.setChatModel(scopeId, value || null);
+        this.store.setChatEffort(scopeId, null);
+        this.store.setChatServiceTier(scopeId, null);
+        orchestrator.syncCurrentBackendSettings(scopeId);
+    }
+    async selectEffort(scopeId, value, orchestrator) {
+        await this.adapter.selectEffort(scopeId, value || null);
+        this.store.setChatEngineEffort(scopeId, value || null);
+        orchestrator.syncCurrentBackendSettings(scopeId);
+    }
+    async selectAccess(scopeId, value, orchestrator) {
+        if (value !== 'read-only' && value !== 'default' && value !== 'full-access')
+            throw new Error('Use read-only, default, or full-access');
+        if (orchestrator.hasActiveTurn(scopeId))
+            throw new Error('Interrupt the active turn before changing DSH permissions');
+        await this.adapter.setAccess(scopeId, value);
+        this.store.setChatAccessPreset(scopeId, value);
+        orchestrator.syncCurrentBackendSettings(scopeId);
+    }
+    async threads(scopeId, locale, orchestrator, messageId, cursor) {
+        const page = await this.adapter.listSessions(scopeId, cursor);
+        const rows = page.sessions.map(session => [this.button(scopeId, 'open', session.sessionId, (session.title || session.sessionId).slice(0, 60), session.cwd)]);
+        if (page.nextCursor)
+            rows.push([this.button(scopeId, 'page', page.nextCursor, this.copy(locale, '下一页', 'Next page'))]);
+        rows.push([{ text: this.copy(locale, '返回设置', 'Back'), callback_data: 'engine:setup:main' }]);
+        await this.panel(scopeId, this.copy(locale, '📁 **DSH 持久会话**', '📁 **Persistent DSH sessions**'), rows, orchestrator, messageId);
+    }
+    async open(scopeId, id, cwd, orchestrator) {
+        if (orchestrator.hasActiveTurn(scopeId))
+            throw new Error('Interrupt the active turn before opening another DSH session');
+        if (!cwd) {
+            let cursor;
+            do {
+                const page = await this.adapter.listSessions(scopeId, cursor);
+                cwd = page.sessions.find(session => session.sessionId === id)?.cwd;
+                cursor = page.nextCursor ?? undefined;
+            } while (!cwd && cursor);
+        }
+        if (!cwd)
+            throw new Error('DSH session not found');
+        const previous = this.store.getBinding(scopeId);
+        this.store.setBinding(scopeId, id, cwd);
+        try {
+            await this.adapter.sessionForScope(scopeId);
+        }
+        catch (error) {
+            if (previous)
+                this.store.setBinding(scopeId, previous.threadId, previous.cwd);
+            else
+                this.store.clearBinding(scopeId);
+            throw error;
+        }
+        orchestrator.syncCurrentBackendSettings(scopeId);
+    }
+    async plugins(scopeId, locale, orchestrator) {
+        const dsh = this.config.dsh;
+        const home = dsh.home || process.env.DSH_HOME || path.join(os.homedir(), '.dsh');
+        let dependencies = {};
+        try {
+            const manifest = JSON.parse(await fs.readFile(path.join(home, 'profiles', dsh.profile, 'package.json'), 'utf8'));
+            if (typeof manifest === 'object' && manifest !== null && 'dependencies' in manifest && typeof manifest.dependencies === 'object' && manifest.dependencies !== null)
+                dependencies = manifest.dependencies;
+        }
+        catch (error) {
+            this.logger.debug('dsh.plugin_manifest_unavailable', { error: String(error) });
+        }
+        await orchestrator.sendMessage(scopeId, `🧩 **DSH ${this.copy(locale, '插件配置', 'plugin configuration')}**\n\nProfile: \`${dsh.profile}\`\n${Object.entries(dependencies).map(([name, version]) => `• ${name}: ${String(version)}`).join('\n') || this.copy(locale, 'Profile 尚未初始化或没有显式依赖。', 'Profile is not initialized or has no explicit dependencies.')}\n• foxclaw-permissions\n\n${this.copy(locale, '已配置补丁', 'Configured patches')}:\n${dsh.patches.map(patch => `• ${patch}`).join('\n') || '—'}\n\n${this.copy(locale, '安装/移除插件请在终端执行，随后重启 foxclaw', 'Install/remove plugins in a terminal, then restart foxclaw')}:\n\`dsh plugin --profile ${dsh.profile} add <package>\`\n\`dsh plugin --profile ${dsh.profile} remove <package>\``);
+    }
+    async command(scopeId, command, args, locale, orchestrator) {
+        try {
+            switch (command) {
+                case 'setup':
+                    await this.setup(scopeId, locale, orchestrator);
+                    return true;
+                case 'models':
+                    await this.models(scopeId, locale, orchestrator);
+                    return true;
+                case 'model':
+                    if (args) {
+                        await this.selectModel(scopeId, args === 'default' ? '' : args, orchestrator);
+                        await this.setup(scopeId, locale, orchestrator);
+                    }
+                    else
+                        await this.models(scopeId, locale, orchestrator);
+                    return true;
+                case 'effort':
+                    if (args) {
+                        await this.selectEffort(scopeId, args === 'default' ? '' : args, orchestrator);
+                        await this.setup(scopeId, locale, orchestrator);
+                    }
+                    else
+                        await this.efforts(scopeId, locale, orchestrator);
+                    return true;
+                case 'access':
+                case 'permissions':
+                    if (args)
+                        await this.selectAccess(scopeId, args, orchestrator);
+                    await this.setup(scopeId, locale, orchestrator);
+                    return true;
+                case 'threads':
+                    await this.threads(scopeId, locale, orchestrator);
+                    return true;
+                case 'open':
+                    if (args) {
+                        await this.open(scopeId, args, undefined, orchestrator);
+                        await this.setup(scopeId, locale, orchestrator);
+                    }
+                    else
+                        await this.threads(scopeId, locale, orchestrator);
+                    return true;
+                case 'plugins':
+                    await this.plugins(scopeId, locale, orchestrator);
+                    return true;
+                case 'where':
+                case 'config':
+                    await this.setup(scopeId, locale, orchestrator);
+                    return true;
+                case 'update':
+                    await orchestrator.sendMessage(scopeId, this.copy(locale, '请在终端执行 `foxclaw update` 升级此独立 DSH Bot。', 'Run `foxclaw update` in a terminal to upgrade this dedicated DSH bot.'));
+                    return true;
+                case 'help':
+                case 'start':
+                    await orchestrator.sendMessage(scopeId, this.copy(locale, '**DSH 命令**\n/setup · 设置\n/models · 模型\n/model <provider/model|default>\n/effort [档位|default]\n/permissions [read-only|default|full-access]\n/threads · 持久会话\n/open <会话 ID>\n/new [目录] · 新建\n/interrupt · 中断\n/active <queue|steer>\n/plugins · 插件配置\n/backend · 切换后端\n/status · 状态', '**DSH commands**\n/setup · Settings\n/models · Models\n/model <provider/model|default>\n/effort [level|default]\n/permissions [read-only|default|full-access]\n/threads · Persistent sessions\n/open <session ID>\n/new [directory]\n/interrupt\n/active <queue|steer>\n/plugins · Plugin configuration\n/backend\n/status'));
+                    return true;
+                case 'backend':
+                case 'backends':
+                case 'engine':
+                case 'engines':
+                case 'status':
+                case 'active':
+                case 'queue':
+                case 'steer':
+                case 'interrupt':
+                case 'stop':
+                case 'abort':
+                case 'new':
+                case 'clear': return false;
+                default:
+                    await orchestrator.sendMessage(scopeId, this.copy(locale, `DSH 的 ACP 接口未提供 /${command}。发送 /help 查看可用操作。`, `DSH ACP does not expose /${command}. Send /help for available commands.`));
+                    return true;
+            }
+        }
+        catch (error) {
+            await orchestrator.sendMessage(scopeId, `⚠️ ${error instanceof Error ? error.message : String(error)}`);
+            return true;
+        }
+    }
+    async callback(scopeId, data, locale, orchestrator, event) {
+        const answer = (text = '') => this.messaging.answerCallback(event?.callbackQueryId ?? '', text);
+        if (!data.startsWith('dsh:')) {
+            if (orchestrator.getBackendDescriptorForScope(scopeId).engineType === 'dsh' && data.startsWith('engine:') && !['engine:setup:main', 'engine:setup:models', 'engine:setup:active_mode', 'engine:setup:new', 'engine:setup:backend'].includes(data) && !data.startsWith('engine:backend:')) {
+                await answer(this.copy(locale, '请重新打开 DSH 设置', 'Open DSH settings again'));
+                return true;
+            }
+            return false;
+        }
+        if (data.startsWith('dsh:p:')) {
+            const [, , key, index] = data.split(':');
+            const pending = this.approvals.get(key);
+            const option = pending?.options[Number(index)];
+            if (!pending || pending.scopeId !== scopeId || !option) {
+                await answer(this.copy(locale, '审批已失效', 'Approval expired'));
+                return true;
+            }
+            pending.resolve({ outcome: { outcome: 'selected', optionId: option.optionId } });
+            await answer(this.copy(locale, '已提交', 'Submitted'));
+            return true;
+        }
+        if (orchestrator.getBackendDescriptorForScope(scopeId).engineType !== 'dsh') {
+            await answer(this.copy(locale, '请先切换到 DSH', 'Switch to DSH first'));
+            return true;
+        }
+        await answer();
+        try {
+            if (data === 'dsh:models')
+                await this.models(scopeId, locale, orchestrator, event?.messageId);
+            else if (data === 'dsh:efforts')
+                await this.efforts(scopeId, locale, orchestrator, event?.messageId);
+            else if (data === 'dsh:threads')
+                await this.threads(scopeId, locale, orchestrator, event?.messageId);
+            else if (data === 'dsh:plugins')
+                await this.plugins(scopeId, locale, orchestrator);
+            else if (data.startsWith('dsh:a:')) {
+                const action = this.actions.get(data.slice(6));
+                if (!action || action.scopeId !== scopeId || action.expires < Date.now())
+                    throw new Error(this.copy(locale, '面板已失效，请重新打开 /setup', 'Panel expired; open /setup again'));
+                if (action.kind === 'model')
+                    await this.selectModel(scopeId, action.value, orchestrator);
+                else if (action.kind === 'effort')
+                    await this.selectEffort(scopeId, action.value, orchestrator);
+                else if (action.kind === 'access')
+                    await this.selectAccess(scopeId, action.value, orchestrator);
+                else if (action.kind === 'open')
+                    await this.open(scopeId, action.value, action.cwd, orchestrator);
+                else if (action.kind === 'page') {
+                    await this.threads(scopeId, locale, orchestrator, event?.messageId, action.value);
+                    return true;
+                }
+                await this.setup(scopeId, locale, orchestrator, event?.messageId);
+            }
+        }
+        catch (error) {
+            await orchestrator.sendMessage(scopeId, `⚠️ ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return true;
+    }
+    async requestPermission(scopeId, request, signal) {
+        if (signal.aborted)
+            return { outcome: { outcome: 'cancelled' } };
+        const key = randomBytes(6).toString('hex');
+        const locale = this.store.getChatSettings(scopeId)?.locale ?? 'zh';
+        let settle;
+        const result = new Promise(resolve => { settle = resolve; });
+        const pending = { scopeId, resolve: settle, options: request.options, messageId: null };
+        this.approvals.set(key, pending);
+        const abort = () => settle({ outcome: { outcome: 'cancelled' } });
+        signal.addEventListener('abort', abort, { once: true });
+        try {
+            pending.messageId = await this.messaging.sendRichMarkdown(scopeId, `${this.copy(locale, '🔐 **DSH 请求审批**', '🔐 **DSH permission request**')}\n\`${request.toolCall.title || request.toolCall.toolCallId}\``, [request.options.map((option, index) => ({ text: option.kind === 'allow_once' ? this.copy(locale, '允许本次', 'Allow once') : option.kind === 'reject_once' ? this.copy(locale, '拒绝', 'Reject') : option.name, callback_data: `dsh:p:${key}:${index}` }))]);
+            return await result;
+        }
+        catch (error) {
+            this.logger.warn('dsh.approval_delivery_failed', { error: String(error) });
+            return { outcome: { outcome: 'cancelled' } };
+        }
+        finally {
+            this.approvals.delete(key);
+            signal.removeEventListener('abort', abort);
+            if (pending.messageId)
+                await this.messaging.editRichMarkdown(scopeId, pending.messageId, this.copy(locale, '🔐 DSH 审批已结束。', '🔐 DSH permission request resolved.'), []).catch(() => { });
+        }
+    }
+    async stop() {
+        for (const pending of this.approvals.values())
+            pending.resolve({ outcome: { outcome: 'cancelled' } });
+        this.actions.clear();
+        await this.adapter.stop();
+    }
+}

package/dist/i18n.d.ts

@@ -1499,4 +1499,8 @@ export declare function getAntigravityTelegramCommands(locale: AppLocale): Array
     command: string;
     description: string;
 }>;
+export declare function getDshTelegramCommands(locale: AppLocale): Array<{
+    command: string;
+    description: string;
+}>;
 export {};

package/dist/i18n.js

@@ -1627,3 +1627,15 @@ export function getAntigravityTelegramCommands(locale) {
             { command: 'interrupt', description: 'Stop active turn' },
         ];
 }
+export function getDshTelegramCommands(locale) {
+    const descriptions = locale === 'zh' ? {
+        help: 'DSH 命令', setup: 'DSH 设置', backend: '切换后端', new: '新建会话', threads: '持久会话列表', open: '打开会话',
+        models: '模型列表', model: '选择模型', effort: '推理档位', permissions: '权限设置', plugins: '插件配置',
+        active: '插话或排队', queue: '排队下一轮', steer: '中断并接管', status: '运行状态', interrupt: '中断任务',
+    } : {
+        help: 'DSH commands', setup: 'DSH settings', backend: 'Switch backend', new: 'New session', threads: 'Persistent sessions', open: 'Open session',
+        models: 'Models', model: 'Select model', effort: 'Reasoning effort', permissions: 'Permissions', plugins: 'Plugin configuration',
+        active: 'Steer or queue', queue: 'Queue next turn', steer: 'Interrupt and steer', status: 'Runtime status', interrupt: 'Stop task',
+    };
+    return Object.entries(descriptions).map(([command, description]) => ({ command, description }));
+}