@jshookmcp/jshook 0.1.8 → 0.1.9

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

@@ -0,0 +1,80 @@
+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

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

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

@@ -0,0 +1,71 @@
+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

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

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

@@ -0,0 +1,104 @@
+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

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

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

@@ -0,0 +1,38 @@
+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

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

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

@@ -0,0 +1,114 @@
+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

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