@jshookmcp/jshook 0.2.6 → 0.2.7

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

@@ -1,57 +0,0 @@
-import { tool } from '../../registry/tool-builder.js';
-export const wasmTools = [
-    tool('wasm_dump')
-        .desc('Dump a WebAssembly module from the current browser page.\n\nExtracts the WASM binary via the webassembly-full hook preset, saves it to disk, and returns module metadata (hash, size, imports, exports).\n\nPrerequisites: A page with WASM must be loaded. The webassembly-full hook preset will be auto-injected if not already active.')
-        .number('moduleIndex', 'Index of the WASM module to dump if multiple were loaded', {
-        default: 0,
-    })
-        .string('outputPath', 'Custom output file path. If omitted, auto-generates in artifacts/wasm/')
-        .build(),
-    tool('wasm_disassemble')
-        .desc('Disassemble a .wasm file to WebAssembly Text Format (WAT) using wasm2wat.\n\nRequires: wabt toolchain installed (wasm2wat in PATH).\n\nUSE THIS to read WASM bytecode as human-readable text. The output shows all functions, imports, exports, and instructions.')
-        .string('inputPath', 'Path to the .wasm file to disassemble')
-        .string('outputPath', 'Output .wat file path. If omitted, auto-generates in artifacts/wasm/')
-        .boolean('foldExprs', 'Fold expressions for more compact output', { default: true })
-        .required('inputPath')
-        .build(),
-    tool('wasm_decompile')
-        .desc('Decompile a .wasm file to C-like pseudo-code using wasm-decompile.\n\nRequires: wabt toolchain installed (wasm-decompile in PATH).\n\nProduces more readable output than WAT, resembling C/JavaScript syntax. Useful for understanding VMP handler logic.')
-        .string('inputPath', 'Path to the .wasm file to decompile')
-        .string('outputPath', 'Output file path. If omitted, auto-generates in artifacts/wasm/')
-        .required('inputPath')
-        .build(),
-    tool('wasm_inspect_sections')
-        .desc('Inspect sections and metadata of a .wasm file using wasm-objdump.\n\nRequires: wabt toolchain installed (wasm-objdump in PATH).\n\nReturns section headers, import/export tables, function signatures, and memory layout.')
-        .string('inputPath', 'Path to the .wasm file to inspect')
-        .enum('sections', ['headers', 'details', 'disassemble', 'all'], 'What to dump: headers (section overview), details (full metadata), disassemble (bytecode), all', { default: 'details' })
-        .required('inputPath')
-        .build(),
-    tool('wasm_offline_run')
-        .desc('Execute a specific exported function from a .wasm file offline using wasmtime or wasmer.\n\nRequires: wasmtime or wasmer installed in PATH.\n\nUSE THIS to run sign/encrypt functions extracted from WASM VMP without a browser. Provide the function name and arguments.\n\nSecurity: Runs in a sandboxed WASM runtime with no filesystem or network access.')
-        .string('inputPath', 'Path to the .wasm file')
-        .string('functionName', 'Name of the exported function to invoke (e.g., "_sign", "encrypt")')
-        .array('args', { type: 'string' }, 'Arguments to pass to the function (will be parsed as integers/floats)')
-        .enum('runtime', ['wasmtime', 'wasmer', 'auto'], 'WASM runtime to use. "auto" tries wasmtime first, then wasmer', { default: 'auto' })
-        .number('timeoutMs', 'Execution timeout in ms', { default: 10000 })
-        .required('inputPath', 'functionName')
-        .build(),
-    tool('wasm_optimize')
-        .desc('Optimize a .wasm file using binaryen wasm-opt.\n\nRequires: binaryen toolchain installed (wasm-opt in PATH).\n\nApplies optimization passes (dead code elimination, constant folding, etc.) to reduce size and improve performance. Optimized output can be re-injected into the browser.')
-        .string('inputPath', 'Path to the .wasm file to optimize')
-        .string('outputPath', 'Output optimized .wasm file path. If omitted, auto-generates in artifacts/wasm/')
-        .enum('level', ['O1', 'O2', 'O3', 'O4', 'Os', 'Oz'], 'Optimization level', { default: 'O2' })
-        .required('inputPath')
-        .build(),
-    tool('wasm_vmp_trace')
-        .desc('Trace WASM VMP (Virtual Machine Protection) opcode execution.\n\nCombines the webassembly-full hook preset with enhanced import call tracing to reconstruct VMP handler tables and execution flows.\n\nUSE THIS when a page uses WASM-based VMP to protect sign/encrypt functions. Returns:\n- Import call sequence (opcode trace)\n- Identified handler patterns\n- Input→output data flow')
-        .number('maxEvents', 'Maximum import call events to capture', { default: 5000 })
-        .string('filterModule', 'Only trace calls to this import module name (e.g., "env", "wasi_snapshot_preview1")')
-        .build(),
-    tool('wasm_memory_inspect')
-        .desc('Inspect WebAssembly.Memory contents from the browser.\n\nReads the linear memory buffer of the active WASM module, displaying it as hex dump, ASCII, or searching for patterns.\n\nUSE THIS to:\n- Examine WASM memory layout (stack, heap, data segments)\n- Find strings, keys, or encoded data in WASM memory\n- Track how input data is transformed through WASM functions')
-        .number('offset', 'Starting byte offset to read from', { default: 0 })
-        .number('length', 'Number of bytes to read', { default: 256 })
-        .enum('format', ['hex', 'ascii', 'both'], 'Output format', { default: 'both' })
-        .string('searchPattern', 'Search for this hex pattern or ASCII string in the memory range')
-        .build(),
-];

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

