@jshookmcp/jshook 0.2.1 → 0.2.2

package/dist/src/modules/monitor/PerformanceMonitor.js

@@ -1,6 +1,7 @@
 import { writeFile } from 'node:fs/promises';
 import { setImmediate as waitForImmediate } from 'node:timers/promises';
 import { logger } from '../../utils/logger.js';
+import { evaluateWithTimeout, coverageStartJSWithTimeout, coverageStartCSSWithTimeout, coverageStopJSWithTimeout, coverageStopCSSWithTimeout, } from '../collector/PageController.js';
 import { PrerequisiteError } from '../../errors/PrerequisiteError.js';
 import { cdpLimit } from '../../utils/concurrency.js';
 import { resolveArtifactPath } from '../../utils/artifacts.js';
@@ -106,15 +107,45 @@ export class PerformanceMonitor {
         this.collector = collector;
     }
     async ensureCDPSession() {
+        const PING = async (cdp) => {
+            await Promise.race([
+                cdp.send('Runtime.evaluate', { expression: '1', returnByValue: true }),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('cdp_unreachable')), 500)),
+            ]);
+        };
         if (!this.cdpSession) {
             const page = await this.collector.getActivePage();
-            this.cdpSession = await page.createCDPSession();
+            this.cdpSession = await Promise.race([
+                page.createCDPSession(),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('cdp_session_timeout')), 500)),
+            ]);
+            return this.cdpSession;
+        }
+        try {
+            await PING(this.cdpSession);
+            return this.cdpSession;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (msg !== 'cdp_unreachable')
+                throw err;
+            logger.warn('PerformanceMonitor CDP session unresponsive, recreating...');
+            try {
+                await this.cdpSession.detach();
+            }
+            catch { }
+            this.cdpSession = null;
+            const page = await this.collector.getActivePage();
+            this.cdpSession = await Promise.race([
+                page.createCDPSession(),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('cdp_session_timeout')), 500)),
+            ]);
+            return this.cdpSession;
         }
