@jshookmcp/jshook 0.1.8 → 0.2.0

package/dist/tests/server/domains/maintenance/handlers.test.js

@@ -0,0 +1,79 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { CoreMaintenanceHandlers } from '../../../../src/server/domains/maintenance/handlers.js';
+function parseJson(response) {
+    return JSON.parse(response.content[0].text);
+}
+describe('CoreMaintenanceHandlers', () => {
+    const tokenBudget = {
+        getStats: vi.fn(),
+        manualCleanup: vi.fn(),
+        reset: vi.fn(),
+    };
+    const unifiedCache = {
+        getGlobalStats: vi.fn(),
+        smartCleanup: vi.fn(),
+        clearAll: vi.fn(),
+    };
+    const artifactCleanup = vi.fn();
+    const environmentDoctor = vi.fn();
+    let handlers;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        handlers = new CoreMaintenanceHandlers({ tokenBudget, unifiedCache, artifactCleanup, environmentDoctor });
+    });
+    it('returns token budget stats with sessionDuration', async () => {
+        tokenBudget.getStats.mockReturnValue({
+            currentUsage: 10,
+            maxTokens: 100,
+            usagePercentage: 10,
+            sessionStartTime: Date.now() - 1200,
+        });
+        const body = parseJson(await handlers.handleGetTokenBudgetStats());
+        expect(body.success).toBe(true);
+        expect(body.sessionDuration).toMatch(/s$/);
+    });
+    it('returns serialized error when reading stats fails', async () => {
+        tokenBudget.getStats.mockImplementation(() => {
+            throw new Error('boom');
+        });
+        const body = parseJson(await handlers.handleGetTokenBudgetStats());
+        expect(body.success).toBe(false);
+        expect(body.error).toBe('boom');
+    });
+    it('manual cleanup computes freed tokens', async () => {
+        tokenBudget.getStats
+            .mockReturnValueOnce({ currentUsage: 80, usagePercentage: 40, maxTokens: 200, sessionStartTime: 1 })
+            .mockReturnValueOnce({ currentUsage: 30, usagePercentage: 15, maxTokens: 200, sessionStartTime: 1 });
+        const body = parseJson(await handlers.handleManualTokenCleanup());
+        expect(tokenBudget.manualCleanup).toHaveBeenCalledOnce();
+        expect(body.success).toBe(true);
+        expect(body.freed.tokens).toBe(50);
+        expect(body.freed.percentage).toBe(25);
+    });
+    it('returns cache stats', async () => {
+        unifiedCache.getGlobalStats.mockResolvedValue({ totalEntries: 3 });
+        const body = parseJson(await handlers.handleGetCacheStats());
+        expect(body.success).toBe(true);
+        expect(body.totalEntries).toBe(3);
+    });
+    it('returns clear-all-caches error on failure', async () => {
+        unifiedCache.clearAll.mockRejectedValue(new Error('cache-fail'));
+        const body = parseJson(await handlers.handleClearAllCaches());
+        expect(body.success).toBe(false);
+        expect(body.error).toBe('cache-fail');
+    });
+    it('runs artifact cleanup with overrides', async () => {
+        artifactCleanup.mockResolvedValue({ success: true, removedFiles: 3, dryRun: true });
+        const body = parseJson(await handlers.handleCleanupArtifacts({ retentionDays: 7, dryRun: true }));
+        expect(artifactCleanup).toHaveBeenCalledWith({ retentionDays: 7, maxTotalBytes: undefined, dryRun: true });
+        expect(body.success).toBe(true);
+        expect(body.removedFiles).toBe(3);
+    });
+    it('returns environment doctor payload', async () => {
+        environmentDoctor.mockResolvedValue({ success: true, recommendations: ['ok'] });
+        const body = parseJson(await handlers.handleEnvironmentDoctor({ includeBridgeHealth: false }));
+        expect(environmentDoctor).toHaveBeenCalledWith({ includeBridgeHealth: false });
+        expect(body.success).toBe(true);
+        expect(body.recommendations).toEqual(['ok']);
+    });
+});

package/dist/tests/server/domains/native-bridge/handlers.test.d.ts

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

package/dist/tests/server/domains/native-bridge/handlers.test.js