@@ -1,56 +0,0 @@
-import type { CodeCollector } from '../../domains/shared/modules.js';
-export declare class WasmToolHandlers {
-    private runner;
-    private registry;
-    private collector;
-    constructor(collector: CodeCollector);
-    private validateOutputPath;
-    handleWasmDump(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleWasmDisassemble(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleWasmDecompile(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleWasmInspectSections(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleWasmOfflineRun(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleWasmOptimize(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleWasmVmpTrace(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-    handleWasmMemoryInspect(args: Record<string, unknown>): Promise<{
-        content: {
-            type: string;
-            text: string;
-        }[];
-    }>;
-}

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

@@ -1,571 +0,0 @@
-import { writeFile, stat } from 'node:fs/promises';
-import { createHash } from 'node:crypto';
-import { resolve, normalize, sep } from 'node:path';
-import { tmpdir } from 'node:os';
-import { resolveArtifactPath } from '../../../utils/artifacts.js';
-import { ExternalToolRunner } from '../../domains/shared/modules.js';
-import { ToolRegistry } from '../../domains/shared/modules.js';
-import { argNumber, argString, argStringRequired, argBool, argStringArray, } from '../../domains/shared/parse-args.js';
-const isRecord = (value) => typeof value === 'object' && value !== null;
-const hasErrorResult = (value) => isRecord(value) && typeof value.error === 'string';
-export class WasmToolHandlers {
-    runner;
-    registry;
-    collector;
-    constructor(collector) {
-        this.collector = collector;
-        this.registry = new ToolRegistry();
-        this.runner = new ExternalToolRunner(this.registry);
-    }
-    validateOutputPath(outputPath) {
-        const safe = resolve(outputPath);
-        const cwd = normalize(process.cwd());
-        const tmp = normalize(tmpdir());
-        if (!safe.startsWith(`${cwd}${sep}`) && !safe.startsWith(`${tmp}${sep}`)) {
-            throw new Error('Path traversal blocked: outputPath must be under project root or temp directory');
-        }
-        return safe;
-    }
-    async handleWasmDump(args) {
-        const moduleIndex = argNumber(args, 'moduleIndex', 0);
-        const outputPath = argString(args, 'outputPath');
-        const page = await this.collector.getActivePage();
-        const result = await page.evaluate((idx) => {
-            const win = window;
-            const hooksRaw = win.__aiHooks?.['preset-webassembly-full'];
-            if (!Array.isArray(hooksRaw) || hooksRaw.length === 0) {
-                return {
-                    error: 'No WASM modules captured. Ensure the webassembly-full hook preset is active and the page has loaded WASM.',
-                };
-            }
-            const hooks = hooksRaw;
-            const instantiatedEvents = hooks.filter((e) => e.type === 'instantiated');
-            if (idx >= instantiatedEvents.length) {
-                return {
-                    error: `Module index ${idx} out of range. Found ${instantiatedEvents.length} instantiated modules.`,
-                };
-            }
-            const event = instantiatedEvents[idx];
-            return {
-                exports: event.exports,
-                importMods: event.importMods,
-                size: event.size,
-                moduleCount: instantiatedEvents.length,
-            };
-        }, moduleIndex);
-        if (hasErrorResult(result)) {
-            return {
-                content: [{ type: 'text', text: JSON.stringify({ success: false, error: result.error }) }],
-            };
-        }
-        const wasmBytes = await page.evaluate((idx) => {
-            const win = window;
-            const storage = win.__wasmModuleStorage;
-            if (!storage?.[idx]) {
-                return null;
-            }
-            const buffer = storage[idx];
-            return Array.from(new Uint8Array(buffer));
-        }, moduleIndex);
-        let savedPath;
-        let hash;
-        if (wasmBytes) {
-            const buffer = Buffer.from(wasmBytes);
-            hash = createHash('sha256').update(buffer).digest('hex').substring(0, 16);
-            if (outputPath) {
-                const safePath = this.validateOutputPath(outputPath);
-                await writeFile(safePath, buffer);
-                savedPath = safePath;
-            }
-            else {
-                const { absolutePath, displayPath } = await resolveArtifactPath({
-                    category: 'wasm',
-                    toolName: 'wasm-dump',
-                    target: hash,
-                    ext: 'wasm',
-                });
-                await writeFile(absolutePath, buffer);
-                savedPath = displayPath;
-            }
-        }
-        else {
-            savedPath = '(binary not available — hook did not store raw bytes)';
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: true,
-                        artifactPath: savedPath,
-                        hash,
-                        size: result.size,
-                        exports: result.exports,
-                        importModules: result.importMods,
-                        totalModules: result.moduleCount,
-                        hint: wasmBytes
-                            ? 'Use wasm_disassemble or wasm_decompile on the dumped file for further analysis.'
-                            : 'Binary not captured. Inject hook_preset("webassembly-full") BEFORE page navigation, with window.__wasmModuleStorage patching.',
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    async handleWasmDisassemble(args) {
-        const inputPath = argStringRequired(args, 'inputPath');
-        const outputPath = argString(args, 'outputPath');
-        const foldExprs = argBool(args, 'foldExprs', true);
-        const toolArgs = [inputPath, '-o', '/dev/stdout'];
-        if (foldExprs)
-            toolArgs.push('--fold-exprs');
-        const result = await this.runner.run({
-            tool: 'wabt.wasm2wat',
-            args: toolArgs,
-            timeoutMs: 60_000,
-        });
-        if (!result.ok) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: result.stderr,
-                            exitCode: result.exitCode,
-                        }),
-                    },
-                ],
-            };
-        }
-        let savedPath;
-        if (outputPath) {
-            const safePath = this.validateOutputPath(outputPath);
-            await writeFile(safePath, result.stdout, 'utf-8');
-            savedPath = safePath;
-        }
-        else {
-            const { absolutePath, displayPath } = await resolveArtifactPath({
-                category: 'wasm',
-                toolName: 'wasm-disassemble',
-                ext: 'wat',
-            });
-            await writeFile(absolutePath, result.stdout, 'utf-8');
-            savedPath = displayPath;
-        }
-        const lines = result.stdout.split('\n');
-        const preview = lines.slice(0, 50).join('\n');
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: true,
-                        artifactPath: savedPath,
-                        totalLines: lines.length,
-                        sizeBytes: result.stdout.length,
-                        preview: preview + (lines.length > 50 ? '\n... (truncated)' : ''),
-                        durationMs: result.durationMs,
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    async handleWasmDecompile(args) {
-        const inputPath = argStringRequired(args, 'inputPath');
-        const outputPath = argString(args, 'outputPath');
-        const result = await this.runner.run({
-            tool: 'wabt.wasm-decompile',
-            args: [inputPath, '-o', '/dev/stdout'],
-            timeoutMs: 60_000,
-        });
-        if (!result.ok) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: result.stderr,
-                            exitCode: result.exitCode,
-                        }),
-                    },
-                ],
-            };
-        }
-        let savedPath;
-        if (outputPath) {
-            const safePath = this.validateOutputPath(outputPath);
-            await writeFile(safePath, result.stdout, 'utf-8');
-            savedPath = safePath;
-        }
-        else {
-            const { absolutePath, displayPath } = await resolveArtifactPath({
-                category: 'wasm',
-                toolName: 'wasm-decompile',
-                ext: 'dcmp',
-            });
-            await writeFile(absolutePath, result.stdout, 'utf-8');
-            savedPath = displayPath;
-        }
-        const lines = result.stdout.split('\n');
-        const preview = lines.slice(0, 60).join('\n');
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: true,
-                        artifactPath: savedPath,
-                        totalLines: lines.length,
-                        preview: preview + (lines.length > 60 ? '\n... (truncated)' : ''),
-                        durationMs: result.durationMs,
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    async handleWasmInspectSections(args) {
-        const inputPath = argStringRequired(args, 'inputPath');
-        const sections = argString(args, 'sections', 'details');
-        const flagMap = {
-            headers: '-h',
-            details: '-x',
-            disassemble: '-d',
-            all: '-h -x -d',
-        };
-        const flags = (flagMap[sections] || '-x').split(' ');
-        const result = await this.runner.run({
-            tool: 'wabt.wasm-objdump',
-            args: [...flags, inputPath],
-            timeoutMs: 60_000,
-        });
-        if (!result.ok) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: result.stderr,
-                            exitCode: result.exitCode,
-                        }),
-                    },
-                ],
-            };
-        }
-        const lines = result.stdout.split('\n');
-        const preview = lines.slice(0, 100).join('\n');
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: true,
-                        totalLines: lines.length,
-                        preview: preview + (lines.length > 100 ? '\n... (truncated)' : ''),
-                        durationMs: result.durationMs,
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    async handleWasmOfflineRun(args) {
-        const inputPath = argStringRequired(args, 'inputPath');
-        const functionName = argStringRequired(args, 'functionName');
-        const fnArgs = argStringArray(args, 'args');
-        const runtime = argString(args, 'runtime', 'auto');
-        const timeoutMs = argNumber(args, 'timeoutMs', 10_000);
-        let toolName;
-        if (runtime === 'auto') {
-            const probes = await this.runner.probeAll();
-            if (probes['runtime.wasmtime']?.available) {
-                toolName = 'runtime.wasmtime';
-            }
-            else if (probes['runtime.wasmer']?.available) {
-                toolName = 'runtime.wasmer';
-            }
-            else {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: false,
-                                error: 'No WASM runtime found. Install wasmtime or wasmer.',
-                            }),
-                        },
-                    ],
-                };
-            }
-        }
-        else {
-            toolName = runtime === 'wasmer' ? 'runtime.wasmer' : 'runtime.wasmtime';
-        }
-        const runArgs = toolName === 'runtime.wasmtime'
-            ? ['run', '--invoke', functionName, inputPath, ...fnArgs]
-            : ['run', inputPath, '--invoke', functionName, '--', ...fnArgs];
-        const result = await this.runner.run({
-            tool: toolName,
-            args: runArgs,
-            timeoutMs,
-        });
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: result.ok,
-                        runtime: toolName,
-                        functionName,
-                        args: fnArgs,
-                        output: result.stdout.trim(),
-                        stderr: result.stderr.trim() || undefined,
-                        exitCode: result.exitCode,
-                        durationMs: result.durationMs,
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    async handleWasmOptimize(args) {
-        const inputPath = argStringRequired(args, 'inputPath');
-        const outputPath = argString(args, 'outputPath');
-        const level = argString(args, 'level', 'O2');
-        let destPath;
-        if (outputPath) {
-            destPath = this.validateOutputPath(outputPath);
-        }
-        else {
-            const { absolutePath } = await resolveArtifactPath({
-                category: 'wasm',
-                toolName: 'wasm-opt',
-                ext: 'wasm',
-            });
-            destPath = absolutePath;
-        }
-        const result = await this.runner.run({
-            tool: 'binaryen.wasm-opt',
-            args: [`-${level}`, inputPath, '-o', destPath],
-            timeoutMs: 120_000,
-        });
-        if (!result.ok) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: result.stderr,
-                            exitCode: result.exitCode,
-                        }),
-                    },
-                ],
-            };
-        }
-        let inputSize = 0;
-        let outputSize = 0;
-        try {
-            inputSize = (await stat(inputPath)).size;
-            outputSize = (await stat(destPath)).size;
-        }
-        catch {
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: true,
-                        artifactPath: destPath,
-                        optimizationLevel: level,
-                        inputSizeBytes: inputSize,
-                        outputSizeBytes: outputSize,
-                        reductionPercent: inputSize > 0 ? ((1 - outputSize / inputSize) * 100).toFixed(1) : '0',
-                        durationMs: result.durationMs,
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    async handleWasmVmpTrace(args) {
-        const maxEvents = argNumber(args, 'maxEvents', 5000);
-        const filterModule = argString(args, 'filterModule');
-        const page = await this.collector.getActivePage();
-        const traceData = await page.evaluate((opts) => {
-            const win = window;
-            const hooksRaw = win.__aiHooks?.['preset-webassembly-full'];
-            if (!Array.isArray(hooksRaw) || hooksRaw.length === 0) {
-                return {
-                    error: 'No WASM hook data. Inject hook_preset("webassembly-full") and reload the page.',
-                };
-            }
-            const hooks = hooksRaw;
-            let importCalls = hooks.filter((e) => e.type === 'import_call');
-            if (opts.filterModule) {
-                importCalls = importCalls.filter((e) => e.mod === opts.filterModule);
-            }
-            const limited = importCalls.slice(0, opts.maxEvents);
-            const fnCounts = {};
-            for (const call of limited) {
-                const key = `${String(call.mod)}.${String(call.fn)}`;
-                fnCounts[key] = (fnCounts[key] || 0) + 1;
-            }
-            const sorted = Object.entries(fnCounts)
-                .toSorted((a, b) => b[1] - a[1])
-                .slice(0, 30)
-                .map(([name, count]) => ({ name, count }));
-            return {
-                totalEvents: importCalls.length,
-                capturedEvents: limited.length,
-                topFunctions: sorted,
-                trace: limited.slice(0, 200).map((e) => ({
-                    mod: e.mod,
-                    fn: e.fn,
-                    args: e.args,
-                    ts: e.ts,
-                })),
-            };
-        }, { maxEvents, filterModule });
-        if (hasErrorResult(traceData)) {
-            return {
-                content: [
-                    { type: 'text', text: JSON.stringify({ success: false, error: traceData.error }) },
-                ],
-            };
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: true,
-                        ...traceData,
-                        hint: 'Top functions show VMP handler dispatch patterns. Use wasm_disassemble to analyze their implementation.',
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    async handleWasmMemoryInspect(args) {
-        const offset = argNumber(args, 'offset', 0);
-        const length = Math.min(argNumber(args, 'length', 256), 65536);
-        const format = argString(args, 'format', 'both');
-        const searchPattern = argString(args, 'searchPattern');
-        const page = await this.collector.getActivePage();
-        const memData = await page.evaluate((opts) => {
-            const win = window;
-            const hooksRaw = win.__aiHooks?.['preset-webassembly-full'];
-            const hooks = Array.isArray(hooksRaw) ? hooksRaw : [];
-            const memoryEvents = hooks.filter((e) => e.type === 'memory_created');
-            const instances = win.__wasmInstances;
-            if (!Array.isArray(instances) || instances.length === 0) {
-                return {
-                    error: 'No WASM memory available. Ensure the webassembly-full hook is active and a WASM module is instantiated.',
-                };
-            }
-            try {
-                const firstInstance = instances[0];
-                const memory = firstInstance.exports?.memory;
-                if (!memory?.buffer) {
-                    return { error: 'WASM module has no exported memory.' };
-                }
-                const buffer = new Uint8Array(memory.buffer);
-                const slice = Array.from(buffer.slice(opts.offset, opts.offset + opts.length));
-                let searchResults;
-                if (opts.searchPattern) {
-                    searchResults = [];
-                    const pattern = opts.searchPattern;
-                    const isHex = /^[0-9a-fA-F\s]+$/.test(pattern);
-                    if (isHex) {
-                        const hexBytes = pattern
-                            .replace(/\s/g, '')
-                            .match(/.{2}/g)
-                            ?.map((h) => parseInt(h, 16)) || [];
-                        for (let i = opts.offset; i <=
-                            Math.min(opts.offset + opts.length - hexBytes.length, buffer.length - hexBytes.length); i++) {
-                            let match = true;
-                            for (let j = 0; j < hexBytes.length; j++) {
-                                if (buffer[i + j] !== hexBytes[j]) {
-                                    match = false;
-                                    break;
-                                }
-                            }
-                            if (match)
-                                searchResults.push({ offset: i });
-                        }
-                    }
-                    else {
-                        const encoder = new TextEncoder();
-                        const patternBytes = encoder.encode(pattern);
-                        for (let i = opts.offset; i <=
-                            Math.min(opts.offset + opts.length - patternBytes.length, buffer.length - patternBytes.length); i++) {
-                            let match = true;
-                            for (let j = 0; j < patternBytes.length; j++) {
-                                if (buffer[i + j] !== patternBytes[j]) {
-                                    match = false;
-                                    break;
-                                }
-                            }
-                            if (match)
-                                searchResults.push({ offset: i });
-                        }
-                    }
-                }
-                return {
-                    totalMemoryPages: memory.buffer.byteLength / 65536,
-                    totalMemoryBytes: memory.buffer.byteLength,
-                    requestedOffset: opts.offset,
-                    requestedLength: opts.length,
-                    data: slice,
-                    searchResults,
-                    memoryInfo: memoryEvents[0] || null,
-                };
-            }
-            catch (e) {
-                const message = e instanceof Error ? e.message : String(e);
-                return { error: `Failed to read WASM memory: ${message}` };
-            }
-        }, { offset, length, searchPattern });
-        if (hasErrorResult(memData)) {
-            return {
-                content: [{ type: 'text', text: JSON.stringify({ success: false, error: memData.error }) }],
-            };
-        }
-        const data = memData.data;
-        let hexDump = '';
-        let asciiDump = '';
-        if (format === 'hex' || format === 'both') {
-            for (let i = 0; i < data.length; i += 16) {
-                const row = data.slice(i, i + 16);
-                const addr = (offset + i).toString(16).padStart(8, '0');
-                const hex = row.map((b) => b.toString(16).padStart(2, '0')).join(' ');
-                const ascii = row
-                    .map((b) => (b >= 0x20 && b < 0x7f ? String.fromCharCode(b) : '.'))
-                    .join('');
-                hexDump += `${addr}  ${hex.padEnd(48)}  |${ascii}|\n`;
-            }
-        }
-        if (format === 'ascii') {
-            asciiDump = data
-                .map((b) => (b >= 0x20 && b < 0x7f ? String.fromCharCode(b) : '.'))
-                .join('');
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: true,
-                        totalMemoryPages: memData.totalMemoryPages,
-                        totalMemoryBytes: memData.totalMemoryBytes,
-                        offset,
-                        length: data.length,
-                        hexDump: format !== 'ascii' ? hexDump : undefined,
-                        asciiDump: format === 'ascii' ? asciiDump : undefined,
-                        searchResults: memData.searchResults,
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-}

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

@@ -1,2 +0,0 @@
-export { wasmTools } from '../../domains/wasm/definitions.js';
-export { WasmToolHandlers } from '../../domains/wasm/handlers.js';