@jshookmcp/jshook 0.2.6 → 0.2.8

package/dist/src/server/domains/process/handlers.impl.core.runtime.inject.js

@@ -1,419 +0,0 @@
-import { logger } from '../../../utils/logger.js';
-import { ENABLE_INJECTION_TOOLS } from '../../../constants.js';
-import { ProcessHandlersBase, requireString, validatePid, } from '../../domains/process/handlers.base.js';
-const INJECTION_TOOLS_DISABLED_ERROR = 'Injection tools are disabled by configuration. Set ENABLE_INJECTION_TOOLS=true before starting the server to enable DLL and shellcode injection.';
-const INJECTION_TOOLS_ENABLE_GUIDANCE = 'Set ENABLE_INJECTION_TOOLS=true before starting the server.';
-const INJECTION_TOOLS_SECURITY_NOTICE = 'Injection tools can destabilize target processes; review impact before use.';
-function buildInjectionDisabledPayload() {
-    return {
-        success: false,
-        error: INJECTION_TOOLS_DISABLED_ERROR,
-        howToEnable: INJECTION_TOOLS_ENABLE_GUIDANCE,
-        securityNotice: INJECTION_TOOLS_SECURITY_NOTICE,
-    };
-}
-function getOptionalPid(value) {
-    const pid = Number(value);
-    return Number.isInteger(pid) && pid > 0 ? pid : null;
-}
-function formatUnknownError(error) {
-    if (error instanceof Error) {
-        return error.message;
-    }
-    if (typeof error === 'object' && error !== null) {
-        try {
-            return JSON.stringify(error, null, 2);
-        }
-        catch {
-            return String(error);
-        }
-    }
-    return String(error);
-}
-function getOptionalString(value) {
-    return typeof value === 'string' && value.length > 0 ? value : null;
-}
-function getShellcodeSize(shellcode, encoding) {
-    if (encoding === 'hex') {
-        const normalized = shellcode.replace(/\s+/g, '');
-        return Math.ceil(normalized.length / 2);
-    }
-    return Buffer.from(shellcode, 'base64').length;
-}
-export class ProcessToolHandlersRuntime extends ProcessHandlersBase {
-    async handleInjectDll(args) {
-        const startedAt = Date.now();
-        if (!ENABLE_INJECTION_TOOLS) {
-            this.recordMemoryAudit({
-                operation: 'inject_dll',
-                pid: getOptionalPid(args.pid),
-                address: getOptionalString(args.dllPath),
-                size: null,
-                result: 'failure',
-                error: INJECTION_TOOLS_DISABLED_ERROR,
-                durationMs: Date.now() - startedAt,
-            });
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(buildInjectionDisabledPayload(), null, 2),
-                    },
-                ],
-            };
-        }
-        try {
-            const pid = validatePid(args.pid);
-            const dllPath = requireString(args.dllPath, 'dllPath');
-            const result = await this.memoryManager.injectDll(pid, dllPath);
-            this.recordMemoryAudit({
-                operation: 'inject_dll',
-                pid,
-                address: dllPath,
-                size: null,
-                result: result.success ? 'success' : 'failure',
-                error: result.error,
-                durationMs: Date.now() - startedAt,
-            });
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(result, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            logger.error('DLL injection failed:', error);
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            this.recordMemoryAudit({
-                operation: 'inject_dll',
-                pid: getOptionalPid(args.pid),
-                address: getOptionalString(args.dllPath),
-                size: null,
-                result: 'failure',
-                error: errorMessage,
-                durationMs: Date.now() - startedAt,
-            });
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({ success: false, error: errorMessage }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-    async handleInjectShellcode(args) {
-        const startedAt = Date.now();
-        if (!ENABLE_INJECTION_TOOLS) {
-            const shellcode = getOptionalString(args.shellcode);
-            const encoding = args.encoding || 'hex';
-            this.recordMemoryAudit({
-                operation: 'inject_shellcode',
-                pid: getOptionalPid(args.pid),
-                address: null,
-                size: shellcode ? getShellcodeSize(shellcode, encoding) : null,
-                result: 'failure',
-                error: INJECTION_TOOLS_DISABLED_ERROR,
-                durationMs: Date.now() - startedAt,
-            });
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(buildInjectionDisabledPayload(), null, 2),
-                    },
-                ],
-            };
-        }
-        try {
-            const pid = validatePid(args.pid);
-            const shellcode = requireString(args.shellcode, 'shellcode');
-            const encoding = args.encoding || 'hex';
-            const size = getShellcodeSize(shellcode, encoding);
-            const result = await this.memoryManager.injectShellcode(pid, shellcode, encoding);
-            this.recordMemoryAudit({
-                operation: 'inject_shellcode',
-                pid,
-                address: null,
-                size,
-                result: result.success ? 'success' : 'failure',
-                error: result.error,
-                durationMs: Date.now() - startedAt,
-            });
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(result, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            logger.error('Shellcode injection failed:', error);
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            const shellcode = getOptionalString(args.shellcode);
-            const encoding = args.encoding || 'hex';
-            this.recordMemoryAudit({
-                operation: 'inject_shellcode',
-                pid: getOptionalPid(args.pid),
-                address: null,
-                size: shellcode ? getShellcodeSize(shellcode, encoding) : null,
-                result: 'failure',
-                error: errorMessage,
-                durationMs: Date.now() - startedAt,
-            });
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({ success: false, error: errorMessage }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-    async handleCheckDebugPort(args) {
-        try {
-            const pid = validatePid(args.pid);
-            const result = await this.memoryManager.checkDebugPort(pid);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(result, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            logger.error('Debug port check failed:', error);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({ success: false, error: error instanceof Error ? error.message : String(error) }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-    async handleEnumerateModules(args) {
-        try {
-            const pid = validatePid(args.pid);
-            const result = await this.memoryManager.enumerateModules(pid);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(result, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            logger.error('Module enumeration failed:', error);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({ success: false, error: error instanceof Error ? error.message : String(error) }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-    async handleElectronAttach(args) {
-        const rawPort = args.port ?? 9229;
-        const port = Number(rawPort);
-        if (!Number.isInteger(port) || port < 1 || port > 65535) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: `Invalid port: ${JSON.stringify(rawPort)}. Must be integer 1-65535.`,
-                        }),
-                    },
-                ],
-            };
-        }
-        const wsEndpointArg = args.wsEndpoint ?? '';
-        const evaluateExpr = args.evaluate ?? '';
-        const pageUrl = args.pageUrl ?? '';
-        try {
-            const baseUrl = `http://127.0.0.1:${port}`;
-            const listUrl = `${baseUrl}/json/list`;
-            let targets;
-            try {
-                const resp = await fetch(listUrl);
-                if (!resp.ok) {
-                    throw new Error(`CDP list endpoint returned HTTP ${resp.status}`);
-                }
-                targets = (await resp.json());
-            }
-            catch (listError) {
-                try {
-                    const resp = await fetch(`${baseUrl}/json`);
-                    if (!resp.ok) {
-                        throw new Error(`CDP fallback endpoint returned HTTP ${resp.status}`, {
-                            cause: listError,
-                        });
-                    }
-                    targets = (await resp.json());
-                }
-                catch (fallbackError) {
-                    const original = formatUnknownError(fallbackError || listError);
-                    throw new Error(`Cannot connect to Electron CDP at ${baseUrl}. ` +
-                        `Ensure the target app is running with a remote debugging port (for example: process_launch_debug with debugPort=${port}), ` +
-                        `then retry electron_attach. Original error: ${original}`, { cause: fallbackError });
-                }
-            }
-            if (!Array.isArray(targets)) {
-                throw new Error('CDP target list is not an array');
-            }
-            const filtered = pageUrl ? targets.filter((t) => t.url.includes(pageUrl)) : targets;
-            if (!evaluateExpr) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                total: targets.length,
-                                filtered: filtered.length,
-                                pages: filtered.map((t) => ({
-                                    id: t.id,
-                                    title: t.title,
-                                    url: t.url,
-                                    type: t.type,
-                                    wsUrl: t.webSocketDebuggerUrl,
-                                })),
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            const target = filtered[0];
-            if (!target?.webSocketDebuggerUrl) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `No matching page found (pageUrl filter: "${pageUrl}"). Available targets:\n` +
-                                targets.map((t) => `  [${t.type}] ${t.title} — ${t.url}`).join('\n'),
-                        },
-                    ],
-                };
-            }
-            const { default: puppeteer } = await import('rebrowser-puppeteer-core');
-            let browserWsEndpoint = wsEndpointArg;
-            if (!browserWsEndpoint) {
-                try {
-                    const versionResp = await fetch(`${baseUrl}/json/version`);
-                    if (versionResp.ok) {
-                        const versionData = (await versionResp.json());
-                        if (versionData.webSocketDebuggerUrl) {
-                            browserWsEndpoint = versionData.webSocketDebuggerUrl;
-                        }
-                    }
-                }
-                catch {
-                }
-            }
-            if (!browserWsEndpoint) {
-                browserWsEndpoint = target.webSocketDebuggerUrl
-                    .replace(/\/devtools\/page\/[^/]+$/, '')
-                    .replace('/devtools/page', '/devtools/browser');
-            }
-            if (!browserWsEndpoint) {
-                throw new Error('Could not determine browser WebSocket endpoint');
-            }
-            const browser = await puppeteer.connect({
-                browserWSEndpoint: browserWsEndpoint,
-                defaultViewport: null,
-            });
-            let evalResult;
-            let evalError;
-            try {
-                const pages = await browser.pages();
-                const matchedPage = pages.find((p) => p.url().includes(target.url)) ?? pages[0];
-                if (!matchedPage)
-                    throw new Error('Could not get page from connected browser');
-                const evaluated = await matchedPage.evaluate((expression) => {
-                    try {
-                        const fn = new Function('return (' + expression + ')');
-                        return { ok: true, result: fn() };
-                    }
-                    catch (e) {
-                        const errorLike = typeof e === 'object' && e !== null
-                            ? e
-                            : {};
-                        return {
-                            ok: false,
-                            error: {
-                                name: errorLike.name || 'Error',
-                                message: String(errorLike.message || e),
-                                stack: errorLike.stack ? String(errorLike.stack) : undefined,
-                            },
-                        };
-                    }
-                }, evaluateExpr);
-                if (!evaluated?.ok) {
-                    evalError = `Evaluation failed: ${evaluated?.error?.name || 'Error'}: ${evaluated?.error?.message || 'Unknown error'}`;
-                }
-                else {
-                    evalResult = evaluated.result;
-                }
-            }
-            finally {
-                await browser.disconnect();
-            }
-            if (evalError) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: false,
-                                error: evalError,
-                                target: { title: target.title, url: target.url },
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            logger.info(`electron_attach: evaluated in ${target.title}`);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            target: { title: target.title, url: target.url },
-                            result: evalResult,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            logger.error('electron_attach failed:', error);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: formatUnknownError(error),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-}

package/dist/src/server/domains/process/handlers.impl.core.runtime.js

@@ -1 +0,0 @@
-export { ProcessToolHandlersRuntime as ProcessToolHandlers } from '../../domains/process/handlers.impl.core.runtime.inject.js';

package/dist/src/server/domains/process/handlers.impl.core.runtime.memory.d.ts

@@ -1 +0,0 @@
-export { ProcessHandlersBase as ProcessToolHandlersMemory } from '../../domains/process/handlers.base.js';

package/dist/src/server/domains/process/handlers.impl.core.runtime.memory.js

@@ -1 +0,0 @@
-export { ProcessHandlersBase as ProcessToolHandlersMemory } from '../../domains/process/handlers.base.js';

package/dist/src/server/domains/process/handlers.impl.d.ts

@@ -1 +0,0 @@
-export { ProcessToolHandlers } from '../../domains/process/handlers.impl.core.js';

package/dist/src/server/domains/process/handlers.impl.js

@@ -1 +0,0 @@
-export { ProcessToolHandlers } from '../../domains/process/handlers.impl.core.js';

package/dist/src/server/domains/process/handlers.js

@@ -1 +0,0 @@
-export { ProcessToolHandlers } from '../../domains/process/handlers.impl.js';

package/dist/src/server/domains/process/index.d.ts

@@ -1,2 +0,0 @@
-export { processToolDefinitions } from '../../domains/process/definitions.js';
-export { ProcessToolHandlers } from '../../domains/process/handlers.js';

package/dist/src/server/domains/process/index.js

@@ -1,2 +0,0 @@
-export { processToolDefinitions } from '../../domains/process/definitions.js';
-export { ProcessToolHandlers } from '../../domains/process/handlers.js';

package/dist/src/server/domains/process/manifest.d.ts

@@ -1,7 +0,0 @@
-import type { DomainManifest } from '../../domains/shared/registry.js';
-import { ProcessToolHandlers } from '../../domains/process/index.js';
-declare const DOMAIN: "process";
-declare const DEP_KEY: "processHandlers";
-type H = ProcessToolHandlers;
-declare const manifest: DomainManifest<typeof DEP_KEY, H, typeof DOMAIN>;
-export default manifest;

package/dist/src/server/domains/process/manifest.js

@@ -1,118 +0,0 @@
-import { bindByDepKey, toolLookup } from '../../domains/shared/registry.js';
-import { processToolDefinitions } from '../../domains/process/definitions.js';
-import { ProcessToolHandlers } from '../../domains/process/index.js';
-const DOMAIN = 'process';
-const DEP_KEY = 'processHandlers';
-const t = toolLookup(processToolDefinitions);
-const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
-const EFFECTIVE_PLATFORM = process.env.JSHOOK_REGISTRY_PLATFORM === 'win32' ||
-    process.env.JSHOOK_REGISTRY_PLATFORM === 'linux' ||
-    process.env.JSHOOK_REGISTRY_PLATFORM === 'darwin'
-    ? process.env.JSHOOK_REGISTRY_PLATFORM
-    : process.platform;
-function ensure(ctx) {
-    if (!ctx.processHandlers)
-        ctx.processHandlers = new ProcessToolHandlers();
-    return ctx.processHandlers;
-}
-const IS_WIN32 = EFFECTIVE_PLATFORM === 'win32';
-const WIN32_ONLY_TOOLS = new Set([
-    'inject_dll',
-    'module_inject_dll',
-    'inject_shellcode',
-    'module_inject_shellcode',
-    'check_debug_port',
-]);
-const allRegistrations = [
-    { tool: t('electron_attach'), domain: DOMAIN, bind: b((h, a) => h.handleElectronAttach(a)) },
-    { tool: t('process_find'), domain: DOMAIN, bind: b((h, a) => h.handleProcessFind(a)) },
-    {
-        tool: t('process_list'),
-        domain: DOMAIN,
-        bind: b((h, _a) => h.handleProcessFind({ pattern: '' })),
-    },
-    { tool: t('process_get'), domain: DOMAIN, bind: b((h, a) => h.handleProcessGet(a)) },
-    { tool: t('process_windows'), domain: DOMAIN, bind: b((h, a) => h.handleProcessWindows(a)) },
-    {
-        tool: t('process_find_chromium'),
-        domain: DOMAIN,
-        bind: b((h, a) => h.handleProcessFindChromium(a)),
-    },
-    {
-        tool: t('process_check_debug_port'),
-        domain: DOMAIN,
-        bind: b((h, a) => h.handleProcessCheckDebugPort(a)),
-    },
-    {
-        tool: t('process_launch_debug'),
-        domain: DOMAIN,
-        bind: b((h, a) => h.handleProcessLaunchDebug(a)),
-    },
-    { tool: t('process_kill'), domain: DOMAIN, bind: b((h, a) => h.handleProcessKill(a)) },
-    { tool: t('memory_read'), domain: DOMAIN, bind: b((h, a) => h.handleMemoryRead(a)) },
-    { tool: t('memory_write'), domain: DOMAIN, bind: b((h, a) => h.handleMemoryWrite(a)) },
-    { tool: t('memory_scan'), domain: DOMAIN, bind: b((h, a) => h.handleMemoryScan(a)) },
-    {
-        tool: t('memory_check_protection'),
-        domain: DOMAIN,
-        bind: b((h, a) => h.handleMemoryCheckProtection(a)),
-    },
-    {
-        tool: t('memory_protect'),
-        domain: DOMAIN,
-        bind: b((h, a) => h.handleMemoryCheckProtection(a)),
-    },
-    {
-        tool: t('memory_scan_filtered'),
-        domain: DOMAIN,
-        bind: b((h, a) => h.handleMemoryScanFiltered(a)),
-    },
-    {
-        tool: t('memory_batch_write'),
-        domain: DOMAIN,
-        bind: b((h, a) => h.handleMemoryBatchWrite(a)),
-    },
-    {
-        tool: t('memory_dump_region'),
-        domain: DOMAIN,
-        bind: b((h, a) => h.handleMemoryDumpRegion(a)),
-    },
-    {
-        tool: t('memory_list_regions'),
-        domain: DOMAIN,
-        bind: b((h, a) => h.handleMemoryListRegions(a)),
-    },
-    {
-        tool: t('memory_audit_export'),
-        domain: DOMAIN,
-        bind: b((h, a) => h.handleMemoryAuditExport(a)),
-    },
-    { tool: t('inject_dll'), domain: DOMAIN, bind: b((h, a) => h.handleInjectDll(a)) },
-    { tool: t('module_inject_dll'), domain: DOMAIN, bind: b((h, a) => h.handleInjectDll(a)) },
-    { tool: t('inject_shellcode'), domain: DOMAIN, bind: b((h, a) => h.handleInjectShellcode(a)) },
-    {
-        tool: t('module_inject_shellcode'),
-        domain: DOMAIN,
-        bind: b((h, a) => h.handleInjectShellcode(a)),
-    },
-    { tool: t('check_debug_port'), domain: DOMAIN, bind: b((h, a) => h.handleCheckDebugPort(a)) },
-    {
-        tool: t('enumerate_modules'),
-        domain: DOMAIN,
-        bind: b((h, a) => h.handleEnumerateModules(a)),
-    },
-    { tool: t('module_list'), domain: DOMAIN, bind: b((h, a) => h.handleEnumerateModules(a)) },
-];
-const registrations = IS_WIN32
-    ? allRegistrations
-    : allRegistrations.filter((r) => !WIN32_ONLY_TOOLS.has(r.tool.name));
-const manifest = {
-    kind: 'domain-manifest',
-    version: 1,
-    domain: DOMAIN,
-    depKey: DEP_KEY,
-    profiles: ['full'],
-    ensure,
-    registrations,
-};
-export default manifest;

package/dist/src/server/domains/sandbox/definitions.d.ts

@@ -1,2 +0,0 @@
-import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-export declare const sandboxTools: Tool[];

package/dist/src/server/domains/sandbox/definitions.js

@@ -1,13 +0,0 @@
-import { tool } from '../../registry/tool-builder.js';
-export const sandboxTools = [
-    tool('execute_sandbox_script')
-        .desc('Execute JavaScript in a WASM-isolated QuickJS sandbox with optional tool bridging and auto-correction')
-        .string('code', 'JavaScript source code to execute')
-        .string('sessionId', 'Session ID for scratchpad persistence across executions')
-        .number('timeoutMs', 'Execution timeout in ms', { default: 1000 })
-        .boolean('autoCorrect', 'Retry failed scripts up to 2 times with error context', {
-        default: false,
-    })
-        .required('code')
-        .build(),
-];

package/dist/src/server/domains/sandbox/handlers.d.ts

@@ -1,7 +0,0 @@
-import type { MCPServerContext } from '../../MCPServer.context.js';
-export declare class SandboxToolHandlers {
-    private readonly ctx;
-    private readonly scratchpad;
-    constructor(ctx: MCPServerContext);
-    handleExecuteSandboxScript(args: Record<string, unknown>): Promise<unknown>;
-}

package/dist/src/server/domains/sandbox/handlers.js

@@ -1,71 +0,0 @@
-import { QuickJSSandbox } from '../../sandbox/QuickJSSandbox.js';
-import { MCPBridge } from '../../sandbox/MCPBridge.js';
-import { SessionScratchpad } from '../../sandbox/SessionScratchpad.js';
-import { executeWithRetry } from '../../sandbox/AutoCorrectionLoop.js';
-export class SandboxToolHandlers {
-    ctx;
-    scratchpad = new SessionScratchpad();
-    constructor(ctx) {
-        this.ctx = ctx;
-    }
-    async handleExecuteSandboxScript(args) {
-        const code = args.code;
-        const sessionId = args.sessionId ?? undefined;
-        const timeoutMs = args.timeoutMs ?? undefined;
-        const autoCorrect = args.autoCorrect ?? false;
-        if (!code || typeof code !== 'string') {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({ ok: false, error: 'code parameter is required' }),
-                    },
-                ],
-            };
-        }
-        const sandbox = new QuickJSSandbox();
-        const bridge = new MCPBridge(this.ctx);
-        sandbox.setBridge(bridge);
-        const options = {};
-        if (timeoutMs !== undefined)
-            options.timeoutMs = timeoutMs;
-        if (sessionId) {
-            options.sessionId = sessionId;
-            const scratchpadState = this.scratchpad.getAll(sessionId);
-            options.globals = {
-                ...options.globals,
-                __scratchpad: scratchpadState,
-            };
-        }
-        let result;
-        if (autoCorrect) {
-            result = await executeWithRetry(sandbox, code, options);
-        }
-        else {
-            result = await sandbox.execute(code, options);
-        }
-        if (sessionId && result.ok && result.output && typeof result.output === 'object') {
-            const output = result.output;
-            if (output.__scratchpad && typeof output.__scratchpad === 'object') {
-                for (const [k, v] of Object.entries(output.__scratchpad)) {
-                    this.scratchpad.set(sessionId, k, v);
-                }
-            }
-        }
-        const summary = [
-            `**Status:** ${result.ok ? '✓ Success' : '✗ Failed'}`,
-            result.timedOut ? '**Timed out:** yes' : '',
-            `**Duration:** ${result.durationMs}ms`,
-            result.logs.length > 0
-                ? `**Console output:**\n\`\`\`\n${result.logs.join('\n')}\n\`\`\``
-                : '',
-            result.output !== undefined ? `**Result:** ${JSON.stringify(result.output)}` : '',
-            result.error ? `**Error:** ${result.error}` : '',
-        ]
-            .filter(Boolean)
-            .join('\n');
-        return {
-            content: [{ type: 'text', text: summary }],
-        };
-    }
-}

package/dist/src/server/domains/sandbox/index.d.ts

@@ -1,2 +0,0 @@
-export { sandboxTools } from '../../domains/sandbox/definitions.js';
-export { SandboxToolHandlers } from '../../domains/sandbox/handlers.js';

package/dist/src/server/domains/sandbox/index.js

@@ -1,2 +0,0 @@
-export { sandboxTools } from '../../domains/sandbox/definitions.js';
-export { SandboxToolHandlers } from '../../domains/sandbox/handlers.js';