@jshookmcp/jshook 0.2.5 → 0.2.7

package/dist/src/server/domains/platform/handlers/bridge-handlers.js

@@ -1,359 +0,0 @@
-import { basename, extname, resolve } from 'node:path';
-import { execFile, spawn } from 'node:child_process';
-import { promisify } from 'node:util';
-import { argStringArray } from '../../../domains/shared/parse-args.js';
-import {} from '../../../domains/shared/modules.js';
-import { toTextResponse, toErrorResponse, parseStringArg, resolveOutputDirectory, checkExternalCommand, } from '../../../domains/platform/handlers/platform-utils.js';
-const execFileAsync = promisify(execFile);
-function generateFridaTemplate(hookType, functionName) {
-    const templates = {
-        intercept: [
-            `// Frida Interceptor template for: ${functionName}`,
-            `Interceptor.attach(Module.getExportByName(null, '${functionName}'), {`,
-            `  onEnter(args) {`,
-            `    console.log('[+] ${functionName} called');`,
-            `    console.log('    arg0:', args[0]);`,
-            `    console.log('    arg1:', args[1]);`,
-            `  },`,
-            `  onLeave(retval) {`,
-            `    console.log('[+] ${functionName} returned:', retval);`,
-            `  }`,
-            `});`,
-        ].join('\n'),
-        replace: [
-            `// Frida Replace template for: ${functionName}`,
-            `Interceptor.replace(Module.getExportByName(null, '${functionName}'),`,
-            `  new NativeCallback(function() {`,
-            `    console.log('[+] ${functionName} replaced');`,
-            `    // Add custom logic here`,
-            `    return 0;`,
-            `  }, 'int', [])`,
-            `);`,
-        ].join('\n'),
-        stalker: [
-            `// Frida Stalker template for tracing: ${functionName}`,
-            `const targetAddr = Module.getExportByName(null, '${functionName}');`,
-            `Interceptor.attach(targetAddr, {`,
-            `  onEnter(args) {`,
-            `    this.tid = Process.getCurrentThreadId();`,
-            `    Stalker.follow(this.tid, {`,
-            `      events: { call: true, ret: false, exec: false },`,
-            `      onCallSummary(summary) {`,
-            `        for (const [addr, count] of Object.entries(summary)) {`,
-            `          const sym = DebugSymbol.fromAddress(ptr(addr));`,
-            `          if (sym.name) console.log(\`  \${sym.name}: \${count}x\`);`,
-            `        }`,
-            `      }`,
-            `    });`,
-            `  },`,
-            `  onLeave() {`,
-            `    Stalker.unfollow(this.tid);`,
-            `  }`,
-            `});`,
-        ].join('\n'),
-        module_export: [
-            `// Frida Module Export enumeration`,
-            `const exports = Module.enumerateExports('${functionName}');`,
-            `console.log(\`[+] Found \${exports.length} exports in ${functionName}\`);`,
-            `exports.forEach((exp, i) => {`,
-            `  console.log(\`  [\${i}] \${exp.type} \${exp.name} @ \${exp.address}\`);`,
-            `});`,
-        ].join('\n'),
-    };
-    return templates[hookType] ?? templates.intercept;
-}
-const fridaSessions = new Map();
-export class BridgeHandlers {
-    runner;
-    constructor(runner) {
-        this.runner = runner;
-    }
-    async handleFridaBridge(args) {
-        const action = parseStringArg(args, 'action', true) ?? 'guide';
-        if (action === 'check_env') {
-            return checkExternalCommand('frida', ['--version'], 'frida');
-        }
-        if (action === 'generate_script') {
-            const target = parseStringArg(args, 'target') ?? '<process_name>';
-            const hookType = parseStringArg(args, 'hookType') ?? 'intercept';
-            const functionName = parseStringArg(args, 'functionName') ?? '<target_function>';
-            const script = generateFridaTemplate(hookType, functionName);
-            return toTextResponse({
-                success: true,
-                target,
-                hookType,
-                functionName,
-                script,
-                usage: `frida -p <PID> -l script.js  // or: frida -n "${target}" -l script.js`,
-                tip: 'Save the script to a .js file, then use the frida CLI to inject it.',
-            });
-        }
-        if (action === 'attach') {
-            return this._handleFridaAttach(args);
-        }
-        if (action === 'run_script') {
-            return this._handleFridaRunScript(args);
-        }
-        if (action === 'detach') {
-            return this._handleFridaDetach(args);
-        }
-        if (action === 'list_sessions') {
-            return this._handleFridaListSessions();
-        }
-        return toTextResponse({
-            success: true,
-            guide: {
-                what: 'Frida is a dynamic instrumentation toolkit for native apps (Android, iOS, Windows, macOS, Linux).',
-                install: ['pip install frida-tools', 'npm install frida  // optional Node.js bindings'],
-                workflow: [
-                    '1. Use process_find / process_find_chromium to locate the target process',
-                    '2. Use frida_bridge(action="attach", pid=<PID>) to live-attach to the process',
-                    '3. Use frida_bridge(action="run_script", sessionId=<id>, script="...") to inject hooks',
-                    '4. Use frida_bridge(action="generate_script") to generate hook templates',
-                    '5. Use frida_bridge(action="detach", sessionId=<id>) to clean disconnect',
-                    '6. Combine with electron_launch_debug for main-process Frida injection',
-                ],
-                actions: [
-                    'check_env',
-                    'attach',
-                    'run_script',
-                    'detach',
-                    'list_sessions',
-                    'generate_script',
-                    'guide',
-                ],
-                links: ['https://frida.re/docs/home/', 'https://frida.re/docs/javascript-api/'],
-                integration: 'Frida hooks can call back to this MCP via fetch("http://localhost:<port>/...") for real-time data exchange.',
-            },
-        });
-    }
-    async _handleFridaAttach(args) {
-        const pid = args.pid;
-        const processName = parseStringArg(args, 'processName');
-        if (!pid && !processName) {
-            throw new Error('Either pid or processName is required for attach');
-        }
-        const fridaArgs = [];
-        if (pid) {
-            fridaArgs.push('-p', String(pid));
-        }
-        else if (processName) {
-            fridaArgs.push('-n', processName);
-        }
-        fridaArgs.push('--no-pause');
-        try {
-            await execFileAsync('frida', ['--version'], { timeout: 5000 });
-        }
-        catch {
-            return toTextResponse({
-                success: false,
-                tool: 'frida_bridge',
-                error: 'frida CLI not found. Install with: pip install frida-tools',
-                note: 'Frida live attach requires the frida CLI tools installed and in PATH.',
-            });
-        }
-        const child = spawn('frida', fridaArgs, {
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        const sessionId = `frida-${pid ?? processName}-${Date.now()}`;
-        const session = {
-            id: sessionId,
-            pid: pid ?? 0,
-            child,
-            output: [],
-            startedAt: Date.now(),
-        };
-        child.stdout?.on('data', (data) => {
-            session.output.push(data.toString());
-            if (session.output.length > 100)
-                session.output.shift();
-        });
-        child.stderr?.on('data', (data) => {
-            session.output.push(`[stderr] ${data.toString()}`);
-            if (session.output.length > 100)
-                session.output.shift();
-        });
-        child.on('exit', () => {
-            fridaSessions.delete(sessionId);
-        });
-        fridaSessions.set(sessionId, session);
-        await new Promise((r) => setTimeout(r, 2000));
-        return toTextResponse({
-            success: true,
-            tool: 'frida_bridge',
-            action: 'attach',
-            sessionId,
-            pid: pid ?? processName,
-            initialOutput: session.output.join('').slice(0, 2000),
-            usage: {
-                runScript: `frida_bridge(action="run_script", sessionId="${sessionId}", script="...")`,
-                detach: `frida_bridge(action="detach", sessionId="${sessionId}")`,
-            },
-        });
-    }
-    async _handleFridaRunScript(args) {
-        const sessionId = parseStringArg(args, 'sessionId', true);
-        const script = parseStringArg(args, 'script', true);
-        if (!sessionId || !script) {
-            throw new Error('sessionId and script are required');
-        }
-        const session = fridaSessions.get(sessionId);
-        if (!session) {
-            const pid = args.pid;
-            const processName = parseStringArg(args, 'processName');
-            if (!pid && !processName) {
-                return toTextResponse({
-                    success: false,
-                    tool: 'frida_bridge',
-                    error: `Session ${sessionId} not found. Provide pid or processName for one-shot execution.`,
-                    activeSessions: Array.from(fridaSessions.keys()),
-                });
-            }
-            const fridaArgs = [];
-            if (pid)
-                fridaArgs.push('-p', String(pid));
-            else if (processName)
-                fridaArgs.push('-n', processName);
-            fridaArgs.push('--no-pause', '-e', script);
-            try {
-                const { stdout, stderr } = await execFileAsync('frida', fridaArgs, {
-                    timeout: 30_000,
-                    maxBuffer: 5 * 1024 * 1024,
-                });
-                return toTextResponse({
-                    success: true,
-                    tool: 'frida_bridge',
-                    action: 'run_script',
-                    mode: 'one-shot',
-                    stdout: stdout.slice(0, 10_000),
-                    stderr: stderr.slice(0, 2000),
-                });
-            }
-            catch (error) {
-                return toErrorResponse('frida_bridge', error);
-            }
-        }
-        session.output.length = 0;
-        session.child.stdin?.write(script + '\n');
-        await new Promise((r) => setTimeout(r, 3000));
-        return toTextResponse({
-            success: true,
-            tool: 'frida_bridge',
-            action: 'run_script',
-            sessionId,
-            mode: 'interactive',
-            output: session.output.join('').slice(0, 10_000),
-        });
-    }
-    async _handleFridaDetach(args) {
-        const sessionId = parseStringArg(args, 'sessionId', true);
-        if (!sessionId)
-            throw new Error('sessionId is required');
-        const session = fridaSessions.get(sessionId);
-        if (!session) {
-            return toTextResponse({
-                success: false,
-                tool: 'frida_bridge',
-                error: `Session not found: ${sessionId}`,
-                activeSessions: Array.from(fridaSessions.keys()),
-            });
-        }
-        session.child.stdin?.write('%quit\n');
-        setTimeout(() => {
-            try {
-                session.child.kill();
-            }
-            catch {
-            }
-        }, 2000);
-        fridaSessions.delete(sessionId);
-        return toTextResponse({
-            success: true,
-            tool: 'frida_bridge',
-            action: 'detach',
-            sessionId,
-            message: 'Frida session detached.',
-        });
-    }
-    async _handleFridaListSessions() {
-        const sessions = Array.from(fridaSessions.entries()).map(([id, s]) => ({
-            sessionId: id,
-            pid: s.pid,
-            uptime: Math.round((Date.now() - s.startedAt) / 1000),
-            outputLines: s.output.length,
-        }));
-        return toTextResponse({
-            success: true,
-            tool: 'frida_bridge',
-            action: 'list_sessions',
-            sessions,
-            count: sessions.length,
-        });
-    }
-    async handleJadxBridge(args) {
-        const action = parseStringArg(args, 'action', true) ?? 'guide';
-        if (action === 'check_env') {
-            return checkExternalCommand('jadx', ['--version'], 'jadx');
-        }
-        if (action === 'decompile') {
-            const inputPath = parseStringArg(args, 'inputPath', true);
-            if (!inputPath) {
-                throw new Error('inputPath is required for decompile action');
-            }
-            const absoluteInput = resolve(inputPath);
-            const outputDirArg = parseStringArg(args, 'outputDir');
-            const extraArgs = argStringArray(args, 'extraArgs');
-            const outputIdentity = basename(absoluteInput, extname(absoluteInput));
-            const outputDirectory = await resolveOutputDirectory('jadx-decompile', outputIdentity, outputDirArg);
-            const jadxArgs = ['-d', outputDirectory.absolutePath, ...extraArgs, absoluteInput];
-            try {
-                const result = await this.runner.run({
-                    tool: 'platform.jadx',
-                    args: jadxArgs,
-                    timeoutMs: 300_000,
-                });
-                return toTextResponse({
-                    success: result.ok,
-                    outputDir: outputDirectory.displayPath,
-                    exitCode: result.exitCode,
-                    stdout: result.stdout.slice(0, 2000),
-                    stderr: result.stderr.slice(0, 2000),
-                    truncated: result.truncated,
-                    durationMs: result.durationMs,
-                });
-            }
-            catch (error) {
-                return toErrorResponse('jadx_bridge', error, {
-                    hint: 'Ensure jadx is installed: https://github.com/skylot/jadx/releases',
-                });
-            }
-        }
-        return toTextResponse({
-            success: true,
-            guide: {
-                what: 'Jadx is a DEX to Java decompiler. Supports APK, DEX, AAR, AAB, and ZIP files.',
-                install: [
-                    'Download from: https://github.com/skylot/jadx/releases',
-                    'Ensure jadx is in PATH (or provide full path)',
-                    'Requires Java 11+ runtime',
-                ],
-                workflow: [
-                    '1. Use jadx_bridge(action="check_env") to verify jadx installation',
-                    '2. Use jadx_bridge(action="decompile", inputPath="app.apk") to decompile',
-                    '3. Use search_in_scripts / collect_code to analyze the decompiled Java source',
-                    '4. Combine with crypto_extract_standalone for sign/encrypt function extraction',
-                ],
-                commonArgs: [
-                    '--deobf            // Enable deobfuscation',
-                    '--show-bad-code    // Show decompiled code even if errors occur',
-                    '--no-res           // Skip resource decoding (faster)',
-                    '--threads-count 4  // Parallel decompilation',
-                ],
-                links: [
-                    'https://github.com/skylot/jadx',
-                    'https://github.com/skylot/jadx/wiki/jadx-CLI-options',
-                ],
-            },
-        });
-    }
-}

package/dist/src/server/domains/platform/handlers/electron-asar-helpers.d.ts

@@ -1,11 +0,0 @@
-import { type AsarFileEntry, type ParsedAsar } from '../../../domains/platform/handlers/platform-utils.js';
-export declare function flattenAsarEntries(headerNode: Record<string, unknown>): AsarFileEntry[];
-export declare function isAsarDataOffsetValid(files: AsarFileEntry[], dataOffset: number, totalSize: number): boolean;
-export declare function parseAsarBuffer(asarBuffer: Buffer): ParsedAsar;
-export declare function readAsarEntryBuffer(asarBuffer: Buffer, parsedAsar: ParsedAsar, entryPath: string): Buffer | undefined;
-export declare function readAsarEntryText(asarBuffer: Buffer, parsedAsar: ParsedAsar, entryPath: string): string | undefined;
-export declare function parseBrowserWindowHints(sourceText: string): {
-    preloadScripts: string[];
-    devToolsEnabled: boolean | null;
-};
-export declare function findFilesystemPreloadScripts(rootDir: string): Promise<string[]>;

package/dist/src/server/domains/platform/handlers/electron-asar-helpers.js

@@ -1,185 +0,0 @@
-import { basename, extname } from 'node:path';
-import { isRecord, sanitizeArchiveRelativePath, toDisplayPath, walkDirectory, } from '../../../domains/platform/handlers/platform-utils.js';
-function trimTrailingNulls(value) {
-    let end = value.length;
-    while (end > 0 && value.charCodeAt(end - 1) === 0) {
-        end -= 1;
-    }
-    return end === value.length ? value : value.slice(0, end);
-}
-export function flattenAsarEntries(headerNode) {
-    if (!isRecord(headerNode.files)) {
-        return [];
-    }
-    const files = [];
-    const walk = (nodes, prefix) => {
-        for (const [name, rawNode] of Object.entries(nodes)) {
-            if (!isRecord(rawNode)) {
-                continue;
-            }
-            const pathPart = prefix.length > 0 ? `${prefix}/${name}` : name;
-            if (isRecord(rawNode.files)) {
-                walk(rawNode.files, pathPart);
-                continue;
-            }
-            const sizeRaw = rawNode.size;
-            const offsetRaw = rawNode.offset;
-            const unpacked = rawNode.unpacked === true;
-            const size = typeof sizeRaw === 'number' && Number.isFinite(sizeRaw) && sizeRaw >= 0 ? sizeRaw : 0;
-            let offset = 0;
-            if (typeof offsetRaw === 'number' || typeof offsetRaw === 'string') {
-                const parsedOffset = Number(offsetRaw);
-                if (Number.isFinite(parsedOffset) && parsedOffset >= 0) {
-                    offset = parsedOffset;
-                }
-            }
-            files.push({
-                path: sanitizeArchiveRelativePath(pathPart),
-                size,
-                offset,
-                unpacked,
-            });
-        }
-    };
-    walk(headerNode.files, '');
-    return files;
-}
-export function isAsarDataOffsetValid(files, dataOffset, totalSize) {
-    const samples = files.filter((entry) => !entry.unpacked).slice(0, 32);
-    for (const file of samples) {
-        const start = dataOffset + file.offset;
-        const end = start + file.size;
-        if (start < 0 || end < start || end > totalSize) {
-            return false;
-        }
-    }
-    return true;
-}
-export function parseAsarBuffer(asarBuffer) {
-    if (asarBuffer.length < 16) {
-        throw new Error('Invalid ASAR: file too small');
-    }
-    const headerSize = asarBuffer.readUInt32LE(0);
-    const headerStringSize = asarBuffer.readUInt32LE(4);
-    const headerContentSize = asarBuffer.readUInt32LE(8);
-    const padding = asarBuffer.readUInt32LE(12);
-    const headerStart = 16;
-    const lengthCandidates = Array.from(new Set([headerContentSize, headerStringSize, headerSize - 8, headerSize])).filter((value) => value > 0 && headerStart + value <= asarBuffer.length);
-    let headerObject = null;
-    let headerLength = 0;
-    for (const candidateLength of lengthCandidates) {
-        const headerText = asarBuffer
-            .subarray(headerStart, headerStart + candidateLength)
-            .toString('utf-8');
-        const normalizedHeaderText = trimTrailingNulls(headerText).trim();
-        if (normalizedHeaderText.length === 0) {
-            continue;
-        }
-        try {
-            const parsed = JSON.parse(normalizedHeaderText);
-            if (isRecord(parsed)) {
-                headerObject = parsed;
-                headerLength = candidateLength;
-                break;
-            }
-        }
-        catch {
-            const lastBrace = normalizedHeaderText.lastIndexOf('}');
-            if (lastBrace > 0) {
-                try {
-                    const trimmed = normalizedHeaderText.substring(0, lastBrace + 1);
-                    const parsed = JSON.parse(trimmed);
-                    if (isRecord(parsed)) {
-                        headerObject = parsed;
-                        headerLength = candidateLength;
-                        break;
-                    }
-                }
-                catch {
-                }
-            }
-        }
-    }
-    if (!headerObject) {
-        throw new Error('Invalid ASAR: cannot parse header JSON');
-    }
-    const rootNode = isRecord(headerObject.files) ? headerObject : { files: headerObject };
-    const files = flattenAsarEntries(rootNode);
-    const offsetCandidates = Array.from(new Set([
-        headerStart + headerLength + padding,
-        8 + headerSize,
-        headerStart + headerContentSize + padding,
-        headerStart + headerStringSize + padding,
-    ])).filter((value) => value >= 0 && value <= asarBuffer.length);
-    let dataOffset = offsetCandidates[0] ?? headerStart + headerLength;
-    for (const candidate of offsetCandidates) {
-        if (isAsarDataOffsetValid(files, candidate, asarBuffer.length)) {
-            dataOffset = candidate;
-            break;
-        }
-    }
-    return {
-        files,
-        dataOffset,
-        headerSize,
-        headerStringSize,
-        headerContentSize,
-        padding,
-    };
-}
-export function readAsarEntryBuffer(asarBuffer, parsedAsar, entryPath) {
-    const normalizedEntryPath = sanitizeArchiveRelativePath(entryPath);
-    if (normalizedEntryPath.length === 0) {
-        return undefined;
-    }
-    const matchedEntry = parsedAsar.files.find((entry) => entry.path === normalizedEntryPath) ??
-        parsedAsar.files.find((entry) => entry.path.endsWith(`/${normalizedEntryPath}`));
-    if (!matchedEntry || matchedEntry.unpacked) {
-        return undefined;
-    }
-    const start = parsedAsar.dataOffset + matchedEntry.offset;
-    const end = start + matchedEntry.size;
-    if (start < 0 || end > asarBuffer.length || end < start) {
-        return undefined;
-    }
-    return asarBuffer.subarray(start, end);
-}
-export function readAsarEntryText(asarBuffer, parsedAsar, entryPath) {
-    const data = readAsarEntryBuffer(asarBuffer, parsedAsar, entryPath);
-    return data ? data.toString('utf-8') : undefined;
-}
-export function parseBrowserWindowHints(sourceText) {
-    const preloadScripts = new Set();
-    const preloadPattern = /preload\s*:\s*(?:path\.(?:join|resolve)\([^)]*?['"`]([^'"`]+)['"`][^)]*\)|['"`]([^'"`]+)['"`])/g;
-    let preloadMatch = preloadPattern.exec(sourceText);
-    while (preloadMatch) {
-        const preloadValue = preloadMatch[1] ?? preloadMatch[2];
-        if (preloadValue) {
-            preloadScripts.add(preloadValue.trim());
-        }
-        preloadMatch = preloadPattern.exec(sourceText);
-    }
-    const explicitDevToolsMatch = sourceText.match(/devTools\s*:\s*(true|false)/);
-    let devToolsEnabled = null;
-    if (explicitDevToolsMatch?.[1]) {
-        devToolsEnabled = explicitDevToolsMatch[1] === 'true';
-    }
-    if (/\.openDevTools\s*\(/.test(sourceText)) {
-        devToolsEnabled = true;
-    }
-    return {
-        preloadScripts: Array.from(preloadScripts),
-        devToolsEnabled,
-    };
-}
-export async function findFilesystemPreloadScripts(rootDir) {
-    const matches = new Set();
-    await walkDirectory(rootDir, async (absolutePath, _fileStats) => {
-        const lowerName = basename(absolutePath).toLowerCase();
-        const lowerExt = extname(absolutePath).toLowerCase();
-        if (lowerExt === '.js' && lowerName.includes('preload')) {
-            matches.add(toDisplayPath(absolutePath));
-        }
-    });
-    return Array.from(matches).toSorted().slice(0, 100);
-}

package/dist/src/server/domains/platform/handlers/electron-dual-cdp.d.ts

@@ -1,3 +0,0 @@
-import { toTextResponse } from '../../../domains/platform/handlers/platform-utils.js';
-export declare function handleElectronLaunchDebug(args: Record<string, unknown>): Promise<ReturnType<typeof toTextResponse>>;
-export declare function handleElectronDebugStatus(args: Record<string, unknown>): Promise<ReturnType<typeof toTextResponse>>;