-        return this.cdpSession;
     }
     async getPerformanceMetrics() {
         const page = await this.collector.getActivePage();
-        const metrics = (await page.evaluate(() => {
+        const metrics = (await evaluateWithTimeout(page, () => {
             const result = {};
             const navTiming = performance.getEntriesByType('navigation')[0];
             if (navTiming) {
@@ -158,7 +189,7 @@ export class PerformanceMonitor {
     }
     async getPerformanceTimeline() {
         const page = await this.collector.getActivePage();
-        const timeline = await page.evaluate(() => {
+        const timeline = await evaluateWithTimeout(page, () => {
             return performance.getEntries().map((entry) => ({
                 name: entry.name,
                 entryType: entry.entryType,
@@ -172,11 +203,11 @@ export class PerformanceMonitor {
     async startCoverage(options) {
         const page = await this.collector.getActivePage();
         await Promise.all([
-            page.coverage.startJSCoverage({
+            coverageStartJSWithTimeout(page, {
                 resetOnNavigation: options?.resetOnNavigation,
                 reportAnonymousScripts: options?.reportAnonymousScripts,
             }),
-            page.coverage.startCSSCoverage({
+            coverageStartCSSWithTimeout(page, {
                 resetOnNavigation: options?.resetOnNavigation,
             }),
         ]);
@@ -189,10 +220,12 @@ export class PerformanceMonitor {
             throw new PrerequisiteError('Coverage not enabled. Call startCoverage() first.');
         }
         const page = this.coveragePage ?? (await this.collector.getActivePage());
-        const [jsCoverage, cssCoverage] = await Promise.all([
-            page.coverage.stopJSCoverage(),
-            page.coverage.stopCSSCoverage(),
+        const [jsCoverageResult, cssCoverageResult] = await Promise.all([
+            coverageStopJSWithTimeout(page),
+            coverageStopCSSWithTimeout(page),
         ]);
+        const jsCoverage = jsCoverageResult;
+        const cssCoverage = cssCoverageResult;
         this.coverageEnabled = false;
         this.coveragePage = null;
         const coverageEntries = [...jsCoverage, ...cssCoverage];
@@ -317,7 +350,11 @@ export class PerformanceMonitor {
                 await writeFile(absolutePath, traceData, 'utf-8');
                 savedPath = displayPath;
             }
-            logger.success('Performance trace saved', { eventCount, sizeBytes: traceData.length, path: savedPath });
+            logger.success('Performance trace saved', {
+                eventCount,
+                sizeBytes: traceData.length,
+                path: savedPath,
+            });
             return {
                 artifactPath: savedPath,
                 eventCount,

package/dist/src/modules/monitor/PlaywrightNetworkMonitor.d.ts

@@ -3,6 +3,7 @@ interface PlaywrightLikePage {
     on(event: string, listener: (...args: unknown[]) => void): void;
     off(event: string, listener: (...args: unknown[]) => void): void;
     evaluate?<T>(pageFunction: string | (() => T | Promise<T>)): Promise<T>;
+    evaluateOnNewDocument?<T>(pageFunction: string | (() => T | Promise<T>)): Promise<T>;
 }
 export declare class PlaywrightNetworkMonitor {
     private page;
@@ -21,6 +22,7 @@ export declare class PlaywrightNetworkMonitor {
     setPage(page: PlaywrightLikePage | null): void;
     private getPageOrThrow;
     private evaluateInPage;
+    private evaluateOnNewDocumentInPage;
     private isUnknownArray;
     private isClearedBuffersResult;
     private isResetInterceptorsResult;
@@ -63,8 +65,12 @@ export declare class PlaywrightNetworkMonitor {
         base64Encoded: boolean;
     } | null>;
     injectScript(script: string): Promise<void>;
-    injectXHRInterceptor(): Promise<void>;
-    injectFetchInterceptor(): Promise<void>;
+    injectXHRInterceptor(options?: {
+        persistent?: boolean;
+    }): Promise<void>;
+    injectFetchInterceptor(options?: {
+        persistent?: boolean;
+    }): Promise<void>;
     getXHRRequests(): Promise<unknown[]>;
     getFetchRequests(): Promise<unknown[]>;
     clearInjectedBuffers(): Promise<{

package/dist/src/modules/monitor/PlaywrightNetworkMonitor.js

@@ -64,6 +64,13 @@ export class PlaywrightNetworkMonitor {
         }
         return page.evaluate(pageFunction);
     }
+    async evaluateOnNewDocumentInPage(pageFunction) {
+        const page = this.getPageOrThrow();
+        if (!page.evaluateOnNewDocument) {
+            throw new Error('Playwright page.evaluateOnNewDocument is not available');
+        }
+        return page.evaluateOnNewDocument(pageFunction);
+    }
     isUnknownArray(value) {
         return Array.isArray(value);
     }
@@ -133,7 +140,7 @@ export class PlaywrightNetworkMonitor {
             const req = res.request();
             const fallbackRequestId = `pw-res-${Date.now()}-${Math.random()}`;
             const requestId = this.isPlaywrightLikeRequest(req)
-                ? this.requestIdMap.get(req) ?? fallbackRequestId
+                ? (this.requestIdMap.get(req) ?? fallbackRequestId)
                 : fallbackRequestId;
             const response = {
                 requestId,
@@ -152,7 +159,9 @@ export class PlaywrightNetworkMonitor {
             }
             if (typeof res.body === 'function') {
                 const captureId = requestId;
-                res.body().then((buf) => {
+                res
+                    .body()
+                    .then((buf) => {
                     if (buf.length > 1_048_576) {
                         logger.debug(`[PW-BodyCache] Skipping oversized body for ${captureId} (${buf.length} bytes)`);
                         return;
@@ -176,7 +185,8 @@ export class PlaywrightNetworkMonitor {
                         });
                     }
                     logger.debug(`[PW-BodyCache] Cached body for ${captureId} (${buf.length} bytes)`);
-                }).catch((err) => {
+                })
+                    .catch((err) => {
                     logger.debug(`[PW-BodyCache] Could not capture body for ${captureId}: ${err instanceof Error ? err.message : String(err)}`);
                 });
             }
@@ -193,14 +203,16 @@ export class PlaywrightNetworkMonitor {
             try {
                 page.off('request', this.boundOnRequest);
             }
-            catch { }
+            catch {
+            }
             this.boundOnRequest = null;
         }
         if (this.boundOnResponse) {
             try {
                 page.off('response', this.boundOnResponse);
             }
-            catch { }
+            catch {
+            }
             this.boundOnResponse = null;
         }
         this.networkEnabled = false;
@@ -287,8 +299,8 @@ export class PlaywrightNetworkMonitor {
     async injectScript(script) {
         await this.evaluateInPage(script);
     }
-    async injectXHRInterceptor() {
-        await this.evaluateInPage(`
+    async injectXHRInterceptor(options) {
+        const script = `
       (function() {
         if (window.__xhrInterceptorInjected) return;
         window.__xhrInterceptorInjected = true;
@@ -320,10 +332,16 @@ export class PlaywrightNetworkMonitor {
         };
         console.log('[PlaywrightXHR] XHR interceptor injected');
       })();
-    `);
+    `;
+        if (options?.persistent) {
+            await this.evaluateOnNewDocumentInPage(script);
+        }
+        else {
+            await this.evaluateInPage(script);
+        }
     }
-    async injectFetchInterceptor() {
-        await this.evaluateInPage(`
+    async injectFetchInterceptor(options) {
+        const script = `
       (function() {
         if (window.__fetchInterceptorInjected) return;
         window.__fetchInterceptorInjected = true;
@@ -353,7 +371,13 @@ export class PlaywrightNetworkMonitor {
         };
         console.log('[PlaywrightFetch] Fetch interceptor injected');
       })();
-    `);
+    `;
+        if (options?.persistent) {
+            await this.evaluateOnNewDocumentInPage(script);
+        }
+        else {
+            await this.evaluateInPage(script);
+        }
     }
     async getXHRRequests() {
         try {
@@ -397,9 +421,7 @@ export class PlaywrightNetworkMonitor {
                 }
                 return { xhrCleared, fetchCleared };
             });
-            return this.isClearedBuffersResult(result)
-                ? result
-                : { xhrCleared: 0, fetchCleared: 0 };
+            return this.isClearedBuffersResult(result) ? result : { xhrCleared: 0, fetchCleared: 0 };
         }
         catch (err) {
             logger.warn(`[PW] Failed to clear injected buffers: ${err instanceof Error ? err.message : String(err)}`);
@@ -430,7 +452,9 @@ export class PlaywrightNetworkMonitor {
                 bridgeWindow.__fetchInterceptorInjected = false;
                 return { xhrReset, fetchReset };
             });
-            return this.isResetInterceptorsResult(result) ? result : { xhrReset: false, fetchReset: false };
+            return this.isResetInterceptorsResult(result)
+                ? result
+                : { xhrReset: false, fetchReset: false };
         }
         catch (err) {
             logger.warn(`[PW] Failed to reset interceptors: ${err instanceof Error ? err.message : String(err)}`);

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

@@ -1,4 +1,4 @@
-import { ProcessInfo, WindowInfo } from '../process/ProcessManager.js';
+import type { ProcessInfo, WindowInfo } from '../process/ProcessManager.js';
 export interface ChromeProcess {
     mainProcess?: ProcessInfo;
     rendererProcesses: ProcessInfo[];

package/dist/src/modules/process/LinuxProcessManager.js

@@ -15,8 +15,10 @@ function safePid(pid) {
 export class LinuxProcessManager {
     isWayland = false;
     constructor() {
-        this.detectDisplayServer();
-        logger.info('LinuxProcessManager initialized', { displayServer: this.isWayland ? 'Wayland' : 'X11' });
+        void this.detectDisplayServer();
+        logger.info('LinuxProcessManager initialized', {
+            displayServer: this.isWayland ? 'Wayland' : 'X11',
+        });
     }
     async detectDisplayServer() {
         try {
@@ -32,7 +34,10 @@ export class LinuxProcessManager {
             const safePattern = sanitizePattern(pattern);
             const { stdout } = await execAsync(`ps aux | grep -i "${safePattern}" | grep -v grep || true`, { maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES });
             const processes = [];
-            const lines = stdout.trim().split('\n').filter(line => line.trim());
+            const lines = stdout
+                .trim()
+                .split('\n')
+                .filter((line) => line.trim());
             for (const line of lines) {
                 const parts = line.trim().split(/\s+/);
                 if (parts.length >= 11) {
@@ -82,7 +87,9 @@ export class LinuxProcessManager {
                 executablePath: await this.getProcessPath(pid),
                 commandLine: cmdline.trim() || undefined,
                 parentPid: status['PPid'] ? parseInt(status['PPid'], 10) : undefined,
-                memoryUsage: status['VmRSS'] ? parseInt(status['VmRSS'].replace(/\D/g, ''), 10) * 1024 : undefined,
+                memoryUsage: status['VmRSS']
+                    ? parseInt(status['VmRSS'].replace(/\D/g, ''), 10) * 1024
+                    : undefined,
                 cpuUsage: utime + stime,
             };
         }
@@ -115,7 +122,10 @@ export class LinuxProcessManager {
             }
             const { stdout } = await execAsync(`xdotool search --all --pid ${pid} 2>/dev/null || true`);
             const windows = [];
-            const windowIds = stdout.trim().split('\n').filter(id => id.trim());
+            const windowIds = stdout
+                .trim()
+                .split('\n')
+                .filter((id) => id.trim());
             for (const windowId of windowIds) {
                 try {
                     const { stdout: title } = await execAsync(`xdotool getwindowname ${windowId} 2>/dev/null || echo ""`);
@@ -172,11 +182,11 @@ export class LinuxProcessManager {
             }
             const allPids = [
                 result.mainProcess?.pid,
-                ...result.rendererProcesses.map(p => p.pid),
+                ...result.rendererProcesses.map((p) => p.pid),
             ].filter(Boolean);
             for (const pid of allPids) {
                 const windows = await this.getProcessWindows(pid);
-                const targetWindow = windows.find(w => w.title.includes('Chrome') ||
+                const targetWindow = windows.find((w) => w.title.includes('Chrome') ||
                     w.className.includes('Chrome') ||
                     w.title.includes('Chromium'));
                 if (targetWindow) {
@@ -243,7 +253,7 @@ export class LinuxProcessManager {
                 stdio: 'ignore',
             });
             child.unref();
-            await new Promise(resolve => setTimeout(resolve, PROCESS_LAUNCH_WAIT_MS));
+            await new Promise((resolve) => setTimeout(resolve, PROCESS_LAUNCH_WAIT_MS));
             if (!child.pid) {
                 logger.error(`Failed to spawn process: PID is undefined for ${executablePath}`);
                 return null;

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

@@ -1,4 +1,4 @@
-import { ProcessInfo, WindowInfo } from '../process/ProcessManager.js';
+import type { ProcessInfo, WindowInfo } from '../process/ProcessManager.js';
 export interface ChromeProcess {
     mainProcess?: ProcessInfo;
     rendererProcesses: ProcessInfo[];

package/dist/src/modules/process/MacProcessManager.js

@@ -31,7 +31,10 @@ export class MacProcessManager {
             const safePattern = sanitizePattern(pattern);
             const { stdout } = await execAsync(`ps aux | grep -i "${safePattern}" | grep -v grep || true`, { maxBuffer: PROCESS_LIST_MAX_BUFFER_BYTES });
             const processes = [];
-            const lines = stdout.trim().split('\n').filter(line => line.trim());
+            const lines = stdout
+                .trim()
+                .split('\n')
+                .filter((line) => line.trim());
             for (const line of lines) {
                 const parts = line.trim().split(/\s+/);
                 if (parts.length >= 11) {
@@ -62,7 +65,10 @@ export class MacProcessManager {
         try {
             pid = safePid(pid);
             const { stdout } = await execAsync(`ps -p ${pid} -o pid,ppid,pcpu,pmem,comm,args 2>/dev/null || echo ""`);
-            const lines = stdout.trim().split('\n').filter(line => line.trim());
+            const lines = stdout
+                .trim()
+                .split('\n')
+                .filter((line) => line.trim());
             if (lines.length < 2) {
                 return null;
             }
@@ -103,31 +109,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 = [];
@@ -175,12 +181,14 @@ export class MacProcessManager {
                         className: win.className,
                         processId: win.processId,
                         threadId: 0,
-                        bounds: win.bounds ? {
-                            x: win.bounds.X || 0,
-                            y: win.bounds.Y || 0,
-                            width: win.bounds.Width || 0,
-                            height: win.bounds.Height || 0,
-                        } : undefined,
+                        bounds: win.bounds
+                            ? {
+                                x: win.bounds.X || 0,
+                                y: win.bounds.Y || 0,
+                                width: win.bounds.Width || 0,
+                                height: win.bounds.Height || 0,
+                            }
+                            : undefined,
                     });
                 }
             }
@@ -292,7 +300,7 @@ export class MacProcessManager {
                 stdio: 'ignore',
             });
             child.unref();
-            await new Promise(resolve => setTimeout(resolve, PROCESS_LAUNCH_WAIT_MS));
+            await new Promise((resolve) => setTimeout(resolve, PROCESS_LAUNCH_WAIT_MS));
             if (!child.pid) {
                 logger.error(`Failed to spawn process: PID is undefined for ${executablePath}`);
                 return null;

package/dist/src/modules/process/MemoryManager.js

@@ -3,10 +3,14 @@ import { readMemory as _readMemory, writeMemory as _writeMemory, batchMemoryWrit
 function detectPlatform() {
     const platform = process.platform;
     switch (platform) {
-        case 'win32': return 'win32';
-        case 'linux': return 'linux';
-        case 'darwin': return 'darwin';
-        default: return 'unknown';
+        case 'win32':
+            return 'win32';
+        case 'linux':
+            return 'linux';
+        case 'darwin':
+            return 'darwin';
+        default:
+            return 'unknown';
     }
 }
 export class MemoryManager {

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

@@ -1,4 +1,4 @@
-import { BrowserInfo } from '../browser/BrowserDiscovery.js';
+import { type BrowserInfo } from '../browser/BrowserDiscovery.js';
 import { type ChromiumProcess, type ProcessInfo, type TargetAppConfig, type WindowInfo } from '../process/ProcessManager.types.js';
 export { DEFAULT_CHROMIUM_CONFIG, type ChromiumProcess, type ProcessInfo, type TargetAppConfig, type WindowInfo, } from '../process/ProcessManager.types.js';
 export declare class ProcessManager {

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

@@ -267,7 +267,7 @@ export class ProcessManager {
                         };
                     }
                 }
-                await new Promise(resolve => setTimeout(resolve, WIN_DEBUG_PORT_POLL_INTERVAL_MS));
+                await new Promise((resolve) => setTimeout(resolve, WIN_DEBUG_PORT_POLL_INTERVAL_MS));
             }
             logger.info(`Launched process with debug port ${debugPort}:`, {
                 pid: child.pid,
@@ -314,7 +314,9 @@ export class ProcessManager {
             }
             const normalizedPid = Math.trunc(pid);
             const psCommand = `Stop-Process -Id ${normalizedPid} -Force -ErrorAction SilentlyContinue; Write-Output "Process ${normalizedPid} killed"`;
-            await execAsync(`${this.powershellPath} -NoProfile -Command "${psCommand}"`, { maxBuffer: 1024 * 1024 });
+            await execAsync(`${this.powershellPath} -NoProfile -Command "${psCommand}"`, {
+                maxBuffer: 1024 * 1024,
+            });
             logger.info(`Process ${normalizedPid} killed successfully`);
             return true;
         }

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

@@ -64,7 +64,9 @@ export async function checkAvailability(platform) {
                     return { available: true };
                 }
                 try {
-                    await execAsync('capsh --print 2>/dev/null | grep -q "cap_sys_ptrace"', { timeout: 2000 });
+                    await execAsync('capsh --print 2>/dev/null | grep -q "cap_sys_ptrace"', {
+                        timeout: 2000,
+                    });
                     return { available: true };
                 }
                 catch {
@@ -75,7 +77,10 @@ export async function checkAvailability(platform) {
                 }
             }
             catch {
-                return { available: false, reason: 'Requires root privileges for /proc/pid/mem access. Run with sudo.' };
+                return {
+                    available: false,
+                    reason: 'Requires root privileges for /proc/pid/mem access. Run with sudo.',
+                };
             }
         case 'darwin':
             try {
@@ -95,7 +100,10 @@ export async function checkAvailability(platform) {
                 };
             }
         default:
-            return { available: false, reason: `Platform ${platform} not supported for memory operations.` };
+            return {
+                available: false,
+                reason: `Platform ${platform} not supported for memory operations.`,
+            };
     }
 }
 export async function checkDebugPort(platform, pid) {
@@ -103,57 +111,60 @@ 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 { stdout } = await executePowerShellScript(psScript, {
+            maxBuffer: 1024 * 1024,
+            timeout: 10000,
+        });
         const _trimmed = stdout.trim();
         if (!_trimmed)
             throw new Error('PowerShell returned empty output');

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

@@ -2,7 +2,7 @@ export type { Platform, PatternType, MemoryReadResult, MemoryWriteResult, Memory
 export { readMemory } from '../../process/memory/reader.js';
 export { writeMemory, batchMemoryWrite } from '../../process/memory/writer.js';
 export { scanMemory, scanMemoryFiltered } from '../../process/memory/scanner.js';
-export { dumpMemoryRegion, enumerateRegions, checkMemoryProtection, enumerateModules } from '../../process/memory/regions.js';
+export { dumpMemoryRegion, enumerateRegions, checkMemoryProtection, enumerateModules, } from '../../process/memory/regions.js';
 export { injectDll, injectShellcode } from '../../process/memory/injector.js';
 export { MemoryMonitorManager } from '../../process/memory/monitor.js';
 export { checkAvailability, checkDebugPort } from '../../process/memory/availability.js';