@jshookmcp/jshook 0.1.8 → 0.1.9

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

@@ -0,0 +1,324 @@
+import { exec, execFile, spawn } from 'child_process';
+import { promisify } from 'util';
+import { logger } from '../../utils/logger.js';
+import { DEBUG_PORT_CANDIDATES, DEFAULT_DEBUG_PORT, PROCESS_LIST_MAX_BUFFER_BYTES, PROCESS_LAUNCH_WAIT_MS, } from '../../constants.js';
+import { ScriptLoader } from '../../native/ScriptLoader.js';
+const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
+function sanitizePattern(s) {
+    return String(s || '').replace(/[^\w\s.@/\-:,+]/g, '');
+}
+function safePid(pid) {
+    const n = Math.trunc(Number(pid));
+    if (!Number.isFinite(n) || n <= 0)
+        throw new Error(`Invalid PID: ${pid}`);
+    return n;
+}
+function renderScriptTemplate(template, placeholders) {
+    let output = template;
+    for (const [key, value] of Object.entries(placeholders)) {
+        const marker = new RegExp(`\\{\\{${key}\\}\\}`, 'g');
+        output = output.replace(marker, String(value));
+    }
+    return output;
+}
+export class MacProcessManager {
+    constructor() {
+        logger.info('MacProcessManager initialized');
+    }
+    async findProcesses(pattern) {
+        try {
+            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());
+            for (const line of lines) {
+                const parts = line.trim().split(/\s+/);
+                if (parts.length >= 11) {
+                    const pid = parseInt(parts[1] || '0', 10);
+                    if (isNaN(pid))
+                        continue;
+                    const cpu = parseFloat(parts[2] || '0');
+                    const mem = parseFloat(parts[3] || '0');
+                    const command = parts.slice(10).join(' ');
+                    processes.push({
+                        pid,
+                        name: parts[10] || command.split(' ')[0] || 'unknown',
+                        commandLine: command,
+                        cpuUsage: cpu,
+                        memoryUsage: mem * 1024 * 1024,
+                    });
+                }
+            }
+            logger.info(`Found ${processes.length} processes matching '${pattern}'`);
+            return processes;
+        }
+        catch (error) {
+            logger.error(`Failed to find processes with pattern '${pattern}':`, error);
+            return [];
+        }
+    }
+    async getProcessByPid(pid) {
+        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());
+            if (lines.length < 2) {
+                return null;
+            }
+            const dataLine = lines[1] || '';
+            const parts = dataLine.trim().split(/\s+/);
+            if (parts.length >= 6) {
+                return {
+                    pid: parseInt(parts[0] || '0', 10),
+                    parentPid: parseInt(parts[1] || '0', 10),
+                    name: parts[4] || 'unknown',
+                    executablePath: await this.getProcessPath(pid),
+                    commandLine: parts.slice(5).join(' '),
+                    cpuUsage: parseFloat(parts[2] || '0'),
+                    memoryUsage: parseFloat(parts[3] || '0') * 1024 * 1024,
+                };
+            }
+            return null;
+        }
+        catch (error) {
+            logger.error(`Failed to get process by PID ${pid}:`, error);
+            return null;
+        }
+    }
+    async getProcessPath(pid) {
+        try {
+            pid = safePid(pid);
+            const { stdout } = await execAsync(`ps -p ${pid} -o comm= 2>/dev/null || echo ""`);
+            return stdout.trim() || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async getProcessWindows(pid) {
+        try {
+            pid = safePid(pid);
+            const process = await this.getProcessByPid(pid);
+            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 { stdout } = await execAsync(`osascript -e '${appleScript.replace(/'/g, "'\"'\"'")}' 2>/dev/null || echo "[]"`, { timeout: 5000 });
+            const windows = [];
+            if (stdout.trim() && stdout.trim() !== '[]') {
+                const titles = stdout.match(/title:([^,}]+)/g);
+                if (titles) {
+                    for (const title of titles) {
+                        const cleanTitle = title.replace('title:', '').trim();
+                        windows.push({
+                            handle: `mac-window-${pid}`,
+                            title: cleanTitle,
+                            className: process.name,
+                            processId: pid,
+                            threadId: 0,
+                        });
+                    }
+                }
+            }
+            return windows;
+        }
+        catch (error) {
+            logger.error(`Failed to get windows for PID ${pid}:`, error);
+            return [];
+        }
+    }
+    async getProcessWindowsCG(pid) {
+        try {
+            pid = safePid(pid);
+            const loader = new ScriptLoader();
+            const pythonTemplate = await loader.loadScript('process_list.py');
+            const pythonScript = renderScriptTemplate(pythonTemplate, {
+                PID: pid,
+            });
+            const { stdout } = await execFileAsync('python3', ['-c', pythonScript], {
+                timeout: 10_000,
+                windowsHide: true,
+            });
+            const windows = [];
+            try {
+                const data = JSON.parse(stdout.trim());
+                for (const win of data) {
+                    windows.push({
+                        handle: win.handle,
+                        title: win.title,
+                        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,
+                    });
+                }
+            }
+            catch {
+            }
+            return windows;
+        }
+        catch (error) {
+            logger.error(`Failed to get windows via CoreGraphics for PID ${pid}:`, error);
+            return [];
+        }
+    }
+    async findChromeProcesses() {
+        const result = {
+            rendererProcesses: [],
+            utilityProcesses: [],
+        };
+        try {
+            const processes = await this.findProcesses('chrome');
+            const detailedInfos = await Promise.all(processes.map((proc) => this.getProcessByPid(proc.pid)));
+            for (let i = 0; i < processes.length; i++) {
+                const proc = processes[i];
+                const detailedInfo = detailedInfos[i];
+                if (detailedInfo?.commandLine) {
+                    const cmd = detailedInfo.commandLine.toLowerCase();
+                    if (cmd.includes('--type=renderer')) {
+                        result.rendererProcesses.push({ ...proc, ...detailedInfo });
+                    }
+                    else if (cmd.includes('--type=gpu-process')) {
+                        result.gpuProcess = { ...proc, ...detailedInfo };
+                    }
+                    else if (cmd.includes('--type=utility')) {
+                        result.utilityProcesses.push({ ...proc, ...detailedInfo });
+                    }
+                    else if (!cmd.includes('--type=')) {
+                        result.mainProcess = { ...proc, ...detailedInfo };
+                    }
+                }
+                else {
+                    if (!result.mainProcess) {
+                        result.mainProcess = proc;
+                    }
+                }
+            }
+            if (result.mainProcess) {
+                const windows = await this.getProcessWindowsCG(result.mainProcess.pid);
+                if (windows.length > 0) {
+                    result.targetWindow = windows[0];
+                }
+            }
+            logger.info('Chrome processes found:', {
+                main: result.mainProcess?.pid,
+                renderers: result.rendererProcesses.length,
+                hasTargetWindow: !!result.targetWindow,
+            });
+            return result;
+        }
+        catch (error) {
+            logger.error('Failed to find Chrome processes:', error);
+            return result;
+        }
+    }
+    async getProcessCommandLine(pid) {
+        try {
+            pid = safePid(pid);
+            const { stdout } = await execAsync(`ps -p ${pid} -o ppid=,args= 2>/dev/null || echo ""`);
+            const parts = stdout.trim().split(/\s+/);
+            if (parts.length >= 2) {
+                return {
+                    parentPid: parseInt(parts[0] || '0', 10),
+                    commandLine: parts.slice(1).join(' ') || undefined,
+                };
+            }
+            return {};
+        }
+        catch (error) {
+            logger.error(`Failed to get command line for PID ${pid}:`, error);
+            return {};
+        }
+    }
+    async checkDebugPort(pid, options) {
+        try {
+            pid = safePid(pid);
+            const commandLine = options?.commandLine ?? (await this.getProcessCommandLine(pid)).commandLine;
+            if (commandLine) {
+                const match = commandLine.match(/--remote-debugging-port=(\d+)/);
+                if (match && match[1]) {
+                    return parseInt(match[1], 10);
+                }
+            }
+            const { stdout } = await execAsync(`lsof -Pan -p ${pid} -i 2>/dev/null | grep LISTEN || true`, { maxBuffer: 1024 * 1024 });
+            for (const port of DEBUG_PORT_CANDIDATES) {
+                if (stdout.includes(`:${port}`)) {
+                    return port;
+                }
+            }
+            return null;
+        }
+        catch (error) {
+            logger.error(`Failed to check debug port for PID ${pid}:`, error);
+            return null;
+        }
+    }
+    async launchWithDebug(executablePath, debugPort = DEFAULT_DEBUG_PORT, args = []) {
+        try {
+            const debugArgs = [`--remote-debugging-port=${debugPort}`, ...args];
+            const child = spawn(executablePath, debugArgs, {
+                detached: true,
+                stdio: 'ignore',
+            });
+            child.unref();
+            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;
+            }
+            const process = await this.getProcessByPid(child.pid);
+            logger.info(`Launched process with debug port ${debugPort}:`, {
+                pid: child.pid,
+                executable: executablePath,
+            });
+            return process;
+        }
+        catch (error) {
+            logger.error('Failed to launch process with debug:', error);
+            return null;
+        }
+    }
+    async killProcess(pid) {
+        try {
+            pid = safePid(pid);
+            await execAsync(`kill -9 ${pid} 2>/dev/null || kill -15 ${pid}`);
+            logger.info(`Process ${pid} killed successfully`);
+            return true;
+        }
+        catch (error) {
+            logger.error(`Failed to kill process ${pid}:`, error);
+            return false;
+        }
+    }
+}

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