@@ -0,0 +1,127 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { NativeBridgeHandlers } from '../../../../src/server/domains/native-bridge/index.js';
+function parseJson(response) {
+    return JSON.parse(response.content[0].text);
+}
+describe('NativeBridgeHandlers', () => {
+    describe('constructor - SSRF loopback validation', () => {
+        it('accepts loopback endpoints', () => {
+            expect(() => new NativeBridgeHandlers('http://127.0.0.1:18080', 'http://127.0.0.1:18081')).not.toThrow();
+        });
+        it('accepts localhost endpoints', () => {
+            expect(() => new NativeBridgeHandlers('http://localhost:18080', 'http://localhost:18081')).not.toThrow();
+        });
+        it('accepts [::1] IPv6 loopback', () => {
+            expect(() => new NativeBridgeHandlers('http://[::1]:18080', 'http://[::1]:18081')).not.toThrow();
+        });
+        it('rejects external Ghidra endpoint', () => {
+            expect(() => new NativeBridgeHandlers('http://evil.com:18080', 'http://127.0.0.1:18081')).toThrow(/Ghidra.*loopback/);
+        });
+        it('rejects external IDA endpoint', () => {
+            expect(() => new NativeBridgeHandlers('http://127.0.0.1:18080', 'http://10.0.0.1:18081')).toThrow(/IDA.*loopback/);
+        });
+        it('rejects non-http protocol', () => {
+            expect(() => new NativeBridgeHandlers('ftp://127.0.0.1:18080')).toThrow(/http\/https/);
+        });
+        it('uses defaults when no args provided', () => {
+            const h = new NativeBridgeHandlers();
+            expect(h).toBeInstanceOf(NativeBridgeHandlers);
+        });
+    });
+    describe('handler input validation', () => {
+        let handlers;
+        beforeEach(() => {
+            handlers = new NativeBridgeHandlers();
+            vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('network disabled')));
+        });
+        it('handleGhidraBridge requires action', async () => {
+            const result = parseJson(await handlers.handleGhidraBridge({}));
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('action');
+        });
+        it('handleIdaBridge requires action', async () => {
+            const result = parseJson(await handlers.handleIdaBridge({}));
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('action');
+        });
+        it('handleNativeSymbolSync requires valid source', async () => {
+            const result = parseJson(await handlers.handleNativeSymbolSync({ source: 'invalid' }));
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('ghidra');
+        });
+        it('handleNativeSymbolSync rejects missing source', async () => {
+            const result = parseJson(await handlers.handleNativeSymbolSync({}));
+            expect(result.success).toBe(false);
+        });
+    });
+    describe('ghidra action routing', () => {
+        let handlers;
+        beforeEach(() => {
+            handlers = new NativeBridgeHandlers();
+            vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('network disabled')));
+        });
+        it('open_project requires binaryPath', async () => {
+            const result = parseJson(await handlers.handleGhidraBridge({ action: 'open_project' }));
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('binaryPath');
+        });
+        it('decompile_function requires functionName', async () => {
+            const result = parseJson(await handlers.handleGhidraBridge({ action: 'decompile_function' }));
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('functionName');
+        });
+        it('run_script requires scriptPath', async () => {
+            const result = parseJson(await handlers.handleGhidraBridge({ action: 'run_script' }));
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('scriptPath');
+        });
+        it('get_xrefs requires functionName', async () => {
+            const result = parseJson(await handlers.handleGhidraBridge({ action: 'get_xrefs' }));
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('functionName');
+        });
+        it('unknown action returns guide', async () => {
+            const result = parseJson(await handlers.handleGhidraBridge({ action: 'help' }));
+            expect(result.guide).toBeDefined();
+            expect(result.guide.actions).toBeInstanceOf(Array);
+        });
+    });
+    describe('ida action routing', () => {
+        let handlers;
+        beforeEach(() => {
+            handlers = new NativeBridgeHandlers();
+            vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('network disabled')));
+        });
+        it('open_binary requires binaryPath', async () => {
+            const result = parseJson(await handlers.handleIdaBridge({ action: 'open_binary' }));
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('binaryPath');
+        });
+        it('decompile_function requires functionName', async () => {
+            const result = parseJson(await handlers.handleIdaBridge({ action: 'decompile_function' }));
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('functionName');
+        });
+        it('unknown action returns guide', async () => {
+            const result = parseJson(await handlers.handleIdaBridge({ action: 'help' }));
+            expect(result.guide).toBeDefined();
+            expect(result.guide.actions).toBeInstanceOf(Array);
+        });
+    });
+    describe('endpoint immutability', () => {
+        it('ignores endpoint override in status args', async () => {
+            const handlers = new NativeBridgeHandlers();
+            vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+                status: 200,
+                json: () => Promise.resolve({ version: '1.0' }),
+            }));
+            const result = parseJson(await handlers.handleNativeBridgeStatus({
+                backend: 'ghidra',
+                ghidraEndpoint: 'http://evil.com:9999',
+            }));
+            expect(result.success).toBe(true);
+            const ghidraResult = result.backends[0];
+            expect(ghidraResult.endpoint).toBe('http://127.0.0.1:18080');
+        });
+    });
+});

