@jshookmcp/jshook 0.2.0 → 0.2.2

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/HookGenerator.test.d.ts

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

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

@@ -1,38 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { generateFunctionHook, generateHookChain, generateHookScript, getInjectionInstructions, } from '../../../src/modules/hook/HookGenerator.js';
-describe('HookGenerator', () => {
-    it('generateHookScript dispatches function hook generation', () => {
-        const script = generateHookScript('window.alert', 'function', 'log');
-        expect(script).toContain('const originalFunction = window.alert');
-        expect(script).toContain("type: 'function'");
-    });
-    it('generateHookScript supports object-method type', () => {
-        const script = generateHookScript('window.localStorage.getItem', 'object-method', 'log');
-        expect(script).toContain("const methodName = 'getItem'");
-        expect(script).toContain('[Object Hook]');
-    });
-    it('throws for unsupported hook type', () => {
-        expect(() => generateHookScript('window.x', 'not-real-type', 'log')).toThrow('Unsupported hook type');
-    });
-    it('generateFunctionHook includes condition and performance branches', () => {
-        const script = generateFunctionHook('window.fetch', 'modify', 'args[0] = "/patched";', { maxCalls: 2, minInterval: 10 }, true);
-        expect(script).toContain('const maxCalls = 2;');
-        expect(script).toContain('const minInterval = 10;');
-        expect(script).toContain('const startTime = performance.now();');
-        expect(script).toContain('args[0] = "/patched";');
-    });
-    it('getInjectionInstructions references selected hook type', () => {
-        const instructions = getInjectionInstructions('eval');
-        expect(instructions).toContain('eval');
-        expect(instructions).toContain('page_evaluate');
-    });
-    it('generateHookChain concatenates hook scripts with summary message', () => {
-        const chain = generateHookChain([
-            { hookId: '1', script: 'console.log(1);', instructions: 'a' },
-            { hookId: '2', script: 'console.log(2);', instructions: 'b' },
-        ]);
-        expect(chain).toContain('console.log(1);');
-        expect(chain).toContain('console.log(2);');
-        expect(chain).toContain('All 2 hooks initialized');
-    });
-});

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

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

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

