@codebolt/codeboltjs 5.0.2 → 5.0.3

package/dist/modules/browser.d.ts

@@ -1,103 +1,159 @@
 import { GoToPageResponse, UrlResponse, GetMarkdownResponse, HtmlReceived, ExtractTextResponse, GetContentResponse, BrowserActionResponseData, BrowserScreenshotResponse, BrowserInfoResponse, BrowserSnapshotResponse } from '@codebolt/types/sdk';
+import type { BrowserInstanceOptions, BrowserOperationOptions, BrowserInstanceInfo, BrowserScreenshotOptions } from '../types/libFunctionTypes';
 /**
  * A module for interacting with a browser through WebSockets.
  */
 declare const cbbrowser: {
     /**
      * Opens a new page in the browser.
+     * @param options - Optional browser instance options
      */
-    newPage: () => Promise<BrowserActionResponseData>;
+    newPage: (options?: BrowserInstanceOptions) => Promise<BrowserActionResponseData>;
     /**
      * Retrieves the current URL of the browser's active page.
+     * @param options - Optional browser operation options
      * @returns {Promise<UrlResponse>} A promise that resolves with the URL.
      */
-    getUrl: () => Promise<UrlResponse>;
+    getUrl: (options?: BrowserOperationOptions) => Promise<UrlResponse>;
     /**
      * Navigates to a specified URL.
      * @param {string} url - The URL to navigate to.
+     * @param options - Optional browser operation options
      * @returns {Promise<GoToPageResponse>} A promise that resolves when navigation is complete.
      */
-    goToPage: (url: string) => Promise<GoToPageResponse>;
+    goToPage: (url: string, options?: BrowserOperationOptions) => Promise<GoToPageResponse>;
     /**
      * Takes a screenshot of the current page.
+     * @param options - Optional browser screenshot options
      */
-    screenshot: () => Promise<BrowserScreenshotResponse>;
+    screenshot: (options?: BrowserScreenshotOptions) => Promise<BrowserScreenshotResponse>;
     /**
      * Retrieves the HTML content of the current page.
+     * @param options - Optional browser operation options
      * @returns {Promise<HtmlReceived>} A promise that resolves with the HTML content.
      */
-    getHTML: () => Promise<HtmlReceived>;
+    getHTML: (options?: BrowserOperationOptions) => Promise<HtmlReceived>;
     /**
      * Retrieves the Markdown content of the current page.
+     * @param options - Optional browser operation options
      * @returns {Promise<GetMarkdownResponse>} A promise that resolves with the Markdown content.
      */
-    getMarkdown: () => Promise<GetMarkdownResponse>;
+    getMarkdown: (options?: BrowserOperationOptions) => Promise<GetMarkdownResponse>;
     /**
      * Retrieves the PDF content of the current page.
-     *
+     * @param options - Optional browser operation options
      */
-    getPDF: () => void;
+    getPDF: (options?: BrowserOperationOptions) => Promise<void>;
     /**
      * Converts the PDF content of the current page to text.
+     * @param options - Optional browser operation options
      */
-    pdfToText: () => void;
+    pdfToText: (options?: BrowserOperationOptions) => Promise<void>;
     /**
      * Retrieves the content of the current page.
-     *  @returns {Promise<GetContentResponse>} A promise that resolves with the content.
+     * @param options - Optional browser operation options
+     * @returns {Promise<GetContentResponse>} A promise that resolves with the content.
      */
-    getContent: () => Promise<GetContentResponse>;
+    getContent: (options?: BrowserOperationOptions) => Promise<GetContentResponse>;
     /**
      * Retrieves the snapshot of the current page.
-     *  @returns {Promise<BrowserSnapshotResponse>} A promise that resolves with the snapshot.
+     * @param options - Optional browser operation options
+     * @returns {Promise<BrowserSnapshotResponse>} A promise that resolves with the snapshot.
      */
-    getSnapShot: () => Promise<BrowserSnapshotResponse>;
+    getSnapShot: (options?: BrowserOperationOptions) => Promise<BrowserSnapshotResponse>;
     /**
      * Retrieves browser info like height width scrollx scrolly of the current page.
-     *  @returns {Promise<BrowserInfoResponse>} A promise that resolves with the browser info.
+     * @param options - Optional browser operation options
+     * @returns {Promise<BrowserInfoResponse>} A promise that resolves with the browser info.
      */
-    getBrowserInfo: () => Promise<BrowserInfoResponse>;
+    getBrowserInfo: (options?: BrowserOperationOptions) => Promise<BrowserInfoResponse>;
     /**
      * Extracts text from the current page.
-     *  @returns {Promise<ExtractTextResponse>} A promise that resolves with the extracted text.
-     *
+     * @param options - Optional browser operation options
+     * @returns {Promise<ExtractTextResponse>} A promise that resolves with the extracted text.
      */
-    extractText: () => Promise<ExtractTextResponse>;
+    extractText: (options?: BrowserOperationOptions) => Promise<ExtractTextResponse>;
     /**
      * Closes the current page.
+     * @param options - Optional browser operation options
      */
-    close: () => void;
+    close: (options?: BrowserOperationOptions) => Promise<void>;
     /**
      * Scrolls the current page in a specified direction by a specified number of pixels.
      * @param {string} direction - The direction to scroll.
      * @param {string} pixels - The number of pixels to scroll.
+     * @param options - Optional browser operation options
      * @returns {Promise<BrowserActionResponseData>} A promise that resolves when the scroll action is complete.
      */
-    scroll: (direction: string, pixels: string) => Promise<BrowserActionResponseData>;
+    scroll: (direction: string, pixels: string, options?: BrowserOperationOptions) => Promise<BrowserActionResponseData>;
     /**
      * Types text into a specified element on the page.
      * @param {string} elementid - The ID of the element to type into.
      * @param {string} text - The text to type.
+     * @param options - Optional browser operation options
      * @returns {Promise<BrowserActionResponseData>} A promise that resolves when the typing action is complete.
      */
-    type: (elementid: string, text: string) => Promise<BrowserActionResponseData>;
+    type: (elementid: string, text: string, options?: BrowserOperationOptions) => Promise<BrowserActionResponseData>;
     /**
      * Clicks on a specified element on the page.
      * @param {string} elementid - The ID of the element to click.
+     * @param options - Optional browser operation options
      * @returns {Promise<BrowserActionResponseData>} A promise that resolves when the click action is complete.
      */
-    click: (elementid: string) => Promise<BrowserActionResponseData>;
+    click: (elementid: string, options?: BrowserOperationOptions) => Promise<BrowserActionResponseData>;
     /**
      * Simulates the Enter key press on the current page.
+     * @param options - Optional browser operation options
      * @returns {Promise<BrowserActionResponseData>} A promise that resolves when the Enter action is complete.
      */
-    enter: () => Promise<BrowserActionResponseData>;
+    enter: (options?: BrowserOperationOptions) => Promise<BrowserActionResponseData>;
     /**
      * Performs a search on the current page using a specified query.
      * @param {string} elementid - The ID of the element to perform the search in.
      * @param {string} query - The search query.
+     * @param options - Optional browser operation options
      * @returns {Promise<BrowserActionResponseData>} A promise that resolves with the search results.
      */
-    search: (elementid: string, query: string) => Promise<BrowserActionResponseData>;
+    search: (elementid: string, query: string, options?: BrowserOperationOptions) => Promise<BrowserActionResponseData>;
+    /**
+     * List all open browser instances
+     * @returns {Promise<BrowserInstanceInfo[]>} Array of browser instance information
+     */
+    listBrowserInstances: () => Promise<BrowserInstanceInfo[]>;
+    /**
+     * Get a specific browser instance by ID
+     * @param {string} instanceId - The instance ID to get
+     * @returns {Promise<BrowserInstanceInfo | null>} Browser instance information or null if not found
+     */
+    getBrowserInstance: (instanceId: string) => Promise<BrowserInstanceInfo | null>;
+    /**
+     * Set the active browser instance
+     * @param {string} instanceId - The instance ID to set as active
+     * @returns {Promise<boolean>} True if successful, false if instance not found
+     */
+    setActiveBrowserInstance: (instanceId: string) => Promise<boolean>;
+    /**
+     * Open a new browser instance
+     * @param options - Optional instance creation options
+     * @returns {Promise<{ instanceId: string }>} The new instance ID
+     */
+    openNewBrowserInstance: (options?: BrowserInstanceOptions) => Promise<{
+        instanceId: string;
+    }>;
+    /**
+     * Close a browser instance
+     * @param {string} instanceId - The instance ID to close
+     * @returns {Promise<boolean>} True if successful, false if instance not found
+     */
+    closeBrowserInstance: (instanceId: string) => Promise<boolean>;
+    /**
+     * Execute action on specific browser instance
+     * @param {string} instanceId - The instance ID to execute on
+     * @param {string} operation - The operation to execute
+     * @param {any} params - Parameters for the operation
+     * @returns {Promise<any>} The operation result
+     */
+    executeOnInstance: (instanceId: string, operation: string, params: any) => Promise<any>;
 };
 export default cbbrowser;
 /***

package/dist/modules/browser.js

@@ -5,202 +5,380 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const websocket_1 = __importDefault(require("../core/websocket"));
 const enum_1 = require("@codebolt/types/enum");
+// Active instance management
+let activeInstanceId = null;
+// Helper function to get or create active instance
+const getOrCreateActiveInstance = async () => {
+    if (activeInstanceId) {
+        // For now, assume the active instance is still valid
+        // We'll implement proper checking when we add the instance management functions
+        return activeInstanceId;
+    }
+    // Create new instance ID (temporary - will be replaced with proper instance creation)
+    const newInstanceId = `browser-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    activeInstanceId = newInstanceId;
+    return newInstanceId;
+};
+// Helper function to resolve instance ID
+const resolveInstanceId = async (options) => {
+    if (options === null || options === void 0 ? void 0 : options.instanceId) {
+        return options.instanceId;
+    }
+    return await getOrCreateActiveInstance();
+};
 /**
  * A module for interacting with a browser through WebSockets.
  */
 const cbbrowser = {
     /**
      * Opens a new page in the browser.
+     * @param options - Optional browser instance options
      */
-    newPage: () => {
+    newPage: async (options) => {
+        const instanceId = (options === null || options === void 0 ? void 0 : options.instanceId) || await getOrCreateActiveInstance();
         return websocket_1.default.messageManager.sendAndWaitForResponse({
             "type": enum_1.EventType.BROWSER_EVENT,
-            action: enum_1.BrowserAction.NEW_PAGE
+            action: enum_1.BrowserAction.NEW_PAGE,
+            instanceId
         }, enum_1.BrowserResponseType.NEW_PAGE_RESPONSE);
     },
     /**
      * Retrieves the current URL of the browser's active page.
+     * @param options - Optional browser operation options
      * @returns {Promise<UrlResponse>} A promise that resolves with the URL.
      */
-    getUrl: () => {
+    getUrl: async (options) => {
+        const instanceId = await resolveInstanceId(options);
         return websocket_1.default.messageManager.sendAndWaitForResponse({
             "type": enum_1.EventType.BROWSER_EVENT,
-            action: enum_1.BrowserAction.GET_URL
+            action: enum_1.BrowserAction.GET_URL,
+            instanceId
         }, enum_1.BrowserResponseType.GET_URL_RESPONSE);
     },
     /**
      * Navigates to a specified URL.
      * @param {string} url - The URL to navigate to.
+     * @param options - Optional browser operation options
      * @returns {Promise<GoToPageResponse>} A promise that resolves when navigation is complete.
      */
-    goToPage: (url) => {
+    goToPage: async (url, options) => {
+        const instanceId = await resolveInstanceId(options);
         return websocket_1.default.messageManager.sendAndWaitForResponse({
             "type": enum_1.EventType.BROWSER_EVENT,
             action: enum_1.BrowserAction.GO_TO_PAGE,
-            url
+            url,
+            instanceId
         }, enum_1.BrowserResponseType.GO_TO_PAGE_RESPONSE);
     },
     /**
      * Takes a screenshot of the current page.
+     * @param options - Optional browser screenshot options
      */
-    screenshot: () => {
+    screenshot: async (options) => {
+        const instanceId = await resolveInstanceId(options);
         return websocket_1.default.messageManager.sendAndWaitForResponse({
             "type": enum_1.EventType.BROWSER_EVENT,
-            action: enum_1.BrowserAction.SCREENSHOT
+            action: enum_1.BrowserAction.SCREENSHOT,
+            instanceId,
+            // Pass through screenshot options
+            fullPage: options === null || options === void 0 ? void 0 : options.fullPage,
+            quality: options === null || options === void 0 ? void 0 : options.quality,
+            format: options === null || options === void 0 ? void 0 : options.format
         }, enum_1.BrowserResponseType.SCREENSHOT_RESPONSE);
     },
     /**
      * Retrieves the HTML content of the current page.
+     * @param options - Optional browser operation options
      * @returns {Promise<HtmlReceived>} A promise that resolves with the HTML content.
      */
-    getHTML: () => {
+    getHTML: async (options) => {
+        const instanceId = await resolveInstanceId(options);
         return websocket_1.default.messageManager.sendAndWaitForResponse({
             "type": enum_1.EventType.BROWSER_EVENT,
-            action: enum_1.BrowserAction.GET_HTML
+            action: enum_1.BrowserAction.GET_HTML,
+            instanceId
         }, enum_1.BrowserResponseType.HTML_RECEIVED);
     },
     /**
      * Retrieves the Markdown content of the current page.
+     * @param options - Optional browser operation options
      * @returns {Promise<GetMarkdownResponse>} A promise that resolves with the Markdown content.
      */
-    getMarkdown: () => {
+    getMarkdown: async (options) => {
+        const instanceId = await resolveInstanceId(options);
         return websocket_1.default.messageManager.sendAndWaitForResponse({
             "type": enum_1.EventType.BROWSER_EVENT,
-            action: enum_1.BrowserAction.GET_MARKDOWN
+            action: enum_1.BrowserAction.GET_MARKDOWN,
+            instanceId
         }, enum_1.BrowserResponseType.GET_MARKDOWN_RESPONSE);
     },
     /**
      * Retrieves the PDF content of the current page.
-     *
+     * @param options - Optional browser operation options
      */
-    getPDF: () => {
+    getPDF: async (options) => {
+        const instanceId = await resolveInstanceId(options);
         websocket_1.default.messageManager.send({
             "type": enum_1.EventType.BROWSER_EVENT,
-            action: enum_1.BrowserAction.GET_PDF
+            action: enum_1.BrowserAction.GET_PDF,
+            instanceId
         });
     },
     /**
      * Converts the PDF content of the current page to text.
+     * @param options - Optional browser operation options
      */
-    pdfToText: () => {
+    pdfToText: async (options) => {
+        const instanceId = await resolveInstanceId(options);
         websocket_1.default.messageManager.send({
             "type": enum_1.EventType.BROWSER_EVENT,
-            action: enum_1.BrowserAction.PDF_TO_TEXT
+            action: enum_1.BrowserAction.PDF_TO_TEXT,
+            instanceId
         });
     },
     /**
      * Retrieves the content of the current page.
-     *  @returns {Promise<GetContentResponse>} A promise that resolves with the content.
+     * @param options - Optional browser operation options
+     * @returns {Promise<GetContentResponse>} A promise that resolves with the content.
      */
-    getContent: () => {
+    getContent: async (options) => {
+        const instanceId = await resolveInstanceId(options);
         return websocket_1.default.messageManager.sendAndWaitForResponse({
             "type": enum_1.EventType.BROWSER_EVENT,
-            action: enum_1.BrowserAction.GET_CONTENT
+            action: enum_1.BrowserAction.GET_CONTENT,
+            instanceId
         }, enum_1.BrowserResponseType.GET_CONTENT_RESPONSE);
     },
     /**
      * Retrieves the snapshot of the current page.
-     *  @returns {Promise<BrowserSnapshotResponse>} A promise that resolves with the snapshot.
+     * @param options - Optional browser operation options
+     * @returns {Promise<BrowserSnapshotResponse>} A promise that resolves with the snapshot.
      */
-    getSnapShot: () => {
+    getSnapShot: async (options) => {
+        const instanceId = await resolveInstanceId(options);
         return websocket_1.default.messageManager.sendAndWaitForResponse({
             "type": enum_1.EventType.BROWSER_EVENT,
-            action: enum_1.BrowserAction.GET_SNAPSHOT
+            action: enum_1.BrowserAction.GET_SNAPSHOT,
+            instanceId
         }, enum_1.BrowserResponseType.GET_SNAPSHOT_RESPONSE);
     },
     /**
      * Retrieves browser info like height width scrollx scrolly of the current page.
-     *  @returns {Promise<BrowserInfoResponse>} A promise that resolves with the browser info.
+     * @param options - Optional browser operation options
+     * @returns {Promise<BrowserInfoResponse>} A promise that resolves with the browser info.
      */
-    getBrowserInfo: () => {
+    getBrowserInfo: async (options) => {
+        const instanceId = await resolveInstanceId(options);
         return websocket_1.default.messageManager.sendAndWaitForResponse({
             "type": enum_1.EventType.BROWSER_EVENT,
-            action: enum_1.BrowserAction.GET_BROWSER_INFO
+            action: enum_1.BrowserAction.GET_BROWSER_INFO,
+            instanceId
         }, enum_1.BrowserResponseType.GET_BROWSER_INFO_RESPONSE);
     },
     /**
      * Extracts text from the current page.
-     *  @returns {Promise<ExtractTextResponse>} A promise that resolves with the extracted text.
-     *
+     * @param options - Optional browser operation options
+     * @returns {Promise<ExtractTextResponse>} A promise that resolves with the extracted text.
      */
-    extractText: () => {
+    extractText: async (options) => {
+        const instanceId = await resolveInstanceId(options);
         return websocket_1.default.messageManager.sendAndWaitForResponse({
             "type": enum_1.EventType.BROWSER_EVENT,
-            action: enum_1.BrowserAction.EXTRACT_TEXT
+            action: enum_1.BrowserAction.EXTRACT_TEXT,
+            instanceId
         }, enum_1.BrowserResponseType.EXTRACT_TEXT_RESPONSE);
     },
     /**
      * Closes the current page.
+     * @param options - Optional browser operation options
      */
-    close: () => {
+    close: async (options) => {
+        const instanceId = await resolveInstanceId(options);
         websocket_1.default.messageManager.send({
             "type": enum_1.EventType.BROWSER_EVENT,
-            action: enum_1.BrowserAction.CLOSE
+            action: enum_1.BrowserAction.CLOSE,
+            instanceId
         });
     },
     /**
      * Scrolls the current page in a specified direction by a specified number of pixels.
      * @param {string} direction - The direction to scroll.
      * @param {string} pixels - The number of pixels to scroll.
+     * @param options - Optional browser operation options
      * @returns {Promise<BrowserActionResponseData>} A promise that resolves when the scroll action is complete.
      */
-    scroll: (direction, pixels) => {
+    scroll: async (direction, pixels, options) => {
+        const instanceId = await resolveInstanceId(options);
         return websocket_1.default.messageManager.sendAndWaitForResponse({
             "type": enum_1.EventType.BROWSER_EVENT,
             action: enum_1.BrowserAction.SCROLL,
             direction,
-            pixels
+            pixels,
+            instanceId
         }, enum_1.BrowserResponseType.SCROLL_RESPONSE);
     },
     /**
      * Types text into a specified element on the page.
      * @param {string} elementid - The ID of the element to type into.
      * @param {string} text - The text to type.
+     * @param options - Optional browser operation options
      * @returns {Promise<BrowserActionResponseData>} A promise that resolves when the typing action is complete.
      */
-    type: (elementid, text) => {
+    type: async (elementid, text, options) => {
+        const instanceId = await resolveInstanceId(options);
         return websocket_1.default.messageManager.sendAndWaitForResponse({
             "type": enum_1.EventType.BROWSER_EVENT,
             action: enum_1.BrowserAction.TYPE,
             text,
-            elementid
+            elementid,
+            instanceId
         }, enum_1.BrowserResponseType.TYPE_RESPONSE);
     },
     /**
      * Clicks on a specified element on the page.
      * @param {string} elementid - The ID of the element to click.
+     * @param options - Optional browser operation options
      * @returns {Promise<BrowserActionResponseData>} A promise that resolves when the click action is complete.
      */
-    click: (elementid) => {
+    click: async (elementid, options) => {
+        const instanceId = await resolveInstanceId(options);
         return websocket_1.default.messageManager.sendAndWaitForResponse({
             "type": enum_1.EventType.BROWSER_EVENT,
             action: enum_1.BrowserAction.CLICK,
-            elementid
+            elementid,
+            instanceId
         }, enum_1.BrowserResponseType.CLICK_RESPONSE);
     },
     /**
      * Simulates the Enter key press on the current page.
+     * @param options - Optional browser operation options
      * @returns {Promise<BrowserActionResponseData>} A promise that resolves when the Enter action is complete.
      */
-    enter: () => {
+    enter: async (options) => {
+        const instanceId = await resolveInstanceId(options);
         return websocket_1.default.messageManager.sendAndWaitForResponse({
             "type": enum_1.EventType.BROWSER_EVENT,
-            action: enum_1.BrowserAction.ENTER
+            action: enum_1.BrowserAction.ENTER,
+            instanceId
         }, enum_1.BrowserResponseType.ENTER_RESPONSE);
     },
     /**
      * Performs a search on the current page using a specified query.
      * @param {string} elementid - The ID of the element to perform the search in.
      * @param {string} query - The search query.
+     * @param options - Optional browser operation options
      * @returns {Promise<BrowserActionResponseData>} A promise that resolves with the search results.
      */
-    search: (elementid, query) => {
+    search: async (elementid, query, options) => {
+        const instanceId = await resolveInstanceId(options);
         return websocket_1.default.messageManager.sendAndWaitForResponse({
             "type": enum_1.EventType.BROWSER_EVENT,
             action: enum_1.BrowserAction.SEARCH,
             elementid,
-            query
+            query,
+            instanceId
         }, enum_1.BrowserResponseType.SEARCH_RESPONSE);
+    },
+    // ================================
+    // Browser Instance Management APIs
+    // ================================
+    /**
+     * List all open browser instances
+     * @returns {Promise<BrowserInstanceInfo[]>} Array of browser instance information
+     */
+    listBrowserInstances: async () => {
+        // For now, return a placeholder implementation
+        // This will be implemented with proper backend communication
+        if (activeInstanceId) {
+            return [{
+                    instanceId: activeInstanceId,
+                    isActive: true,
+                    isReady: true,
+                    currentUrl: '',
+                    createdAt: new Date().toISOString(),
+                    title: ''
+                }];
+        }
+        return [];
+    },
+    /**
+     * Get a specific browser instance by ID
+     * @param {string} instanceId - The instance ID to get
+     * @returns {Promise<BrowserInstanceInfo | null>} Browser instance information or null if not found
+     */
+    getBrowserInstance: async (instanceId) => {
+        const instances = await cbbrowser.listBrowserInstances();
+        return instances.find(inst => inst.instanceId === instanceId) || null;
+    },
+    /**
+     * Set the active browser instance
+     * @param {string} instanceId - The instance ID to set as active
+     * @returns {Promise<boolean>} True if successful, false if instance not found
+     */
+    setActiveBrowserInstance: async (instanceId) => {
+        const instances = await cbbrowser.listBrowserInstances();
+        const instance = instances.find(inst => inst.instanceId === instanceId);
+        if (instance) {
+            activeInstanceId = instanceId;
+            return true;
+        }
+        return false;
+    },
+    /**
+     * Open a new browser instance
+     * @param options - Optional instance creation options
+     * @returns {Promise<{ instanceId: string }>} The new instance ID
+     */
+    openNewBrowserInstance: async (options) => {
+        const newInstanceId = (options === null || options === void 0 ? void 0 : options.instanceId) || `browser-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        // Create the new page for this instance
+        await cbbrowser.newPage({ instanceId: newInstanceId });
+        // Set as active if requested (default true)
+        if ((options === null || options === void 0 ? void 0 : options.setActive) !== false) {
+            activeInstanceId = newInstanceId;
+        }
+        return { instanceId: newInstanceId };
+    },
+    /**
+     * Close a browser instance
+     * @param {string} instanceId - The instance ID to close
+     * @returns {Promise<boolean>} True if successful, false if instance not found
+     */
+    closeBrowserInstance: async (instanceId) => {
+        try {
+            // Close the browser instance
+            await cbbrowser.close({ instanceId });
+            // Clear active instance if it was the one being closed
+            if (activeInstanceId === instanceId) {
+                activeInstanceId = null;
+            }
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    },
+    /**
+     * Execute action on specific browser instance
+     * @param {string} instanceId - The instance ID to execute on
+     * @param {string} operation - The operation to execute
+     * @param {any} params - Parameters for the operation
+     * @returns {Promise<any>} The operation result
+     */
+    executeOnInstance: async (instanceId, operation, params) => {
+        // This will be implemented with proper backend communication
+        // For now, use the existing browser functions with explicit instanceId
+        const options = { instanceId, ...params };
+        switch (operation) {
+            case 'goToPage':
+                return await cbbrowser.goToPage(params.url, options);
+            case 'screenshot':
+                return await cbbrowser.screenshot(options);
+            case 'getContent':
+                return await cbbrowser.getContent(options);
+            default:
+                throw new Error(`Unknown operation: ${operation}`);
+        }
     }
 };
 exports.default = cbbrowser;