@jshookmcp/jshook 0.2.5 → 0.2.7

package/dist/src/modules/external/ExternalToolRunner.js

@@ -1,174 +0,0 @@
-import { spawn } from 'node:child_process';
-import { resolve, relative, sep, isAbsolute } from 'node:path';
-import { getProjectRoot } from '../../utils/outputPaths.js';
-import { logger } from '../../utils/logger.js';
-import { ioLimit } from '../../utils/concurrency.js';
-import {} from '../external/ToolRegistry.js';
-import { EXTERNAL_TOOL_TIMEOUT_MS, EXTERNAL_TOOL_MAX_STDOUT_BYTES, EXTERNAL_TOOL_MAX_STDERR_BYTES, EXTERNAL_TOOL_FORCE_KILL_GRACE_MS, } from '../../constants.js';
-const DEFAULT_TIMEOUT_MS = EXTERNAL_TOOL_TIMEOUT_MS;
-const DEFAULT_MAX_STDOUT = EXTERNAL_TOOL_MAX_STDOUT_BYTES;
-const DEFAULT_MAX_STDERR = EXTERNAL_TOOL_MAX_STDERR_BYTES;
-export class ExternalToolRunner {
-    registry;
-    constructor(registry) {
-        this.registry = registry;
-    }
-    async probeAll(force = false) {
-        return this.registry.probeAll(force);
-    }
-    async run(request) {
-        return ioLimit(() => this._run(request));
-    }
-    async _run(request) {
-        const spec = this.registry.getSpec(request.tool);
-        const probe = this.registry.getCachedProbe(request.tool);
-        if (probe && !probe.available) {
-            return {
-                ok: false,
-                exitCode: null,
-                signal: null,
-                stdout: '',
-                stderr: `Tool '${request.tool}' (${spec.command}) is not available: ${probe.reason}`,
-                durationMs: 0,
-                truncated: false,
-            };
-        }
-        const cwd = this.validateCwd(request.cwd);
-        const args = [...(spec.defaultArgs || []), ...request.args];
-        const env = { PATH: process.env.PATH || '' };
-        if (process.platform === 'win32') {
-            const systemRoot = process.env.SYSTEMROOT || process.env.SystemRoot || process.env.WINDIR;
-            if (systemRoot) {
-                env.SYSTEMROOT = systemRoot;
-            }
-            if (process.env.TEMP) {
-                env.TEMP = process.env.TEMP;
-            }
-            if (process.env.TMP) {
-                env.TMP = process.env.TMP;
-            }
-        }
-        if (spec.envAllowlist) {
-            for (const key of spec.envAllowlist) {
-                if (process.env[key]) {
-                    env[key] = process.env[key];
-                }
-            }
-        }
-        const timeoutMs = request.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-        const maxStdout = request.maxStdoutBytes ?? DEFAULT_MAX_STDOUT;
-        const maxStderr = request.maxStderrBytes ?? DEFAULT_MAX_STDERR;
-        logger.debug(`[ExternalToolRunner] Running: ${spec.command} ${args.join(' ')}`);
-        const startTime = Date.now();
-        return new Promise((resolvePromise) => {
-            const child = spawn(spec.command, args, {
-                cwd,
-                env,
-                shell: false,
-                windowsHide: true,
-                stdio: ['pipe', 'pipe', 'pipe'],
-            });
-            let stdout = '';
-            let stderr = '';
-            let stdoutTruncated = false;
-            let stderrTruncated = false;
-            let settled = false;
-            const timeoutHandle = setTimeout(() => {
-                if (!settled) {
-                    child.kill('SIGTERM');
-                    setTimeout(() => {
-                        if (!settled) {
-                            child.kill('SIGKILL');
-                            finish(null, 'SIGKILL');
-                        }
-                    }, EXTERNAL_TOOL_FORCE_KILL_GRACE_MS);
-                    request.onProgress?.({ phase: 'timeout', ts: Date.now() });
-                }
-            }, timeoutMs);
-            const finish = (exitCode, signal) => {
-                if (settled)
-                    return;
-                settled = true;
-                clearTimeout(timeoutHandle);
-                const durationMs = Date.now() - startTime;
-                const result = {
-                    ok: exitCode === 0,
-                    exitCode,
-                    signal,
-                    stdout,
-                    stderr,
-                    durationMs,
-                    truncated: stdoutTruncated || stderrTruncated,
-                };
-                if (result.ok) {
-                    logger.debug(`[ExternalToolRunner] ${spec.command} completed in ${durationMs}ms`);
-                }
-                else {
-                    logger.warn(`[ExternalToolRunner] ${spec.command} failed (exit=${exitCode}, signal=${signal}) in ${durationMs}ms`);
-                }
-                resolvePromise(result);
-            };
-            if (request.stdin) {
-                child.stdin.write(request.stdin);
-                child.stdin.end();
-            }
-            else {
-                child.stdin.end();
-            }
-            child.stdout.on('data', (chunk) => {
-                if (stdout.length < maxStdout) {
-                    const remaining = maxStdout - stdout.length;
-                    stdout += chunk.toString('utf-8', 0, Math.min(chunk.length, remaining));
-                    if (stdout.length >= maxStdout)
-                        stdoutTruncated = true;
-                }
-                request.onProgress?.({
-                    phase: 'stdout',
-                    bytesRead: stdout.length,
-                    ts: Date.now(),
-                });
-            });
-            child.stderr.on('data', (chunk) => {
-                if (stderr.length < maxStderr) {
-                    const remaining = maxStderr - stderr.length;
-                    stderr += chunk.toString('utf-8', 0, Math.min(chunk.length, remaining));
-                    if (stderr.length >= maxStderr)
-                        stderrTruncated = true;
-                }
-                request.onProgress?.({
-                    phase: 'stderr',
-                    bytesRead: stderr.length,
-                    ts: Date.now(),
-                });
-            });
-            child.on('close', (code, signal) => {
-                finish(code, signal);
-            });
-            child.on('error', (err) => {
-                stderr += `\nSpawn error: ${err.message}`;
-                finish(1, null);
-            });
-            request.onProgress?.({ phase: 'spawn', ts: Date.now() });
-        });
-    }
-    validateCwd(requestedCwd) {
-        if (!requestedCwd) {
-            return getProjectRoot();
-        }
-        const resolved = resolve(requestedCwd);
-        const projectRoot = getProjectRoot();
-        const rel = relative(projectRoot, resolved);
-        if (rel && !rel.startsWith('..') && !isAbsolute(rel) && !resolve(rel).startsWith(sep)) {
-            return resolved;
-        }
-        const tmpDirs = [process.env.TEMP, process.env.TMP, '/tmp', '/var/tmp'].filter(Boolean);
-        for (const tmp of tmpDirs) {
-            const resolvedTmp = resolve(tmp);
-            if (resolved === resolvedTmp || resolved.startsWith(resolvedTmp + sep)) {
-                return resolved;
-            }
-        }
-        logger.warn(`[ExternalToolRunner] CWD '${requestedCwd}' outside allowed boundaries, using project root`);
-        return projectRoot;
-    }
-}