package/dist/tests/server/domains/network/handlers.test.d.ts

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

package/dist/tests/server/domains/network/handlers.test.js

@@ -0,0 +1,102 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const replayRequestMock = vi.fn();
+vi.mock('@src/server/domains/network/replay', () => ({
+    replayRequest: (...args) => replayRequestMock(...args),
+}));
+vi.mock('@src/utils/DetailedDataManager', () => ({
+    DetailedDataManager: {
+        getInstance: () => ({
+            smartHandle: (payload) => payload,
+        }),
+    },
+}));
+import { AdvancedToolHandlers } from '../../../../src/server/domains/network/handlers.js';
+function parseJson(response) {
+    return JSON.parse(response.content[0].text);
+}
+describe('AdvancedToolHandlers (network)', () => {
+    const collector = {};
+    const consoleMonitor = {
+        isNetworkEnabled: vi.fn(),
+        enable: vi.fn(),
+        getNetworkStatus: vi.fn(),
+        getNetworkRequests: vi.fn(),
+        getResponseBody: vi.fn(),
+        disable: vi.fn(),
+    };
+    let handlers;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        handlers = new AdvancedToolHandlers(collector, consoleMonitor);
+    });
+    it('enables network with parsed boolean args', async () => {
+        consoleMonitor.getNetworkStatus.mockReturnValue({
+            enabled: true,
+            cdpSessionActive: true,
+            listenerCount: 1,
+        });
+        const body = parseJson(await handlers.handleNetworkEnable({ enableExceptions: '0' }));
+        expect(consoleMonitor.enable).toHaveBeenCalledWith({
+            enableNetwork: true,
+            enableExceptions: false,
+        });
+        expect(body.success).toBe(true);
+    });
+    it('returns disabled status payload when monitoring is off', async () => {
+        consoleMonitor.getNetworkStatus.mockReturnValue({
+            enabled: false,
+            requestCount: 0,
+            responseCount: 0,
+            listenerCount: 0,
+            cdpSessionActive: false,
+        });
+        const body = parseJson(await handlers.handleNetworkGetStatus({}));
+        expect(body.success).toBe(false);
+        expect(body.enabled).toBe(false);
+    });
+    it('returns guidance when get_requests called with monitoring disabled', async () => {
+        consoleMonitor.isNetworkEnabled.mockReturnValue(false);
+        const body = parseJson(await handlers.handleNetworkGetRequests({ autoEnable: false }));
+        expect(body.success).toBe(false);
+        expect(body.message).toContain('not enabled');
+    });
+    it('auto-enables and reports empty capture set', async () => {
+        consoleMonitor.isNetworkEnabled
+            .mockReturnValueOnce(false)
+            .mockReturnValueOnce(true);
+        consoleMonitor.getNetworkRequests.mockReturnValue([]);
+        const body = parseJson(await handlers.handleNetworkGetRequests({ autoEnable: true }));
+        expect(consoleMonitor.enable).toHaveBeenCalledOnce();
+        expect(body.success).toBe(true);
+        expect(body.total).toBe(0);
+        expect(body.message).toContain('No network requests captured');
+    });
+    it('filters and paginates captured requests', async () => {
+        consoleMonitor.isNetworkEnabled.mockReturnValue(true);
+        consoleMonitor.getNetworkRequests.mockReturnValue([
+            { requestId: '1', url: 'https://vmoranv.github.io/jshookmcp/api/a', method: 'GET' },
+            { requestId: '2', url: 'https://vmoranv.github.io/jshookmcp/api/b', method: 'POST' },
+            { requestId: '3', url: 'https://vmoranv.github.io/jshookmcp/cdn/c', method: 'GET' },
+        ]);
+        const body = parseJson(await handlers.handleNetworkGetRequests({ url: 'jshookmcp/api/', method: 'ALL', limit: 1, offset: 1 }));
+        expect(body.success).toBe(true);
+        expect(body.page.returned).toBe(1);
+        expect(body.page.totalAfterFilter).toBe(2);
+        expect(body.requests[0].requestId).toBe('2');
+    });
+    it('validates network_replay_request requires requestId', async () => {
+        const body = parseJson(await handlers.handleNetworkReplayRequest({}));
+        expect(body.success).toBe(false);
+        expect(body.error).toContain('requestId is required');
+    });
+    it('replays captured request with dryRun default true', async () => {
+        consoleMonitor.getNetworkRequests.mockReturnValue([
+            { requestId: 'abc', url: 'https://api', method: 'POST' },
+        ]);
+        replayRequestMock.mockResolvedValue({ dryRun: true, requestId: 'abc' });
+        const body = parseJson(await handlers.handleNetworkReplayRequest({ requestId: 'abc' }));
+        expect(replayRequestMock).toHaveBeenCalledWith(expect.objectContaining({ requestId: 'abc' }), expect.objectContaining({ requestId: 'abc', dryRun: true }));
+        expect(body.success).toBe(true);
+        expect(body.dryRun).toBe(true);
+    });
+});

