@foxden-app/foxclaw 0.11.1 → 0.13.0

package/dist/core/queued_engine_input.d.ts

@@ -0,0 +1,12 @@
+import type { StagedAttachment } from './attachment_types.js';
+export interface QueuedEngineInput {
+    version: 1;
+    prompt: string;
+    backendId: string;
+    cwd: string;
+    stagedAttachments: StagedAttachment[];
+}
+export declare function decodeQueuedEngineInput(inputJson: string, fallbackPrompt: string): QueuedEngineInput | {
+    prompt: string;
+    stagedAttachments: StagedAttachment[];
+};

package/dist/core/queued_engine_input.js

@@ -0,0 +1,16 @@
+export function decodeQueuedEngineInput(inputJson, fallbackPrompt) {
+    const input = JSON.parse(inputJson);
+    // Legacy queues contained only a Codex-shaped text input array.
+    if (Array.isArray(input)) {
+        const text = input[0]?.text;
+        return { prompt: typeof text === 'string' ? text : fallbackPrompt, stagedAttachments: [] };
+    }
+    if (typeof input !== 'object' || input === null || !('version' in input) || input.version !== 1 ||
+        !('prompt' in input) || typeof input.prompt !== 'string' ||
+        !('backendId' in input) || typeof input.backendId !== 'string' ||
+        !('cwd' in input) || typeof input.cwd !== 'string' ||
+        !('stagedAttachments' in input) || !Array.isArray(input.stagedAttachments)) {
+        throw new Error('Invalid queued engine input');
+    }
+    return input;
+}

package/dist/core/runtime_supervisor.d.ts

@@ -0,0 +1,19 @@
+export interface ManagedRuntime {
+    start?(): void | Promise<void>;
+    stop(): void | Promise<void>;
+}
+export interface ShutdownFailure {
+    name: string;
+    error: unknown;
+}
+/** Owns resources from allocation onward, including partially started runtimes. */
+export declare class RuntimeSupervisor {
+    private readonly entries;
+    private readonly identities;
+    private closing;
+    private shutdown;
+    register(name: string, resource: ManagedRuntime): void;
+    start(name: string): Promise<void>;
+    stop(): Promise<ShutdownFailure[]>;
+    private stopAll;
+}

package/dist/core/runtime_supervisor.js

@@ -0,0 +1,45 @@
+/** Owns resources from allocation onward, including partially started runtimes. */
+export class RuntimeSupervisor {
+    entries = [];
+    identities = new Set();
+    closing = false;
+    shutdown = null;
+    register(name, resource) {
+        if (this.closing)
+            throw new Error('Runtime supervisor is stopping');
+        if (this.identities.has(resource))
+            return;
+        if (this.entries.some(entry => entry.name === name))
+            throw new Error(`Runtime already registered: ${name}`);
+        this.identities.add(resource);
+        this.entries.push({ name, resource, start: null });
+    }
+    start(name) {
+        if (this.closing)
+            return Promise.reject(new Error('Runtime supervisor is stopping'));
+        const entry = this.entries.find(entry => entry.name === name);
+        if (!entry)
+            return Promise.reject(new Error(`Unknown runtime: ${name}`));
+        entry.start ??= Promise.resolve().then(() => entry.resource.start?.());
+        return entry.start;
+    }
+    stop() {
+        this.closing = true;
+        this.shutdown ??= this.stopAll();
+        return this.shutdown;
+    }
+    async stopAll() {
+        const failures = [];
+        // Consumers are registered after their dependencies and stopped before them.
+        for (const entry of [...this.entries].reverse()) {
+            await entry.start?.catch(() => { });
+            try {
+                await entry.resource.stop();
+            }
+            catch (error) {
+                failures.push({ name: entry.name, error });
+            }
+        }
+        return failures;
+    }
+}

package/dist/core/scope_operations.d.ts

@@ -0,0 +1,7 @@
+/** Serialize state changes for one conversation; unrelated scopes proceed independently. */
+export declare class ScopeOperations {
+    private readonly tails;
+    run<T>(scopeId: string, operation: () => Promise<T>): Promise<T>;
+    isIdle(): boolean;
+    idle(): Promise<void>;
+}

package/dist/core/scope_operations.js

