@foxden-app/foxclaw 0.11.0 → 0.12.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: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 }));
+}

package/dist/main.js

@@ -349,7 +349,7 @@ async function runSendVoiceCli() {
         throw new Error('Telegram voice files must be 50MB or smaller.');
     }
     const inferredBotId = parsed.botId ?? inferTelegramBotId(process.env.CODEX_HOME) ?? inferTelegramBotId(config.codexHome);
-    const allTokens = [...config.codexBotTokens, ...config.antigravityBotTokens];
+    const allTokens = [...config.codexBotTokens, ...config.antigravityBotTokens, ...(config.dshBotToken ? [config.dshBotToken] : [])];
     const { botId, botToken } = resolveTelegramVoiceTarget(allTokens, inferredBotId);
     const { BridgeStore } = await import('./store/database.js');
     const store = new BridgeStore(config.storePath);
@@ -395,7 +395,7 @@ async function runSendMediaCli() {
     }
     const plan = planTelegramOutboundMedia(filePath);
     const inferredBotId = parsed.botId ?? inferTelegramBotId(process.env.CODEX_HOME) ?? inferTelegramBotId(config.codexHome);
-    const allTokens = [...config.codexBotTokens, ...config.antigravityBotTokens];
+    const allTokens = [...config.codexBotTokens, ...config.antigravityBotTokens, ...(config.dshBotToken ? [config.dshBotToken] : [])];
     const { botId, botToken } = resolveTelegramVoiceTarget(allTokens, inferredBotId);
     const { BridgeStore } = await import('./store/database.js');
     const store = new BridgeStore(config.storePath);