package/dist/tests/server/domains/network/replay.test.d.ts

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

package/dist/tests/server/domains/network/replay.test.js

@@ -0,0 +1,51 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const lookupMock = vi.fn();
+vi.mock('node:dns/promises', () => ({
+    lookup: (...args) => lookupMock(...args),
+}));
+import { replayRequest } from '../../../../src/server/domains/network/replay.js';
+function buildReservedDocIpv4() {
+    return [203, 0, 113, 10].map(String).join('.');
+}
+describe('replayRequest', () => {
+    const fetchMock = vi.fn();
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.stubGlobal('fetch', fetchMock);
+    });
+    it('keeps https requests on the original hostname to preserve TLS validation', async () => {
+        lookupMock.mockResolvedValue({ address: buildReservedDocIpv4(), family: 4 });
+        fetchMock.mockResolvedValue(new Response('ok', {
+            status: 200,
+            headers: { 'content-type': 'text/plain' },
+        }));
+        const result = await replayRequest({
+            url: 'https://vmoranv.github.io/jshookmcp/assets/main.js',
+            method: 'GET',
+            headers: {},
+        }, {
+            requestId: 'req-https',
+            dryRun: false,
+        });
+        expect(result.dryRun).toBe(false);
+        expect(result.status).toBe(200);
+        expect(fetchMock).toHaveBeenCalledWith('https://vmoranv.github.io/jshookmcp/assets/main.js', expect.objectContaining({
+            method: 'GET',
+            redirect: 'manual',
+            headers: {},
+        }));
+    });
+    it('blocks remote http requests unless they are loopback', async () => {
+        const resolvedAddress = buildReservedDocIpv4();
+        lookupMock.mockResolvedValue({ address: resolvedAddress, family: 4 });
+        await expect(replayRequest({
+            url: 'http://vmoranv.github.io/jshookmcp/assets/main.js',
+            method: 'GET',
+            headers: {},
+        }, {
+            requestId: 'req-http',
+            dryRun: false,
+        })).rejects.toThrow('insecure HTTP is only allowed for loopback targets');
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+});

package/dist/tests/server/domains/platform/handlers.test.d.ts

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

package/dist/tests/server/domains/platform/handlers.test.js

