@jshookmcp/jshook 0.2.2 → 0.2.5

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

@@ -0,0 +1,170 @@
+import { spawn } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import { toTextResponse, toErrorResponse, parseStringArg, pathExists, } from '../../../domains/platform/handlers/platform-utils.js';
+const FUSE_SENTINEL = 'dL7pKGdnNz796PbbjQWNKmHXBZIA';
+const FUSE_ENABLE = 0x31;
+const launchedProcesses = new Map();
+async function quickFuseCheck(exePath) {
+    try {
+        const buffer = await readFile(exePath);
+        const sentinelBuf = Buffer.from(FUSE_SENTINEL, 'ascii');
+        const idx = buffer.indexOf(sentinelBuf);
+        if (idx === -1)
+            return { fuseFound: false, runAsNode: false, inspectArgs: false, nodeOptions: false };
+        const base = idx + sentinelBuf.length;
+        return {
+            fuseFound: true,
+            runAsNode: buffer[base] === FUSE_ENABLE,
+            nodeOptions: buffer[base + 2] === FUSE_ENABLE,
+            inspectArgs: buffer[base + 3] === FUSE_ENABLE,
+        };
+    }
+    catch {
+        return { fuseFound: false, runAsNode: false, inspectArgs: false, nodeOptions: false };
+    }
+}
+async function waitForCDP(port, timeoutMs = 10_000) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        try {
+            const res = await fetch(`http://127.0.0.1:${port}/json/version`, {
+                signal: AbortSignal.timeout(2000),
+            });
+            if (res.ok) {
+                const info = await res.text();
+                return { ok: true, info };
+            }
+        }
+        catch {
+        }
+        await new Promise((r) => setTimeout(r, 500));
+    }
+    return { ok: false, error: `CDP port ${port} did not respond within ${timeoutMs}ms` };
+}
+export async function handleElectronLaunchDebug(args) {
+    try {
+        const exePath = parseStringArg(args, 'exePath', true);
+        if (!exePath) {
+            throw new Error('exePath is required — path to the Electron .exe');
+        }
+        if (!(await pathExists(exePath))) {
+            return toTextResponse({
+                success: false,
+                tool: 'electron_launch_debug',
+                error: `File does not exist: ${exePath}`,
+            });
+        }
+        const mainPort = args.mainPort ?? 9229;
+        const rendererPort = args.rendererPort ?? 9222;
+        const extraArgs = args.args ?? [];
+        const skipFuseCheck = args.skipFuseCheck === true;
+        const waitMs = args.waitMs ?? 8000;
+        const fuseWarnings = [];
+        if (!skipFuseCheck) {
+            const fuses = await quickFuseCheck(exePath);
+            if (fuses.fuseFound) {
+                if (!fuses.inspectArgs) {
+                    fuseWarnings.push('EnableNodeCliInspectArguments is DISABLED — main process --inspect may be blocked. Use electron_patch_fuses first.');
+                }
+                if (!fuses.nodeOptions) {
+                    fuseWarnings.push('EnableNodeOptionsEnvironmentVariable is DISABLED — NODE_OPTIONS injection blocked.');
+                }
+                if (!fuses.runAsNode) {
+                    fuseWarnings.push('RunAsNode is DISABLED — ELECTRON_RUN_AS_NODE=1 will not work.');
+                }
+            }
+        }
+        const launchArgs = [
+            `--inspect=${mainPort}`,
+            `--remote-debugging-port=${rendererPort}`,
+            ...extraArgs,
+        ];
+        const child = spawn(exePath, launchArgs, {
+            stdio: 'ignore',
+            detached: true,
+            env: { ...process.env },
+        });
+        child.unref();
+        if (!child.pid) {
+            return toTextResponse({
+                success: false,
+                tool: 'electron_launch_debug',
+                error: 'Failed to spawn process — no PID returned.',
+            });
+        }
+        const sessionId = `electron-${child.pid}`;
+        launchedProcesses.set(sessionId, {
+            child,
+            pid: child.pid,
+            ports: { main: mainPort, renderer: rendererPort },
+        });
+        const [mainCDP, rendererCDP] = await Promise.all([
+            waitForCDP(mainPort, waitMs),
+            waitForCDP(rendererPort, waitMs),
+        ]);
+        return toTextResponse({
+            success: true,
+            tool: 'electron_launch_debug',
+            sessionId,
+            pid: child.pid,
+            ports: {
+                main: { port: mainPort, available: mainCDP.ok, info: mainCDP.ok ? 'Ready' : mainCDP.error },
+                renderer: {
+                    port: rendererPort,
+                    available: rendererCDP.ok,
+                    info: rendererCDP.ok ? 'Ready' : rendererCDP.error,
+                },
+            },
+            fuseWarnings: fuseWarnings.length > 0 ? fuseWarnings : undefined,
+            usage: {
+                main: `Use electron_attach(port=${mainPort}) to debug the main process (Node.js)`,
+                renderer: `Use electron_attach(port=${rendererPort}) to debug the renderer (Chromium)`,
+                combined: 'Both sessions can be used simultaneously for cross-process analysis',
+            },
+        });
+    }
+    catch (error) {
+        return toErrorResponse('electron_launch_debug', error);
+    }
+}
+export async function handleElectronDebugStatus(args) {
+    try {
+        const sessionId = parseStringArg(args, 'sessionId');
+        if (sessionId) {
+            const session = launchedProcesses.get(sessionId);
+            if (!session) {
+                return toTextResponse({
+                    success: false,
+                    tool: 'electron_debug_status',
+                    error: `No session found: ${sessionId}`,
+                    activeSessions: Array.from(launchedProcesses.keys()),
+                });
+            }
+            const [mainCDP, rendererCDP] = await Promise.all([
+                waitForCDP(session.ports.main, 2000),
+                waitForCDP(session.ports.renderer, 2000),
+            ]);
+            return toTextResponse({
+                success: true,
+                tool: 'electron_debug_status',
+                sessionId,
+                pid: session.pid,
+                main: { port: session.ports.main, alive: mainCDP.ok },
+                renderer: { port: session.ports.renderer, alive: rendererCDP.ok },
+            });
+        }
+        const sessions = Array.from(launchedProcesses.entries()).map(([id, s]) => ({
+            sessionId: id,
+            pid: s.pid,
+            ports: s.ports,
+        }));
+        return toTextResponse({
+            success: true,
+            tool: 'electron_debug_status',
+            sessions,
+        });
+    }
+    catch (error) {
+        return toErrorResponse('electron_debug_status', error);
+    }
+}

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

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

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