@@ -1,114 +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(),
-}));
-const hookGenState = vi.hoisted(() => ({
-    generateHookScript: vi.fn(() => '/*hook*/'),
-    getInjectionInstructions: vi.fn(() => 'inject'),
-    generateAntiDebugBypass: vi.fn(() => 'bypass-code'),
-    generateHookTemplate: vi.fn(() => 'template-code'),
-    generateHookChain: vi.fn(() => 'chain-code'),
-}));
-vi.mock('@src/utils/logger', () => ({
-    logger: loggerState,
-}));
-vi.mock('@src/modules/hook/HookGenerator', () => ({
-    generateHookScript: hookGenState.generateHookScript,
-    getInjectionInstructions: hookGenState.getInjectionInstructions,
-    generateAntiDebugBypass: hookGenState.generateAntiDebugBypass,
-    generateHookTemplate: hookGenState.generateHookTemplate,
-    generateHookChain: hookGenState.generateHookChain,
-}));
-import { HookManager } from '../../../src/modules/hook/HookManager.js';
-describe('HookManager', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-        Object.values(loggerState).forEach((fn) => fn.mockReset?.());
-        Object.values(hookGenState).forEach((fn) => fn.mockReset?.());
-        hookGenState.generateHookScript.mockReturnValue('/*hook*/');
-        hookGenState.getInjectionInstructions.mockReturnValue('inject');
-        hookGenState.generateAntiDebugBypass.mockReturnValue('bypass-code');
-        hookGenState.generateHookTemplate.mockReturnValue('template-code');
-        hookGenState.generateHookChain.mockReturnValue('chain-code');
-    });
-    it('creates hook script and metadata entries', async () => {
-        const manager = new HookManager();
-        const result = await manager.createHook({
-            target: 'window.fetch',
-            type: 'function',
-            action: 'log',
-            condition: { maxCalls: 5 },
-        });
-        expect(result.script).toBe('/*hook*/');
-        expect(result.instructions).toBe('inject');
-        expect(manager.getAllHooks()).toContain(result.hookId);
-        expect(manager.getHookMetadata(result.hookId)?.enabled).toBe(true);
-    });
-    it('records hook events and supports clear operations', async () => {
-        const manager = new HookManager();
-        const { hookId } = await manager.createHook({ target: 'x', type: 'function' });
-        manager.recordHookEvent(hookId, { args: [1] });
-        manager.recordHookEvent(hookId, { args: [2] });
-        expect(manager.getHookRecords(hookId)).toHaveLength(2);
-        manager.clearHookRecords(hookId);
-        expect(manager.getHookRecords(hookId)).toHaveLength(0);
-    });
-    it('toggles hook enabled state and exposes stats', async () => {
-        const manager = new HookManager();
-        const { hookId } = await manager.createHook({ target: 'x', type: 'function' });
-        manager.disableHook(hookId);
-        expect(manager.getHookStats(hookId)?.enabled).toBe(false);
-        manager.enableHook(hookId);
-        expect(manager.getHookStats(hookId)?.enabled).toBe(true);
-    });
-    it('exports single/all hook payloads', async () => {
-        const manager = new HookManager();
-        const a = await manager.createHook({ target: 'a', type: 'function' });
-        const b = await manager.createHook({ target: 'b', type: 'function' });
-        manager.recordHookEvent(a.hookId, { foo: 1 });
-        const single = manager.exportHookData(a.hookId);
-        const all = manager.exportHookData();
-        expect(single.metadata).toHaveLength(1);
-        expect(single.records[a.hookId]).toHaveLength(1);
-        expect(Object.keys(all.scripts)).toEqual(expect.arrayContaining([a.hookId, b.hookId]));
-    });
-    it('enforces record limits and performs oldest-record cleanup', async () => {
-        const manager = new HookManager();
-        manager.MAX_HOOK_RECORDS = 2;
-        manager.MAX_TOTAL_RECORDS = 3;
-        const h1 = await manager.createHook({ target: 'h1', type: 'function' });
-        const h2 = await manager.createHook({ target: 'h2', type: 'function' });
-        manager.recordHookCall(h1.hookId, { hookId: h1.hookId, timestamp: 1, context: {} });
-        manager.recordHookCall(h1.hookId, { hookId: h1.hookId, timestamp: 2, context: {} });
-        manager.recordHookCall(h1.hookId, { hookId: h1.hookId, timestamp: 3, context: {} });
-        manager.recordHookCall(h2.hookId, { hookId: h2.hookId, timestamp: 4, context: {} });
-        expect(manager.getHookRecords(h1.hookId).length).toBeLessThanOrEqual(2);
-        const stats = manager.getHookRecordsStats();
-        expect(stats.totalRecords).toBeLessThanOrEqual(3);
-    });
-    it('continues batch hook creation when one target fails', async () => {
-        const manager = new HookManager();
-        const createSpy = vi.spyOn(manager, 'createHook');
-        createSpy
-            .mockResolvedValueOnce({ hookId: 'ok-1', script: 's1', instructions: 'i1' })
-            .mockRejectedValueOnce(new Error('boom'))
-            .mockResolvedValueOnce({ hookId: 'ok-2', script: 's2', instructions: 'i2' });
-        const results = await manager.createBatchHooks([
-            { target: 'a', type: 'function' },
-            { target: 'b', type: 'function' },
-            { target: 'c', type: 'function' },
-        ]);
-        expect(results).toHaveLength(2);
-        expect(results.map((r) => r.hookId)).toEqual(['ok-1', 'ok-2']);
-    });
-    it('delegates helper generation methods to HookGenerator functions', () => {
-        const manager = new HookManager();
-        expect(manager.generateAntiDebugBypass()).toBe('bypass-code');
-        expect(manager.generateHookTemplate('x', 'function')).toBe('template-code');
-        expect(manager.generateHookChain([])).toBe('chain-code');
-    });
-});

package/dist/tests/modules/monitor/ConsoleMonitor.test.d.ts

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