@@ -0,0 +1,19 @@
+/** Serialize state changes for one conversation; unrelated scopes proceed independently. */
+export class ScopeOperations {
+    tails = new Map();
+    run(scopeId, operation) {
+        const previous = this.tails.get(scopeId) ?? Promise.resolve();
+        const next = previous.catch(() => { }).then(operation);
+        this.tails.set(scopeId, next);
+        void next.finally(() => {
+            if (this.tails.get(scopeId) === next)
+                this.tails.delete(scopeId);
+        }).catch(() => { });
+        return next;
+    }
+    isIdle() { return this.tails.size === 0; }
+    async idle() {
+        while (this.tails.size)
+            await Promise.allSettled([...this.tails.values()]);
+    }
+}

package/dist/core/stream_preview.js

@@ -1,5 +1,5 @@
 import { formatMetricTokenCount } from '../store/token_usage.js';
-import { chunkTelegramMessage } from '../telegram/text.js';
+import { chunkMessage } from './message_text.js';
 export function formatElapsedDuration(seconds, locale = 'zh') {
     if (!Number.isFinite(seconds) || seconds <= 0)
         return '0s';
@@ -75,14 +75,26 @@ export function buildFoldedToolsSummary(options) {
                 : '';
             previewLines = [...head, omittedNote, ...tail].filter(Boolean);
         }
-        toolDetailSection = `\n\n<i>${locale === 'zh' ? '工具调用记录:' : 'Tool calls:'}</i>\n${previewLines.join('\n')}`;
+        // Keep whole formatted lines within the summary budget; never slice through tags/entities.
+        const bounded = [];
+        let budget = 1500;
+        for (const line of [...previewLines].reverse()) {
+            if (line.length + 1 > budget)
+                continue;
+            bounded.unshift(line);
+            budget -= line.length + 1;
+        }
+        const omittedBySize = previewLines.length - bounded.length;
+        if (omittedBySize)
+            bounded.unshift(`<i>${locale === 'zh' ? `另有 ${omittedBySize} 项记录已收起` : `${omittedBySize} additional entries omitted`}</i>`);
+        toolDetailSection = `\n\n<i>${locale === 'zh' ? '工具调用记录:' : 'Tool calls:'}</i>\n${bounded.join('\n')}`;
     }
     return `<blockquote expandable>${header}${usageLine}${toolDetailSection}</blockquote>\n\n`;
 }
 export function combineSummaryAndResponse(foldedSummary, responseText, limit = 4000) {
     const content = (responseText || '(无输出 / No output)').trim();
     if (!foldedSummary) {
-        return chunkTelegramMessage(content, limit);
+        return chunkMessage(content, limit);
     }
     const combined = `${foldedSummary}${content}`;
     if (combined.length <= limit) {
@@ -96,18 +108,18 @@ export function combineSummaryAndResponse(foldedSummary, responseText, limit = 4
         if (splitAt >= Math.floor(remainingInFirstChunk / 3)) {
             const firstChunkText = content.slice(0, splitAt + 1).trim();
             const rest = content.slice(splitAt + 1).trim();
-            const restChunks = chunkTelegramMessage(rest, limit);
+            const restChunks = chunkMessage(rest, limit);
             return [`${foldedSummary}${firstChunkText}`, ...restChunks];
         }
     }
     // If foldedSummary takes up most of the message or no clean paragraph break was found,
     // foldedSummary gets its own clean message, and responseText is chunked independently.
-    const responseChunks = chunkTelegramMessage(content, limit);
+    const responseChunks = chunkMessage(content, limit);
     return [foldedSummary.trim(), ...responseChunks];
 }
 export function renderStreamPreviewContent(state) {
     const parts = [];
-    const name = state.engineName || 'AI';
+    const name = escapeTelegramHtml(state.engineName || 'AI');
     const roundText = state.stepIndex && state.stepIndex > 0 ? `第 ${state.stepIndex} 轮` : '';
     const toolText = typeof state.toolCount === 'number' && state.toolCount > 0 ? `累计执行 ${state.toolCount} 次工具` : '';
     const timeText = typeof state.elapsedSeconds === 'number' && state.elapsedSeconds > 0 ? `已耗时 ${state.elapsedSeconds}s` : '';
@@ -125,13 +137,13 @@ export function renderStreamPreviewContent(state) {
         parts.push('');
     }
     if (state.toolLines.length > 0) {
-        const recent = state.toolLines.slice(-6);
+        const recent = state.toolLines.slice(-3);
         parts.push(`<blockquote expandable>🛠️ <b>正在调用工具 (${state.toolLines.length} 项)</b>\n${recent.join('\n')}</blockquote>`);
         parts.push('');
     }
     if (state.accumulatedText) {
-        const preview = state.accumulatedText.slice(-3000);
-        parts.push(preview);
+        const preview = state.accumulatedText.slice(-1000);
+        parts.push(escapeTelegramHtml(preview));
     }
     else {
         parts.push(state.isBoost ? `🚀 ${name} (Boost 模式) 正在深度思考中…` : `⏳ ${name} 正在思考中…`);

package/dist/dsh/adapter.d.ts

@@ -0,0 +1,48 @@
+import type { SessionConfigSelectOption } from '@agentclientprotocol/sdk';
+import type { IEngineAdapter, EngineModel, EngineTurnRequest, EngineTurnExecution } from '../core/engine_spi.js';
+import type { AccessPresetValue } from '../types.js';
+import { DshClient, type SessionConfigOption } from './client.js';
+export declare function optionChoices(option?: SessionConfigOption): SessionConfigSelectOption[];
+export declare function modelId(value: string): string;
+interface ScopePreferences {
+    cwd: string;
+    threadId: string | null;
+    model: string | null;
+    effort: string | null;
+    access: AccessPresetValue;
+}
+interface ScopeSession {
+    client: DshClient;
+    sessionId: string;
+    cwd: string;
+    defaultModel: string;
+    defaultEffort: string | null;
+}
+/** Persistent DSH sessions over the shipped ACP profile. */
+export declare class DshEngineAdapter implements IEngineAdapter {
+    private readonly options;
+    readonly id = "dsh";
+    readonly name = "DeepSeek Harness (DSH)";
+    private readonly clients;
+    private readonly sessions;
+    private readonly pending;
+    private readonly busy;
+    private closed;
+    constructor(options: {
+        createClient: (scopeId: string) => DshClient;
+        preferences: (scopeId: string) => ScopePreferences;
+        bind: (scopeId: string, sessionId: string, cwd: string) => void;
+    });
+    sessionForScope(scopeId: string): Promise<ScopeSession>;
+    private openSession;
+    listModels(scopeId?: string): Promise<EngineModel[]>;
+    selectModel(scopeId: string, id: string | null): Promise<void>;
+    listEfforts(scopeId: string): Promise<SessionConfigSelectOption[]>;
+    selectEffort(scopeId: string, effort: string | null): Promise<void>;
+    setAccess(scopeId: string, access: AccessPresetValue): Promise<void>;
+    listSessions(scopeId: string, cursor?: string): Promise<import("@agentclientprotocol/sdk").ListSessionsResponse>;
+    isBusy(scopeId: string): boolean;
+    executeTurn(request: EngineTurnRequest): EngineTurnExecution;
+    stop(): Promise<void>;
+}
+export {};

package/dist/dsh/adapter.js

@@ -0,0 +1,205 @@
+import { EventEmitter } from 'node:events';
+import fs from 'node:fs/promises';
+import { buildAttachmentPrompt, isNativeImageAttachment } from '../core/attachment_files.js';
+export function optionChoices(option) {
+    if (option?.type !== 'select')
+        return [];
+    return option.options.flatMap(item => 'options' in item ? item.options : [item]);
+}
+export function modelId(value) {
+    const route = JSON.parse(value);
+    if (!Array.isArray(route) || route.length !== 2 || !route.every(part => typeof part === 'string' && part.length > 0))
+        throw new Error('Invalid DSH model route');
+    return `${route[0]}/${route[1]}`;
+}
+/** Persistent DSH sessions over the shipped ACP profile. */
+export class DshEngineAdapter {
+    options;
+    id = 'dsh';
+    name = 'DeepSeek Harness (DSH)';
+    clients = new Map();
+    sessions = new Map();
+    pending = new Map();
+    busy = new Set();
+    closed = false;
+    constructor(options) {
+        this.options = options;
+    }
+    async sessionForScope(scopeId) {
+        if (this.closed)
+            throw new Error('DSH backend is stopped');
+        const existing = this.pending.get(scopeId);
+        if (existing)
+            return existing;
+        const task = this.openSession(scopeId).finally(() => this.pending.delete(scopeId));
+        this.pending.set(scopeId, task);
+        return task;
+    }
+    async openSession(scopeId) {
+        const prefs = this.options.preferences(scopeId);
+        let client = this.clients.get(scopeId);
+        if (!client) {
+            client = this.options.createClient(scopeId);
+            this.clients.set(scopeId, client);
+        }
+        await client.setAccess(prefs.access);
+        const previous = this.sessions.get(scopeId);
+        if (client.connected && previous && previous.sessionId === prefs.threadId && previous.cwd === prefs.cwd)
+            return previous;
+        if (previous && this.busy.has(scopeId))
+            throw new Error('DSH session is busy');
+        if (previous && client.connected)
+            await client.closeSession(previous.sessionId);
+        const sessionId = await client.session(prefs.cwd, prefs.threadId);
+        const config = client.configOptions(sessionId);
+        const model = config.find(item => item.id === 'model');
+        const effort = config.find(item => item.id === 'reasoning_effort');
+        const state = { client, sessionId, cwd: prefs.cwd, defaultModel: String(model?.currentValue ?? ''), defaultEffort: effort?.type === 'select' ? effort.currentValue : null };
+        this.sessions.set(scopeId, state);
+        this.options.bind(scopeId, sessionId, prefs.cwd);
+        return state;
+    }
+    async listModels(scopeId = 'dsh:catalog') {
+        const state = await this.sessionForScope(scopeId);
+        return optionChoices(state.client.configOptions(state.sessionId).find(option => option.id === 'model')).map(choice => ({ id: modelId(choice.value), name: choice.name, description: choice.description ?? undefined, isDefault: choice.value === state.defaultModel }));
+    }
+    async selectModel(scopeId, id) {
+        const state = await this.sessionForScope(scopeId);
+        const model = state.client.configOptions(state.sessionId).find(option => option.id === 'model');
+        const choice = optionChoices(model).find(choice => id === null ? choice.value === state.defaultModel : modelId(choice.value) === id);
+        if (!choice)
+            throw new Error(`DSH model unavailable: ${id}`);
+        await state.client.setConfig(state.sessionId, 'model', choice.value);
+        const effort = state.client.configOptions(state.sessionId).find(option => option.id === 'reasoning_effort');
+        state.defaultEffort = effort?.type === 'select' ? effort.currentValue : null;
+    }
+    async listEfforts(scopeId) {
+        const state = await this.sessionForScope(scopeId);
+        return optionChoices(state.client.configOptions(state.sessionId).find(option => option.id === 'reasoning_effort'));
+    }
+    async selectEffort(scopeId, effort) {
+        const state = await this.sessionForScope(scopeId);
+        const choices = await this.listEfforts(scopeId);
+        if (choices.length === 0 && effort === null)
+            return;
+        const value = effort ?? state.defaultEffort;
+        if (value === null || !choices.some(choice => choice.value === value))
+            throw new Error(`DSH reasoning effort unavailable: ${effort}`);
+        await state.client.setConfig(state.sessionId, 'reasoning_effort', value);
+    }
+    async setAccess(scopeId, access) {
+        const state = await this.sessionForScope(scopeId);
+        await state.client.setAccess(access);
+    }
+    async listSessions(scopeId, cursor) { return (await this.sessionForScope(scopeId)).client.listSessions(cursor); }
+    isBusy(scopeId) { return this.busy.has(scopeId); }
+    executeTurn(request) {
+        const emitter = new EventEmitter();
+        let cancelled = false;
+        let state;
+        let finished = false;
+        let ownsSlot = false;
+        let result = null;
+        let resolveResult;
+        const promise = new Promise(resolve => { resolveResult = resolve; });
+        let response = '';
+        let finalMessage = '';
+        let finalMessageId;
+        const tools = new Map();
+        const onUpdate = (notification) => {
+            if (cancelled || notification.sessionId !== state?.sessionId)
+                return;
+            const update = notification.update;
+            if (update.sessionUpdate === 'agent_message_chunk' && update.content.type === 'text') {
+                if (update.messageId && update.messageId !== finalMessageId) {
+                    finalMessageId = update.messageId;
+                    finalMessage = '';
+                }
+                finalMessage += update.content.text;
+                response += update.content.text;
+                emitter.emit('delta', update.content.text);
+            }
+            else if (update.sessionUpdate === 'tool_call') {
+                tools.set(update.toolCallId, update.title);
+                emitter.emit('tool', { name: update.title, args: update.rawInput == null ? undefined : JSON.stringify(update.rawInput), status: 'running' });
+            }
+            else if (update.sessionUpdate === 'tool_call_update') {
+                emitter.emit('tool', { name: tools.get(update.toolCallId) ?? update.toolCallId, status: update.status === 'failed' ? 'failed' : update.status === 'completed' ? 'completed' : 'running' });
+            }
+        };
+        const run = async () => {
+            try {
+                if (this.busy.has(request.scopeId))
+                    throw new Error('DSH already has an active turn in this scope');
+                state = await this.sessionForScope(request.scopeId);
+                if (cancelled)
+                    return;
+                if (this.busy.has(request.scopeId))
+                    throw new Error('DSH already has an active turn in this scope');
+                this.busy.add(request.scopeId);
+                ownsSlot = true;
+                emitter.emit('conversation', state.sessionId);
+                await this.selectModel(request.scopeId, request.model === 'default' ? null : request.model);
+                await this.selectEffort(request.scopeId, request.effort ?? null);
+                if (cancelled)
+                    return;
+                const attachments = request.stagedAttachments ?? [];
+                const images = state.client.imageSupported ? attachments.filter(isNativeImageAttachment) : [];
+                const files = attachments.filter(attachment => !images.includes(attachment));
+                const content = [{ type: 'text', text: files.length ? buildAttachmentPrompt(request.prompt, files) : request.prompt }];
+                for (const attachment of images)
+                    content.push({ type: 'image', data: (await fs.readFile(attachment.localPath)).toString('base64'), mimeType: attachment.mimeType || 'image/jpeg' });
+                state.client.on('update', onUpdate);
+                if (cancelled)
+                    return;
+                const value = await state.client.agent.request('session/prompt', { sessionId: state.sessionId, prompt: content });
+                result = { kind: 'result', status: cancelled || value.stopReason === 'cancelled' ? 'INTERRUPTED' : 'SUCCESS', response: finalMessage || response, conversationId: state.sessionId };
+            }
+            catch (error) {
+                result = { kind: 'result', status: cancelled ? 'INTERRUPTED' : 'ERROR', response: finalMessage || response, error: error instanceof Error ? error.message : String(error), conversationId: state?.sessionId ?? request.threadId };
+            }
+            finally {
+                state?.client.off('update', onUpdate);
+                if (ownsSlot)
+                    this.busy.delete(request.scopeId);
+                result ??= { kind: 'result', status: 'INTERRUPTED', response: finalMessage || response, conversationId: state?.sessionId ?? request.threadId };
+                finished = true;
+                resolveResult(result);
+                emitter.emit('result', result);
+            }
+        };
+        queueMicrotask(() => { void run(); });
+        return {
+            cancel: async () => {
+                if (finished || cancelled) {
+                    await promise;
+                    return;
+                }
+                cancelled = true;
+                state?.client.cancelPermissions?.();
+                if (state?.client.connected)
+                    await state.client.agent.notify('session/cancel', { sessionId: state.sessionId }).catch(() => { });
+                let timer;
+                try {
+                    await Promise.race([promise, new Promise(resolve => { timer = setTimeout(resolve, 5000); })]);
+                    if (!finished)
+                        await this.clients.get(request.scopeId)?.stop();
+                    await promise;
+                }
+                finally {
+                    if (timer)
+                        clearTimeout(timer);
+                }
+            },
+            waitForResult: () => promise,
+            on: (event, listener) => { emitter.on(event, listener); },
+        };
+    }
+    async stop() {
+        this.closed = true;
+        await Promise.allSettled([...this.pending.values()]);
+        await Promise.all([...this.clients.values()].map(client => client.stop()));
+        this.clients.clear();
+        this.sessions.clear();
+    }
+}

package/dist/dsh/backend.d.ts

@@ -0,0 +1,7 @@
+import type { AppConfig } from '../config.js';
+import type { BridgeStore } from '../store/database.js';
+import type { Logger } from '../logger.js';
+import type { ChannelPort } from '../core/channel_port.js';
+import type { BackendDescriptor } from '../core/engine_spi.js';
+/** Same definition is mounted on a shared bot or on a dedicated DSH bot. */
+export declare function createDshBackend(config: AppConfig, store: BridgeStore, logger: Logger, messaging: ChannelPort): BackendDescriptor;

package/dist/dsh/backend.js

@@ -0,0 +1,21 @@
+import { getDshTelegramCommands } from '../i18n.js';
+import { DshUi } from './ui.js';
+/** Same definition is mounted on a shared bot or on a dedicated DSH bot. */
+export function createDshBackend(config, store, logger, messaging) {
+    const ui = new DshUi(config, store, logger, messaging);
+    return {
+        id: ui.adapter.id, name: ui.adapter.name, engineType: ui.adapter.id, adapter: ui.adapter,
+        defaults: { reasoningEffort: null, supportedReasoningEfforts: [], boost: false, tokenUsage: false },
+        commands: getDshTelegramCommands,
+        createUi: host => ({
+            ownsCallback: data => data.startsWith('dsh:'),
+            getPendingApprovals: () => ui.pendingApprovals,
+            stop: () => ui.stop(),
+            renderCustomStatus: async (scopeId, locale) => ui.status(scopeId, locale),
+            renderSetupMenu: async (scopeId, locale, messageId) => { await ui.setup(scopeId, locale, host, messageId); return true; },
+            renderModelsMenu: async (scopeId, locale, messageId) => { await ui.models(scopeId, locale, host, messageId); return true; },
+            handleCustomCommand: (scopeId, command, args, locale) => ui.command(scopeId, command, args, locale, host),
+            handleCustomCallback: (scopeId, data, locale, _messageId, event) => ui.callback(scopeId, data, locale, host, event),
+        }),
+    };
+}

package/dist/dsh/client.d.ts

@@ -0,0 +1,46 @@
+import { EventEmitter } from 'node:events';
+import { type SessionConfigOption, type SessionNotification, type RequestPermissionRequest, type RequestPermissionResponse } from '@agentclientprotocol/sdk';
+import type { Logger } from '../logger.js';
+import type { AccessPresetValue } from '../types.js';
+export interface DshClientOptions {
+    cliBin: string;
+    sourceDir?: string | null;
+    home?: string | null;
+    profile: string;
+    patches: string[];
+    runtimeDir: string;
+    startupTimeoutMs: number;
+}
+/** An owned ACP process; protocol stdout stays separate from diagnostics. */
+export declare class DshClient extends EventEmitter {
+    readonly options: DshClientOptions;
+    readonly scopeId: string;
+    private readonly logger;
+    private process;
+    private connection;
+    private starting;
+    private stopping;
+    private optionsBySession;
+    private capabilities;
+    private policyPath;
+    private policyWrite;
+    private stderr;
+    permissionHandler?: (request: RequestPermissionRequest, signal: AbortSignal) => Promise<RequestPermissionResponse>;
+    cancelPermissions?: () => void;
+    constructor(options: DshClientOptions, scopeId: string, logger: Logger);
+    setAccess(preset: AccessPresetValue): Promise<void>;
+    private writeAccess;
+    start(): Promise<void>;
+    private launch;
+    get connected(): boolean;
+    get imageSupported(): boolean;
+    get agent(): import("@agentclientprotocol/sdk").ClientContext;
+    session(cwd: string, sessionId?: string | null): Promise<string>;
+    configOptions(sessionId: string): SessionConfigOption[];
+    setConfig(sessionId: string, configId: string, value: string): Promise<void>;
+    listSessions(cursor?: string): Promise<import("@agentclientprotocol/sdk").ListSessionsResponse>;
+    closeSession(sessionId: string): Promise<void>;
+    stop(): Promise<void>;
+    private dispose;
+}
+export type { SessionConfigOption, SessionNotification, RequestPermissionRequest, RequestPermissionResponse };