@@ -0,0 +1,376 @@
+import { exec, spawn } from 'child_process';
+import { promisify } from 'util';
+import { logger } from '../../utils/logger.js';
+import { DEBUG_PORT_CANDIDATES, DEFAULT_DEBUG_PORT, PROCESS_LIST_MAX_BUFFER_BYTES, WIN_DEBUG_PORT_POLL_ATTEMPTS, WIN_DEBUG_PORT_POLL_INTERVAL_MS, } from '../../constants.js';
+import { ScriptLoader } from '../../native/ScriptLoader.js';
+import { BrowserDiscovery } from '../browser/BrowserDiscovery.js';
+import { findChromiumProcessesWithConfig } from '../process/ProcessManager.chromium.js';
+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, '');
+}
+function safePid(pid) {
+    const n = Math.trunc(Number(pid));
+    if (!Number.isFinite(n) || n <= 0)
+        throw new Error(`Invalid PID: ${pid}`);
+    return n;
+}
+export class ProcessManager {
+    powershellPath = 'powershell.exe';
+    scriptLoader;
+    browserDiscovery;
+    processCache = new Map();
+    constructor() {
+        this.scriptLoader = new ScriptLoader();
+        this.browserDiscovery = new BrowserDiscovery();
+        logger.info('ProcessManager initialized for Windows platform');
+    }
+    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`;
+            }
+            else {
+                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 lines = stdout.trim();
+            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 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;
+        }
+        catch (error) {
+            logger.error(`Failed to find processes with pattern '${pattern}':`, error);
+            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);
+            const psCommand = `Get-Process -Id ${pid} -ErrorAction SilentlyContinue | Select-Object Id, ProcessName, Path, MainWindowTitle, MainWindowHandle, CPU, WorkingSet64, StartTime | ConvertTo-Json -Compress`;
+            const { stdout } = await execAsync(`${this.powershellPath} -NoProfile -Command "${psCommand}"`, { maxBuffer: 1024 * 1024 });
+            if (!stdout.trim() || stdout.trim() === 'null') {
+                return null;
+            }
+            const proc = JSON.parse(stdout.trim());
+            return {
+                pid: proc.Id,
+                name: proc.ProcessName,
+                executablePath: proc.Path,
+                windowTitle: proc.MainWindowTitle,
+                windowHandle: proc.MainWindowHandle?.toString(),
+                cpuUsage: proc.CPU,
+                memoryUsage: proc.WorkingSet64,
+            };
+        }
+        catch (error) {
+            logger.error(`Failed to get process by PID ${pid}:`, error);
+            return null;
+        }
+    }
+    async getProcessWindows(pid) {
+        try {
+            pid = safePid(pid);
+            const scriptPath = await this.scriptLoader.getScriptPath('enum-windows.ps1');
+            const { stdout } = await execAsync(`${this.powershellPath} -NoProfile -ExecutionPolicy Bypass -File "${scriptPath}" -TargetPid ${pid}`, { maxBuffer: 1024 * 1024 });
+            if (!stdout.trim() || stdout.trim() === 'null') {
+                return [];
+            }
+            const data = JSON.parse(stdout.trim());
+            const windows = [];
+            const winList = Array.isArray(data) ? data : [data];
+            for (const win of winList) {
+                windows.push({
+                    handle: win.Handle,
+                    title: win.Title,
+                    className: win.ClassName,
+                    processId: win.ProcessId,
+                    threadId: 0,
+                });
+            }
+            return windows;
+        }
+        catch (error) {
+            logger.error(`Failed to get windows for PID ${pid}:`, error);
+            return [];
+        }
+    }
+    async findChromiumProcesses(config = DEFAULT_CHROMIUM_CONFIG) {
+        return findChromiumProcessesWithConfig(config, {
+            findProcesses: (pattern) => this.findProcesses(pattern),
+            getProcessCommandLine: (pid) => this.getProcessCommandLine(pid),
+            getProcessWindows: (pid) => this.getProcessWindows(pid),
+            logInfo: (message, payload) => logger.info(message, payload),
+            logError: (message, error) => logger.error(message, error),
+        });
+    }
+    async findChromiumAppProcesses() {
+        return this.findChromiumProcesses();
+    }
+    async getProcessCommandLine(pid) {
+        try {
+            pid = safePid(pid);
+            const psCommand = `Get-CimInstance Win32_Process -Filter 'ProcessId = ${pid}' | Select-Object CommandLine, ParentProcessId | ConvertTo-Json -Compress`;
+            const { stdout } = await execAsync(`${this.powershellPath} -NoProfile -Command "${psCommand}"`, { maxBuffer: 1024 * 1024 });
+            if (!stdout.trim() || stdout.trim() === 'null') {
+                return {};
+            }
+            const data = JSON.parse(stdout.trim());
+            return {
+                commandLine: data.CommandLine,
+                parentPid: data.ParentProcessId,
+            };
+        }
+        catch (error) {
+            logger.error(`Failed to get command line for PID ${pid}:`, error);
+            return {};
+        }
+    }
+    async checkDebugPort(pid, options) {
+        try {
+            pid = safePid(pid);
+            const commandLine = options?.commandLine ?? (await this.getProcessCommandLine(pid)).commandLine;
+            if (commandLine) {
+                const match = commandLine.match(/--remote-debugging-port=(\d+)/);
+                if (match && match[1]) {
+                    return parseInt(match[1], 10);
+                }
+            }
+            const psCommand = `Get-NetTCPConnection -OwningProcess ${pid} -State Listen -ErrorAction SilentlyContinue | Select-Object LocalPort | ConvertTo-Json -Compress`;
+            const { stdout } = await execAsync(`${this.powershellPath} -NoProfile -Command "${psCommand}"`, { maxBuffer: 1024 * 1024 });
+            if (stdout.trim() && stdout.trim() !== 'null') {
+                const data = JSON.parse(stdout.trim());
+                const ports = Array.isArray(data) ? data : [data];
+                for (const port of ports) {
+                    if (DEBUG_PORT_CANDIDATES.includes(port.LocalPort)) {
+                        return port.LocalPort;
+                    }
+                }
+            }
+            return null;
+        }
+        catch (error) {
+            logger.error(`Failed to check debug port for PID ${pid}:`, error);
+            return null;
+        }
+    }
+    async findPidByListeningPort(port) {
+        try {
+            const psCommand = `Get-NetTCPConnection -LocalPort ${port} -State Listen -ErrorAction SilentlyContinue | Select-Object -First 1 OwningProcess | ConvertTo-Json -Compress`;
+            const { stdout } = await execAsync(`${this.powershellPath} -NoProfile -Command "${psCommand}"`, { maxBuffer: 1024 * 1024 });
+            if (!stdout.trim() || stdout.trim() === 'null') {
+                return null;
+            }
+            const data = JSON.parse(stdout.trim());
+            const first = Array.isArray(data) ? data[0] : data;
+            const rawPid = first?.OwningProcess ?? first?.owningProcess ?? first;
+            const pid = Number(rawPid);
+            return Number.isFinite(pid) && pid > 0 ? pid : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async launchWithDebug(executablePath, debugPort = DEFAULT_DEBUG_PORT, args = []) {
+        try {
+            const debugArgs = [`--remote-debugging-port=${debugPort}`, ...args];
+            const child = spawn(executablePath, debugArgs, {
+                detached: true,
+                stdio: 'ignore',
+            });
+            child.unref();
+            const childPid = child.pid || 0;
+            const executableName = executablePath.split(/[\\/]/).pop() || 'unknown';
+            let resolvedPid = childPid > 0 ? childPid : null;
+            for (let attempt = 0; attempt < WIN_DEBUG_PORT_POLL_ATTEMPTS; attempt++) {
+                const debugPid = await this.findPidByListeningPort(debugPort);
+                if (debugPid && debugPid > 0) {
+                    resolvedPid = debugPid;
+                }
+                if (resolvedPid && resolvedPid > 0) {
+                    const process = await this.getProcessByPid(resolvedPid);
+                    if (process) {
+                        logger.info(`Launched process with debug port ${debugPort}:`, {
+                            pid: child.pid,
+                            resolvedPid,
+                            executable: executablePath,
+                        });
+                        return process;
+                    }
+                    if (debugPid && debugPid === resolvedPid) {
+                        logger.info(`Launched process with debug port ${debugPort}:`, {
+                            pid: child.pid,
+                            resolvedPid,
+                            executable: executablePath,
+                        });
+                        return {
+                            pid: resolvedPid,
+                            name: executableName,
+                            executablePath,
+                        };
+                    }
+                }
+                await new Promise(resolve => setTimeout(resolve, WIN_DEBUG_PORT_POLL_INTERVAL_MS));
+            }
+            logger.info(`Launched process with debug port ${debugPort}:`, {
+                pid: child.pid,
+                resolvedPid,
+                executable: executablePath,
+            });
+            if (resolvedPid && resolvedPid > 0) {
+                return {
+                    pid: resolvedPid,
+                    name: executableName,
+                    executablePath,
+                };
+            }
+            return null;
+        }
+        catch (error) {
+            logger.error('Failed to launch process with debug:', error);
+            return null;
+        }
+    }
+    async injectDll(_pid, _dllPath) {
+        try {
+            if (!Number.isFinite(_pid) || _pid <= 0) {
+                logger.error(`Invalid PID for injectDll: ${_pid}`);
+                return false;
+            }
+            const scriptPath = this.scriptLoader.getScriptPath('inject-dll.ps1');
+            const normalizedPid = Math.trunc(_pid);
+            const escapedDllPath = String(_dllPath).replace(/'/g, "''");
+            await execAsync(`${this.powershellPath} -NoProfile -ExecutionPolicy Bypass -File "${scriptPath}" -TargetPid ${normalizedPid} -DllPath '${escapedDllPath}'`, { maxBuffer: 1024 * 1024 });
+            logger.warn('DLL injection is disabled for safety in this implementation');
+            return false;
+        }
+        catch (error) {
+            logger.error('DLL injection failed:', error);
+            return false;
+        }
+    }
+    async killProcess(pid) {
+        try {
+            if (!Number.isFinite(pid) || pid <= 0) {
+                logger.error(`Invalid PID for killProcess: ${pid}`);
+                return false;
+            }
+            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 });
+            logger.info(`Process ${normalizedPid} killed successfully`);
+            return true;
+        }
+        catch (error) {
+            logger.error(`Failed to kill process ${pid}:`, error);
+            return false;
+        }
+    }
+    async discoverBrowsers() {
+        try {
+            const browsers = await this.browserDiscovery.discoverBrowsers();
+            logger.info(`Discovered ${browsers.length} browser instances`);
+            return browsers;
+        }
+        catch (error) {
+            logger.error('Failed to discover browsers:', error);
+            return [];
+        }
+    }
+    async findBrowserByWindowClass(classNamePattern) {
+        try {
+            const browsers = await this.browserDiscovery.findByWindowClass(classNamePattern);
+            logger.info(`Found ${browsers.length} browsers matching window class '${classNamePattern}'`);
+            return browsers;
+        }
+        catch (error) {
+            logger.error(`Failed to find browser by window class '${classNamePattern}':`, error);
+            return [];
+        }
+    }
+    async findBrowserByProcessName(name) {
+        try {
+            const browsers = await this.browserDiscovery.findByProcessName(name);
+            logger.info(`Found ${browsers.length} browsers matching process name '${name}'`);
+            return browsers;
+        }
+        catch (error) {
+            logger.error(`Failed to find browser by process name '${name}':`, error);
+            return [];
+        }
+    }
+    async detectBrowserDebugPort(pid, ports) {
+        try {
+            const portsToCheck = ports || DEBUG_PORT_CANDIDATES;
+            const debugPort = await this.browserDiscovery.detectDebugPort(pid, portsToCheck);
+            if (debugPort) {
+                logger.info(`Detected debug port ${debugPort} for process ${pid}`);
+            }
+            else {
+                logger.warn(`No debug port detected for process ${pid}`);
+            }
+            return debugPort;
+        }
+        catch (error) {
+            logger.error(`Failed to detect debug port for PID ${pid}:`, error);
+            return null;
+        }
+    }
+}