@jshookmcp/jshook 0.2.1 → 0.2.2

package/dist/tests/modules/external/ExternalToolRunner.test.js

@@ -1,159 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { EventEmitter } from 'node:events';
-const state = vi.hoisted(() => {
-    const spawn = vi.fn();
-    const getProjectRoot = vi.fn(() => '/repo/root');
-    const ioLimit = vi.fn(async (task) => task());
-    return { spawn, getProjectRoot, ioLimit };
-});
-vi.mock('node:child_process', () => ({
-    spawn: state.spawn,
-}));
-vi.mock('@src/utils/outputPaths', () => ({
-    getProjectRoot: state.getProjectRoot,
-}));
-vi.mock('@src/utils/concurrency', () => ({
-    ioLimit: state.ioLimit,
-}));
-vi.mock('@src/utils/logger', () => ({
-    logger: {
-        debug: vi.fn(),
-        info: vi.fn(),
-        warn: vi.fn(),
-        error: vi.fn(),
-    },
-}));
-import { ExternalToolRunner } from '../../../src/modules/external/ExternalToolRunner.js';
-function createChildProcessMock() {
-    const child = new EventEmitter();
-    child.stdout = new EventEmitter();
-    child.stderr = new EventEmitter();
-    child.stdin = {
-        write: vi.fn(),
-        end: vi.fn(),
-    };
-    child.kill = vi.fn();
-    return child;
-}
-describe('ExternalToolRunner', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        vi.useRealTimers();
-    });
-    it('delegates probeAll to registry', async () => {
-        const registry = {
-            probeAll: vi.fn().mockResolvedValue({ ok: true }),
-            getSpec: vi.fn(),
-            getCachedProbe: vi.fn(),
-        };
-        const runner = new ExternalToolRunner(registry);
-        const result = await runner.probeAll(true);
-        expect(registry.probeAll).toHaveBeenCalledWith(true);
-        expect(result).toEqual({ ok: true });
-    });
-    it('returns early when cached probe indicates unavailable tool', async () => {
-        const registry = {
-            probeAll: vi.fn(),
-            getSpec: vi.fn().mockReturnValue({ command: 'wasm2wat' }),
-            getCachedProbe: vi.fn().mockReturnValue({ available: false, reason: 'missing' }),
-        };
-        const runner = new ExternalToolRunner(registry);
-        const result = await runner.run({ tool: 'wabt.wasm2wat', args: [] });
-        expect(result.ok).toBe(false);
-        expect(result.stderr).toContain('not available: missing');
-        expect(state.spawn).not.toHaveBeenCalled();
-    });
-    it('spawns process with merged args and captures output', async () => {
-        const child = createChildProcessMock();
-        state.spawn.mockReturnValue(child);
-        const registry = {
-            probeAll: vi.fn(),
-            getSpec: vi.fn().mockReturnValue({
-                command: 'tool-bin',
-                defaultArgs: ['--default'],
-            }),
-            getCachedProbe: vi.fn().mockReturnValue({ available: true }),
-        };
-        const runner = new ExternalToolRunner(registry);
-        const progress = vi.fn();
-        const runPromise = runner.run({
-            tool: 'wabt.wasm2wat',
-            args: ['--foo'],
-            onProgress: progress,
-        });
-        child.stdout.emit('data', Buffer.from('hello'));
-        child.stderr.emit('data', Buffer.from('warn'));
-        child.emit('close', 0, null);
-        const result = await runPromise;
-        expect(state.spawn).toHaveBeenCalledWith('tool-bin', ['--default', '--foo'], expect.objectContaining({ cwd: '/repo/root', shell: false }));
-        expect(result).toMatchObject({
-            ok: true,
-            exitCode: 0,
-            stdout: 'hello',
-            stderr: 'warn',
-            truncated: false,
-        });
-        expect(progress).toHaveBeenCalled();
-    });
-    it('truncates stdout when maxStdoutBytes is exceeded', async () => {
-        const child = createChildProcessMock();
-        state.spawn.mockReturnValue(child);
-        const registry = {
-            probeAll: vi.fn(),
-            getSpec: vi.fn().mockReturnValue({ command: 'tool-bin' }),
-            getCachedProbe: vi.fn().mockReturnValue({ available: true }),
-        };
-        const runner = new ExternalToolRunner(registry);
-        const runPromise = runner.run({
-            tool: 'wabt.wasm2wat',
-            args: [],
-            maxStdoutBytes: 4,
-        });
-        child.stdout.emit('data', Buffer.from('abcdef'));
-        child.emit('close', 0, null);
-        const result = await runPromise;
-        expect(result.stdout).toBe('abcd');
-        expect(result.truncated).toBe(true);
-    });
-    it('uses project root when cwd is outside allowed boundaries', async () => {
-        const child = createChildProcessMock();
-        state.spawn.mockReturnValue(child);
-        const registry = {
-            probeAll: vi.fn(),
-            getSpec: vi.fn().mockReturnValue({ command: 'tool-bin' }),
-            getCachedProbe: vi.fn().mockReturnValue({ available: true }),
-        };
-        const runner = new ExternalToolRunner(registry);
-        const runPromise = runner.run({
-            tool: 'wabt.wasm2wat',
-            args: [],
-            cwd: '/etc',
-        });
-        child.emit('close', 0, null);
-        await runPromise;
-        expect(state.spawn).toHaveBeenCalledWith('tool-bin', [], expect.objectContaining({ cwd: '/repo/root' }));
-    });
-    it('kills hung process on timeout and reports SIGKILL', async () => {
-        vi.useFakeTimers();
-        const child = createChildProcessMock();
-        state.spawn.mockReturnValue(child);
-        const registry = {
-            probeAll: vi.fn(),
-            getSpec: vi.fn().mockReturnValue({ command: 'tool-bin' }),
-            getCachedProbe: vi.fn().mockReturnValue({ available: true }),
-        };
-        const runner = new ExternalToolRunner(registry);
-        const pending = runner.run({
-            tool: 'wabt.wasm2wat',
-            args: [],
-            timeoutMs: 10,
-        });
-        await vi.advanceTimersByTimeAsync(11);
-        await vi.advanceTimersByTimeAsync(2001);
-        const result = await pending;
-        expect(child.kill).toHaveBeenCalledWith('SIGTERM');
-        expect(child.kill).toHaveBeenCalledWith('SIGKILL');
-        expect(result.signal).toBe('SIGKILL');
-        expect(result.ok).toBe(false);
-    });
-});

