@jshookmcp/jshook 0.2.3 → 0.2.5

package/dist/src/server/domains/platform/handlers/electron-ipc-sniffer.js

@@ -0,0 +1,370 @@
+import { toTextResponse, toErrorResponse, parseStringArg, } from '../../../domains/platform/handlers/platform-utils.js';
+const ipcSessions = new Map();
+const IPC_HOOK_PAYLOAD = `
+(function() {
+  if (window.__ipcSnifferInstalled) return 'already_installed';
+
+  const captured = [];
+  window.__ipcSnifferCaptured = captured;
+  window.__ipcSnifferInstalled = true;
+
+  // Try to access ipcRenderer from contextBridge-exposed API or require
+  let ipcRenderer = null;
+
+  // Method 1: Direct require (works if nodeIntegration is enabled)
+  try {
+    ipcRenderer = require('electron').ipcRenderer;
+  } catch(e) {}
+
+  // Method 2: window.electron (common contextBridge pattern)
+  if (!ipcRenderer && window.electron && window.electron.ipcRenderer) {
+    ipcRenderer = window.electron.ipcRenderer;
+  }
+
+  if (!ipcRenderer) {
+    return 'ipcRenderer_not_accessible';
+  }
+
+  // Hook invoke
+  const origInvoke = ipcRenderer.invoke.bind(ipcRenderer);
+  ipcRenderer.invoke = function(channel, ...args) {
+    captured.push({
+      timestamp: Date.now(),
+      method: 'invoke',
+      channel: channel,
+      args: args.map(a => {
+        try { return JSON.parse(JSON.stringify(a)); }
+        catch { return String(a); }
+      })
+    });
+    return origInvoke(channel, ...args);
+  };
+
+  // Hook send
+  const origSend = ipcRenderer.send.bind(ipcRenderer);
+  ipcRenderer.send = function(channel, ...args) {
+    captured.push({
+      timestamp: Date.now(),
+      method: 'send',
+      channel: channel,
+      args: args.map(a => {
+        try { return JSON.parse(JSON.stringify(a)); }
+        catch { return String(a); }
+      })
+    });
+    return origSend(channel, ...args);
+  };
+
+  // Hook sendSync
+  if (ipcRenderer.sendSync) {
+    const origSendSync = ipcRenderer.sendSync.bind(ipcRenderer);
+    ipcRenderer.sendSync = function(channel, ...args) {
+      captured.push({
+        timestamp: Date.now(),
+        method: 'sendSync',
+        channel: channel,
+        args: args.map(a => {
+          try { return JSON.parse(JSON.stringify(a)); }
+          catch { return String(a); }
+        })
+      });
+      return origSendSync(channel, ...args);
+    };
+  }
+
+  return 'hooks_installed';
+})();
+`;
+const IPC_DUMP_PAYLOAD = `
+(function() {
+  const captured = window.__ipcSnifferCaptured || [];
+  const result = JSON.stringify(captured);
+  return result;
+})();
+`;
+const IPC_CLEAR_PAYLOAD = `
+(function() {
+  if (window.__ipcSnifferCaptured) {
+    const count = window.__ipcSnifferCaptured.length;
+    window.__ipcSnifferCaptured.length = 0;
+    return String(count);
+  }
+  return '0';
+})();
+`;
+async function cdpEvaluate(wsDebuggerUrl, expression) {
+    const match = wsDebuggerUrl.match(/ws:\/\/([\d.]+:\d+)\//);
+    if (!match?.[1]) {
+        return { ok: false, error: `Invalid wsDebuggerUrl: ${wsDebuggerUrl}` };
+    }
+    const hostPort = match[1];
+    try {
+        const listRes = await fetch(`http://${hostPort}/json`, {
+            signal: AbortSignal.timeout(5000),
+        });
+        const targets = (await listRes.json());
+        const page = targets.find((t) => t.type === 'page');
+        if (!page) {
+            return { ok: false, error: 'No page target found' };
+        }
+        const pageWsUrl = page.webSocketDebuggerUrl;
+        if (!pageWsUrl) {
+            return { ok: false, error: 'Page target has no WebSocket debugger URL' };
+        }
+        return await cdpEvalViaWs(pageWsUrl, expression);
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function cdpEvalViaWs(wsUrl, expression) {
+    return new Promise((resolve) => {
+        try {
+            const WS = globalThis.WebSocket;
+            if (!WS) {
+                resolve({
+                    ok: false,
+                    error: 'WebSocket not available. Requires Node.js 21+ or ws package.',
+                });
+                return;
+            }
+            const ws = new WS(wsUrl);
+            const timeout = setTimeout(() => {
+                try {
+                    ws.close();
+                }
+                catch {
+                }
+                resolve({ ok: false, error: 'CDP WebSocket timeout (10s)' });
+            }, 10_000);
+            ws.addEventListener('open', () => {
+                ws.send(JSON.stringify({
+                    id: 1,
+                    method: 'Runtime.evaluate',
+                    params: {
+                        expression,
+                        returnByValue: true,
+                        awaitPromise: false,
+                    },
+                }));
+            });
+            ws.addEventListener('message', (event) => {
+                clearTimeout(timeout);
+                try {
+                    const data = JSON.parse(String(event.data));
+                    if (data.result?.exceptionDetails) {
+                        resolve({ ok: false, error: data.result.exceptionDetails.text });
+                    }
+                    else {
+                        resolve({ ok: true, result: String(data.result?.result?.value ?? '') });
+                    }
+                }
+                catch (e) {
+                    resolve({ ok: false, error: `Parse error: ${e}` });
+                }
+                try {
+                    ws.close();
+                }
+                catch {
+                }
+            });
+            ws.addEventListener('error', (err) => {
+                clearTimeout(timeout);
+                resolve({ ok: false, error: `WebSocket error: ${err}` });
+            });
+        }
+        catch (error) {
+            resolve({
+                ok: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    });
+}
+export async function handleElectronIPCSniff(args) {
+    try {
+        const action = parseStringArg(args, 'action') ?? 'guide';
+        if (action === 'start') {
+            const port = args.port ?? 9222;
+            const sessionId = `ipc-sniff-${port}-${Date.now()}`;
+            let wsUrl;
+            try {
+                const res = await fetch(`http://127.0.0.1:${port}/json/version`, {
+                    signal: AbortSignal.timeout(5000),
+                });
+                const info = (await res.json());
+                wsUrl = info.webSocketDebuggerUrl ?? `ws://127.0.0.1:${port}/devtools/browser`;
+            }
+            catch {
+                return toTextResponse({
+                    success: false,
+                    tool: 'electron_ipc_sniff',
+                    error: `Cannot connect to CDP at port ${port}. Ensure Electron is launched with --remote-debugging-port=${port}.`,
+                    hint: 'Use electron_launch_debug to start the app with CDP enabled.',
+                });
+            }
+            const injectResult = await cdpEvaluate(wsUrl, IPC_HOOK_PAYLOAD);
+            if (!injectResult.ok) {
+                return toTextResponse({
+                    success: false,
+                    tool: 'electron_ipc_sniff',
+                    error: `Failed to inject IPC hooks: ${injectResult.error}`,
+                    hint: 'The renderer may have contextIsolation enabled. Try injecting via main process CDP instead.',
+                });
+            }
+            const session = {
+                id: sessionId,
+                port,
+                wsUrl,
+                messages: [],
+                startedAt: Date.now(),
+                active: true,
+            };
+            ipcSessions.set(sessionId, session);
+            return toTextResponse({
+                success: true,
+                tool: 'electron_ipc_sniff',
+                action: 'start',
+                sessionId,
+                port,
+                hookStatus: injectResult.result,
+                usage: {
+                    dump: `electron_ipc_sniff(action="dump", sessionId="${sessionId}")`,
+                    stop: `electron_ipc_sniff(action="stop", sessionId="${sessionId}")`,
+                },
+                note: injectResult.result === 'ipcRenderer_not_accessible'
+                    ? 'ipcRenderer not accessible — contextIsolation may be enabled. IPC hooking requires nodeIntegration or a custom preload.'
+                    : 'IPC hooks installed. Interact with the app, then use dump to retrieve captured messages.',
+            });
+        }
+        if (action === 'dump') {
+            const sessionId = parseStringArg(args, 'sessionId');
+            const port = args.port;
+            const clear = args.clear !== false;
+            let session;
+            if (sessionId) {
+                session = ipcSessions.get(sessionId);
+            }
+            else if (port) {
+                session = Array.from(ipcSessions.values()).find((s) => s.port === port);
+            }
+            else {
+                const sessions = Array.from(ipcSessions.values());
+                session = sessions[sessions.length - 1];
+            }
+            if (!session) {
+                return toTextResponse({
+                    success: false,
+                    tool: 'electron_ipc_sniff',
+                    error: 'No active IPC sniff session found.',
+                    activeSessions: Array.from(ipcSessions.keys()),
+                    hint: 'Start a session first: electron_ipc_sniff(action="start", port=9222)',
+                });
+            }
+            const dumpResult = await cdpEvaluate(session.wsUrl, IPC_DUMP_PAYLOAD);
+            if (!dumpResult.ok) {
+                return toTextResponse({
+                    success: false,
+                    tool: 'electron_ipc_sniff',
+                    error: `Failed to dump IPC messages: ${dumpResult.error}`,
+                });
+            }
+            let messages = [];
+            try {
+                messages = JSON.parse(dumpResult.result ?? '[]');
+            }
+            catch {
+                messages = [];
+            }
+            if (clear && messages.length > 0) {
+                await cdpEvaluate(session.wsUrl, IPC_CLEAR_PAYLOAD);
+            }
+            const channelSummary = {};
+            for (const msg of messages) {
+                channelSummary[msg.channel] = (channelSummary[msg.channel] ?? 0) + 1;
+            }
+            return toTextResponse({
+                success: true,
+                tool: 'electron_ipc_sniff',
+                action: 'dump',
+                sessionId: session.id,
+                messageCount: messages.length,
+                channelSummary,
+                messages: messages.slice(0, 200),
+                cleared: clear,
+                note: messages.length > 200
+                    ? `Showing first 200 of ${messages.length} messages. Use dump repeatedly for ongoing capture.`
+                    : undefined,
+            });
+        }
+        if (action === 'stop') {
+            const sessionId = parseStringArg(args, 'sessionId');
+            if (!sessionId) {
+                return toTextResponse({
+                    success: false,
+                    tool: 'electron_ipc_sniff',
+                    error: 'sessionId is required for stop.',
+                    activeSessions: Array.from(ipcSessions.keys()),
+                });
+            }
+            const session = ipcSessions.get(sessionId);
+            if (!session) {
+                return toTextResponse({
+                    success: false,
+                    tool: 'electron_ipc_sniff',
+                    error: `Session not found: ${sessionId}`,
+                });
+            }
+            session.active = false;
+            ipcSessions.delete(sessionId);
+            return toTextResponse({
+                success: true,
+                tool: 'electron_ipc_sniff',
+                action: 'stop',
+                sessionId,
+                message: 'IPC sniff session stopped.',
+                uptime: Math.round((Date.now() - session.startedAt) / 1000),
+            });
+        }
+        if (action === 'list') {
+            const sessions = Array.from(ipcSessions.entries()).map(([id, s]) => ({
+                sessionId: id,
+                port: s.port,
+                active: s.active,
+                uptime: Math.round((Date.now() - s.startedAt) / 1000),
+            }));
+            return toTextResponse({
+                success: true,
+                tool: 'electron_ipc_sniff',
+                action: 'list',
+                sessions,
+                count: sessions.length,
+            });
+        }
+        return toTextResponse({
+            success: true,
+            guide: {
+                what: 'Electron IPC sniffer — intercepts ipcRenderer.invoke/send/sendSync messages via CDP injection.',
+                workflow: [
+                    '1. Launch Electron with: electron_launch_debug(exePath="...")',
+                    '2. Start sniffing: electron_ipc_sniff(action="start", port=9222)',
+                    '3. Interact with the app to trigger IPC messages',
+                    '4. Dump captured: electron_ipc_sniff(action="dump", sessionId="...")',
+                    '5. Stop when done: electron_ipc_sniff(action="stop", sessionId="...")',
+                ],
+                actions: ['start', 'dump', 'stop', 'list', 'guide'],
+                limitations: [
+                    'Requires renderer CDP port (--remote-debugging-port)',
+                    'contextIsolation=true may block direct ipcRenderer access',
+                    'Main process IPC (ipcMain) is captured indirectly through renderer-side hooks',
+                ],
+            },
+        });
+    }
+    catch (error) {
+        return toErrorResponse('electron_ipc_sniff', error);
+    }
+}

package/dist/src/server/domains/platform/handlers/electron-userdata-handler.d.ts

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

package/dist/src/server/domains/platform/handlers/electron-userdata-handler.js

@@ -0,0 +1,78 @@
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { toTextResponse, toErrorResponse, parseStringArg, pathExists, } from '../../../domains/platform/handlers/platform-utils.js';
+export async function handleElectronScanUserdata(args) {
+    try {
+        const dirPath = parseStringArg(args, 'dirPath', true);
+        if (!dirPath) {
+            throw new Error('dirPath is required');
+        }
+        const maxFiles = typeof args.maxFiles === 'number' && args.maxFiles > 0 ? args.maxFiles : 20;
+        const maxFileSizeKB = typeof args.maxFileSizeKB === 'number' && args.maxFileSizeKB > 0 ? args.maxFileSizeKB : 1024;
+        const maxFileSize = maxFileSizeKB * 1024;
+        if (!(await pathExists(dirPath))) {
+            return toTextResponse({
+                success: false,
+                tool: 'electron_scan_userdata',
+                error: `Directory does not exist: ${dirPath}`,
+            });
+        }
+        const dirStat = await stat(dirPath);
+        if (!dirStat.isDirectory()) {
+            return toTextResponse({
+                success: false,
+                tool: 'electron_scan_userdata',
+                error: `Path is not a directory: ${dirPath}`,
+            });
+        }
+        let dirEntries;
+        try {
+            dirEntries = await readdir(dirPath);
+        }
+        catch {
+            return toTextResponse({
+                success: false,
+                tool: 'electron_scan_userdata',
+                error: `Cannot read directory: ${dirPath}`,
+            });
+        }
+        const jsonFiles = dirEntries.filter((name) => name.endsWith('.json')).slice(0, maxFiles);
+        const files = [];
+        const skipped = [];
+        for (const fileName of jsonFiles) {
+            const filePath = join(dirPath, fileName);
+            try {
+                const fileStat = await stat(filePath);
+                if (!fileStat.isFile()) {
+                    skipped.push({ name: fileName, reason: 'not a file' });
+                    continue;
+                }
+                if (fileStat.size > maxFileSize) {
+                    skipped.push({ name: fileName, reason: 'exceeds maxFileSizeKB' });
+                    continue;
+                }
+                const raw = await readFile(filePath, 'utf-8');
+                const parsed = JSON.parse(raw);
+                files.push({
+                    name: fileName,
+                    sizeBytes: fileStat.size,
+                    content: parsed,
+                });
+            }
+            catch {
+                skipped.push({ name: fileName, reason: 'read or parse error' });
+            }
+        }
+        return toTextResponse({
+            success: true,
+            tool: 'electron_scan_userdata',
+            files,
+            skipped,
+            totalScanned: jsonFiles.length,
+            directory: dirPath,
+        });
+    }
+    catch (error) {
+        return toErrorResponse('electron_scan_userdata', error);
+    }
+}

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

@@ -368,10 +368,10 @@ export class MiniappHandlers {
             return toTextResponse({
                 success: true,
                 unpackedDir: absoluteUnpackedDir.replace(/\\/g, '/'),
-                pages: Array.from(pages).sort(),
+                pages: Array.from(pages).toSorted(),
                 subPackages,
-                components: Array.from(components).sort(),
-                jsFiles: jsFiles.sort(),
+                components: Array.from(components).toSorted(),
+                jsFiles: jsFiles.toSorted(),
                 totalSize,
                 appId,
                 discovered: {

package/dist/src/server/domains/platform/handlers/v8-bytecode-handler.d.ts

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

package/dist/src/server/domains/platform/handlers/v8-bytecode-handler.js

@@ -0,0 +1,207 @@
+import { readFile, stat } from 'node:fs/promises';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { extname } from 'node:path';
+import { toTextResponse, toErrorResponse, parseStringArg, pathExists, } from '../../../domains/platform/handlers/platform-utils.js';
+const execFileAsync = promisify(execFile);
+const V8_MAGIC = Buffer.from([0xc0, 0xde]);
+const BYTENODE_MAGIC = Buffer.from('BYTN');
+const JSC_EXTENSIONS = new Set(['.jsc', '.bin']);
+function detectFormat(buffer, filePath) {
+    const ext = extname(filePath).toLowerCase();
+    if (buffer.length >= 4 && buffer.subarray(0, 4).equals(BYTENODE_MAGIC)) {
+        return 'bytenode';
+    }
+    if (buffer.length >= 2 && buffer.subarray(0, 2).equals(V8_MAGIC)) {
+        return 'v8-raw';
+    }
+    if (JSC_EXTENSIONS.has(ext)) {
+        return 'jsc-extension';
+    }
+    const v8Markers = [
+        Buffer.from('Ldar'),
+        Buffer.from('Star'),
+        Buffer.from('LdaSmi'),
+        Buffer.from('CallRuntime'),
+    ];
+    for (const marker of v8Markers) {
+        if (buffer.indexOf(marker) !== -1) {
+            return 'v8-heuristic';
+        }
+    }
+    return null;
+}
+async function tryView8(filePath) {
+    try {
+        const { stdout, stderr } = await execFileAsync('python', ['-m', 'view8', filePath], {
+            timeout: 60_000,
+            maxBuffer: 10 * 1024 * 1024,
+        });
+        if (stdout && stdout.trim().length > 0) {
+            return { ok: true, output: stdout };
+        }
+        return { ok: false, error: stderr || 'Empty output from view8' };
+    }
+    catch {
+        try {
+            const { stdout } = await execFileAsync('python3', ['-m', 'view8', filePath], {
+                timeout: 60_000,
+                maxBuffer: 10 * 1024 * 1024,
+            });
+            if (stdout && stdout.trim().length > 0) {
+                return { ok: true, output: stdout };
+            }
+            return { ok: false, error: 'Empty output from view8' };
+        }
+        catch {
+            return { ok: false, error: 'view8 not available. Install with: pip install view8' };
+        }
+    }
+}
+function extractConstantPool(buffer) {
+    const strings = [];
+    const numbers = [];
+    const seen = new Set();
+    const MIN_STRING_LEN = 4;
+    const MAX_STRING_LEN = 2000;
+    let currentString = '';
+    for (let i = 0; i < buffer.length; i++) {
+        const byte = buffer[i];
+        if (byte >= 0x20 && byte <= 0x7e) {
+            currentString += String.fromCharCode(byte);
+        }
+        else {
+            if (currentString.length >= MIN_STRING_LEN && currentString.length <= MAX_STRING_LEN) {
+                if (isLikelyCodeString(currentString) && !seen.has(currentString)) {
+                    seen.add(currentString);
+                    strings.push(currentString);
+                }
+            }
+            currentString = '';
+        }
+    }
+    for (let i = 0; i < buffer.length - 3; i++) {
+        if (buffer[i + 1] === 0x00 && buffer[i] >= 0x20 && buffer[i] <= 0x7e) {
+            let utf16str = '';
+            let j = i;
+            while (j < buffer.length - 1 &&
+                buffer[j] >= 0x20 &&
+                buffer[j] <= 0x7e &&
+                buffer[j + 1] === 0x00) {
+                utf16str += String.fromCharCode(buffer[j]);
+                j += 2;
+            }
+            if (utf16str.length >= MIN_STRING_LEN && utf16str.length <= MAX_STRING_LEN) {
+                if (isLikelyCodeString(utf16str) && !seen.has(utf16str)) {
+                    seen.add(utf16str);
+                    strings.push(utf16str);
+                }
+            }
+        }
+    }
+    return { strings, numbers };
+}
+function isLikelyCodeString(s) {
+    if (new Set(s).size <= 2)
+        return false;
+    const specialRatio = (s.match(/[^a-zA-Z0-9_\-.\s/\\:;=+*&|!?,'"(){}[\]<>@#$%^~`]/g) ?? []).length / s.length;
+    if (specialRatio > 0.3)
+        return false;
+    const codePatterns = [
+        /[a-zA-Z_$][a-zA-Z0-9_$]*/,
+        /function\s/,
+        /return\s/,
+        /const\s/,
+        /let\s/,
+        /var\s/,
+        /require\(/,
+        /module\.exports/,
+        /import\s/,
+        /\.prototype\./,
+        /\.call\(/,
+        /\.apply\(/,
+        /async\s/,
+        /await\s/,
+        /Promise/,
+        /https?:\/\//,
+        /[a-zA-Z]+Error/,
+    ];
+    return codePatterns.some((p) => p.test(s));
+}
+export async function handleV8BytecodeDecompile(args) {
+    try {
+        const filePath = parseStringArg(args, 'filePath', true);
+        if (!filePath) {
+            throw new Error('filePath is required — path to a .jsc or V8 bytecode file');
+        }
+        if (!(await pathExists(filePath))) {
+            return toTextResponse({
+                success: false,
+                tool: 'v8_bytecode_decompile',
+                error: `File does not exist: ${filePath}`,
+            });
+        }
+        const fileStat = await stat(filePath);
+        if (fileStat.size > 50 * 1024 * 1024) {
+            return toTextResponse({
+                success: false,
+                tool: 'v8_bytecode_decompile',
+                error: `File too large (${(fileStat.size / 1024 / 1024).toFixed(1)}MB). Maximum: 50MB.`,
+            });
+        }
+        const buffer = await readFile(filePath);
+        const format = detectFormat(buffer, filePath);
+        if (!format) {
+            return toTextResponse({
+                success: false,
+                tool: 'v8_bytecode_decompile',
+                filePath,
+                fileSize: fileStat.size,
+                error: 'Not a recognized V8 bytecode format. Expected .jsc, bytenode, or V8 serialized bytecode.',
+                hint: 'Ensure the file is a V8 compiled bytecode file (created by bytenode or v8.serialize).',
+            });
+        }
+        const result = {
+            success: false,
+            tool: 'v8_bytecode_decompile',
+            filePath,
+            fileSize: fileStat.size,
+            detectedFormat: format,
+            strategy: 'pending',
+        };
+        const view8Result = await tryView8(filePath);
+        if (view8Result.ok && view8Result.output) {
+            result.success = true;
+            result.strategy = 'view8';
+            result.pseudocode =
+                view8Result.output.length > 50_000
+                    ? view8Result.output.slice(0, 50_000) +
+                        '\n\n... [truncated, total ' +
+                        view8Result.output.length +
+                        ' chars]'
+                    : view8Result.output;
+            return toTextResponse(result);
+        }
+        const { strings } = extractConstantPool(buffer);
+        if (strings.length > 0) {
+            result.success = true;
+            result.strategy = 'constant-pool-extraction';
+            result.strings = strings.slice(0, 500);
+            result.note = [
+                `view8 unavailable (${view8Result.error}). Used built-in constant pool extraction.`,
+                `Found ${strings.length} code-relevant strings. These include function names, identifiers, URLs, and string literals from the original source.`,
+                `For full decompilation, install view8: pip install view8`,
+            ].join(' ');
+        }
+        else {
+            result.success = false;
+            result.strategy = 'none';
+            result.error = `Could not decompile. view8: ${view8Result.error}. Built-in extraction found no code strings.`;
+            result.note = 'The bytecode may be heavily optimized or use an unsupported V8 version.';
+        }
+        return toTextResponse(result);
+    }
+    catch (error) {
+        return toErrorResponse('v8_bytecode_decompile', error);
+    }
+}