@@ -0,0 +1,193 @@
+import { readFile, writeFile, copyFile } from 'node:fs/promises';
+import { toTextResponse, toErrorResponse, parseStringArg, pathExists, } from '../../../domains/platform/handlers/platform-utils.js';
+const FUSE_SENTINEL = 'dL7pKGdnNz796PbbjQWNKmHXBZIA';
+const FUSE_NAMES = [
+    'RunAsNode',
+    'EnableCookieEncryption',
+    'EnableNodeOptionsEnvironmentVariable',
+    'EnableNodeCliInspectArguments',
+    'EnableEmbeddedAsarIntegrityValidation',
+    'OnlyLoadAppFromAsar',
+    'LoadBrowserProcessSpecificV8Snapshot',
+    'GrantFileProtocolExtraPrivileges',
+];
+const FUSE_DISABLE = 0x30;
+const FUSE_ENABLE = 0x31;
+const FUSE_REMOVED = 0x72;
+const FUSE_LABEL = {
+    [FUSE_DISABLE]: 'DISABLE',
+    [FUSE_ENABLE]: 'ENABLE',
+    [FUSE_REMOVED]: 'REMOVED',
+};
+const DEBUG_PATCH_PROFILE = {
+    RunAsNode: 'ENABLE',
+    EnableNodeOptionsEnvironmentVariable: 'ENABLE',
+    EnableNodeCliInspectArguments: 'ENABLE',
+    OnlyLoadAppFromAsar: 'DISABLE',
+};
+function parseFuses(buffer, sentinelIndex) {
+    const fuseDataStart = sentinelIndex + Buffer.from(FUSE_SENTINEL, 'ascii').length;
+    const fuses = {};
+    for (let i = 0; i < FUSE_NAMES.length; i++) {
+        const fuseName = FUSE_NAMES[i];
+        if (!fuseName)
+            continue;
+        const byteIndex = fuseDataStart + i;
+        if (byteIndex >= buffer.length) {
+            fuses[fuseName] = 'UNKNOWN';
+            continue;
+        }
+        const byteValue = buffer[byteIndex];
+        if (byteValue === undefined) {
+            fuses[fuseName] = 'UNKNOWN';
+            continue;
+        }
+        fuses[fuseName] = FUSE_LABEL[byteValue] ?? 'UNKNOWN';
+    }
+    return fuses;
+}
+export async function handleElectronCheckFuses(args) {
+    try {
+        const exePath = parseStringArg(args, 'exePath', true);
+        if (!exePath) {
+            throw new Error('exePath is required');
+        }
+        if (!(await pathExists(exePath))) {
+            return toTextResponse({
+                success: false,
+                tool: 'electron_check_fuses',
+                error: `File does not exist: ${exePath}`,
+            });
+        }
+        const buffer = await readFile(exePath);
+        const sentinelBuffer = Buffer.from(FUSE_SENTINEL, 'ascii');
+        const sentinelIndex = buffer.indexOf(sentinelBuffer);
+        if (sentinelIndex === -1) {
+            return toTextResponse({
+                success: true,
+                tool: 'electron_check_fuses',
+                exePath,
+                fuseWireFound: false,
+                fuses: {},
+                note: 'No fuse sentinel found. This may not be an Electron binary, or fuses are not configured.',
+            });
+        }
+        const fuses = parseFuses(buffer, sentinelIndex);
+        return toTextResponse({
+            success: true,
+            tool: 'electron_check_fuses',
+            exePath,
+            fuseWireFound: true,
+            fuses,
+        });
+    }
+    catch (error) {
+        return toErrorResponse('electron_check_fuses', error);
+    }
+}
+export async function handleElectronPatchFuses(args) {
+    try {
+        const exePath = parseStringArg(args, 'exePath', true);
+        if (!exePath) {
+            throw new Error('exePath is required');
+        }
+        if (!(await pathExists(exePath))) {
+            return toTextResponse({
+                success: false,
+                tool: 'electron_patch_fuses',
+                error: `File does not exist: ${exePath}`,
+            });
+        }
+        const profile = parseStringArg(args, 'profile') ?? 'debug';
+        const createBackup = args.createBackup !== false;
+        let patchMap;
+        if (profile === 'debug') {
+            patchMap = { ...DEBUG_PATCH_PROFILE };
+        }
+        else if (profile === 'custom') {
+            const customFuses = args.fuses;
+            if (!customFuses || Object.keys(customFuses).length === 0) {
+                throw new Error('profile="custom" requires a `fuses` object mapping fuse names to ENABLE/DISABLE');
+            }
+            patchMap = {};
+            for (const [name, value] of Object.entries(customFuses)) {
+                if (!FUSE_NAMES.includes(name)) {
+                    throw new Error(`Unknown fuse: ${name}. Valid: ${FUSE_NAMES.join(', ')}`);
+                }
+                if (value !== 'ENABLE' && value !== 'DISABLE') {
+                    throw new Error(`Invalid fuse value for ${name}: ${value}. Must be ENABLE or DISABLE`);
+                }
+                patchMap[name] = value;
+            }
+        }
+        else {
+            throw new Error(`Unknown profile: ${profile}. Use "debug" or "custom"`);
+        }
+        const buffer = await readFile(exePath);
+        const sentinelBuffer = Buffer.from(FUSE_SENTINEL, 'ascii');
+        const sentinelIndex = buffer.indexOf(sentinelBuffer);
+        if (sentinelIndex === -1) {
+            return toTextResponse({
+                success: false,
+                tool: 'electron_patch_fuses',
+                error: 'No fuse sentinel found. This may not be an Electron binary.',
+                exePath,
+            });
+        }
+        const fusesBefore = parseFuses(buffer, sentinelIndex);
+        const fuseDataStart = sentinelIndex + sentinelBuffer.length;
+        const changes = [];
+        for (const [fuseName, targetState] of Object.entries(patchMap)) {
+            const fuseIndex = FUSE_NAMES.indexOf(fuseName);
+            if (fuseIndex === -1)
+                continue;
+            const byteIndex = fuseDataStart + fuseIndex;
+            if (byteIndex >= buffer.length)
+                continue;
+            const currentByte = buffer[byteIndex];
+            if (currentByte === FUSE_REMOVED) {
+                changes.push({ fuse: fuseName, before: 'REMOVED', after: 'REMOVED (cannot patch)' });
+                continue;
+            }
+            const targetByte = targetState === 'ENABLE' ? FUSE_ENABLE : FUSE_DISABLE;
+            const currentLabel = FUSE_LABEL[currentByte ?? 0] ?? 'UNKNOWN';
+            if (currentByte === targetByte) {
+                continue;
+            }
+            buffer[byteIndex] = targetByte;
+            changes.push({ fuse: fuseName, before: currentLabel, after: targetState });
+        }
+        if (changes.length === 0) {
+            return toTextResponse({
+                success: true,
+                tool: 'electron_patch_fuses',
+                exePath,
+                message: 'All target fuses are already in the desired state. No changes needed.',
+                fuses: fusesBefore,
+            });
+        }
+        let backupPath = null;
+        if (createBackup) {
+            backupPath = `${exePath}.bak`;
+            await copyFile(exePath, backupPath);
+        }
+        await writeFile(exePath, buffer);
+        const fusesAfter = parseFuses(buffer, sentinelIndex);
+        return toTextResponse({
+            success: true,
+            tool: 'electron_patch_fuses',
+            exePath,
+            backupPath,
+            profile,
+            changes,
+            fusesBefore,
+            fusesAfter,
+            note: backupPath
+                ? `Backup created at ${backupPath}. Restore with: copy "${backupPath}" "${exePath}"`
+                : 'No backup created (createBackup=false).',
+        });
+    }
+    catch (error) {
+        return toErrorResponse('electron_patch_fuses', error);
+    }
+}

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