package/dist/tests/modules/external/ToolProbe.test.d.ts

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

package/dist/tests/modules/external/ToolProbe.test.js

@@ -1,80 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-const state = vi.hoisted(() => {
-    const execFileAsync = vi.fn();
-    const promisify = vi.fn(() => execFileAsync);
-    return { execFileAsync, promisify };
-});
-vi.mock('node:child_process', () => ({
-    execFile: vi.fn(),
-}));
-vi.mock('node:util', () => ({
-    promisify: state.promisify,
-}));
-vi.mock('@src/utils/logger', () => ({
-    logger: {
-        debug: vi.fn(),
-        info: vi.fn(),
-        warn: vi.fn(),
-        error: vi.fn(),
-    },
-}));
-import { probeAll, probeCommand } from '../../../src/modules/external/ToolProbe.js';
-describe('ToolProbe', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('returns available=true with path and version when both probes succeed', async () => {
-        state.execFileAsync
-            .mockResolvedValueOnce({ stdout: '/usr/bin/tool\n', stderr: '' })
-            .mockResolvedValueOnce({ stdout: 'tool 1.2.3\n', stderr: '' });
-        const result = await probeCommand('tool', ['-v'], 1000);
-        expect(result).toEqual({
-            available: true,
-            path: '/usr/bin/tool',
-            version: 'tool 1.2.3',
-        });
-    });
-    it('keeps command available even when version probe fails', async () => {
-        state.execFileAsync
-            .mockResolvedValueOnce({ stdout: '/usr/local/bin/tool\n', stderr: '' })
-            .mockRejectedValueOnce(new Error('version failed'));
-        const result = await probeCommand('tool');
-        expect(result.available).toBe(true);
-        expect(result.path).toBe('/usr/local/bin/tool');
-        expect(result.version).toBeUndefined();
-    });
-    it('reports command-not-found when executable lookup returns ENOENT', async () => {
-        state.execFileAsync.mockRejectedValueOnce({ code: 'ENOENT', message: 'not found' });
-        const result = await probeCommand('missing-tool');
-        expect(result.available).toBe(false);
-        expect(result.reason).toContain("Command 'missing-tool' not found in PATH");
-    });
-    it('returns generic probe failure reason for other errors', async () => {
-        state.execFileAsync.mockRejectedValueOnce(new Error('boom'));
-        const result = await probeCommand('broken');
-        expect(result.available).toBe(false);
-        expect(result.reason).toContain('Probe failed: boom');
-    });
-    it('probes all commands and returns map keyed by command name', async () => {
-        const whichCmd = process.platform === 'win32' ? 'where' : 'which';
-        state.execFileAsync.mockImplementation(async (cmd, args) => {
-            if (cmd === whichCmd && args[0] === 'tool-a')
-                return { stdout: '/bin/tool-a\n', stderr: '' };
-            if (cmd === whichCmd && args[0] === 'tool-b')
-                return { stdout: '/bin/tool-b\n', stderr: '' };
-            if (cmd === 'tool-a')
-                return { stdout: 'a v1\n', stderr: '' };
-            if (cmd === 'tool-b')
-                throw new Error('no version');
-            throw new Error('unexpected call');
-        });
-        const result = await probeAll([
-            { command: 'tool-a', versionArgs: ['--version'] },
-            { command: 'tool-b', versionArgs: ['--version'] },
-        ]);
-        expect(result.get('tool-a')?.available).toBe(true);
-        expect(result.get('tool-a')?.version).toBe('a v1');
-        expect(result.get('tool-b')?.available).toBe(true);
-        expect(result.get('tool-b')?.version).toBeUndefined();
-    });
-});

