hanseol-dev 4.0.12

package/dist/tools/browser/browser-client.js

@@ -0,0 +1,1083 @@
+import { spawn, execSync } from 'child_process';
+import * as path from 'path';
+import * as fs from 'fs';
+import WebSocket from 'ws';
+import { logger } from '../../utils/logger.js';
+import { LOCAL_HOME_DIR } from '../../constants.js';
+import { getPlatform, getPowerShellPath, } from '../../utils/platform-utils.js';
+class CDPConnection {
+    ws = null;
+    messageId = 0;
+    pendingMessages = new Map();
+    eventHandlers = new Map();
+    async connect(wsUrl) {
+        return new Promise((resolve, reject) => {
+            this.ws = new WebSocket(wsUrl);
+            this.ws.on('open', () => {
+                logger.debug('[CDP] WebSocket connected');
+                resolve();
+            });
+            this.ws.on('message', (data) => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    if (message.id !== undefined) {
+                        const pending = this.pendingMessages.get(message.id);
+                        if (pending) {
+                            this.pendingMessages.delete(message.id);
+                            if (message.error) {
+                                pending.reject(new Error(message.error.message));
+                            }
+                            else {
+                                pending.resolve(message.result);
+                            }
+                        }
+                    }
+                    else if (message.method) {
+                        const handlers = this.eventHandlers.get(message.method) || [];
+                        for (const handler of handlers) {
+                            handler(message.params);
+                        }
+                    }
+                }
+                catch (e) {
+                    logger.debug('[CDP] Failed to parse message: ' + e);
+                }
+            });
+            this.ws.on('error', (error) => {
+                logger.debug('[CDP] WebSocket error: ' + error.message);
+                reject(error);
+            });
+            this.ws.on('close', () => {
+                logger.debug('[CDP] WebSocket closed');
+                for (const [, pending] of this.pendingMessages) {
+                    pending.reject(new Error('WebSocket closed'));
+                }
+                this.pendingMessages.clear();
+            });
+        });
+    }
+    async send(method, params) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            throw new Error('WebSocket not connected');
+        }
+        const id = ++this.messageId;
+        const message = { id, method, params };
+        return new Promise((resolve, reject) => {
+            this.pendingMessages.set(id, { resolve, reject });
+            this.ws.send(JSON.stringify(message));
+            setTimeout(() => {
+                if (this.pendingMessages.has(id)) {
+                    this.pendingMessages.delete(id);
+                    reject(new Error(`CDP command timeout: ${method}`));
+                }
+            }, 30000);
+        });
+    }
+    on(event, handler) {
+        if (!this.eventHandlers.has(event)) {
+            this.eventHandlers.set(event, []);
+        }
+        this.eventHandlers.get(event).push(handler);
+    }
+    off(event) {
+        this.eventHandlers.delete(event);
+    }
+    close() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        this.pendingMessages.clear();
+        this.eventHandlers.clear();
+    }
+    isConnected() {
+        return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+    }
+}
+class BrowserClient {
+    cdp = null;
+    browserProcess = null;
+    platform;
+    cdpPort = 9222;
+    browserType = 'chrome';
+    screenshotDir;
+    consoleLogs = [];
+    networkLogs = [];
+    constructor() {
+        this.platform = getPlatform();
+        logger.debug('[BrowserClient] constructor: platform = ' + this.platform);
+        this.screenshotDir = path.join(LOCAL_HOME_DIR, 'screenshots', 'browser');
+        if (!fs.existsSync(this.screenshotDir)) {
+            fs.mkdirSync(this.screenshotDir, { recursive: true });
+        }
+        logger.debug('[BrowserClient] constructor: CDP URL = ' + this.getCDPUrl());
+    }
+    getCDPUrl() {
+        return `http://localhost:${this.cdpPort}`;
+    }
+    getScreenshotDir() {
+        return this.screenshotDir;
+    }
+    findBrowserPath(windowsPaths, linuxPaths) {
+        if (this.platform === 'native-windows') {
+            for (const p of windowsPaths) {
+                if (fs.existsSync(p))
+                    return p;
+            }
+            return null;
+        }
+        if (this.platform === 'wsl') {
+            for (const winPath of windowsPaths) {
+                const wslPath = winPath
+                    .replace(/^([A-Z]):\\/i, (_, drive) => `/mnt/${drive.toLowerCase()}/`)
+                    .replace(/\\/g, '/');
+                if (fs.existsSync(wslPath)) {
+                    logger.debug(`[BrowserClient] findBrowserPath: found via WSL mount: ${wslPath} → ${winPath}`);
+                    return winPath;
+                }
+            }
+            try {
+                const powerShellPath = getPowerShellPath();
+                const conditions = windowsPaths
+                    .map((p, index) => {
+                    const keyword = index === 0 ? 'if' : 'elseif';
+                    return `${keyword} (Test-Path '${p}') { Write-Output '${p}' }`;
+                })
+                    .join(' ');
+                const result = execSync(`${powerShellPath} -Command "${conditions}"`, { encoding: 'utf-8', timeout: 5000 }).trim();
+                if (result)
+                    return result;
+            }
+            catch (error) {
+                logger.debug(`[BrowserClient] findBrowserPath: PowerShell check failed (${error instanceof Error ? error.message : String(error)})`);
+            }
+            return null;
+        }
+        if (linuxPaths) {
+            for (const p of linuxPaths) {
+                if (fs.existsSync(p))
+                    return p;
+            }
+        }
+        return null;
+    }
+    findChromePath() {
+        return this.findBrowserPath([
+            'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
+            'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe',
+        ], [
+            '/usr/bin/google-chrome',
+            '/usr/bin/google-chrome-stable',
+            '/usr/bin/chromium',
+            '/usr/bin/chromium-browser',
+            '/snap/bin/chromium',
+        ]);
+    }
+    findEdgePath() {
+        return this.findBrowserPath([
+            'C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe',
+            'C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe',
+        ], [
+            '/usr/bin/microsoft-edge',
+            '/usr/bin/microsoft-edge-stable',
+        ]);
+    }
+    killExistingBrowser() {
+        logger.debug('[BrowserClient] killExistingBrowser: killing processes on port ' + this.cdpPort);
+        try {
+            if (this.platform === 'native-windows') {
+                const powerShellPath = getPowerShellPath();
+                execSync(`${powerShellPath} -Command "Get-NetTCPConnection -LocalPort ${this.cdpPort} -ErrorAction SilentlyContinue | ForEach-Object { Stop-Process -Id $_.OwningProcess -Force -ErrorAction SilentlyContinue }"`, { stdio: 'ignore', timeout: 5000 });
+            }
+            else if (this.platform === 'wsl') {
+                try {
+                    const powerShellPath = getPowerShellPath();
+                    execSync(`${powerShellPath} -Command "Get-NetTCPConnection -LocalPort ${this.cdpPort} -ErrorAction SilentlyContinue | ForEach-Object { Stop-Process -Id $_.OwningProcess -Force -ErrorAction SilentlyContinue }"`, { stdio: 'ignore', timeout: 5000 });
+                }
+                catch { }
+            }
+            else {
+                try {
+                    execSync(`fuser -k ${this.cdpPort}/tcp 2>/dev/null || true`, { stdio: 'ignore', timeout: 5000 });
+                }
+                catch {
+                    try {
+                        execSync(`lsof -ti:${this.cdpPort} | xargs -r kill -9 2>/dev/null || true`, { stdio: 'ignore', timeout: 5000 });
+                    }
+                    catch {
+                    }
+                }
+            }
+        }
+        catch {
+        }
+    }
+    async isCDPAvailable() {
+        try {
+            const response = await fetch(`${this.getCDPUrl()}/json/version`, {
+                signal: AbortSignal.timeout(2000),
+            });
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    async getTargets() {
+        const response = await fetch(`${this.getCDPUrl()}/json`);
+        return await response.json();
+    }
+    async isRunning() {
+        return this.cdp !== null && this.cdp.isConnected();
+    }
+    async getHealth() {
+        const chromePath = this.findChromePath();
+        const edgePath = this.findEdgePath();
+        return {
+            success: true,
+            status: 'running',
+            version: '2.0.0-pure-cdp',
+            browser: {
+                active: this.cdp !== null && this.cdp.isConnected(),
+                type: this.browserType,
+                chrome_available: chromePath !== null,
+                edge_available: edgePath !== null,
+            },
+        };
+    }
+    async startServer() {
+        return true;
+    }
+    async stopServer() {
+        return this.close().then(() => true).catch(() => true);
+    }
+    setupLogging() {
+        if (!this.cdp)
+            return;
+        this.cdp.send('Console.enable').catch(err => logger.debug('[CDP] Failed to enable Console domain: ' + err));
+        this.cdp.on('Console.messageAdded', (params) => {
+            const p = params;
+            this.consoleLogs.push({
+                level: p.message.level.toUpperCase(),
+                message: p.message.text,
+                timestamp: Date.now(),
+            });
+        });
+        this.cdp.send('Runtime.enable').catch(err => logger.debug('[CDP] Failed to enable Runtime domain: ' + err));
+        this.cdp.on('Runtime.consoleAPICalled', (params) => {
+            const p = params;
+            const message = p.args.map(a => a.value || a.description || '').join(' ');
+            this.consoleLogs.push({
+                level: p.type.toUpperCase(),
+                message,
+                timestamp: Date.now(),
+            });
+        });
+        this.cdp.send('Network.enable').catch(err => logger.debug('[CDP] Failed to enable Network domain: ' + err));
+        this.cdp.on('Network.requestWillBeSent', (params) => {
+            const p = params;
+            this.networkLogs.push({
+                type: 'request',
+                url: p.request.url,
+                method: p.request.method,
+                timestamp: Date.now(),
+                requestId: p.requestId,
+            });
+        });
+        this.cdp.on('Network.responseReceived', (params) => {
+            const p = params;
+            this.networkLogs.push({
+                type: 'response',
+                url: p.response.url,
+                status: p.response.status,
+                statusText: p.response.statusText,
+                mimeType: p.response.mimeType,
+                timestamp: Date.now(),
+                requestId: p.requestId,
+            });
+        });
+    }
+    async getCurrentPageInfo() {
+        if (!this.cdp || !this.cdp.isConnected()) {
+            return { url: '', title: '' };
+        }
+        const evalResult = await this.cdp.send('Runtime.evaluate', {
+            expression: 'JSON.stringify({ url: window.location.href, title: document.title })',
+            returnByValue: true,
+        });
+        return JSON.parse(evalResult.result.value);
+    }
+    async launch(options) {
+        const headless = options?.headless ?? false;
+        const preferredBrowser = options?.browser ?? 'chrome';
+        logger.debug(`[BrowserClient] launch: starting browser (preferred=${preferredBrowser}, headless=${headless})`);
+        try {
+            if (this.cdp) {
+                this.cdp.close();
+                this.cdp = null;
+            }
+            this.killExistingBrowser();
+            await new Promise(resolve => setTimeout(resolve, 500));
+            let browserPath = null;
+            if (preferredBrowser === 'chrome') {
+                browserPath = this.findChromePath();
+                if (!browserPath) {
+                    browserPath = this.findEdgePath();
+                    this.browserType = 'edge';
+                }
+                else {
+                    this.browserType = 'chrome';
+                }
+            }
+            else {
+                browserPath = this.findEdgePath();
+                if (!browserPath) {
+                    browserPath = this.findChromePath();
+                    this.browserType = 'chrome';
+                }
+                else {
+                    this.browserType = 'edge';
+                }
+            }
+            if (!browserPath) {
+                return {
+                    success: false,
+                    error: 'No browser found',
+                    details: 'Neither Chrome nor Edge is installed',
+                };
+            }
+            logger.debug(`[BrowserClient] launch: using ${this.browserType} at ${browserPath}`);
+            const baseArgs = [
+                `--remote-debugging-port=${this.cdpPort}`,
+                '--no-first-run',
+                '--no-default-browser-check',
+                '--disable-popup-blocking',
+                '--start-maximized',
+            ];
+            if (headless) {
+                baseArgs.push('--headless=new');
+            }
+            if (this.platform === 'native-windows') {
+                const userDataDir = `${process.env['LOCALAPPDATA']}\\hanseol-browser-profile-${Date.now()}`;
+                const args = [...baseArgs, `--user-data-dir=${userDataDir}`];
+                logger.debug(`[BrowserClient] launch: spawning browser directly on Windows`);
+                this.browserProcess = spawn(browserPath, args, {
+                    detached: true,
+                    stdio: 'ignore',
+                });
+            }
+            else if (this.platform === 'wsl') {
+                const argsForPowerShell = ['--user-data-dir=$dir', ...baseArgs];
+                const argsString = argsForPowerShell.map(arg => `"${arg}"`).join(',');
+                const psCommand = `$dir = "$env:LOCALAPPDATA\\hanseol-browser-profile-${Date.now()}"; Start-Process -FilePath '${browserPath}' -ArgumentList ${argsString}`;
+                logger.debug(`[BrowserClient] launch: executing PowerShell command from WSL`);
+                const powershellPath = getPowerShellPath();
+                this.browserProcess = spawn(powershellPath, ['-Command', psCommand], {
+                    detached: true,
+                    stdio: 'ignore',
+                });
+            }
+            else {
+                const userDataDir = `${process.env['HOME']}/.hanseol-browser-profile-${Date.now()}`;
+                const args = [...baseArgs, `--user-data-dir=${userDataDir}`];
+                logger.debug(`[BrowserClient] launch: spawning browser directly on Linux`);
+                this.browserProcess = spawn(browserPath, args, {
+                    detached: true,
+                    stdio: 'ignore',
+                });
+            }
+            this.browserProcess.unref();
+            logger.debug('[BrowserClient] launch: waiting for CDP endpoint...');
+            const maxWait = 15000;
+            const startTime = Date.now();
+            while (Date.now() - startTime < maxWait) {
+                if (await this.isCDPAvailable()) {
+                    break;
+                }
+                await new Promise(resolve => setTimeout(resolve, 500));
+            }
+            if (!(await this.isCDPAvailable())) {
+                return {
+                    success: false,
+                    error: 'CDP endpoint not available',
+                    details: `Timeout waiting for browser to start on port ${this.cdpPort}`,
+                };
+            }
+            const targets = await this.getTargets();
+            const pageTarget = targets.find(t => t.type === 'page');
+            if (!pageTarget) {
+                return {
+                    success: false,
+                    error: 'No page target found',
+                    details: 'Browser started but no page available',
+                };
+            }
+            logger.debug('[BrowserClient] launch: connecting to page via WebSocket...');
+            this.cdp = new CDPConnection();
+            await this.cdp.connect(pageTarget.webSocketDebuggerUrl);
+            this.consoleLogs = [];
+            this.networkLogs = [];
+            this.setupLogging();
+            await this.cdp.send('Page.enable');
+            try {
+                await this.cdp.send('Page.bringToFront');
+            }
+            catch {
+                logger.debug('[BrowserClient] launch: Page.bringToFront failed (non-critical)');
+            }
+            logger.debug('[BrowserClient] launch: browser connected successfully');
+            return {
+                success: true,
+                message: `${this.browserType} launched successfully`,
+                browser: this.browserType,
+                headless,
+            };
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            logger.debug('[BrowserClient] launch: error - ' + errorMsg);
+            return {
+                success: false,
+                error: 'Failed to launch browser',
+                details: errorMsg,
+            };
+        }
+    }
+    async close() {
+        try {
+            if (this.cdp) {
+                this.cdp.close();
+            }
+            this.cdp = null;
+            this.consoleLogs = [];
+            this.networkLogs = [];
+            try {
+                if (this.platform === 'native-windows' || this.platform === 'wsl') {
+                    const processName = this.browserType === 'chrome' ? 'chrome.exe' : 'msedge.exe';
+                    execSync(`powershell.exe -Command "Get-WmiObject Win32_Process -Filter \\"name='${processName}'\\" | Where-Object { \\$_.CommandLine -like '*hanseol*' } | ForEach-Object { Stop-Process -Id \\$_.ProcessId -Force -ErrorAction SilentlyContinue }"`, { stdio: 'ignore', timeout: 10000 });
+                }
+                else {
+                    const processName = this.browserType === 'chrome' ? 'chrome' : 'msedge';
+                    execSync(`pkill -f "${processName}.*hanseol-browser-profile" 2>/dev/null || true`, { stdio: 'ignore', timeout: 10000 });
+                }
+            }
+            catch {
+            }
+            this.killExistingBrowser();
+            return { success: true, message: 'Browser closed' };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: 'Failed to close browser',
+                details: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async navigate(url) {
+        try {
+            if (!this.cdp || !this.cdp.isConnected()) {
+                return { success: false, error: 'Browser not running. Use launch first.' };
+            }
+            try {
+                await this.cdp.send('Page.bringToFront');
+            }
+            catch { }
+            await this.cdp.send('Page.navigate', { url });
+            await new Promise((resolve, reject) => {
+                const timeoutId = setTimeout(() => {
+                    this.cdp?.off('Page.loadEventFired');
+                    reject(new Error(`Navigation to ${url} timed out after 30 seconds`));
+                }, 30000);
+                const handler = () => {
+                    clearTimeout(timeoutId);
+                    this.cdp?.off('Page.loadEventFired');
+                    resolve();
+                };
+                this.cdp?.on('Page.loadEventFired', handler);
+            });
+            const pageInfo = await this.getCurrentPageInfo();
+            return {
+                success: true,
+                message: 'Navigated successfully',
+                url: pageInfo.url,
+                title: pageInfo.title,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: 'Failed to navigate',
+                details: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async screenshot(fullPage = false) {
+        try {
+            if (!this.cdp || !this.cdp.isConnected()) {
+                return { success: false, error: 'Browser not running. Use launch first.' };
+            }
+            const params = { format: 'png' };
+            if (fullPage) {
+                const layoutMetrics = await this.cdp.send('Page.getLayoutMetrics');
+                params['clip'] = {
+                    x: 0,
+                    y: 0,
+                    width: layoutMetrics.contentSize.width,
+                    height: layoutMetrics.contentSize.height,
+                    scale: 1,
+                };
+                params['captureBeyondViewport'] = true;
+            }
+            const result = await this.cdp.send('Page.captureScreenshot', params);
+            const pageInfo = await this.getCurrentPageInfo();
+            return {
+                success: true,
+                message: 'Screenshot captured',
+                image: result.data,
+                format: 'png',
+                encoding: 'base64',
+                url: pageInfo.url,
+                title: pageInfo.title,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: 'Failed to take screenshot',
+                details: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async click(selector) {
+        try {
+            if (!this.cdp || !this.cdp.isConnected()) {
+                return { success: false, error: 'Browser not running. Use launch first.' };
+            }
+            const result = await this.cdp.send('Runtime.evaluate', {
+                expression: `
+          (function() {
+            const el = document.querySelector(${JSON.stringify(selector)});
+            if (!el) return { success: false, error: 'Element not found' };
+            el.click();
+            return { success: true };
+          })()
+        `,
+                returnByValue: true,
+            });
+            if (!result.result.value.success) {
+                return {
+                    success: false,
+                    error: result.result.value.error || 'Click failed',
+                };
+            }
+            const urlResult = await this.cdp.send('Runtime.evaluate', {
+                expression: 'window.location.href',
+                returnByValue: true,
+            });
+            return {
+                success: true,
+                message: 'Element clicked',
+                selector,
+                current_url: urlResult.result.value,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: 'Failed to click element',
+                details: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async fill(selector, value) {
+        try {
+            if (!this.cdp || !this.cdp.isConnected()) {
+                return { success: false, error: 'Browser not running. Use launch first.' };
+            }
+            const result = await this.cdp.send('Runtime.evaluate', {
+                expression: `
+          (function() {
+            const el = document.querySelector(${JSON.stringify(selector)});
+            if (!el) return { success: false, error: 'Element not found' };
+            el.focus();
+            el.value = ${JSON.stringify(value)};
+            el.dispatchEvent(new Event('input', { bubbles: true }));
+            el.dispatchEvent(new Event('change', { bubbles: true }));
+            return { success: true };
+          })()
+        `,
+                returnByValue: true,
+            });
+            if (!result.result.value.success) {
+                return {
+                    success: false,
+                    error: result.result.value.error || 'Fill failed',
+                };
+            }
+            return {
+                success: true,
+                message: 'Field filled',
+                selector,
+                length: value.length,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: 'Failed to fill field',
+                details: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async getText(selector) {
+        try {
+            if (!this.cdp || !this.cdp.isConnected()) {
+                return { success: false, error: 'Browser not running. Use launch first.' };
+            }
+            const expression = selector
+                ? `
+          (function() {
+            const el = document.querySelector(${JSON.stringify(selector)});
+            if (!el) return { success: false, error: 'Element not found: ${selector}' };
+            return { success: true, text: el.textContent || '' };
+          })()
+        `
+                : `({ success: true, text: document.body.innerText || '' })`;
+            const result = await this.cdp.send('Runtime.evaluate', {
+                expression,
+                returnByValue: true,
+            });
+            if (!result.result.value.success) {
+                return {
+                    success: false,
+                    error: result.result.value.error || 'Get text failed',
+                };
+            }
+            return {
+                success: true,
+                message: 'Text retrieved',
+                selector,
+                text: result.result.value.text || '',
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: 'Failed to get text',
+                details: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async getPageInfo() {
+        try {
+            if (!this.cdp || !this.cdp.isConnected()) {
+                return { success: false, error: 'Browser not running. Use launch first.' };
+            }
+            const result = await this.cdp.send('Runtime.evaluate', {
+                expression: `JSON.stringify({
+          url: window.location.href,
+          title: document.title,
+          domain: window.location.hostname,
+          protocol: window.location.protocol,
+          pathname: window.location.pathname,
+          readyState: document.readyState,
+          bodyLength: document.body?.innerHTML.length || 0,
+          linkCount: document.querySelectorAll('a').length,
+          imageCount: document.querySelectorAll('img').length,
+          formCount: document.querySelectorAll('form').length,
+          inputCount: document.querySelectorAll('input').length,
+        })`,
+                returnByValue: true,
+            });
+            const pageInfo = JSON.parse(result.result.value);
+            return {
+                success: true,
+                message: 'Page info retrieved',
+                ...pageInfo,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: 'Failed to get page info',
+                details: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async getHtml() {
+        try {
+            if (!this.cdp || !this.cdp.isConnected()) {
+                return { success: false, error: 'Browser not running. Use launch first.' };
+            }
+            const result = await this.cdp.send('Runtime.evaluate', {
+                expression: 'JSON.stringify({ url: window.location.href, title: document.title, html: document.documentElement.outerHTML })',
+                returnByValue: true,
+            });
+            const pageInfo = JSON.parse(result.result.value);
+            return {
+                success: true,
+                message: 'HTML retrieved',
+                url: pageInfo.url,
+                title: pageInfo.title,
+                html: pageInfo.html,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: 'Failed to get HTML',
+                details: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async executeScript(script) {
+        try {
+            if (!this.cdp || !this.cdp.isConnected()) {
+                return { success: false, error: 'Browser not running. Use launch first.' };
+            }
+            const wrappedScript = `(async function() { ${script} })()`;
+            const result = await this.cdp.send('Runtime.evaluate', {
+                expression: wrappedScript,
+                returnByValue: true,
+                awaitPromise: true,
+            });
+            if (result.exceptionDetails) {
+                return {
+                    success: false,
+                    error: 'Script execution error',
+                    details: result.exceptionDetails.exception?.description || result.exceptionDetails.text || 'Unknown error',
+                };
+            }
+            return {
+                success: true,
+                message: 'Script executed',
+                result: result.result.value,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: 'Failed to execute script',
+                details: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async getConsole() {
+        return {
+            success: true,
+            message: 'Console logs retrieved',
+            logs: [...this.consoleLogs],
+            count: this.consoleLogs.length,
+        };
+    }
+    async waitFor(selector, timeout = 10) {
+        try {
+            if (!this.cdp || !this.cdp.isConnected()) {
+                return { success: false, error: 'Browser not running. Use launch first.' };
+            }
+            const startTime = Date.now();
+            const timeoutMs = timeout * 1000;
+            while (Date.now() - startTime < timeoutMs) {
+                const result = await this.cdp.send('Runtime.evaluate', {
+                    expression: `document.querySelector(${JSON.stringify(selector)}) !== null`,
+                    returnByValue: true,
+                });
+                if (result.result.value) {
+                    return {
+                        success: true,
+                        message: 'Element found',
+                        selector,
+                    };
+                }
+                await new Promise(resolve => setTimeout(resolve, 100));
+            }
+            return {
+                success: false,
+                error: 'Timeout waiting for element',
+                selector,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: 'Timeout waiting for element',
+                details: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async getNetwork() {
+        return {
+            success: true,
+            message: 'Network logs retrieved',
+            logs: [...this.networkLogs],
+            count: this.networkLogs.length,
+        };
+    }
+    async focus() {
+        try {
+            if (!this.cdp || !this.cdp.isConnected()) {
+                return { success: false, error: 'Browser not running. Use launch first.' };
+            }
+            await this.cdp.send('Page.bringToFront');
+            return {
+                success: true,
+                message: 'Browser window focused',
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: 'Failed to focus browser',
+                details: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async pressKey(key, selector) {
+        try {
+            if (!this.cdp || !this.cdp.isConnected()) {
+                return { success: false, error: 'Browser not running. Use launch first.' };
+            }
+            const keyMap = {
+                'Enter': { key: 'Enter', code: 'Enter', keyCode: 13 },
+                'Tab': { key: 'Tab', code: 'Tab', keyCode: 9 },
+                'Escape': { key: 'Escape', code: 'Escape', keyCode: 27 },
+                'Backspace': { key: 'Backspace', code: 'Backspace', keyCode: 8 },
+                'Delete': { key: 'Delete', code: 'Delete', keyCode: 46 },
+                'Space': { key: ' ', code: 'Space', keyCode: 32 },
+                'ArrowUp': { key: 'ArrowUp', code: 'ArrowUp', keyCode: 38 },
+                'ArrowDown': { key: 'ArrowDown', code: 'ArrowDown', keyCode: 40 },
+                'ArrowLeft': { key: 'ArrowLeft', code: 'ArrowLeft', keyCode: 37 },
+                'ArrowRight': { key: 'ArrowRight', code: 'ArrowRight', keyCode: 39 },
+                'Home': { key: 'Home', code: 'Home', keyCode: 36 },
+                'End': { key: 'End', code: 'End', keyCode: 35 },
+                'PageUp': { key: 'PageUp', code: 'PageUp', keyCode: 33 },
+                'PageDown': { key: 'PageDown', code: 'PageDown', keyCode: 34 },
+                'Insert': { key: 'Insert', code: 'Insert', keyCode: 45 },
+                'Control': { key: 'Control', code: 'ControlLeft', keyCode: 17 },
+                'Alt': { key: 'Alt', code: 'AltLeft', keyCode: 18 },
+                'Shift': { key: 'Shift', code: 'ShiftLeft', keyCode: 16 },
+                'Meta': { key: 'Meta', code: 'MetaLeft', keyCode: 91 },
+                'F1': { key: 'F1', code: 'F1', keyCode: 112 },
+                'F2': { key: 'F2', code: 'F2', keyCode: 113 },
+                'F3': { key: 'F3', code: 'F3', keyCode: 114 },
+                'F4': { key: 'F4', code: 'F4', keyCode: 115 },
+                'F5': { key: 'F5', code: 'F5', keyCode: 116 },
+                'F6': { key: 'F6', code: 'F6', keyCode: 117 },
+                'F7': { key: 'F7', code: 'F7', keyCode: 118 },
+                'F8': { key: 'F8', code: 'F8', keyCode: 119 },
+                'F9': { key: 'F9', code: 'F9', keyCode: 120 },
+                'F10': { key: 'F10', code: 'F10', keyCode: 121 },
+                'F11': { key: 'F11', code: 'F11', keyCode: 122 },
+                'F12': { key: 'F12', code: 'F12', keyCode: 123 },
+            };
+            if (selector) {
+                await this.cdp.send('Runtime.evaluate', {
+                    expression: `document.querySelector(${JSON.stringify(selector)})?.focus()`,
+                });
+            }
+            const parts = key.split('+');
+            const modifiers = {};
+            let mainKey = key;
+            if (parts.length > 1) {
+                for (let i = 0; i < parts.length - 1; i++) {
+                    const mod = parts[i]?.toLowerCase();
+                    if (mod === 'control' || mod === 'ctrl')
+                        modifiers.ctrl = true;
+                    else if (mod === 'alt')
+                        modifiers.alt = true;
+                    else if (mod === 'shift')
+                        modifiers.shift = true;
+                    else if (mod === 'meta' || mod === 'cmd')
+                        modifiers.meta = true;
+                }
+                mainKey = parts[parts.length - 1] || key;
+            }
+            let keyInfo = keyMap[mainKey];
+            if (!keyInfo) {
+                if (mainKey.length === 1) {
+                    const charCode = mainKey.charCodeAt(0);
+                    const isUpper = mainKey >= 'A' && mainKey <= 'Z';
+                    keyInfo = {
+                        key: mainKey,
+                        code: `Key${mainKey.toUpperCase()}`,
+                        keyCode: isUpper ? charCode : charCode - 32,
+                    };
+                }
+                else {
+                    keyInfo = { key: mainKey, code: mainKey, keyCode: 0 };
+                }
+            }
+            let modifierFlags = 0;
+            if (modifiers.alt)
+                modifierFlags |= 1;
+            if (modifiers.ctrl)
+                modifierFlags |= 2;
+            if (modifiers.meta)
+                modifierFlags |= 4;
+            if (modifiers.shift)
+                modifierFlags |= 8;
+            await this.cdp.send('Input.dispatchKeyEvent', {
+                type: 'keyDown',
+                key: keyInfo.key,
+                code: keyInfo.code,
+                windowsVirtualKeyCode: keyInfo.keyCode,
+                nativeVirtualKeyCode: keyInfo.keyCode,
+                modifiers: modifierFlags,
+            });
+            await this.cdp.send('Input.dispatchKeyEvent', {
+                type: 'keyUp',
+                key: keyInfo.key,
+                code: keyInfo.code,
+                windowsVirtualKeyCode: keyInfo.keyCode,
+                nativeVirtualKeyCode: keyInfo.keyCode,
+                modifiers: modifierFlags,
+            });
+            return {
+                success: true,
+                message: `Key "${key}" pressed successfully`,
+                key,
+                selector: selector || '(focused element)',
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: 'Failed to press key',
+                details: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async type(text, selector) {
+        try {
+            if (!this.cdp || !this.cdp.isConnected()) {
+                return { success: false, error: 'Browser not running. Use launch first.' };
+            }
+            if (selector) {
+                await this.cdp.send('Runtime.evaluate', {
+                    expression: `document.querySelector(${JSON.stringify(selector)})?.focus()`,
+                });
+            }
+            for (const char of text) {
+                await this.cdp.send('Input.dispatchKeyEvent', {
+                    type: 'char',
+                    text: char,
+                });
+                await new Promise(resolve => setTimeout(resolve, 50));
+            }
+            return {
+                success: true,
+                message: `Typed ${text.length} characters`,
+                length: text.length,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: 'Failed to type text',
+                details: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async isBrowserActive() {
+        return this.cdp !== null && this.cdp.isConnected();
+    }
+    saveScreenshot(base64Image, prefix = 'browser') {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const filename = `${prefix}_${timestamp}.png`;
+        const filepath = path.join(this.screenshotDir, filename);
+        const imageBuffer = Buffer.from(base64Image, 'base64');
+        fs.writeFileSync(filepath, imageBuffer);
+        logger.debug('[BrowserClient] saveScreenshot: saved to ' + filepath);
+        return filepath;
+    }
+    getServerExePath() {
+        return null;
+    }
+    getServerUrl() {
+        return this.getCDPUrl();
+    }
+    async connect(port) {
+        try {
+            if (port)
+                this.cdpPort = port;
+            if (!(await this.isCDPAvailable())) {
+                return { success: false, error: `No browser found on port ${this.cdpPort}` };
+            }
+            const targets = await this.getTargets();
+            const pageTarget = targets.find(t => t.type === 'page');
+            if (!pageTarget) {
+                return { success: false, error: 'No page target found' };
+            }
+            if (this.cdp) {
+                this.cdp.close();
+            }
+            this.cdp = new CDPConnection();
+            await this.cdp.connect(pageTarget.webSocketDebuggerUrl);
+            await this.cdp.send('Page.enable');
+            this.consoleLogs = [];
+            this.networkLogs = [];
+            this.setupLogging();
+            return {
+                success: true,
+                message: 'Connected to existing browser',
+                url: pageTarget.url,
+                title: pageTarget.title,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: 'Failed to connect to browser',
+                details: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async send(method, params) {
+        try {
+            if (!this.cdp || !this.cdp.isConnected()) {
+                return { success: false, error: 'Browser not running. Use launch first.' };
+            }
+            const result = await this.cdp.send(method, params);
+            return { success: true, message: 'Command sent', result };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: 'Failed to send CDP command',
+                details: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async focusElement(selector) {
+        try {
+            if (!this.cdp || !this.cdp.isConnected()) {
+                return { success: false, error: 'Browser not running. Use launch first.' };
+            }
+            const result = await this.cdp.send('Runtime.evaluate', {
+                expression: `
+          (function() {
+            const el = document.querySelector(${JSON.stringify(selector)});
+            if (!el) return { success: false, error: 'Element not found' };
+            el.focus();
+            return { success: true };
+          })()
+        `,
+                returnByValue: true,
+            });
+            if (!result.result.value.success) {
+                return { success: false, error: result.result.value.error || 'Focus failed' };
+            }
+            return { success: true, message: 'Element focused', selector };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: 'Failed to focus element',
+                details: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+}
+export const browserClient = new BrowserClient();
+//# sourceMappingURL=browser-client.js.map