@foxden-app/foxclaw 0.11.0 → 0.12.0

package/dist/dsh/client.js

@@ -0,0 +1,184 @@
+import { spawn } from 'node:child_process';
+import { Readable, Writable } from 'node:stream';
+import { EventEmitter } from 'node:events';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { createHash } from 'node:crypto';
+import { ClientApp, ndJsonStream, PROTOCOL_VERSION } from '@agentclientprotocol/sdk';
+/** An owned ACP process; protocol stdout stays separate from diagnostics. */
+export class DshClient extends EventEmitter {
+    options;
+    scopeId;
+    logger;
+    process = null;
+    connection = null;
+    starting = null;
+    stopping = null;
+    optionsBySession = new Map();
+    capabilities = { image: false, resume: false, list: false };
+    policyPath = '';
+    policyWrite = Promise.resolve();
+    stderr = '';
+    permissionHandler;
+    cancelPermissions;
+    constructor(options, scopeId, logger) {
+        super();
+        this.options = options;
+        this.scopeId = scopeId;
+        this.logger = logger;
+    }
+    setAccess(preset) {
+        const write = this.policyWrite.then(() => this.writeAccess(preset));
+        this.policyWrite = write.catch(() => { });
+        return write;
+    }
+    async writeAccess(preset) {
+        const folder = path.join(this.options.runtimeDir, createHash('sha256').update(this.scopeId).digest('hex'));
+        await fs.mkdir(folder, { recursive: true, mode: 0o700 });
+        this.policyPath = path.join(folder, 'permissions');
+        const temporary = `${this.policyPath}.tmp`;
+        await fs.writeFile(temporary, preset === 'full-access' ? 'danger-full-access' : preset === 'read-only' ? 'read-only' : 'workspace-write', { mode: 0o600 });
+        await fs.rename(temporary, this.policyPath);
+    }
+    start() {
+        if (this.connection && !this.connection.signal.aborted)
+            return Promise.resolve();
+        this.starting ??= this.launch().finally(() => { this.starting = null; });
+        return this.starting;
+    }
+    async launch() {
+        if (this.stopping)
+            await this.stopping;
+        if (this.process)
+            await this.stop();
+        if (!this.policyPath)
+            await this.setAccess('default');
+        const patchPath = path.join(path.dirname(this.policyPath), 'bridge.patch.yml');
+        let pluginPath = fileURLToPath(new URL('./permissions_plugin.js', import.meta.url));
+        try {
+            await fs.access(pluginPath);
+        }
+        catch {
+            pluginPath = pluginPath.replace(/\.js$/, '.ts');
+        }
+        await fs.writeFile(patchPath, `- insert:\n    - id: foxclaw-permissions\n      name: ${JSON.stringify(pathToFileURL(pluginPath).href)}\n      config:\n        policyPath: ${JSON.stringify(this.policyPath)}\n`, { mode: 0o600 });
+        const args = ['--profile', this.options.profile, ...this.options.patches.flatMap(p => ['--patch', path.resolve(p)]), '--patch', patchPath];
+        let command = this.options.cliBin;
+        let cwd = process.cwd();
+        if (this.options.sourceDir) {
+            cwd = path.resolve(this.options.sourceDir);
+            command = process.execPath;
+            args.unshift('--import', 'tsx/esm', path.join(cwd, 'apps/cli/src/bin.ts'));
+        }
+        else if (/\.[cm]?js$/.test(command)) {
+            args.unshift(path.resolve(command));
+            command = process.execPath;
+        }
+        const child = spawn(command, args, { cwd, env: { ...process.env, ...(this.options.home ? { DSH_HOME: this.options.home } : {}) }, stdio: 'pipe', windowsHide: true });
+        this.process = child;
+        this.stderr = '';
+        this.optionsBySession.clear();
+        const app = new ClientApp({ name: 'foxclaw' })
+            .onNotification('session/update', ({ params }) => {
+            if (params.update.sessionUpdate === 'config_option_update')
+                this.optionsBySession.set(params.sessionId, params.update.configOptions);
+            this.emit('update', params);
+        })
+            .onRequest('session/request_permission', ({ params, signal }) => this.permissionHandler?.(params, signal) ?? Promise.resolve({ outcome: { outcome: 'cancelled' } }));
+        const connection = app.connect(ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout)));
+        this.connection = connection;
+        child.stdin.on('error', error => connection.close(error));
+        child.stderr.on('data', (data) => { this.stderr = (this.stderr + data.toString()).slice(-4000); });
+        child.once('error', error => connection.close(error));
+        child.once('exit', (code, signal) => {
+            connection.close(new Error(`DSH exited (${code ?? signal}): ${this.stderr}`));
+            if (this.process === child)
+                this.process = null;
+            this.emit('disconnected');
+        });
+        const controller = new AbortController();
+        let timer;
+        const timeout = new Promise((_resolve, reject) => {
+            timer = setTimeout(() => { controller.abort(); reject(new Error('DSH initialization timed out')); }, this.options.startupTimeoutMs);
+        });
+        try {
+            const initialized = await Promise.race([connection.agent.request('initialize', { protocolVersion: PROTOCOL_VERSION, clientCapabilities: {}, clientInfo: { name: 'foxclaw', version: '1' } }, { cancellationSignal: controller.signal }), timeout]);
+            this.capabilities = { image: initialized.agentCapabilities?.promptCapabilities?.image === true, resume: initialized.agentCapabilities?.sessionCapabilities?.resume != null, list: initialized.agentCapabilities?.sessionCapabilities?.list != null };
+        }
+        catch (error) {
+            await this.stop();
+            throw new Error(`Cannot start DSH: ${error instanceof Error ? error.message : String(error)}${this.stderr ? `\n${this.stderr}` : ''}`);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    get connected() { return this.connection !== null && !this.connection.signal.aborted; }
+    get imageSupported() { return this.capabilities.image; }
+    get agent() {
+        if (!this.connected)
+            throw new Error('DSH is disconnected');
+        return this.connection.agent;
+    }
+    async session(cwd, sessionId) {
+        await this.start();
+        if (sessionId && this.optionsBySession.has(sessionId))
+            return sessionId;
+        if (sessionId) {
+            if (!this.capabilities.resume)
+                throw new Error('This DSH profile cannot resume sessions');
+            const result = await this.agent.request('session/resume', { sessionId, cwd, mcpServers: [] });
+            this.optionsBySession.set(sessionId, result.configOptions ?? []);
+            return sessionId;
+        }
+        const result = await this.agent.request('session/new', { cwd, mcpServers: [] });
+        this.optionsBySession.set(result.sessionId, result.configOptions ?? []);
+        return result.sessionId;
+    }
+    configOptions(sessionId) { return this.optionsBySession.get(sessionId) ?? []; }
+    async setConfig(sessionId, configId, value) {
+        const result = await this.agent.request('session/set_config_option', { sessionId, configId, value });
+        this.optionsBySession.set(sessionId, result.configOptions);
+    }
+    async listSessions(cursor) {
+        await this.start();
+        if (!this.capabilities.list)
+            throw new Error('This DSH profile cannot list sessions');
+        return this.agent.request('session/list', cursor ? { cursor } : {});
+    }
+    async closeSession(sessionId) {
+        await this.agent.request('session/close', { sessionId });
+        this.optionsBySession.delete(sessionId);
+    }
+    stop() {
+        this.stopping ??= this.dispose().finally(() => { this.stopping = null; });
+        return this.stopping;
+    }
+    async dispose() {
+        this.cancelPermissions?.();
+        const child = this.process;
+        const connection = this.connection;
+        this.connection = null;
+        this.optionsBySession.clear();
+        if (!child || !child.pid) {
+            connection?.close();
+            return;
+        }
+        const exited = new Promise(resolve => child.once('exit', () => resolve()));
+        child.stdin.end();
+        let timer;
+        await Promise.race([exited, new Promise(resolve => { timer = setTimeout(resolve, 6000); })]);
+        clearTimeout(timer);
+        if (child.exitCode === null && child.signalCode === null) {
+            this.logger.warn('dsh.force_stop', { scopeId: this.scopeId });
+            child.kill('SIGTERM');
+            const killTimer = setTimeout(() => child.kill('SIGKILL'), 3000);
+            await exited;
+            clearTimeout(killTimer);
+        }
+        connection?.close();
+        if (this.process === child)
+            this.process = null;
+    }
+}