package/dist/tests/modules/external/ToolRegistry.test.d.ts

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

package/dist/tests/modules/external/ToolRegistry.test.js

@@ -1,71 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-const probeState = vi.hoisted(() => ({
-    probeCommand: vi.fn(),
-}));
-vi.mock('@src/modules/external/ToolProbe', () => ({
-    probeCommand: probeState.probeCommand,
-}));
-import { ToolRegistry } from '../../../src/modules/external/ToolRegistry.js';
-function available(path = '/bin/tool', version = '1.0.0') {
-    return { available: true, path, version };
-}
-describe('ToolRegistry', () => {
-    beforeEach(() => {
-        probeState.probeCommand.mockReset();
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('contains default registered tools', () => {
-        const registry = new ToolRegistry();
-        const tools = registry.getRegisteredTools();
-        expect(tools).toContain('wabt.wasm2wat');
-        expect(tools).toContain('binaryen.wasm-opt');
-        expect(tools).toContain('platform.jadx');
-        expect(registry.isRegistered('runtime.wasmtime')).toBe(true);
-    });
-    it('throws when requesting unknown tool spec', () => {
-        const registry = new ToolRegistry();
-        expect(() => registry.getSpec('unknown.tool')).toThrow('not registered');
-    });
-    it('registers tool at runtime and updates spec lookup', () => {
-        const registry = new ToolRegistry();
-        registry.register({
-            name: 'runtime.wasmer',
-            command: 'wasmer-custom',
-            required: false,
-            versionArgs: ['--version'],
-            envAllowlist: [],
-        });
-        expect(registry.getSpec('runtime.wasmer').command).toBe('wasmer-custom');
-    });
-    it('probes tools and reuses cache when not forced', async () => {
-        probeState.probeCommand.mockResolvedValue(available());
-        const registry = new ToolRegistry();
-        const first = await registry.probeAll();
-        const second = await registry.probeAll();
-        expect(probeState.probeCommand).toHaveBeenCalledTimes(registry.getRegisteredTools().length);
-        expect(second).toEqual(first);
-    });
-    it('re-probes when force=true and updates cache', async () => {
-        probeState.probeCommand
-            .mockResolvedValueOnce(available('/bin/old', '1.0.0'))
-            .mockResolvedValue(available('/bin/new', '2.0.0'));
-        const registry = new ToolRegistry();
-        await registry.probeAll();
-        const forced = await registry.probeAll(true);
-        expect(probeState.probeCommand).toHaveBeenCalledTimes(registry.getRegisteredTools().length * 2);
-        expect(forced['wabt.wasm2wat'].path).toBe('/bin/new');
-    });
-    it('exposes cached probe result for specific tool', async () => {
-        probeState.probeCommand.mockResolvedValue(available('/usr/local/bin/tool', '3.1.4'));
-        const registry = new ToolRegistry();
-        await registry.probeAll(true);
-        const cached = registry.getCachedProbe('runtime.wasmer');
-        expect(cached).toMatchObject({
-            available: true,
-            path: '/usr/local/bin/tool',
-            version: '3.1.4',
-        });
-    });
-});

package/dist/tests/modules/hook/AIHookGenerator.test.d.ts

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

package/dist/tests/modules/hook/AIHookGenerator.test.js

@@ -1,104 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-const loggerState = vi.hoisted(() => ({
-    debug: vi.fn(),
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-    success: vi.fn(),
-}));
-vi.mock('@src/utils/logger', () => ({
-    logger: loggerState,
-}));
-import { AIHookGenerator } from '../../../src/modules/hook/AIHookGenerator.js';
-describe('AIHookGenerator', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-        Object.values(loggerState).forEach((fn) => fn.mockReset?.());
-    });
-    it('generates function hook with argument/return capture', () => {
-        const generator = new AIHookGenerator();
-        const result = generator.generateHook({
-            description: 'hook login',
-            target: { type: 'function', name: 'login' },
-            behavior: { captureArgs: true, captureReturn: true, logToConsole: true },
-        });
-        expect(result.success).toBe(true);
-        expect(result.injectionMethod).toBe('evaluateOnNewDocument');
-        expect(result.generatedCode).toContain('window.login');
-        expect(result.generatedCode).toContain('args: args');
-    });
-    it('generates fetch API hook script', () => {
-        const generator = new AIHookGenerator();
-        const result = generator.generateHook({
-            description: 'hook fetch',
-            target: { type: 'api', name: 'fetch' },
-            behavior: { captureArgs: true, captureReturn: true, logToConsole: true },
-            condition: { urlPattern: '/api/' },
-        });
-        expect(result.success).toBe(true);
-        expect(result.generatedCode).toContain('window.fetch');
-        expect(result.generatedCode).toContain('urlPattern');
-    });
-    it('uses evaluate injection for event hooks', () => {
-        const generator = new AIHookGenerator();
-        const result = generator.generateHook({
-            description: 'hook click',
-            target: { type: 'event', name: 'click' },
-            behavior: { captureArgs: true, logToConsole: true },
-            condition: { maxCalls: 2 },
-        });
-        expect(result.success).toBe(true);
-        expect(result.injectionMethod).toBe('evaluate');
-        expect(result.generatedCode).toContain('addEventListener');
-    });
-    it('passes through custom replace code for custom hooks', () => {
-        const generator = new AIHookGenerator();
-        const result = generator.generateHook({
-            description: 'custom',
-            target: { type: 'custom' },
-            behavior: {},
-            customCode: { replace: 'window.__custom = true;' },
-        });
-        expect(result.success).toBe(true);
-        expect(result.generatedCode).toContain('window.__custom = true');
-        expect(result.explanation).toContain('Custom Hook');
-    });
-    it('returns failure payload for unsupported target type', () => {
-        const generator = new AIHookGenerator();
-        const result = generator.generateHook({
-            description: 'bad',
-            target: { type: 'not-supported' },
-            behavior: {},
-        });
-        expect(result.success).toBe(false);
-        expect(result.warnings).toContain('Hook generation failed');
-    });
-    it('adds validation warnings for dangerous or malformed code', () => {
-        const generator = new AIHookGenerator();
-        const result = generator.generateHook({
-            description: 'danger',
-            target: { type: 'custom' },
-            behavior: {},
-            customCode: { replace: 'eval("x"); {' },
-        });
-        expect(result.success).toBe(true);
-        expect(result.warnings?.some((w) => w.includes('eval'))).toBe(true);
-        expect(result.warnings?.some((w) => w.includes('unmatched braces'))).toBe(true);
-    });
-    it('creates unique hook ids for consecutive requests', () => {
-        const generator = new AIHookGenerator();
-        const a = generator.generateHook({
-            description: 'a',
-            target: { type: 'custom' },
-            behavior: {},
-            customCode: { replace: '1;' },
-        });
-        const b = generator.generateHook({
-            description: 'b',
-            target: { type: 'custom' },
-            behavior: {},
-            customCode: { replace: '2;' },
-        });
-        expect(a.hookId).not.toBe(b.hookId);
-    });
-});

