@jshookmcp/jshook 0.1.5 → 0.1.6

package/dist/modules/monitor/NetworkMonitor.impl.js

@@ -55,6 +55,7 @@ export class NetworkMonitor {
     responses = new Map();
     MAX_NETWORK_RECORDS = 500;
     MAX_INJECTED_RECORDS = 500;
+    JS_RESPONSE_CONCURRENCY = 6;
     responseBodyCache = new Map();
     MAX_BODY_CACHE_ENTRIES = 200;
     networkListeners = {};
@@ -313,24 +314,30 @@ export class NetworkMonitor {
         }
     }
     async getAllJavaScriptResponses() {
-        const jsResponses = [];
-        for (const [requestId, response] of this.responses.entries()) {
-            if (response.mimeType.includes('javascript') ||
+        const candidates = Array.from(this.responses.entries()).filter(([, response]) => {
+            return (response.mimeType.includes('javascript') ||
                 response.url.endsWith('.js') ||
-                response.url.includes('.js?')) {
+                response.url.includes('.js?'));
+        });
+        const jsResponses = [];
+        for (let i = 0; i < candidates.length; i += this.JS_RESPONSE_CONCURRENCY) {
+            const batch = candidates.slice(i, i + this.JS_RESPONSE_CONCURRENCY);
+            const batchResults = await Promise.all(batch.map(async ([requestId, response]) => {
                 const bodyResult = await this.getResponseBody(requestId);
-                if (bodyResult) {
-                    const content = bodyResult.base64Encoded
-                        ? Buffer.from(bodyResult.body, 'base64').toString('utf-8')
-                        : bodyResult.body;
-                    jsResponses.push({
-                        url: response.url,
-                        content,
-                        size: content.length,
-                        requestId,
-                    });
+                if (!bodyResult) {
+                    return null;
                 }
-            }
+                const content = bodyResult.base64Encoded
+                    ? Buffer.from(bodyResult.body, 'base64').toString('utf-8')
+                    : bodyResult.body;
+                return {
+                    url: response.url,
+                    content,
+                    size: content.length,
+                    requestId,
+                };
+            }));
+            jsResponses.push(...batchResults.filter((value) => value !== null));
         }
         logger.info(`Collected ${jsResponses.length} JavaScript responses`);
         return jsResponses;

package/dist/modules/monitor/PerformanceMonitor.js

@@ -1,4 +1,5 @@
 import { writeFile } from 'node:fs/promises';
+import { setImmediate as waitForImmediate } from 'node:timers/promises';
 import { logger } from '../../utils/logger.js';
 import { PrerequisiteError } from '../../errors/PrerequisiteError.js';
 import { cdpLimit } from '../../utils/concurrency.js';
@@ -65,6 +66,62 @@ function isCDPHeapSamplingNode(value) {
 function isCDPHeapSamplingPayload(value) {
     return isRecord(value) && isRecord(value.profile) && isCDPHeapSamplingNode(value.profile.head);
 }
+async function yieldToEventLoop() {
+    await waitForImmediate();
+}
+function countTraceEvents(traceData) {
+    const eventPattern = /"ph"\s*:/g;
+    let count = 0;
+    while (eventPattern.exec(traceData) !== null) {
+        count++;
+    }
+    return count;
+}
+function insertTopAllocation(topAllocations, candidate, topN) {
+    if (topN <= 0) {
+        return;
+    }
+    if (topAllocations.length === topN &&
+        candidate.selfSize <= topAllocations[topAllocations.length - 1].selfSize) {
+        return;
+    }
+    let insertIndex = topAllocations.findIndex((entry) => candidate.selfSize > entry.selfSize);
+    if (insertIndex === -1) {
+        insertIndex = topAllocations.length;
+    }
+    topAllocations.splice(insertIndex, 0, candidate);
+    if (topAllocations.length > topN) {
+        topAllocations.length = topN;
+    }
+}
+function collectTopHeapAllocations(root, topN) {
+    const stack = [root];
+    const topAllocations = [];
+    let sampleCount = 0;
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (!node) {
+            continue;
+        }
+        if (node.callFrame) {
+            sampleCount++;
+            insertTopAllocation(topAllocations, {
+                functionName: node.callFrame.functionName || '(anonymous)',
+                url: node.callFrame.url || '',
+                selfSize: node.selfSize || 0,
+            }, topN);
+        }
+        if (Array.isArray(node.children)) {
+            for (let i = node.children.length - 1; i >= 0; i--) {
+                const child = node.children[i];
+                if (child) {
+                    stack.push(child);
+                }
+            }
+        }
+    }
+    return { sampleCount, topAllocations };
+}
 export class PerformanceMonitor {
     collector;
     cdpSession = null;
@@ -306,14 +363,7 @@ export class PerformanceMonitor {
                 traceData = traceChunks.join('');
             }
             this.tracingEnabled = false;
-            let eventCount = 0;
-            try {
-                const parsed = JSON.parse(traceData);
-                eventCount = Array.isArray(parsed) ? parsed.length : (parsed.traceEvents?.length ?? 0);
-            }
-            catch {
-                eventCount = (traceData.match(/"ph":/g) || []).length;
-            }
+            const eventCount = countTraceEvents(traceData);
             let savedPath;
             if (options?.artifactPath) {
                 await writeFile(options.artifactPath, traceData, 'utf-8');
@@ -364,28 +414,10 @@ export class PerformanceMonitor {
             await cdp.send('HeapProfiler.disable');
             this.heapSamplingEnabled = false;
             const topN = options?.topN ?? 20;
-            const allNodes = [];
-            function walkNodes(node) {
-                if (!isCDPHeapSamplingNode(node)) {
-                    return;
-                }
-                if (node.callFrame) {
-                    allNodes.push({
-                        functionName: node.callFrame.functionName || '(anonymous)',
-                        url: node.callFrame.url || '',
-                        selfSize: node.selfSize || 0,
-                    });
-                }
-                if (node.children) {
-                    for (const child of node.children) {
-                        walkNodes(child);
-                    }
-                }
-            }
-            walkNodes(profile.head);
-            allNodes.sort((a, b) => b.selfSize - a.selfSize);
-            const topAllocations = allNodes.slice(0, topN);
-            const profileJson = JSON.stringify(profile, null, 2);
+            await yieldToEventLoop();
+            const { sampleCount, topAllocations } = collectTopHeapAllocations(profile.head, topN);
+            await yieldToEventLoop();
+            const profileJson = JSON.stringify(profile);
             let savedPath;
             if (options?.artifactPath) {
                 await writeFile(options.artifactPath, profileJson, 'utf-8');
@@ -400,10 +432,10 @@ export class PerformanceMonitor {
                 await writeFile(absolutePath, profileJson, 'utf-8');
                 savedPath = displayPath;
             }
-            logger.success('Heap sampling profile saved', { sampleCount: allNodes.length, path: savedPath });
+            logger.success('Heap sampling profile saved', { sampleCount, path: savedPath });
             return {
                 artifactPath: savedPath,
-                sampleCount: allNodes.length,
+                sampleCount,
                 topAllocations,
             };
         });

package/dist/modules/process/LinuxProcessManager.d.ts

@@ -19,7 +19,9 @@ export declare class LinuxProcessManager {
         commandLine?: string;
         parentPid?: number;
     }>;
-    checkDebugPort(pid: number): Promise<number | null>;
+    checkDebugPort(pid: number, options?: {
+        commandLine?: string;
+    }): Promise<number | null>;
     launchWithDebug(executablePath: string, debugPort?: number, args?: string[]): Promise<ProcessInfo | null>;
     killProcess(pid: number): Promise<boolean>;
     isRunningOnWayland(): boolean;

package/dist/modules/process/LinuxProcessManager.js

@@ -212,10 +212,10 @@ export class LinuxProcessManager {
             return {};
         }
     }
-    async checkDebugPort(pid) {
+    async checkDebugPort(pid, options) {
         try {
             pid = safePid(pid);
-            const { commandLine } = await this.getProcessCommandLine(pid);
+            const commandLine = options?.commandLine ?? (await this.getProcessCommandLine(pid)).commandLine;
             if (commandLine) {
                 const match = commandLine.match(/--remote-debugging-port=(\d+)/);
                 if (match && match[1]) {
@@ -244,7 +244,11 @@ export class LinuxProcessManager {
             });
             child.unref();
             await new Promise(resolve => setTimeout(resolve, PROCESS_LAUNCH_WAIT_MS));
-            const process = await this.getProcessByPid(child.pid || 0);
+            if (!child.pid) {
+                logger.error(`Failed to spawn process: PID is undefined for ${executablePath}`);
+                return null;
+            }
+            const process = await this.getProcessByPid(child.pid);
             logger.info(`Launched process with debug port ${debugPort}:`, {
                 pid: child.pid,
                 executable: executablePath,

package/dist/modules/process/MacProcessManager.d.ts

@@ -18,7 +18,9 @@ export declare class MacProcessManager {
         commandLine?: string;
         parentPid?: number;
     }>;
-    checkDebugPort(pid: number): Promise<number | null>;
+    checkDebugPort(pid: number, options?: {
+        commandLine?: string;
+    }): Promise<number | null>;
     launchWithDebug(executablePath: string, debugPort?: number, args?: string[]): Promise<ProcessInfo | null>;
     killProcess(pid: number): Promise<boolean>;
 }

package/dist/modules/process/MacProcessManager.js

@@ -103,31 +103,31 @@ export class MacProcessManager {
             if (!process) {
                 return [];
             }
-            const appleScript = `
-        tell application "System Events"
-          set processList to {}
-          try
-            set targetProcess to first process whose unix id is ${pid}
-            set procName to name of targetProcess
-            set windowList to {}
-
-            tell targetProcess
-              repeat with win in windows
-                set winInfo to {|
-                  title:name of win,
-                  className:procName,
-                  processId:${pid},
-                  handle:"applescript-window"
-                |}
-                set end of windowList to winInfo
-              end repeat
-            end tell
-
-            return windowList
-          on error
-            return {}
-          end try
-        end tell
+            const appleScript = `
+        tell application "System Events"
+          set processList to {}
+          try
+            set targetProcess to first process whose unix id is ${pid}
+            set procName to name of targetProcess
+            set windowList to {}
+
+            tell targetProcess
+              repeat with win in windows
+                set winInfo to {|
+                  title:name of win,
+                  className:procName,
+                  processId:${pid},
+                  handle:"applescript-window"
+                |}
+                set end of windowList to winInfo
+              end repeat
+            end tell
+
+            return windowList
+          on error
+            return {}
+          end try
+        end tell
       `;
             const { stdout } = await execAsync(`osascript -e '${appleScript.replace(/'/g, "'\"'\"'")}' 2>/dev/null || echo "[]"`, { timeout: 5000 });
             const windows = [];
@@ -261,10 +261,10 @@ export class MacProcessManager {
             return {};
         }
     }
-    async checkDebugPort(pid) {
+    async checkDebugPort(pid, options) {
         try {
             pid = safePid(pid);
-            const { commandLine } = await this.getProcessCommandLine(pid);
+            const commandLine = options?.commandLine ?? (await this.getProcessCommandLine(pid)).commandLine;
             if (commandLine) {
                 const match = commandLine.match(/--remote-debugging-port=(\d+)/);
                 if (match && match[1]) {
@@ -293,7 +293,11 @@ export class MacProcessManager {
             });
             child.unref();
             await new Promise(resolve => setTimeout(resolve, PROCESS_LAUNCH_WAIT_MS));
-            const process = await this.getProcessByPid(child.pid || 0);
+            if (!child.pid) {
+                logger.error(`Failed to spawn process: PID is undefined for ${executablePath}`);
+                return null;
+            }
+            const process = await this.getProcessByPid(child.pid);
             logger.info(`Launched process with debug port ${debugPort}:`, {
                 pid: child.pid,
                 executable: executablePath,

package/dist/modules/process/ProcessManager.impl.d.ts

@@ -5,8 +5,10 @@ export declare class ProcessManager {
     private powershellPath;
     private scriptLoader;
     private browserDiscovery;
+    private processCache;
     constructor();
     findProcesses(pattern: string): Promise<ProcessInfo[]>;
+    private computeProcessDiff;
     getProcessByPid(pid: number): Promise<ProcessInfo | null>;
     getProcessWindows(pid: number): Promise<WindowInfo[]>;
     findChromiumProcesses(config?: TargetAppConfig): Promise<ChromiumProcess>;
@@ -15,7 +17,9 @@ export declare class ProcessManager {
         commandLine?: string;
         parentPid?: number;
     }>;
-    checkDebugPort(pid: number): Promise<number | null>;
+    checkDebugPort(pid: number, options?: {
+        commandLine?: string;
+    }): Promise<number | null>;
     private findPidByListeningPort;
     launchWithDebug(executablePath: string, debugPort?: number, args?: string[]): Promise<ProcessInfo | null>;
     injectDll(_pid: number, _dllPath: string): Promise<boolean>;

package/dist/modules/process/ProcessManager.impl.js

@@ -8,6 +8,7 @@ import { findChromiumProcessesWithConfig } from '../process/ProcessManager.chrom
 import { DEFAULT_CHROMIUM_CONFIG, } from '../process/ProcessManager.types.js';
 export { DEFAULT_CHROMIUM_CONFIG, } from '../process/ProcessManager.types.js';
 const execAsync = promisify(exec);
+const PROCESS_SNAPSHOT_CACHE_TTL_MS = 3000;
 function sanitizePsPattern(s) {
     return String(s || '').replace(/[`$"'{}();|<>@#%!\\\n\r]/g, '');
 }
@@ -21,6 +22,7 @@ export class ProcessManager {
     powershellPath = 'powershell.exe';
     scriptLoader;
     browserDiscovery;
+    processCache = new Map();
     constructor() {
         this.scriptLoader = new ScriptLoader();
         this.browserDiscovery = new BrowserDiscovery();
@@ -29,6 +31,12 @@ export class ProcessManager {
     async findProcesses(pattern) {
         try {
             const normalizedPattern = sanitizePsPattern(String(pattern || '').trim());
+            const cacheKey = normalizedPattern.toLowerCase() || '*';
+            const now = Date.now();
+            const cachedEntry = this.processCache.get(cacheKey);
+            if (cachedEntry && cachedEntry.expiresAt > now) {
+                return cachedEntry.snapshot;
+            }
             let psCommand;
             if (normalizedPattern) {
                 psCommand = `Get-Process -Name "*${normalizedPattern.replace(/"/g, '""')}*" -ErrorAction SilentlyContinue | Select-Object Id, ProcessName, Path, MainWindowTitle, MainWindowHandle, CPU, WorkingSet64 | ConvertTo-Json -Compress`;
@@ -37,20 +45,30 @@ export class ProcessManager {
                 psCommand = `Get-Process -ErrorAction SilentlyContinue | Select-Object Id, ProcessName, Path, MainWindowTitle, MainWindowHandle, CPU, WorkingSet64 | ConvertTo-Json -Compress`;
             }
             const { stdout } = await execAsync(`${this.powershellPath} -NoProfile -Command "${psCommand}"`, { maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES });
-            const processes = [];
             const lines = stdout.trim();
-            if (!lines || lines === 'null' || lines === '') {
-                return processes;
+            const processes = [];
+            if (lines && lines !== 'null') {
+                const data = JSON.parse(lines);
+                const procList = Array.isArray(data) ? data : [data];
+                for (const proc of procList) {
+                    processes.push({
+                        pid: proc.Id,
+                        name: proc.ProcessName,
+                        executablePath: proc.Path,
+                    });
+                }
             }
-            const data = JSON.parse(lines);
-            const procList = Array.isArray(data) ? data : [data];
-            for (const proc of procList) {
-                processes.push({
-                    pid: proc.Id,
-                    name: proc.ProcessName,
-                    executablePath: proc.Path,
-                });
+            const byPid = new Map();
+            for (const process of processes) {
+                byPid.set(process.pid, process);
             }
+            const lastDelta = this.computeProcessDiff(cachedEntry?.byPid ?? new Map(), byPid);
+            this.processCache.set(cacheKey, {
+                expiresAt: now + PROCESS_SNAPSHOT_CACHE_TTL_MS,
+                snapshot: processes,
+                byPid,
+                lastDelta,
+            });
             const patternStr = normalizedPattern.length > 0 ? `'${normalizedPattern}'` : 'all';
             logger.info(`Found ${processes.length} processes matching ${patternStr}`);
             return processes;
@@ -60,6 +78,29 @@ export class ProcessManager {
             return [];
         }
     }
+    computeProcessDiff(previousByPid, nextByPid) {
+        const added = [];
+        const removed = [];
+        const changed = [];
+        for (const [pid, nextProcess] of nextByPid) {
+            const previousProcess = previousByPid.get(pid);
+            if (!previousProcess) {
+                added.push(nextProcess);
+                continue;
+            }
+            if (previousProcess.pid !== nextProcess.pid ||
+                previousProcess.name !== nextProcess.name ||
+                previousProcess.executablePath !== nextProcess.executablePath) {
+                changed.push({ before: previousProcess, after: nextProcess });
+            }
+        }
+        for (const [pid, previousProcess] of previousByPid) {
+            if (!nextByPid.has(pid)) {
+                removed.push(previousProcess);
+            }
+        }
+        return { added, removed, changed };
+    }
     async getProcessByPid(pid) {
         try {
             pid = safePid(pid);
@@ -142,10 +183,10 @@ export class ProcessManager {
             return {};
         }
     }
-    async checkDebugPort(pid) {
+    async checkDebugPort(pid, options) {
         try {
             pid = safePid(pid);
-            const { commandLine } = await this.getProcessCommandLine(pid);
+            const commandLine = options?.commandLine ?? (await this.getProcessCommandLine(pid)).commandLine;
             if (commandLine) {
                 const match = commandLine.match(/--remote-debugging-port=(\d+)/);
                 if (match && match[1]) {

package/dist/modules/process/index.d.ts

@@ -22,7 +22,9 @@ export declare class UnifiedProcessManager {
     findProcesses(pattern: string): Promise<import("../process/ProcessManager.js").ProcessInfo[]>;
     getProcessByPid(pid: number): Promise<import("../process/ProcessManager.js").ProcessInfo | null>;
     getProcessWindows(pid: number): Promise<import("../process/ProcessManager.js").WindowInfo[]>;
-    checkDebugPort(pid: number): Promise<number | null>;
+    checkDebugPort(pid: number, options?: {
+        commandLine?: string;
+    }): Promise<number | null>;
     launchWithDebug(executablePath: string, debugPort?: number, args?: string[]): Promise<import("../process/ProcessManager.js").ProcessInfo | null>;
     killProcess(pid: number): Promise<boolean>;
     getProcessCommandLine(pid: number): Promise<{

package/dist/modules/process/index.js

@@ -58,8 +58,8 @@ export class UnifiedProcessManager {
     async getProcessWindows(pid) {
         return this.manager.getProcessWindows(pid);
     }
-    async checkDebugPort(pid) {
-        return this.manager.checkDebugPort(pid);
+    async checkDebugPort(pid, options) {
+        return this.manager.checkDebugPort(pid, options);
     }
     async launchWithDebug(executablePath, debugPort, args) {
         return this.manager.launchWithDebug(executablePath, debugPort, args);

package/dist/modules/process/memory/AuditTrail.d.ts

@@ -0,0 +1,25 @@
+export interface AuditEntry {
+    timestamp: string;
+    operation: string;
+    pid: number | null;
+    address: string | null;
+    size: number | null;
+    result: 'success' | 'failure';
+    error?: string;
+    durationMs: number;
+    user: string;
+    pattern?: string;
+    resultsCount?: number;
+    dllPath?: string;
+}
+export declare class MemoryAuditTrail {
+    private buffer;
+    private head;
+    private count;
+    private readonly capacity;
+    constructor(capacity?: number);
+    record(entry: Omit<AuditEntry, 'timestamp' | 'user'>): void;
+    exportJson(): string;
+    clear(): void;
+    size(): number;
+}

package/dist/modules/process/memory/AuditTrail.js

@@ -0,0 +1,44 @@
+export class MemoryAuditTrail {
+    buffer;
+    head = 0;
+    count = 0;
+    capacity;
+    constructor(capacity = 5000) {
+        this.capacity = Number.isInteger(capacity) && capacity > 0 ? capacity : 5000;
+        this.buffer = [];
+    }
+    record(entry) {
+        const fullEntry = {
+            ...entry,
+            timestamp: new Date().toISOString(),
+            user: process.env.USERNAME || process.env.USER || 'unknown',
+        };
+        if (this.count < this.capacity) {
+            const writeIndex = (this.head + this.count) % this.capacity;
+            this.buffer[writeIndex] = fullEntry;
+            this.count += 1;
+            return;
+        }
+        this.buffer[this.head] = fullEntry;
+        this.head = (this.head + 1) % this.capacity;
+    }
+    exportJson() {
+        const entries = [];
+        for (let i = 0; i < this.count; i += 1) {
+            const index = (this.head + i) % this.capacity;
+            const entry = this.buffer[index];
+            if (entry) {
+                entries.push(entry);
+            }
+        }
+        return JSON.stringify(entries, null, 2);
+    }
+    clear() {
+        this.buffer = [];
+        this.head = 0;
+        this.count = 0;
+    }
+    size() {
+        return this.count;
+    }
+}

package/dist/modules/process/memory/availability.js

@@ -103,55 +103,55 @@ export async function checkDebugPort(platform, pid) {
         return { success: false, error: 'Debug port check currently only implemented for Windows' };
     }
     try {
-        const psScript = `
-Add-Type @"
-using System;
-using System.Runtime.InteropServices;
-using System.ComponentModel;
-
-public class DebugChecker {
-    [DllImport("ntdll.dll")]
-    public static extern int NtQueryInformationProcess(IntPtr processHandle, int processInformationClass, out IntPtr processInformation, int processInformationLength, out int returnLength);
-
-    [DllImport("kernel32.dll", SetLastError = true)]
-    public static extern IntPtr OpenProcess(int access, bool inherit, int pid);
-
-    [DllImport("kernel32.dll", SetLastError = true)]
-    public static extern bool CloseHandle(IntPtr handle);
-
-    const int PROCESS_QUERY_INFORMATION = 0x0400;
-    const int ProcessDebugPort = 7;
-
-    public static object Check(int pid) {
-        IntPtr hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, false, pid);
-        if (hProcess == IntPtr.Zero) {
-            int error = Marshal.GetLastWin32Error();
-            throw new Win32Exception(error, "Failed to open process");
-        }
-
-        try {
-            IntPtr debugPort;
-            int returnLength;
-            int status = NtQueryInformationProcess(hProcess, ProcessDebugPort, out debugPort, IntPtr.Size, out returnLength);
-
-            if (status != 0) {
-                return new { success = false, error = "NtQueryInformationProcess failed with status: 0x" + status.ToString("X") };
-            }
-
-            return new { success = true, isDebugged = debugPort != IntPtr.Zero };
-        } finally {
-            CloseHandle(hProcess);
-        }
-    }
-}
-"@
-
-try {
-    $result = [DebugChecker]::Check(${pid})
-    $result | ConvertTo-Json -Compress
-} catch {
-    @{ success = $false; error = $_.Exception.Message } | ConvertTo-Json -Compress
-}
+        const psScript = `
+Add-Type @"
+using System;
+using System.Runtime.InteropServices;
+using System.ComponentModel;
+
+public class DebugChecker {
+    [DllImport("ntdll.dll")]
+    public static extern int NtQueryInformationProcess(IntPtr processHandle, int processInformationClass, out IntPtr processInformation, int processInformationLength, out int returnLength);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    public static extern IntPtr OpenProcess(int access, bool inherit, int pid);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    public static extern bool CloseHandle(IntPtr handle);
+
+    const int PROCESS_QUERY_INFORMATION = 0x0400;
+    const int ProcessDebugPort = 7;
+
+    public static object Check(int pid) {
+        IntPtr hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, false, pid);
+        if (hProcess == IntPtr.Zero) {
+            int error = Marshal.GetLastWin32Error();
+            throw new Win32Exception(error, "Failed to open process");
+        }
+
+        try {
+            IntPtr debugPort;
+            int returnLength;
+            int status = NtQueryInformationProcess(hProcess, ProcessDebugPort, out debugPort, IntPtr.Size, out returnLength);
+
+            if (status != 0) {
+                return new { success = false, error = "NtQueryInformationProcess failed with status: 0x" + status.ToString("X") };
+            }
+
+            return new { success = true, isDebugged = debugPort != IntPtr.Zero };
+        } finally {
+            CloseHandle(hProcess);
+        }
+    }
+}
+"@
+
+try {
+    $result = [DebugChecker]::Check(${pid})
+    $result | ConvertTo-Json -Compress
+} catch {
+    @{ success = $false; error = $_.Exception.Message } | ConvertTo-Json -Compress
+}
     `;
         const { stdout } = await executePowerShellScript(psScript, { maxBuffer: 1024 * 1024, timeout: 10000 });
         const _trimmed = stdout.trim();