@@ -14,4 +14,10 @@ export declare class ElectronHandlers {
             text: string;
         }[];
     }>;
+    handleAsarSearch(args: Record<string, unknown>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    }>;
 }

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

@@ -200,7 +200,7 @@ export class ElectronHandlers {
                 : 'index.js';
             const version = typeof packageJson.version === 'string' ? packageJson.version : null;
             const dependenciesRaw = packageJson.dependencies;
-            const dependencies = isRecord(dependenciesRaw) ? Object.keys(dependenciesRaw).sort() : [];
+            const dependencies = isRecord(dependenciesRaw) ? Object.keys(dependenciesRaw).toSorted() : [];
             let mainScriptSource = '';
             let mainScriptPath = '';
             if (packageSource === 'asar' && parsedAsar && asarBuffer) {
@@ -273,7 +273,7 @@ export class ElectronHandlers {
                 scanRoot: scanRoot.replace(/\\/g, '/'),
                 mainEntry,
                 version,
-                preloadScripts: Array.from(preloadScripts).sort(),
+                preloadScripts: Array.from(preloadScripts).toSorted(),
                 dependencies,
                 devToolsEnabled,
                 packageSource,
@@ -292,4 +292,97 @@ export class ElectronHandlers {
             return toErrorResponse('electron_inspect_app', error);
         }
     }
+    async handleAsarSearch(args) {
+        try {
+            const inputPath = parseStringArg(args, 'inputPath', true);
+            const searchPattern = parseStringArg(args, 'pattern', true);
+            if (!inputPath)
+                throw new Error('inputPath is required');
+            if (!searchPattern)
+                throw new Error('pattern is required');
+            const fileGlob = parseStringArg(args, 'fileGlob') || '*.js';
+            const maxResults = typeof args.maxResults === 'number' && args.maxResults > 0 ? args.maxResults : 100;
+            const searchAbsPath = resolve(inputPath);
+            if (!(await pathExists(searchAbsPath))) {
+                return toTextResponse({
+                    success: false,
+                    tool: 'asar_search',
+                    error: `File does not exist: ${inputPath}`,
+                });
+            }
+            const searchAsarBuf = await readFile(searchAbsPath);
+            const searchParsed = parseAsarBuffer(searchAsarBuf);
+            const globExt = fileGlob.startsWith('*.') ? fileGlob.slice(1) : null;
+            const matchingFiles = searchParsed.files.filter((entry) => {
+                if (entry.unpacked || entry.size <= 0)
+                    return false;
+                if (globExt) {
+                    return extname(entry.path).toLowerCase() === globExt.toLowerCase();
+                }
+                return true;
+            });
+            let regex;
+            try {
+                regex = new RegExp(searchPattern, 'gi');
+            }
+            catch {
+                return toTextResponse({
+                    success: false,
+                    tool: 'asar_search',
+                    error: `Invalid regex pattern: ${searchPattern}`,
+                });
+            }
+            const matches = [];
+            let totalMatches = 0;
+            let filesScanned = 0;
+            for (const entry of matchingFiles) {
+                if (totalMatches >= maxResults)
+                    break;
+                const start = searchParsed.dataOffset + entry.offset;
+                const end = start + entry.size;
+                if (start < 0 || end > searchAsarBuf.length || end < start)
+                    continue;
+                if (entry.size > 512_000)
+                    continue;
+                const content = searchAsarBuf.subarray(start, end).toString('utf-8');
+                filesScanned++;
+                regex.lastIndex = 0;
+                const lines = content.split('\n');
+                const fileMatches = [];
+                for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+                    if (totalMatches >= maxResults)
+                        break;
+                    const line = lines[lineIdx];
+                    if (!line)
+                        continue;
+                    regex.lastIndex = 0;
+                    if (regex.test(line)) {
+                        fileMatches.push({
+                            lineNumber: lineIdx + 1,
+                            text: line.slice(0, 200),
+                        });
+                        totalMatches++;
+                    }
+                }
+                if (fileMatches.length > 0) {
+                    matches.push({
+                        filePath: entry.path,
+                        matchCount: fileMatches.length,
+                        matchLines: fileMatches,
+                    });
+                }
+            }
+            return toTextResponse({
+                success: true,
+                tool: 'asar_search',
+                matches,
+                totalMatches,
+                filesScanned,
+                pattern: searchPattern,
+            });
+        }
+        catch (error) {
+            return toErrorResponse('asar_search', error);
+        }
+    }
 }

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

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