@jshookmcp/jshook 0.1.9 → 0.2.1

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

@@ -0,0 +1,303 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+const mockExecFileAsync = vi.fn();
+vi.mock('node:child_process', () => ({
+    execFile: vi.fn(),
+}));
+vi.mock('node:util', () => ({
+    promisify: () => mockExecFileAsync,
+}));
+vi.mock('@utils/logger', () => ({
+    logger: { warn: vi.fn(), debug: vi.fn(), info: vi.fn(), error: vi.fn() },
+}));
+vi.mock('@utils/artifacts', () => ({
+    resolveArtifactPath: vi.fn(async () => ({
+        absolutePath: '/tmp/artifacts/test.tmpdir',
+        displayPath: 'artifacts/test.tmpdir',
+    })),
+}));
+import { BridgeHandlers } from '../../../../src/server/domains/platform/handlers/bridge-handlers.js';
+function parsePayload(response) {
+    const text = response.content[0]?.text;
+    if (!text) {
+        throw new Error('Missing text response payload');
+    }
+    return JSON.parse(text);
+}
+function makeRunner(overrides = {}) {
+    const run = vi.fn(async () => ({
+        ok: true,
+        exitCode: 0,
+        signal: null,
+        stdout: 'done',
+        stderr: '',
+        truncated: false,
+        durationMs: 100,
+    }));
+    const probeAll = vi.fn(async () => ({}));
+    return {
+        run,
+        probeAll,
+        ...overrides,
+    };
+}
+describe('BridgeHandlers', () => {
+    let runner;
+    let handlers;
+    beforeEach(() => {
+        runner = makeRunner();
+        handlers = new BridgeHandlers(runner);
+    });
+    describe('handleFridaBridge', () => {
+        describe('action = guide', () => {
+            it('throws when action is not provided (required param)', async () => {
+                await expect(handlers.handleFridaBridge({})).rejects.toThrow('action must be a non-empty string');
+            });
+            it('returns a guide when action is explicitly "guide"', async () => {
+                const result = parsePayload(await handlers.handleFridaBridge({ action: 'guide' }));
+                expect(result.success).toBe(true);
+                expect(result).toHaveProperty('guide');
+                const guide = result.guide;
+                expect(guide).toHaveProperty('what');
+                expect(guide).toHaveProperty('install');
+                expect(guide).toHaveProperty('workflow');
+                expect(guide).toHaveProperty('links');
+                expect(guide).toHaveProperty('integration');
+            });
+        });
+        describe('action = check_env', () => {
+            it('reports frida as available when the command succeeds', async () => {
+                mockExecFileAsync.mockResolvedValueOnce({
+                    stdout: '16.1.0\n',
+                    stderr: '',
+                });
+                const result = parsePayload(await handlers.handleFridaBridge({ action: 'check_env' }));
+                expect(result.success).toBe(true);
+                expect(result.available).toBe(true);
+                expect(result.version).toBe('16.1.0');
+                expect(result.tool).toBe('frida');
+            });
+            it('reports frida as unavailable when the command fails', async () => {
+                mockExecFileAsync.mockRejectedValueOnce(new Error('spawn frida ENOENT'));
+                const result = parsePayload(await handlers.handleFridaBridge({ action: 'check_env' }));
+                expect(result.success).toBe(true);
+                expect(result.available).toBe(false);
+                expect(result.reason).toContain('ENOENT');
+                expect(result.installHint).toBe('pip install frida-tools');
+            });
+        });
+        describe('action = generate_script', () => {
+            it('generates an intercept script by default', async () => {
+                const result = parsePayload(await handlers.handleFridaBridge({
+                    action: 'generate_script',
+                    target: 'com.example.app',
+                    functionName: 'encrypt',
+                }));
+                expect(result.success).toBe(true);
+                expect(result.target).toBe('com.example.app');
+                expect(result.hookType).toBe('intercept');
+                expect(result.functionName).toBe('encrypt');
+                expect(typeof result.script).toBe('string');
+                expect(result.script).toContain('Interceptor.attach');
+                expect(result.script).toContain('encrypt');
+                expect(typeof result.usage).toBe('string');
+            });
+            it('generates a replace script when hookType is "replace"', async () => {
+                const result = parsePayload(await handlers.handleFridaBridge({
+                    action: 'generate_script',
+                    hookType: 'replace',
+                    functionName: 'verify',
+                }));
+                expect(result.hookType).toBe('replace');
+                expect(result.script).toContain('Interceptor.replace');
+                expect(result.script).toContain('NativeCallback');
+            });
+            it('generates a stalker script when hookType is "stalker"', async () => {
+                const result = parsePayload(await handlers.handleFridaBridge({
+                    action: 'generate_script',
+                    hookType: 'stalker',
+                    functionName: 'processData',
+                }));
+                expect(result.hookType).toBe('stalker');
+                expect(result.script).toContain('Stalker.follow');
+                expect(result.script).toContain('Stalker.unfollow');
+            });
+            it('generates a module_export script when hookType is "module_export"', async () => {
+                const result = parsePayload(await handlers.handleFridaBridge({
+                    action: 'generate_script',
+                    hookType: 'module_export',
+                    functionName: 'libcrypto.so',
+                }));
+                expect(result.hookType).toBe('module_export');
+                expect(result.script).toContain('Module.enumerateExports');
+                expect(result.script).toContain('libcrypto.so');
+            });
+            it('falls back to intercept template for unknown hookType', async () => {
+                const result = parsePayload(await handlers.handleFridaBridge({
+                    action: 'generate_script',
+                    hookType: 'unknown_type',
+                    functionName: 'fn',
+                }));
+                expect(result.script).toContain('Interceptor.attach');
+            });
+            it('uses placeholder defaults when target/functionName are omitted', async () => {
+                const result = parsePayload(await handlers.handleFridaBridge({ action: 'generate_script' }));
+                expect(result.target).toBe('<process_name>');
+                expect(result.functionName).toBe('<target_function>');
+            });
+        });
+    });
+    describe('handleJadxBridge', () => {
+        describe('action = guide', () => {
+            it('throws when action is not provided (required param)', async () => {
+                await expect(handlers.handleJadxBridge({})).rejects.toThrow('action must be a non-empty string');
+            });
+            it('returns a jadx guide when action is explicitly "guide"', async () => {
+                const result = parsePayload(await handlers.handleJadxBridge({ action: 'guide' }));
+                expect(result.success).toBe(true);
+                expect(result).toHaveProperty('guide');
+                const guide = result.guide;
+                expect(guide).toHaveProperty('what');
+                expect(guide).toHaveProperty('install');
+                expect(guide).toHaveProperty('workflow');
+                expect(guide).toHaveProperty('commonArgs');
+                expect(guide).toHaveProperty('links');
+            });
+        });
+        describe('action = check_env', () => {
+            it('reports jadx as available', async () => {
+                mockExecFileAsync.mockResolvedValueOnce({
+                    stdout: 'jadx 1.4.7\n',
+                    stderr: '',
+                });
+                const result = parsePayload(await handlers.handleJadxBridge({ action: 'check_env' }));
+                expect(result.success).toBe(true);
+                expect(result.available).toBe(true);
+                expect(result.version).toBe('jadx 1.4.7');
+                expect(result.tool).toBe('jadx');
+            });
+            it('reports jadx as unavailable on error', async () => {
+                mockExecFileAsync.mockRejectedValueOnce(new Error('spawn jadx ENOENT'));
+                const result = parsePayload(await handlers.handleJadxBridge({ action: 'check_env' }));
+                expect(result.available).toBe(false);
+                expect(result.installHint).toContain('jadx/releases');
+            });
+        });
+        describe('action = decompile', () => {
+            it('throws when inputPath is missing', async () => {
+                await expect(handlers.handleJadxBridge({ action: 'decompile' })).rejects.toThrow('inputPath must be a non-empty string');
+            });
+            it('runs jadx with correct arguments on successful decompile', async () => {
+                const mockRun = vi.fn(async () => ({
+                    ok: true,
+                    exitCode: 0,
+                    signal: null,
+                    stdout: 'Decompilation complete',
+                    stderr: '',
+                    truncated: false,
+                    durationMs: 5000,
+                }));
+                const customRunner = makeRunner({ run: mockRun });
+                const customHandlers = new BridgeHandlers(customRunner);
+                const result = parsePayload(await customHandlers.handleJadxBridge({
+                    action: 'decompile',
+                    inputPath: '/path/to/app.apk',
+                }));
+                expect(result.success).toBe(true);
+                expect(result.exitCode).toBe(0);
+                expect(mockRun).toHaveBeenCalledOnce();
+                const firstCall = mockRun.mock.calls[0];
+                if (!firstCall) {
+                    throw new Error('Expected jadx runner to be called');
+                }
+                const [callArgs] = firstCall;
+                expect(callArgs.tool).toBe('platform.jadx');
+                expect(callArgs.timeoutMs).toBe(300_000);
+            });
+            it('passes extra args to jadx', async () => {
+                const mockRun = vi.fn(async () => ({
+                    ok: true,
+                    exitCode: 0,
+                    signal: null,
+                    stdout: 'done',
+                    stderr: '',
+                    truncated: false,
+                    durationMs: 100,
+                }));
+                const customRunner = makeRunner({ run: mockRun });
+                const customHandlers = new BridgeHandlers(customRunner);
+                await customHandlers.handleJadxBridge({
+                    action: 'decompile',
+                    inputPath: '/path/to/app.apk',
+                    extraArgs: ['--deobf', '--show-bad-code'],
+                });
+                const firstCall = mockRun.mock.calls[0];
+                if (!firstCall) {
+                    throw new Error('Expected jadx runner to be called');
+                }
+                const [callArgs] = firstCall;
+                expect(callArgs.args).toContain('--deobf');
+                expect(callArgs.args).toContain('--show-bad-code');
+            });
+            it('filters non-string entries from extraArgs', async () => {
+                const mockRun = vi.fn(async () => ({
+                    ok: true,
+                    exitCode: 0,
+                    signal: null,
+                    stdout: 'done',
+                    stderr: '',
+                    truncated: false,
+                    durationMs: 100,
+                }));
+                const customRunner = makeRunner({ run: mockRun });
+                const customHandlers = new BridgeHandlers(customRunner);
+                await customHandlers.handleJadxBridge({
+                    action: 'decompile',
+                    inputPath: '/path/to/app.apk',
+                    extraArgs: ['--deobf', 42, null, '--threads-count'],
+                });
+                const firstCall = mockRun.mock.calls[0];
+                if (!firstCall) {
+                    throw new Error('Expected jadx runner to be called');
+                }
+                const [callArgs] = firstCall;
+                expect(callArgs.args).toContain('--deobf');
+                expect(callArgs.args).toContain('--threads-count');
+                expect(callArgs.args).not.toContain('42');
+            });
+            it('returns error payload when runner throws', async () => {
+                const mockRun = vi.fn(async () => {
+                    throw new Error('jadx not found');
+                });
+                const customRunner = makeRunner({ run: mockRun });
+                const customHandlers = new BridgeHandlers(customRunner);
+                const result = parsePayload(await customHandlers.handleJadxBridge({
+                    action: 'decompile',
+                    inputPath: '/path/to/app.apk',
+                }));
+                expect(result.success).toBe(false);
+                expect(result.error).toContain('jadx not found');
+                expect(result.hint).toContain('jadx');
+            });
+            it('returns runner failure details when exit code is non-zero', async () => {
+                const mockRun = vi.fn(async () => ({
+                    ok: false,
+                    exitCode: 1,
+                    signal: null,
+                    stdout: 'partial output',
+                    stderr: 'some error',
+                    truncated: false,
+                    durationMs: 200,
+                }));
+                const customRunner = makeRunner({ run: mockRun });
+                const customHandlers = new BridgeHandlers(customRunner);
+                const result = parsePayload(await customHandlers.handleJadxBridge({
+                    action: 'decompile',
+                    inputPath: '/path/to/app.apk',
+                }));
+                expect(result.success).toBe(false);
+                expect(result.exitCode).toBe(1);
+                expect(result.stderr).toBe('some error');
+            });
+        });
+    });
+});

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

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

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