package/dist/tests/modules/hook/AIHookGeneratorTemplates.test.d.ts

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

package/dist/tests/modules/hook/AIHookGeneratorTemplates.test.js

@@ -1,82 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { generateEventHookTemplate, generatePropertyHookTemplate, } from '../../../src/modules/hook/AIHookGeneratorTemplates.js';
-describe('AIHookGeneratorTemplates', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('builds property hook templates with explicit captures and filters', () => {
-        const result = generatePropertyHookTemplate({
-            target: { object: 'window.appState', property: 'token' },
-            behavior: {
-                captureArgs: true,
-                captureReturn: true,
-                captureStack: true,
-                logToConsole: true,
-                blockExecution: true,
-            },
-            condition: {
-                argFilter: 'args[0] !== null',
-            },
-        }, 'hook-token');
-        expect(result.explanation).toBe('Property hook: window.appState.token (get + set intercepted via Object.defineProperty)');
-        expect(result.code).toContain('const targetObject = window.appState;');
-        expect(result.code).toContain("const propName = 'token';");
-        expect(result.code).toContain('value: value,');
-        expect(result.code).toContain('newValue: newValue,');
-        expect(result.code).toContain('stack: new Error().stack,');
-        expect(result.code).toContain("console.log('[hook-token] Property get:', hookData);");
-        expect(result.code).toContain("console.log('[hook-token] Property set:', hookData);");
-        expect(result.code).toContain('const args = [newValue];');
-        expect(result.code).toContain('try { return args[0] !== null; } catch(e) { return true; }');
-        expect(result.code).toContain('if (!true) {');
-        expect(result.code).toContain("window.__aiHooks['hook-token'].push(hookData);");
-    });
-    it('falls back to default property targets and omits optional captures when disabled', () => {
-        const result = generatePropertyHookTemplate({
-            target: {},
-            behavior: {},
-        }, 'hook-default');
-        expect(result.explanation).toBe('Property hook: window.unknownProperty (get + set intercepted via Object.defineProperty)');
-        expect(result.code).toContain('const targetObject = window;');
-        expect(result.code).toContain("const propName = 'unknownProperty';");
-        expect(result.code).toContain('if (!false) {');
-        expect(result.code).not.toContain('value: value,');
-        expect(result.code).not.toContain('newValue: newValue,');
-        expect(result.code).not.toContain('stack: new Error().stack,');
-    });
-    it('builds scoped event hook templates with listener forwarding', () => {
-        const result = generateEventHookTemplate({
-            target: { name: 'submit' },
-            behavior: {
-                captureArgs: true,
-                captureStack: true,
-                logToConsole: true,
-                blockExecution: false,
-            },
-            condition: {
-                maxCalls: 3,
-            },
-        }, 'hook-submit');
-        expect(result.explanation).toBe('Event hook: "submit" events via EventTarget.prototype.addEventListener override');
-        expect(result.code).toContain("if (type !== 'submit') {");
-        expect(result.code).toContain('const maxCalls = 3;');
-        expect(result.code).toContain('event: {');
-        expect(result.code).toContain('stack: new Error().stack,');
-        expect(result.code).toContain("console.log('[hook-submit] Event fired:', hookData);");
-        expect(result.code).toContain("if (typeof listener === 'function') {");
-        expect(result.code).toContain('listener.handleEvent(event);');
-    });
-    it('supports unfiltered event hooks that block downstream listener execution', () => {
-        const result = generateEventHookTemplate({
-            target: {},
-            behavior: {
-                blockExecution: true,
-            },
-        }, 'hook-all-events');
-        expect(result.explanation).toBe('Event hook: all events via EventTarget.prototype.addEventListener override');
-        expect(result.code).not.toContain('if (type !==');
-        expect(result.code).toContain('const maxCalls = Infinity;');
-        expect(result.code).toContain('// Execution blocked');
-        expect(result.code).not.toContain('listener.call(this, event);');
-    });
-});

package/dist/tests/modules/hook/HookGenerator.generateHookScript.test.d.ts

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