chrome-cdp-cli 1.2.2 → 1.3.0

package/dist/handlers/HandleDialogHandler.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HandleDialogHandler = void 0;
+class HandleDialogHandler {
+    constructor() {
+        this.name = 'handle_dialog';
+        this.pendingDialog = null;
+        this.dialogPromise = null;
+        this.dialogResolve = null;
+    }
+    async execute(client, args) {
+        const dialogArgs = args;
+        if (!dialogArgs.action) {
+            return {
+                success: false,
+                error: 'Action is required for handle_dialog command (accept or dismiss)'
+            };
+        }
+        if (!['accept', 'dismiss'].includes(dialogArgs.action)) {
+            return {
+                success: false,
+                error: 'Action must be either "accept" or "dismiss"'
+            };
+        }
+        try {
+            await client.send('Page.enable');
+            await client.send('Runtime.enable');
+            const timeout = dialogArgs.timeout || 5000;
+            const waitForDialog = dialogArgs.waitForDialog !== false;
+            this.setupDialogListener(client);
+            let dialog;
+            if (waitForDialog) {
+                dialog = await this.waitForDialog(timeout);
+            }
+            else {
+                if (!this.pendingDialog) {
+                    return {
+                        success: false,
+                        error: 'No dialog is currently open'
+                    };
+                }
+                dialog = this.pendingDialog;
+            }
+            const result = await this.handleDialog(client, dialog, dialogArgs.action, dialogArgs.text);
+            this.pendingDialog = null;
+            return result;
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    setupDialogListener(client) {
+        client.off('Page.javascriptDialogOpening', this.onDialogOpening.bind(this));
+        client.on('Page.javascriptDialogOpening', this.onDialogOpening.bind(this));
+    }
+    onDialogOpening(params) {
+        const dialogParams = params;
+        const dialog = {
+            type: dialogParams.type,
+            message: dialogParams.message,
+            defaultPrompt: dialogParams.defaultPrompt
+        };
+        this.pendingDialog = dialog;
+        if (this.dialogResolve) {
+            this.dialogResolve(dialog);
+            this.dialogResolve = null;
+            this.dialogPromise = null;
+        }
+    }
+    async waitForDialog(timeout) {
+        if (this.pendingDialog) {
+            return this.pendingDialog;
+        }
+        this.dialogPromise = new Promise((resolve, reject) => {
+            this.dialogResolve = resolve;
+            setTimeout(() => {
+                if (this.dialogResolve === resolve) {
+                    this.dialogResolve = null;
+                    this.dialogPromise = null;
+                    reject(new Error(`Timeout after ${timeout}ms waiting for dialog to appear`));
+                }
+            }, timeout);
+        });
+        return this.dialogPromise;
+    }
+    async handleDialog(client, dialog, action, text) {
+        try {
+            const accept = action === 'accept';
+            let promptText;
+            if (dialog.type === 'prompt' && accept) {
+                promptText = text !== undefined ? text : dialog.defaultPrompt || '';
+            }
+            await client.send('Page.handleJavaScriptDialog', {
+                accept: accept,
+                promptText: promptText
+            });
+            return {
+                success: true,
+                data: {
+                    action: action,
+                    dialog: {
+                        type: dialog.type,
+                        message: dialog.message,
+                        defaultPrompt: dialog.defaultPrompt
+                    },
+                    promptText: promptText
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to handle dialog: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    validateArgs(args) {
+        if (typeof args !== 'object' || args === null) {
+            return false;
+        }
+        const dialogArgs = args;
+        if (!dialogArgs.action || !['accept', 'dismiss'].includes(dialogArgs.action)) {
+            return false;
+        }
+        if (dialogArgs.text !== undefined && typeof dialogArgs.text !== 'string') {
+            return false;
+        }
+        if (dialogArgs.waitForDialog !== undefined && typeof dialogArgs.waitForDialog !== 'boolean') {
+            return false;
+        }
+        if (dialogArgs.timeout !== undefined && typeof dialogArgs.timeout !== 'number') {
+            return false;
+        }
+        return true;
+    }
+    getHelp() {
+        return `
+handle_dialog - Handle browser dialogs (alert, confirm, prompt)
+
+Usage:
+  handle_dialog <action>
+  handle_dialog accept
+  handle_dialog dismiss
+  handle_dialog accept --text "user input"
+  handle_dialog accept --timeout 10000
+
+Arguments:
+  <action>                Action to take: "accept" or "dismiss"
+
+Options:
+  --text <string>        Text to enter for prompt dialogs (when accepting)
+  --wait-for-dialog      Wait for dialog to appear (default: true)
+  --no-wait             Don't wait for dialog (handle immediately if present)
+  --timeout <ms>        Timeout for waiting for dialog (default: 5000ms)
+
+Examples:
+  # Accept an alert dialog
+  handle_dialog accept
+
+  # Dismiss a confirm dialog
+  handle_dialog dismiss
+
+  # Accept a prompt dialog with text input
+  handle_dialog accept --text "John Doe"
+
+  # Accept a prompt dialog with empty text
+  handle_dialog accept --text ""
+
+  # Handle dialog with custom timeout
+  handle_dialog accept --timeout 10000
+
+  # Handle dialog without waiting (if already present)
+  handle_dialog accept --no-wait
+
+Dialog Types:
+  alert                  Simple message dialog (only "OK" button)
+  confirm                Yes/No dialog ("OK" and "Cancel" buttons)
+  prompt                 Input dialog with text field
+  beforeunload           Page unload confirmation dialog
+
+Actions:
+  accept                 Click "OK" or "Yes" button
+  dismiss                Click "Cancel" or "No" button
+
+Note:
+  - Uses CDP Page.javascriptDialogOpening event to detect dialogs
+  - Automatically waits for dialogs to appear unless --no-wait is specified
+  - For prompt dialogs, use --text to provide input (defaults to empty string)
+  - Dialog must be triggered by JavaScript (alert(), confirm(), prompt())
+  - Command will timeout if no dialog appears within the specified time
+`;
+    }
+}
+exports.HandleDialogHandler = HandleDialogHandler;

package/dist/handlers/HoverHandler.js

@@ -0,0 +1,268 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HoverHandler = void 0;
+class HoverHandler {
+    constructor() {
+        this.name = 'hover';
+    }
+    async execute(client, args) {
+        const hoverArgs = args;
+        if (!hoverArgs.selector) {
+            return {
+                success: false,
+                error: 'CSS selector is required for hover command'
+            };
+        }
+        if (typeof hoverArgs.selector !== 'string') {
+            return {
+                success: false,
+                error: 'CSS selector must be a string'
+            };
+        }
+        try {
+            await client.send('DOM.enable');
+            await client.send('Runtime.enable');
+            const timeout = hoverArgs.timeout || 5000;
+            const waitForElement = hoverArgs.waitForElement !== false;
+            if (waitForElement) {
+                const elementFound = await this.waitForElement(client, hoverArgs.selector, timeout);
+                if (!elementFound) {
+                    return {
+                        success: false,
+                        error: `Element with selector "${hoverArgs.selector}" not found within ${timeout}ms`
+                    };
+                }
+            }
+            const cdpResult = await this.hoverViaCDP(client, hoverArgs.selector);
+            if (cdpResult.success) {
+                return cdpResult;
+            }
+            const evalResult = await this.hoverViaEval(client, hoverArgs.selector);
+            return evalResult;
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+    async waitForElement(client, selector, timeout) {
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeout) {
+            try {
+                const result = await client.send('Runtime.evaluate', {
+                    expression: `document.querySelector('${selector.replace(/'/g, "\\'")}') !== null`,
+                    returnByValue: true
+                });
+                if (result.result.value) {
+                    return true;
+                }
+                await new Promise(resolve => setTimeout(resolve, 100));
+            }
+            catch (error) {
+                await new Promise(resolve => setTimeout(resolve, 100));
+            }
+        }
+        return false;
+    }
+    async hoverViaCDP(client, selector) {
+        try {
+            const documentResponse = await client.send('DOM.getDocument');
+            const rootNodeId = documentResponse.root.nodeId;
+            const queryResponse = await client.send('DOM.querySelector', {
+                nodeId: rootNodeId,
+                selector: selector
+            });
+            if (!queryResponse.nodeId || queryResponse.nodeId === 0) {
+                return {
+                    success: false,
+                    error: `Element with selector "${selector}" not found`
+                };
+            }
+            const objectResponse = await client.send('DOM.resolveNode', {
+                nodeId: queryResponse.nodeId
+            });
+            if (!objectResponse.object?.objectId) {
+                return {
+                    success: false,
+                    error: 'Failed to resolve element to remote object'
+                };
+            }
+            const hoverResponse = await client.send('Runtime.callFunctionOn', {
+                objectId: objectResponse.object.objectId,
+                functionDeclaration: `
+          function() {
+            // Scroll element into view if needed
+            this.scrollIntoView({ behavior: 'instant', block: 'center' });
+            
+            // Create and dispatch mouseover event
+            const mouseOverEvent = new MouseEvent('mouseover', {
+              bubbles: true,
+              cancelable: true,
+              view: window
+            });
+            this.dispatchEvent(mouseOverEvent);
+            
+            // Create and dispatch mouseenter event
+            const mouseEnterEvent = new MouseEvent('mouseenter', {
+              bubbles: false,
+              cancelable: false,
+              view: window
+            });
+            this.dispatchEvent(mouseEnterEvent);
+            
+            return {
+              success: true,
+              tagName: this.tagName,
+              id: this.id,
+              className: this.className
+            };
+          }
+        `,
+                returnByValue: true,
+                userGesture: true
+            });
+            if (hoverResponse.exceptionDetails) {
+                return {
+                    success: false,
+                    error: `Hover execution failed: ${hoverResponse.exceptionDetails.exception?.description || hoverResponse.exceptionDetails.text}`
+                };
+            }
+            return {
+                success: true,
+                data: {
+                    selector: selector,
+                    element: hoverResponse.result.value,
+                    method: 'CDP'
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `CDP hover failed: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    async hoverViaEval(client, selector) {
+        try {
+            const escapedSelector = selector.replace(/'/g, "\\'").replace(/"/g, '\\"');
+            const expression = `
+        (function() {
+          const element = document.querySelector('${escapedSelector}');
+          if (!element) {
+            throw new Error('Element with selector "${escapedSelector}" not found');
+          }
+          
+          // Scroll element into view if needed
+          element.scrollIntoView({ behavior: 'instant', block: 'center' });
+          
+          // Create and dispatch mouseover event
+          const mouseOverEvent = new MouseEvent('mouseover', {
+            bubbles: true,
+            cancelable: true,
+            view: window
+          });
+          element.dispatchEvent(mouseOverEvent);
+          
+          // Create and dispatch mouseenter event
+          const mouseEnterEvent = new MouseEvent('mouseenter', {
+            bubbles: false,
+            cancelable: false,
+            view: window
+          });
+          element.dispatchEvent(mouseEnterEvent);
+          
+          return {
+            success: true,
+            tagName: element.tagName,
+            id: element.id,
+            className: element.className
+          };
+        })()
+      `;
+            const response = await client.send('Runtime.evaluate', {
+                expression: expression,
+                returnByValue: true,
+                userGesture: true
+            });
+            if (response.exceptionDetails) {
+                return {
+                    success: false,
+                    error: response.exceptionDetails.exception?.description || response.exceptionDetails.text
+                };
+            }
+            return {
+                success: true,
+                data: {
+                    selector: selector,
+                    element: response.result.value,
+                    method: 'eval'
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Eval hover failed: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    validateArgs(args) {
+        if (typeof args !== 'object' || args === null) {
+            return false;
+        }
+        const hoverArgs = args;
+        if (!hoverArgs.selector || typeof hoverArgs.selector !== 'string') {
+            return false;
+        }
+        if (hoverArgs.waitForElement !== undefined && typeof hoverArgs.waitForElement !== 'boolean') {
+            return false;
+        }
+        if (hoverArgs.timeout !== undefined && typeof hoverArgs.timeout !== 'number') {
+            return false;
+        }
+        return true;
+    }
+    getHelp() {
+        return `
+hover - Hover over an element using CSS selector
+
+Usage:
+  hover <selector>
+  hover "#menu-item"
+  hover ".dropdown-trigger" --timeout 10000
+  hover "button[data-tooltip]" --no-wait
+
+Arguments:
+  <selector>              CSS selector for the element to hover over
+
+Options:
+  --wait-for-element      Wait for element to be available (default: true)
+  --no-wait              Don't wait for element (same as --wait-for-element=false)
+  --timeout <ms>         Timeout for waiting for element (default: 5000ms)
+
+Examples:
+  # Hover over a menu item by ID
+  hover "#menu-item"
+
+  # Hover over a dropdown trigger
+  hover ".dropdown-trigger"
+
+  # Hover with custom timeout
+  hover ".slow-loading-element" --timeout 10000
+
+  # Hover without waiting (fail immediately if not found)
+  hover "#optional-tooltip" --no-wait
+
+Note:
+  - Uses CDP DOM.querySelector and Runtime.callFunctionOn for precise control
+  - Falls back to JavaScript eval if CDP approach fails
+  - Automatically scrolls element into view before hovering
+  - Dispatches both 'mouseover' and 'mouseenter' events
+  - Works with CSS :hover selectors and JavaScript event listeners
+`;
+    }
+}
+exports.HoverHandler = HoverHandler;