@@ -0,0 +1,176 @@
+import { describe, expect, it } from 'vitest';
+import { platformTools } from '../../../../src/server/domains/platform/definitions.js';
+function getTool(name) {
+    const tool = platformTools.find((candidate) => candidate.name === name);
+    expect(tool).toBeDefined();
+    return tool;
+}
+function getToolProperty(toolName, propertyName) {
+    const tool = getTool(toolName);
+    const property = tool.inputSchema.properties?.[propertyName];
+    expect(property).toBeDefined();
+    return property;
+}
+describe('platform tool definitions', () => {
+    describe('platformTools array', () => {
+        it('is a non-empty array', () => {
+            expect(Array.isArray(platformTools)).toBe(true);
+            expect(platformTools.length).toBeGreaterThan(0);
+        });
+        it('contains exactly 5 tools', () => {
+            expect(platformTools).toHaveLength(5);
+        });
+        it('has unique tool names', () => {
+            const names = platformTools.map((t) => t.name);
+            expect(new Set(names).size).toBe(names.length);
+        });
+        it.each(platformTools.map((tool) => [tool.name, tool]))('tool "%s" has required MCP structure', (_name, tool) => {
+            expect(tool).toEqual(expect.objectContaining({
+                name: expect.any(String),
+                description: expect.any(String),
+                inputSchema: expect.objectContaining({
+                    type: 'object',
+                    properties: expect.any(Object),
+                }),
+            }));
+        });
+        it('every tool has a non-empty description', () => {
+            for (const tool of platformTools) {
+                expect(tool.description?.trim().length ?? 0).toBeGreaterThan(0);
+            }
+        });
+        it('every tool inputSchema.type is "object"', () => {
+            for (const tool of platformTools) {
+                expect(tool.inputSchema.type).toBe('object');
+            }
+        });
+    });
+    describe('expected tool names', () => {
+        const expectedNames = [
+            'miniapp_pkg_scan',
+            'miniapp_pkg_unpack',
+            'miniapp_pkg_analyze',
+            'asar_extract',
+            'electron_inspect_app',
+        ];
+        it.each(expectedNames)('includes tool "%s"', (name) => {
+            const found = platformTools.find((tool) => tool.name === name);
+            expect(found).toBeDefined();
+        });
+    });
+    describe('miniapp_pkg_scan', () => {
+        it('has optional searchPath property', () => {
+            const tool = getTool('miniapp_pkg_scan');
+            expect(tool.inputSchema.properties).toHaveProperty('searchPath');
+            const searchPathProp = getToolProperty('miniapp_pkg_scan', 'searchPath');
+            expect(searchPathProp.type).toBe('string');
+        });
+        it('has no required properties', () => {
+            const tool = getTool('miniapp_pkg_scan');
+            expect(tool.inputSchema.required).toBeUndefined();
+        });
+    });
+    describe('miniapp_pkg_unpack', () => {
+        it('requires inputPath', () => {
+            const tool = getTool('miniapp_pkg_unpack');
+            expect(tool.inputSchema.required ?? []).toContain('inputPath');
+        });
+        it('has inputPath and outputDir properties', () => {
+            const tool = getTool('miniapp_pkg_unpack');
+            expect(tool.inputSchema.properties).toHaveProperty('inputPath');
+            expect(tool.inputSchema.properties).toHaveProperty('outputDir');
+        });
+        it('inputPath is type string', () => {
+            const prop = getToolProperty('miniapp_pkg_unpack', 'inputPath');
+            expect(prop.type).toBe('string');
+        });
+        it('outputDir is type string', () => {
+            const prop = getToolProperty('miniapp_pkg_unpack', 'outputDir');
+            expect(prop.type).toBe('string');
+        });
+    });
+    describe('miniapp_pkg_analyze', () => {
+        it('requires unpackedDir', () => {
+            const tool = getTool('miniapp_pkg_analyze');
+            expect(tool.inputSchema.required ?? []).toContain('unpackedDir');
+        });
+        it('unpackedDir is type string', () => {
+            const prop = getToolProperty('miniapp_pkg_analyze', 'unpackedDir');
+            expect(prop.type).toBe('string');
+        });
+    });
+    describe('asar_extract', () => {
+        it('requires inputPath', () => {
+            const tool = getTool('asar_extract');
+            expect(tool.inputSchema.required ?? []).toContain('inputPath');
+        });
+        it('has inputPath, outputDir, and listOnly properties', () => {
+            const tool = getTool('asar_extract');
+            expect(tool.inputSchema.properties).toHaveProperty('inputPath');
+            expect(tool.inputSchema.properties).toHaveProperty('outputDir');
+            expect(tool.inputSchema.properties).toHaveProperty('listOnly');
+        });
+        it('listOnly is type boolean with default false', () => {
+            const prop = getToolProperty('asar_extract', 'listOnly');
+            expect(prop.type).toBe('boolean');
+            expect(prop.default).toBe(false);
+        });
+        it('inputPath is type string', () => {
+            const prop = getToolProperty('asar_extract', 'inputPath');
+            expect(prop.type).toBe('string');
+        });
+    });
+    describe('electron_inspect_app', () => {
+        it('requires appPath', () => {
+            const tool = getTool('electron_inspect_app');
+            expect(tool.inputSchema.required ?? []).toContain('appPath');
+        });
+        it('appPath is type string', () => {
+            const prop = getToolProperty('electron_inspect_app', 'appPath');
+            expect(prop.type).toBe('string');
+        });
+        it('has only one property', () => {
+            const tool = getTool('electron_inspect_app');
+            expect(Object.keys(tool.inputSchema.properties ?? {})).toHaveLength(1);
+        });
+    });
+    describe('description quality', () => {
+        it('miniapp_pkg_scan mentions scanning', () => {
+            const tool = getTool('miniapp_pkg_scan');
+            expect(tool.description?.length ?? 0).toBeGreaterThan(10);
+        });
+        it('miniapp_pkg_unpack mentions unpacking', () => {
+            const tool = getTool('miniapp_pkg_unpack');
+            expect(tool.description?.length ?? 0).toBeGreaterThan(10);
+        });
+        it('asar_extract mentions Electron or asar', () => {
+            const tool = getTool('asar_extract');
+            const desc = tool.description?.toLowerCase() ?? '';
+            expect(desc.includes('electron') || desc.includes('asar')).toBe(true);
+        });
+        it('electron_inspect_app mentions Electron', () => {
+            const tool = getTool('electron_inspect_app');
+            const desc = tool.description?.toLowerCase() ?? '';
+            expect(desc).toContain('electron');
+        });
+    });
+    describe('required fields completeness', () => {
+        it('tools with required field declare an array', () => {
+            for (const tool of platformTools) {
+                if (tool.inputSchema.required) {
+                    expect(Array.isArray(tool.inputSchema.required)).toBe(true);
+                    expect(tool.inputSchema.required.length).toBeGreaterThan(0);
+                }
+            }
+        });
+        it('every required field exists in properties', () => {
+            for (const tool of platformTools) {
+                if (tool.inputSchema.required) {
+                    for (const reqField of tool.inputSchema.required) {
+                        expect(tool.inputSchema.properties).toHaveProperty(reqField);
+                    }
+                }
+            }
+        });
+    });
+});

package/dist/tests/server/domains/platform/electron-asar-helpers.test.d.ts

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