package/dist/dsh/permissions_plugin.d.ts

@@ -0,0 +1,30 @@
+/** Minimal service face so the bridge plugin needs no DSH package dependency. */
+interface Session {
+    header: {
+        parentSession?: string;
+    };
+}
+interface Context {
+    permissionPresets: {
+        set(session: Session, preset: string): void;
+    };
+    on(event: 'agent/created', listener: (payload: {
+        agent: {
+            session: Session;
+        };
+    }) => void): void;
+    on(event: 'agent/pre-step', listener: (payload: {
+        agent: {
+            session: Session;
+        };
+    }, next: () => Promise<unknown>) => Promise<unknown>, options: {
+        prepend: boolean;
+    }): void;
+}
+export declare const name = "foxclaw-permissions";
+export declare const inject: string[];
+/** Apply FoxClaw's selected native preset before fresh/restored root agents run. */
+export declare function apply(ctx: Context, config: {
+    policyPath: string;
+}): void;
+export {};

package/dist/dsh/permissions_plugin.js

@@ -0,0 +1,21 @@
+import fs from 'node:fs';
+export const name = 'foxclaw-permissions';
+export const inject = ['permissionPresets'];
+/** Apply FoxClaw's selected native preset before fresh/restored root agents run. */
+export function apply(ctx, config) {
+    const permissions = ctx.permissionPresets;
+    const select = (session) => {
+        if (session.header.parentSession)
+            return;
+        const preset = fs.readFileSync(config.policyPath, 'utf8').trim();
+        if (!['read-only', 'workspace-write', 'danger-full-access'].includes(preset)) {
+            throw new Error('Invalid FoxClaw DSH permission preset');
+        }
+        permissions.set(session, preset);
+    };
+    ctx.on('agent/created', ({ agent }) => select(agent.session));
+    ctx.on('agent/pre-step', async ({ agent }, next) => {
+        select(agent.session);
+        return next();
+    }, { prepend: true });
+}