package/dist/src/modules/external/ToolProbe.d.ts

@@ -1,11 +0,0 @@
-export interface ProbeResult {
-    available: boolean;
-    path?: string;
-    version?: string;
-    reason?: string;
-}
-export declare function probeCommand(command: string, versionArgs?: string[], timeoutMs?: number): Promise<ProbeResult>;
-export declare function probeAll(specs: Array<{
-    command: string;
-    versionArgs?: string[];
-}>): Promise<Map<string, ProbeResult>>;

package/dist/src/modules/external/ToolProbe.js

@@ -1,58 +0,0 @@
-import { EXTERNAL_TOOL_PROBE_TIMEOUT_MS } from '../../constants.js';
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import { logger } from '../../utils/logger.js';
-const execFileAsync = promisify(execFile);
-export async function probeCommand(command, versionArgs = ['--version'], timeoutMs = EXTERNAL_TOOL_PROBE_TIMEOUT_MS) {
-    try {
-        const whichCmd = process.platform === 'win32' ? 'where' : 'which';
-        const { stdout: pathOutput } = await execFileAsync(whichCmd, [command], {
-            timeout: timeoutMs,
-            windowsHide: true,
-        });
-        const resolvedPath = pathOutput.trim().split(/\r?\n/)[0];
-        let version;
-        try {
-            const { stdout: versionOutput } = await execFileAsync(command, versionArgs, {
-                timeout: timeoutMs,
-                windowsHide: true,
-            });
-            const firstLine = versionOutput.trim().split(/\r?\n/)[0];
-            version = firstLine ? firstLine.substring(0, 100) : undefined;
-        }
-        catch {
-        }
-        return { available: true, path: resolvedPath, version };
-    }
-    catch (err) {
-        const errorCode = typeof err === 'object' && err !== null && 'code' in err
-            ? err.code
-            : undefined;
-        const errorMessage = err instanceof Error
-            ? err.message
-            : typeof err === 'object' && err !== null && 'message' in err
-                ? String(err.message ?? '')
-                : String(err ?? '');
-        return {
-            available: false,
-            reason: errorCode === 'ENOENT'
-                ? `Command '${command}' not found in PATH`
-                : `Probe failed: ${errorMessage.substring(0, 200)}`,
-        };
-    }
-}
-export async function probeAll(specs) {
-    const results = new Map();
-    const promises = specs.map(async (spec) => {
-        const result = await probeCommand(spec.command, spec.versionArgs);
-        results.set(spec.command, result);
-        if (result.available) {
-            logger.debug(`[ToolProbe] ${spec.command}: available at ${result.path} (${result.version || 'unknown version'})`);
-        }
-        else {
-            logger.debug(`[ToolProbe] ${spec.command}: not available — ${result.reason}`);
-        }
-    });
-    await Promise.all(promises);
-    return results;
-}