@@ -0,0 +1,108 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const miniappMocks = {
+    handleMiniappPkgScan: vi.fn(async (args) => ({ kind: 'miniapp_scan', args })),
+    handleMiniappPkgUnpack: vi.fn(async (args) => ({ kind: 'miniapp_unpack', args })),
+    handleMiniappPkgAnalyze: vi.fn(async (args) => ({ kind: 'miniapp_analyze', args })),
+};
+const electronMocks = {
+    handleAsarExtract: vi.fn(async (args) => ({ kind: 'asar_extract', args })),
+    handleElectronInspectApp: vi.fn(async (args) => ({ kind: 'inspect', args })),
+};
+const bridgeMocks = {
+    handleFridaBridge: vi.fn(async (args) => ({ kind: 'frida', args })),
+    handleJadxBridge: vi.fn(async (args) => ({ kind: 'jadx', args })),
+};
+const toolRegistryCtor = vi.fn();
+const externalRunnerCtor = vi.fn();
+const miniappCtor = vi.fn(() => miniappMocks);
+const electronCtor = vi.fn(() => electronMocks);
+const bridgeCtor = vi.fn(() => bridgeMocks);
+vi.mock('@src/modules/external/ToolRegistry', () => ({
+    ToolRegistry: class {
+        constructor() {
+            toolRegistryCtor();
+        }
+    },
+}));
+vi.mock('@src/modules/external/ExternalToolRunner', () => ({
+    ExternalToolRunner: class {
+        constructor(registry) {
+            externalRunnerCtor(registry);
+        }
+    },
+}));
+vi.mock('@src/server/domains/platform/handlers/miniapp-handlers', () => ({
+    MiniappHandlers: class {
+        constructor(runner, collector) {
+            miniappCtor(runner, collector);
+            return miniappMocks;
+        }
+    },
+}));
+vi.mock('@src/server/domains/platform/handlers/electron-handlers', () => ({
+    ElectronHandlers: class {
+        constructor(collector) {
+            electronCtor(collector);
+            return electronMocks;
+        }
+    },
+}));
+vi.mock('@src/server/domains/platform/handlers/bridge-handlers', () => ({
+    BridgeHandlers: class {
+        constructor(runner) {
+            bridgeCtor(runner);
+            return bridgeMocks;
+        }
+    },
+}));
+import { PlatformToolHandlers } from '../../../../src/server/domains/platform/handlers.js';
+describe('PlatformToolHandlers', () => {
+    const collector = { getActivePage: vi.fn() };
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('constructs internal dependencies and handler modules', () => {
+        new PlatformToolHandlers(collector);
+        expect(toolRegistryCtor).toHaveBeenCalledOnce();
+        expect(externalRunnerCtor).toHaveBeenCalledOnce();
+        expect(miniappCtor).toHaveBeenCalledOnce();
+        expect(electronCtor).toHaveBeenCalledWith(collector);
+        expect(bridgeCtor).toHaveBeenCalledOnce();
+    });
+    it('delegates miniapp package scan', async () => {
+        const handlers = new PlatformToolHandlers(collector);
+        const args = { path: 'a' };
+        await expect(handlers.handleMiniappPkgScan(args)).resolves.toEqual({
+            kind: 'miniapp_scan',
+            args,
+        });
+        expect(miniappMocks.handleMiniappPkgScan).toHaveBeenCalledWith(args);
+    });
+    it('delegates asar extraction', async () => {
+        const handlers = new PlatformToolHandlers(collector);
+        const args = { input: 'app.asar' };
+        await expect(handlers.handleAsarExtract(args)).resolves.toEqual({
+            kind: 'asar_extract',
+            args,
+        });
+        expect(electronMocks.handleAsarExtract).toHaveBeenCalledWith(args);
+    });
+    it('delegates frida bridge', async () => {
+        const handlers = new PlatformToolHandlers(collector);
+        const args = { cmd: 'hook' };
+        await expect(handlers.handleFridaBridge(args)).resolves.toEqual({
+            kind: 'frida',
+            args,
+        });
+        expect(bridgeMocks.handleFridaBridge).toHaveBeenCalledWith(args);
+    });
+    it('delegates jadx bridge', async () => {
+        const handlers = new PlatformToolHandlers(collector);
+        const args = { dex: 'classes.dex' };
+        await expect(handlers.handleJadxBridge(args)).resolves.toEqual({
+            kind: 'jadx',
+            args,
+        });
+        expect(bridgeMocks.handleJadxBridge).toHaveBeenCalledWith(args);
+    });
+});

package/dist/tests/server/domains/process/handlers.inject.test.d.ts

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