package/dist/dsh/runtime.d.ts

@@ -0,0 +1,21 @@
+import type { AppConfig } from '../config.js';
+import type { Logger } from '../logger.js';
+import type { BridgeStore } from '../store/database.js';
+/** Dedicated DSH bot using the same backend and channel orchestration as other bots. */
+export declare class DshTelegramRuntime {
+    private readonly bot;
+    private readonly ui;
+    private readonly orchestrator;
+    private running;
+    constructor(config: AppConfig, store: BridgeStore, logger: Logger);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getRuntimeStatus(): {
+        id: string;
+        username: string | null;
+        connected: boolean;
+        activeTurns: number;
+        pendingApprovals: number;
+        defaultBackend: "dsh";
+    };
+}

package/dist/dsh/runtime.js

@@ -0,0 +1,45 @@
+import { TelegramGateway } from '../telegram/gateway.js';
+import { TelegramMessagingPort } from '../channels/telegram/telegram_messaging_port.js';
+import { getDshTelegramCommands } from '../i18n.js';
+import { UnifiedChannelOrchestrator } from '../core/orchestrator.js';
+import { DshUi } from './ui.js';
+import { BRIDGE_SCOPE_TELEGRAM_PREFIX, parseTelegramTargetFromBridgeScope } from '../core/bridge_scope.js';
+/** Dedicated DSH bot using the same backend and channel orchestration as other bots. */
+export class DshTelegramRuntime {
+    bot;
+    ui;
+    orchestrator;
+    running = false;
+    constructor(config, store, logger) {
+        if (!config.dshBotToken)
+            throw new Error('DSH_BOT_TOKEN is required');
+        this.bot = new TelegramGateway(config.dshBotToken, config.tgAllowedUserId, config.tgAllowedChatId, config.telegramPollIntervalMs, store, logger, true, getDshTelegramCommands);
+        const messaging = new TelegramMessagingPort(this.bot);
+        this.ui = new DshUi(config, store, logger, messaging);
+        this.orchestrator = new UnifiedChannelOrchestrator({
+            config, store, logger, bot: this.bot, adapter: this.ui.adapter, messaging,
+            ownsScope: scopeId => scopeId.startsWith(BRIDGE_SCOPE_TELEGRAM_PREFIX) && parseTelegramTargetFromBridgeScope(scopeId).botId === this.bot.identity,
+            customUi: {
+                renderCustomStatus: async (scopeId, locale) => this.ui.status(scopeId, locale),
+                renderSetupMenu: async (scopeId, locale, messageId) => { await this.ui.setup(scopeId, locale, this.orchestrator, messageId); return true; },
+                renderModelsMenu: async (scopeId, locale, messageId) => { await this.ui.models(scopeId, locale, this.orchestrator, messageId); return true; },
+                handleCustomCommand: (scopeId, command, args, locale) => this.ui.command(scopeId, command, args, locale, this.orchestrator),
+                handleCustomCallback: (scopeId, data, locale, _messageId, event) => this.ui.callback(scopeId, data, locale, this.orchestrator, event),
+            },
+        });
+        this.orchestrator.registerInboundHandlers();
+    }
+    async start() {
+        await this.bot.initializeIdentity();
+        await this.orchestrator.start();
+        this.running = true;
+    }
+    async stop() {
+        this.running = false;
+        await this.orchestrator.stop();
+        await this.ui.stop();
+    }
+    getRuntimeStatus() {
+        return { id: this.bot.identity ?? 'dsh', username: this.bot.username, connected: this.running, activeTurns: this.orchestrator.getActiveTurnsCount(), pendingApprovals: this.ui.pendingApprovals, defaultBackend: 'dsh' };
+    }
+}