package/dist/src/modules/external/ToolRegistry.d.ts

@@ -1,15 +0,0 @@
-import type { ExternalToolName, ExternalToolSpec } from '../external/types.js';
-import { type ProbeResult } from '../external/ToolProbe.js';
-export declare class ToolRegistry {
-    private specs;
-    private probeCache;
-    private probeCacheExpiry;
-    private readonly PROBE_CACHE_TTL;
-    constructor(additionalSpecs?: ExternalToolSpec[]);
-    getSpec(name: ExternalToolName): ExternalToolSpec;
-    isRegistered(name: string): name is ExternalToolName;
-    getRegisteredTools(): ExternalToolName[];
-    probeAll(force?: boolean): Promise<Record<ExternalToolName, ProbeResult>>;
-    getCachedProbe(name: ExternalToolName): ProbeResult | undefined;
-    register(spec: ExternalToolSpec): void;
-}

package/dist/src/modules/external/ToolRegistry.js

@@ -1,117 +0,0 @@
-import { EXTERNAL_TOOL_PROBE_CACHE_TTL_MS } from '../../constants.js';
-import { probeCommand } from '../external/ToolProbe.js';
-import { logger } from '../../utils/logger.js';
-const DEFAULT_SPECS = [
-    {
-        name: 'wabt.wasm2wat',
-        command: 'wasm2wat',
-        versionArgs: ['--version'],
-        required: false,
-        envAllowlist: [],
-    },
-    {
-        name: 'wabt.wasm-objdump',
-        command: 'wasm-objdump',
-        versionArgs: ['--version'],
-        required: false,
-        envAllowlist: [],
-    },
-    {
-        name: 'wabt.wasm-decompile',
-        command: 'wasm-decompile',
-        versionArgs: ['--version'],
-        required: false,
-        envAllowlist: [],
-    },
-    {
-        name: 'binaryen.wasm-opt',
-        command: 'wasm-opt',
-        versionArgs: ['--version'],
-        required: false,
-        envAllowlist: [],
-    },
-    {
-        name: 'runtime.wasmtime',
-        command: 'wasmtime',
-        versionArgs: ['--version'],
-        required: false,
-        envAllowlist: [],
-    },
-    {
-        name: 'runtime.wasmer',
-        command: 'wasmer',
-        versionArgs: ['--version'],
-        required: false,
-        envAllowlist: [],
-    },
-    {
-        name: 'miniapp.unpacker',
-        command: 'unveilr',
-        versionArgs: ['--version'],
-        required: false,
-        envAllowlist: [],
-    },
-    {
-        name: 'platform.jadx',
-        command: 'jadx',
-        versionArgs: ['--version'],
-        required: false,
-        envAllowlist: [],
-    },
-];
-export class ToolRegistry {
-    specs = new Map();
-    probeCache = new Map();
-    probeCacheExpiry = 0;
-    PROBE_CACHE_TTL = EXTERNAL_TOOL_PROBE_CACHE_TTL_MS;
-    constructor(additionalSpecs) {
-        for (const spec of DEFAULT_SPECS) {
-            this.specs.set(spec.name, spec);
-        }
-        if (additionalSpecs) {
-            for (const spec of additionalSpecs) {
-                this.specs.set(spec.name, spec);
-            }
-        }
-    }
-    getSpec(name) {
-        const spec = this.specs.get(name);
-        if (!spec) {
-            throw new Error(`Tool '${name}' is not registered in the allowlist`);
-        }
-        return spec;
-    }
-    isRegistered(name) {
-        return this.specs.has(name);
-    }
-    getRegisteredTools() {
-        return Array.from(this.specs.keys());
-    }
-    async probeAll(force = false) {
-        const now = Date.now();
-        if (!force && this.probeCache.size > 0 && now < this.probeCacheExpiry) {
-            return Object.fromEntries(this.probeCache);
-        }
-        const results = {};
-        const promises = [];
-        for (const [name, spec] of this.specs) {
-            promises.push(probeCommand(spec.command, spec.versionArgs).then((result) => {
-                results[name] = result;
-                this.probeCache.set(name, result);
-            }));
-        }
-        await Promise.all(promises);
-        this.probeCacheExpiry = now + this.PROBE_CACHE_TTL;
-        const available = Object.values(results).filter((r) => r.available).length;
-        logger.info(`[ToolRegistry] Probed ${this.specs.size} tools: ${available} available`);
-        return results;
-    }
-    getCachedProbe(name) {
-        return this.probeCache.get(name);
-    }
-    register(spec) {
-        this.specs.set(spec.name, spec);
-        this.probeCache.delete(spec.name);
-        logger.debug(`[ToolRegistry] Registered tool: ${spec.name} -> ${spec.command}`);
-    }
-}