@@ -605,7 +605,7 @@ function truncateStatusLine(value, maxLength) {
     return normalized.length <= maxLength ? normalized : `${normalized.slice(0, Math.max(0, maxLength - 1))}…`;
 }
 async function runServeCli() {
-    const [{ BridgeMessagingRouter }, { TelegramMessagingPort }, { WeixinChannelAdapter }, { WeixinMessagingPort }, { attachIlinkRuntimeFromBridgeLogger }, { loadWeixinAccount }, { Logger }, { BridgeStore }, { TelegramGateway }, { CodexAppClient }, { BridgeSessionCore }, { TelegramChannelAdapter }, { AuthCandidateMirror }, { CrossNodeAuthSync }, { OpencodeTelegramRuntime }, { UnifiedBridgeCore }, { AntigravityAppClient }, { AntigravityAuthManager, linkAntigravityAuthTokens },] = await Promise.all([
+    const [{ BridgeMessagingRouter }, { TelegramMessagingPort }, { WeixinChannelAdapter }, { WeixinMessagingPort }, { attachIlinkRuntimeFromBridgeLogger }, { loadWeixinAccount }, { Logger }, { BridgeStore }, { TelegramGateway }, { CodexAppClient }, { BridgeSessionCore }, { TelegramChannelAdapter }, { AuthCandidateMirror }, { CrossNodeAuthSync }, { OpencodeTelegramRuntime }, { DshTelegramRuntime }, { UnifiedBridgeCore }, { AntigravityAppClient }, { AntigravityAuthManager, linkAntigravityAuthTokens },] = await Promise.all([
         import('./channels/bridge_messaging_router.js'),
         import('./channels/telegram/telegram_messaging_port.js'),
         import('./channels/weixin/weixin_channel_adapter.js'),
@@ -621,6 +621,7 @@ async function runServeCli() {
         import('./auth/mirror.js'),
         import('./auth/cross_node_sync.js'),
         import('./opencode/runtime.js'),
+        import('./dsh/runtime.js'),
         import('./antigravity/controller.js'),
         import('./antigravity/client.js'),
         import('./antigravity/auth.js'),
@@ -639,11 +640,47 @@ async function runServeCli() {
     let activeAuthMirror = null;
     let activeAuthSync = null;
     let activeOpencodeRuntime = null;
+    let activeDshRuntime = null;
     let sharedCodexApp = null;
     let sharedAntigravityApp = null;
     let sharedAntigravityAuth = null;
     try {
         store = new BridgeStore(config.storePath);
+        if (config.dshBotToken) {
+            activeDshRuntime = new DshTelegramRuntime(config, store, logger);
+            await activeDshRuntime.start();
+            logger.info('dsh.bridge.started', activeDshRuntime.getRuntimeStatus());
+        }
+        if (config.opencodeBotToken) {
+            activeOpencodeRuntime = new OpencodeTelegramRuntime(config, store, logger);
+            await activeOpencodeRuntime.start();
+            logger.info('opencode.bridge.started', activeOpencodeRuntime.getRuntimeStatus());
+        }
+        if (config.dshBotToken && config.codexBotTokens.length === 0 && config.antigravityBotTokens.length === 0) {
+            const writeDshStatus = (running = true) => {
+                const status = activeDshRuntime.getRuntimeStatus();
+                writeRuntimeStatus(config.statusPath, {
+                    running, connected: running && status.connected, userAgent: 'DSH ACP', botUsername: status.username,
+                    currentBindings: store.countBindings(), pendingApprovals: status.pendingApprovals, pendingUserInputs: 0, queuedTurns: store.countQueuedTurnInputs(),
+                    activeTurns: running ? status.activeTurns + (activeOpencodeRuntime?.getRuntimeStatus().activeTurns ?? 0) : 0, lastError: null, updatedAt: new Date().toISOString(),
+                    channels: { telegram: running, weixin: false }, bots: [{ ...status, connected: running && status.connected }, ...(activeOpencodeRuntime ? [{ id: 'opencode', username: activeOpencodeRuntime.getRuntimeStatus().botUsername, connected: running && activeOpencodeRuntime.getRuntimeStatus().connected, activeTurns: activeOpencodeRuntime.getRuntimeStatus().activeTurns }] : [])],
+                });
+            };
+            writeDshStatus();
+            const timer = setInterval(writeDshStatus, 5000);
+            const shutdown = async () => {
+                clearInterval(timer);
+                await activeDshRuntime.stop();
+                await activeOpencodeRuntime?.stop();
+                writeDshStatus(false);
+                store.close();
+                processLock.release();
+                process.exit(0);
+            };
+            process.on('SIGINT', () => void shutdown());
+            process.on('SIGTERM', () => void shutdown());
+            return;
+        }
         const selfUpdater = createSelfUpdateRuntime({
             entryPoint,
             nodePath: process.execPath,
@@ -658,12 +695,7 @@ async function runServeCli() {
         if (config.codexCliBin) {
             sharedCodexApp = new CodexAppClient(config.codexCliBin, config.codexAppLaunchCmd, config.codexAppAutolaunch, config.codexAppServerStatePath, config.codexAppServerLogPath, logger, config.codexHome ? { CODEX_HOME: config.codexHome } : null, codexApiProviderOverrides);
         }
-        if (config.opencodeBotToken) {
-            activeOpencodeRuntime = new OpencodeTelegramRuntime(config, store, logger);
-            await activeOpencodeRuntime.start();
-            logger.info('opencode.bridge.started', activeOpencodeRuntime.getRuntimeStatus());
-        }
-        const totalBots = config.codexBotTokens.length + config.antigravityBotTokens.length;
+        const totalBots = config.codexBotTokens.length + config.antigravityBotTokens.length + (config.dshBotToken ? 1 : 0);
         const namespacedScopes = totalBots > 1;
         const seeds = [];
         const canonicalAuthDir = config.codexAuthDir ?? config.codexHome ?? path.join(os.homedir(), '.codex');
@@ -809,27 +841,27 @@ async function runServeCli() {
                 ...(first?.codexAppServer ? { codexAppServer: first.codexAppServer } : {}),
                 botUsername: first?.botUsername ?? null,
                 currentBindings: store.countBindings(),
-                pendingApprovals: store.countPendingApprovals(),
+                pendingApprovals: store.countPendingApprovals() + statuses.reduce((sum, status) => sum + status.dshPendingApprovals, 0) + (activeDshRuntime?.getRuntimeStatus().pendingApprovals ?? 0),
                 pendingUserInputs: store.countPendingUserInputs(),
                 queuedTurns: store.countQueuedTurnInputs(),
                 activeTurns: statuses.reduce((sum, status) => sum + status.activeTurns, 0)
-                    + (weixinStatus?.activeTurns ?? 0),
+                    + (weixinStatus?.activeTurns ?? 0) + (activeDshRuntime?.getRuntimeStatus().activeTurns ?? 0),
                 lastError: statuses.find((status) => status.lastError)?.lastError
                     ?? weixinStatus?.lastError
                     ?? null,
                 updatedAt: new Date().toISOString(),
                 channels: { telegram: running, weixin: running && config.wxEnabled },
-                bots: runtimes.map((runtime, index) => ({
-                    id: runtime.id,
-                    username: statuses[index]?.botUsername ?? runtime.bot.username,
-                    connected: running && Boolean(statuses[index]?.connected),
-                    activeTurns: running ? (statuses[index]?.activeTurns ?? 0) : 0,
-                    runtimeKind: runtime.sharedDefaultRuntime ? 'default' : 'isolated',
-                    defaultBackend: runtime.defaultBackend,
-                    codexHome: statuses[index]?.codexHome ?? runtime.home,
-                    antigravityHome: runtime.antigravityHome,
-                    ...(statuses[index]?.codexAppServer ? { codexAppServer: statuses[index].codexAppServer } : {}),
-                })),
+                bots: [...runtimes.map((runtime, index) => ({
+                        id: runtime.id,
+                        username: statuses[index]?.botUsername ?? runtime.bot.username,
+                        connected: running && Boolean(statuses[index]?.connected),
+                        activeTurns: running ? (statuses[index]?.activeTurns ?? 0) : 0,
+                        runtimeKind: runtime.sharedDefaultRuntime ? 'default' : 'isolated',
+                        defaultBackend: runtime.defaultBackend,
+                        codexHome: statuses[index]?.codexHome ?? runtime.home,
+                        antigravityHome: runtime.antigravityHome,
+                        ...(statuses[index]?.codexAppServer ? { codexAppServer: statuses[index].codexAppServer } : {}),
+                    })), ...(activeDshRuntime ? [activeDshRuntime.getRuntimeStatus()] : [])],
                 ...(weixinStatus ? {
                     weixinRuntime: {
                         connected: running && weixinStatus.connected,
@@ -844,6 +876,7 @@ async function runServeCli() {
             });
         };
         const authSyncLocalIdle = () => runtimes.every((runtime) => runtime.core.isIdleForServiceUpdate())
+            && (activeDshRuntime?.getRuntimeStatus().activeTurns ?? 0) === 0
             && (!activeWeixinCore || activeWeixinCore.isIdleForServiceUpdate())
             && mirror.isIdle();
         const clusterUpdateScheduler = createClusterUpdateScheduler({
@@ -896,19 +929,19 @@ async function runServeCli() {
             statusUpdated: () => writeAggregateStatus(),
             getServiceStatus: async () => ({
                 currentVersion: readPackageVersion(),
-                bots: await Promise.all(runtimes.map(async (runtime) => {
-                    const status = runtime.core.getRuntimeStatus();
-                    return {
-                        id: runtime.id,
-                        username: status.botUsername ?? runtime.bot.username,
-                        connected: status.connected,
-                        activeTurns: status.activeTurns,
-                        runtimeKind: runtime.sharedDefaultRuntime ? 'default' : 'isolated',
-                        currentAuth: await runtime.core.getCurrentAuthLabel().catch(() => null),
-                        codexHome: status.codexHome ?? runtime.home,
-                        ...(status.codexAppServer ? { codexAppServer: status.codexAppServer } : {}),
-                    };
-                })),
+                bots: [...await Promise.all(runtimes.map(async (runtime) => {
+                        const status = runtime.core.getRuntimeStatus();
+                        return {
+                            id: runtime.id,
+                            username: status.botUsername ?? runtime.bot.username,
+                            connected: status.connected,
+                            activeTurns: status.activeTurns,
+                            runtimeKind: runtime.sharedDefaultRuntime ? 'default' : 'isolated',
+                            currentAuth: await runtime.core.getCurrentAuthLabel().catch(() => null),
+                            codexHome: status.codexHome ?? runtime.home,
+                            ...(status.codexAppServer ? { codexAppServer: status.codexAppServer } : {}),
+                        };
+                    })), ...(activeDshRuntime ? [activeDshRuntime.getRuntimeStatus()] : [])],
                 ...(activeWeixinCore ? {
                     weixinRuntime: {
                         connected: activeWeixinCore.getRuntimeStatus().connected,
@@ -1027,6 +1060,7 @@ async function runServeCli() {
             await activeWeixinCore?.stop();
             await Promise.all(runtimes.map((runtime) => runtime.telegram.stop()));
             await activeOpencodeRuntime?.stop();
+            await activeDshRuntime?.stop();
             writeAggregateStatus(false);
             const allManaged = [...managedApps, ...(sharedCodexApp ? [sharedCodexApp] : [])];
             await Promise.all(allManaged.map((app) => app.stop({ terminateServer: true }).catch((error) => {
@@ -1047,6 +1081,7 @@ async function runServeCli() {
         await activeWeixinCore?.stop().catch(() => { });
         await Promise.allSettled(activeTelegramAdapters.map((adapter) => adapter.stop()));
         await activeOpencodeRuntime?.stop().catch(() => { });
+        await activeDshRuntime?.stop().catch(() => { });
         await Promise.allSettled(managedApps.map((app) => app.stop({ terminateServer: true })));
         store?.close();
         processLock.release();
@@ -1537,10 +1572,23 @@ async function configureEnvInteractively(envPath, existed) {
         else {
             skipped.push('TG_ALLOWED_USER_ID');
         }
+        const dshToken = sanitizeEnvInput(await rl.question('DeepSeek Harness Telegram bot token (DSH_BOT_TOKEN) [optional]: '));
+        if (dshToken) {
+            updates.DSH_BOT_TOKEN = dshToken;
+            if (!codexTokens && !existed) {
+                updates.CODEX_BOT_TOKENS = '';
+                skipped.splice(skipped.indexOf('CODEX_BOT_TOKENS'), 1);
+            }
+            const dshSource = sanitizeEnvInput(await rl.question('DeepSeek Harness source directory (DSH_SOURCE_DIR) [Enter to use installed dsh]: '));
+            if (dshSource)
+                updates.DSH_SOURCE_DIR = normalizeUserPath(dshSource);
+            if (!/^\d+:[A-Za-z0-9_-]+$/.test(dshToken))
+                warnings.push('DSH_BOT_TOKEN does not look like a standard Telegram bot token.');
+        }
         const cwdDefault = defaultInitCwd();
         const cwdPrompt = cwdDefault
-            ? `Default Codex workspace (DEFAULT_CWD) [${cwdDefault}]: `
-            : 'Default Codex workspace (DEFAULT_CWD): ';
+            ? `Default workspace (DEFAULT_CWD) [${cwdDefault}]: `
+            : 'Default workspace (DEFAULT_CWD): ';
         const cwdAnswer = sanitizeEnvInput(await rl.question(cwdPrompt));
         const cwd = cwdAnswer ? normalizeUserPath(cwdAnswer) : cwdDefault;
         if (cwd) {
@@ -1741,12 +1789,24 @@ function runDoctorChecks() {
         ...(process.env.ANTIGRAVITY_BOT_TOKENS ?? '').split(','),
         process.env.ANTIGRAVITY_BOT_TOKEN ?? '',
     ].map((value) => value.trim()).filter(Boolean);
+    const dshToken = process.env.DSH_BOT_TOKEN?.trim();
+    const dshFlag = process.env.DSH_ENABLED;
+    const dshEnabled = dshFlag ? dshFlag !== 'false' && dshFlag !== '0' : Boolean(dshToken || process.env.DSH_SOURCE_DIR?.trim() || process.env.DSH_CLI_BIN?.trim());
     const checks = [
         ['node >= 24', Number(process.versions.node.split('.')[0]) >= 24],
-        ['codex cli available', hasConfiguredCommand(configuredCodexBin, 'codex')],
-        ['telegram bot token(s) configured', codexTokens.length > 0 || antigravityTokens.length > 0],
+        ['telegram bot token(s) configured', codexTokens.length > 0 || antigravityTokens.length > 0 || Boolean(dshToken)],
         ['telegram allowed user configured', Boolean(process.env.TG_ALLOWED_USER_ID)],
     ];
+    if (codexTokens.length > 0 || process.env.WX_ENABLED === 'true' || process.env.WX_ENABLED === '1')
+        checks.push(['codex cli available', hasConfiguredCommand(configuredCodexBin, 'codex')]);
+    if (dshEnabled) {
+        const source = process.env.DSH_SOURCE_DIR?.trim();
+        checks.push(['DSH CLI available', source ? fs.existsSync(path.join(path.resolve(source), 'apps/cli/src/bin.ts')) : hasConfiguredCommand(process.env.DSH_CLI_BIN, 'dsh')]);
+        if (dshToken)
+            checks.push(['DSH uses an independent Telegram bot', ![...codexTokens, ...antigravityTokens, process.env.OPENCODE_BOT_TOKEN?.trim()].includes(dshToken)]);
+    }
+    if (dshToken)
+        checks.push(['DSH backend enabled for its Telegram bot', dshEnabled]);
     if (process.env.OPENCODE_BOT_TOKEN?.trim()) {
         const configuredOpencodeBin = process.env.OPENCODE_CLI_BIN;
         checks.push(['opencode cli available', hasConfiguredCommand(configuredOpencodeBin, 'opencode')]);

package/dist/store/database.d.ts

@@ -74,6 +74,8 @@ export declare class BridgeStore {
     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;
+    /** Persist an adapter-advertised reasoning id without imposing Codex's vocabulary. */
+    setChatEngineEffort(chatId: string, effort: string | null): void;
     setChatLocale(chatId: string, locale: AppLocale): void;
     setChatAccessPreset(chatId: string, accessPreset: AccessPresetValue | null): void;
     setChatCollaborationMode(chatId: string, collaborationMode: CollaborationModeValue | null): void;
@@ -140,7 +142,7 @@ export declare class BridgeStore {
     countQueuedTurnInputs(scopeId?: string): number;
     updateQueuedTurnInputStatus(queueId: string, status: QueuedTurnInputStatus, error?: string | null): void;
     cancelQueuedTurnInputs(scopeId: string): number;
-    requeueInterruptedQueuedTurnInputs(): number;
+    requeueInterruptedQueuedTurnInputs(scopeId?: string): number;
     savePendingAttachmentBatch(record: PendingAttachmentBatchRecord): void;
     getPendingAttachmentBatch(batchId: string): PendingAttachmentBatchRecord | null;
     findPendingAttachmentBatchByMediaGroup(scopeId: string, mediaGroupId: string): PendingAttachmentBatchRecord | null;