@jshookmcp/jshook 0.1.8 → 0.1.9

package/dist/modules/process/MacProcessManager.js

@@ -1,324 +0,0 @@
-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/modules/process/ProcessManager.impl.js

@@ -1,376 +0,0 @@
-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;
-        }
-    }
-}