package/dist/src/modules/external/types.d.ts

@@ -1,40 +0,0 @@
-export type ExternalToolName = 'wabt.wasm2wat' | 'wabt.wasm-objdump' | 'wabt.wasm-decompile' | 'binaryen.wasm-opt' | 'runtime.wasmtime' | 'runtime.wasmer' | 'miniapp.unpacker' | 'platform.jadx';
-export interface ExternalToolSpec {
-    name: ExternalToolName;
-    command: string;
-    defaultArgs?: string[];
-    versionArgs?: string[];
-    required: boolean;
-    envAllowlist?: string[];
-}
-export interface ToolRunRequest {
-    tool: ExternalToolName;
-    args: string[];
-    cwd?: string;
-    timeoutMs?: number;
-    maxStdoutBytes?: number;
-    maxStderrBytes?: number;
-    stdin?: Buffer | string;
-    onProgress?: (event: ProgressEvent) => void;
-}
-export interface ProgressEvent {
-    phase: 'spawn' | 'stdout' | 'stderr' | 'heartbeat' | 'exit' | 'timeout';
-    message?: string;
-    bytesRead?: number;
-    ts: number;
-}
-export interface ToolRunResult {
-    ok: boolean;
-    exitCode: number | null;
-    signal: NodeJS.Signals | null;
-    stdout: string;
-    stderr: string;
-    durationMs: number;
-    truncated: boolean;
-}
-export interface ToolProbeResult {
-    available: boolean;
-    path?: string;
-    version?: string;
-    reason?: string;
-}

package/dist/src/modules/external/types.js

@@ -1 +0,0 @@
-export {};

package/dist/src/modules/hook/HookGenerator.d.ts

@@ -1,4 +0,0 @@
-import type { HookOptions } from '../../types/index.js';
-import { generateFunctionHook, generateXHRHook, generateFetchHook, generateWebSocketHook, generateLocalStorageHook, generateCookieHook, getInjectionInstructions, generateEvalHook, generateObjectMethodHook, generateAntiDebugBypass, generateHookTemplate, generateHookChain } from '../hook/HookGeneratorBuilders.js';
-export { generateFunctionHook, generateXHRHook, generateFetchHook, generateWebSocketHook, generateLocalStorageHook, generateCookieHook, getInjectionInstructions, generateEvalHook, generateObjectMethodHook, generateAntiDebugBypass, generateHookTemplate, generateHookChain, };
-export declare function generateHookScript(target: string, type: HookOptions['type'], action: string, customCode?: string, condition?: HookOptions['condition'], performance?: boolean): string;

package/dist/src/modules/hook/HookGenerator.js