package/dist/dsh/ui.d.ts

@@ -0,0 +1,38 @@
+import type { AppConfig } from '../config.js';
+import type { BridgeStore } from '../store/database.js';
+import type { Logger } from '../logger.js';
+import type { TelegramMessagingPort } from '../channels/telegram/telegram_messaging_port.js';
+import type { AppLocale } from '../types.js';
+import type { TelegramCallbackEvent } from '../telegram/gateway.js';
+import type { UnifiedChannelOrchestrator } from '../core/orchestrator.js';
+import { DshEngineAdapter } from './adapter.js';
+/** DSH controls shared by the unified bot and the optional dedicated bot. */
+export declare class DshUi {
+    private readonly config;
+    private readonly store;
+    private readonly logger;
+    private readonly messaging;
+    private readonly actions;
+    private readonly approvals;
+    readonly adapter: DshEngineAdapter;
+    get pendingApprovals(): number;
+    constructor(config: AppConfig, store: BridgeStore, logger: Logger, messaging: TelegramMessagingPort);
+    private defaultAccess;
+    private copy;
+    status(scopeId: string, locale: AppLocale): string;
+    private button;
+    private panel;
+    setup(scopeId: string, locale: AppLocale, orchestrator: UnifiedChannelOrchestrator, messageId?: number): Promise<void>;
+    models(scopeId: string, locale: AppLocale, orchestrator: UnifiedChannelOrchestrator, messageId?: number): Promise<void>;
+    private efforts;
+    private selectModel;
+    private selectEffort;
+    private selectAccess;
+    private threads;
+    private open;
+    private plugins;
+    command(scopeId: string, command: string, args: string, locale: AppLocale, orchestrator: UnifiedChannelOrchestrator): Promise<boolean>;
+    callback(scopeId: string, data: string, locale: AppLocale, orchestrator: UnifiedChannelOrchestrator, event?: TelegramCallbackEvent): Promise<boolean>;
+    private requestPermission;
+    stop(): Promise<void>;
+}