@@ -1,24 +0,0 @@
-import { generateFunctionHook, generateXHRHook, generateFetchHook, generateWebSocketHook, generateLocalStorageHook, generateCookieHook, getInjectionInstructions, generateEvalHook, generateObjectMethodHook, generateAntiDebugBypass, generateHookTemplate, generateHookChain, } from '../hook/HookGeneratorBuilders.js';
-export { generateFunctionHook, generateXHRHook, generateFetchHook, generateWebSocketHook, generateLocalStorageHook, generateCookieHook, getInjectionInstructions, generateEvalHook, generateObjectMethodHook, generateAntiDebugBypass, generateHookTemplate, generateHookChain, };
-export function generateHookScript(target, type, action, customCode, condition, performance = false) {
-    switch (type) {
-        case 'function':
-            return generateFunctionHook(target, action, customCode, condition, performance);
-        case 'xhr':
-            return generateXHRHook(action, customCode, condition, performance);
-        case 'fetch':
-            return generateFetchHook(action, customCode, condition, performance);
-        case 'websocket':
-            return generateWebSocketHook(action, customCode, condition, performance);
-        case 'localstorage':
-            return generateLocalStorageHook(action, customCode, condition, performance);
-        case 'cookie':
-            return generateCookieHook(action, customCode, condition, performance);
-        case 'eval':
-            return generateEvalHook(action, customCode, condition, performance);
-        case 'object-method':
-            return generateObjectMethodHook(target, action, customCode, condition, performance);
-        default:
-            throw new Error(`Unsupported hook type: ${type}`);
-    }
-}

package/dist/src/modules/hook/HookGeneratorBuilders.core.d.ts

@@ -1 +0,0 @@
-export { generateAntiDebugBypass, generateCookieHook, generateEvalHook, generateFetchHook, generateFunctionHook, generateHookChain, generateHookTemplate, generateLocalStorageHook, generateObjectMethodHook, generateWebSocketHook, generateXHRHook, getInjectionInstructions, } from '../hook/HookGeneratorBuilders.core.generators.js';

package/dist/src/modules/hook/HookGeneratorBuilders.core.generators.compose.d.ts

@@ -1,2 +0,0 @@
-import type { HookResult } from '../../types/index.js';
-export declare function generateHookChain(hooks: HookResult[]): string;

package/dist/src/modules/hook/HookGeneratorBuilders.core.generators.compose.js

@@ -1,9 +0,0 @@
-export function generateHookChain(hooks) {
-    const scripts = hooks.map((h) => h.script).join('\n\n');
-    return `
-
-${scripts}
-
-console.log('[Hook Chain] All ${hooks.length} hooks initialized');
-`.trim();
-}

package/dist/src/modules/hook/HookGeneratorBuilders.core.generators.d.ts

@@ -1,4 +0,0 @@
-export { generateAntiDebugBypass, generateEvalHook, generateFunctionHook, generateHookTemplate, generateObjectMethodHook, } from '../hook/HookGeneratorBuilders.core.generators.runtime.js';
-export { generateFetchHook, generateWebSocketHook, generateXHRHook, } from '../hook/HookGeneratorBuilders.core.generators.network.js';
-export { generateCookieHook, generateLocalStorageHook, getInjectionInstructions, } from '../hook/HookGeneratorBuilders.core.generators.storage.js';
-export { generateHookChain } from '../hook/HookGeneratorBuilders.core.generators.compose.js';

package/dist/src/modules/hook/HookGeneratorBuilders.core.generators.js

@@ -1,4 +0,0 @@
-export { generateAntiDebugBypass, generateEvalHook, generateFunctionHook, generateHookTemplate, generateObjectMethodHook, } from '../hook/HookGeneratorBuilders.core.generators.runtime.js';
-export { generateFetchHook, generateWebSocketHook, generateXHRHook, } from '../hook/HookGeneratorBuilders.core.generators.network.js';
-export { generateCookieHook, generateLocalStorageHook, getInjectionInstructions, } from '../hook/HookGeneratorBuilders.core.generators.storage.js';
-export { generateHookChain } from '../hook/HookGeneratorBuilders.core.generators.compose.js';

package/dist/src/modules/hook/HookGeneratorBuilders.core.generators.network.d.ts

@@ -1,4 +0,0 @@
-import type { HookOptions } from '../../types/index.js';
-export declare function generateXHRHook(action: string, customCode?: string, _condition?: HookOptions['condition'], _performance?: boolean): string;
-export declare function generateFetchHook(action: string, customCode?: string, _condition?: HookOptions['condition'], _performance?: boolean): string;
-export declare function generateWebSocketHook(action: string, customCode?: string, _condition?: HookOptions['condition'], _performance?: boolean): string;