@codebolt/codeboltjs 2.0.4 → 2.0.5

package/dist/core/messageManager.d.ts

@@ -0,0 +1,47 @@
+/// <reference types="node" />
+import WebSocket from 'ws';
+import { EventEmitter } from 'events';
+export interface PendingRequest {
+    resolve: (value: any) => void;
+    reject: (reason?: any) => void;
+    messageTypes: string[];
+    requestId?: string;
+}
+/**
+ * Centralized message manager for handling WebSocket communications
+ */
+export declare class MessageManager extends EventEmitter {
+    pendingRequests: Map<string, PendingRequest>;
+    websocket: WebSocket | null;
+    requestCounter: number;
+    /**
+     * Initialize the message manager with a WebSocket instance
+     */
+    initialize(websocket: WebSocket): void;
+    /**
+     * Setup the centralized message listener
+     */
+    setupMessageListener(): void;
+    /**
+     * Handle incoming messages and resolve pending requests
+     */
+    handleMessage(response: any): void;
+    /**
+     * Send a message and wait for a specific response type
+     */
+    sendAndWaitForResponse<T = any>(message: any, expectedResponseType: string, timeout?: number): Promise<T>;
+    /**
+     * Send a message without waiting for response
+     */
+    send(message: any): void;
+    /**
+     * Get the WebSocket instance
+     */
+    getWebSocket(): WebSocket | null;
+    /**
+     * Clean up all pending requests
+     */
+    cleanup(): void;
+}
+declare const _default: MessageManager;
+export default _default;

package/dist/core/messageManager.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageManager = void 0;
+const events_1 = require("events");
+/**
+ * Centralized message manager for handling WebSocket communications
+ */
+class MessageManager extends events_1.EventEmitter {
+    constructor() {
+        super(...arguments);
+        this.pendingRequests = new Map();
+        this.websocket = null;
+        this.requestCounter = 0;
+    }
+    /**
+     * Initialize the message manager with a WebSocket instance
+     */
+    initialize(websocket) {
+        this.websocket = websocket;
+        this.setupMessageListener();
+    }
+    /**
+     * Setup the centralized message listener
+     */
+    setupMessageListener() {
+        if (!this.websocket)
+            return;
+        this.websocket.on('message', (data) => {
+            try {
+                const response = JSON.parse(data.toString());
+                this.handleMessage(response);
+            }
+            catch (error) {
+                console.error('Error parsing WebSocket message:', error);
+            }
+        });
+    }
+    /**
+     * Handle incoming messages and resolve pending requests
+     */
+    handleMessage(response) {
+        const { type, requestId } = response;
+        // Handle requests with specific requestId
+        if (requestId && this.pendingRequests.has(requestId)) {
+            const request = this.pendingRequests.get(requestId);
+            this.pendingRequests.delete(requestId);
+            request.resolve(response);
+            return;
+        }
+        // Handle requests by message type
+        for (const [id, request] of this.pendingRequests.entries()) {
+            if (request.messageTypes.includes(type)) {
+                this.pendingRequests.delete(id);
+                request.resolve(response);
+                return;
+            }
+        }
+        // Emit the message for any other listeners (like onUserMessage)
+        this.emit('message', response);
+    }
+    /**
+     * Send a message and wait for a specific response type
+     */
+    sendAndWaitForResponse(message, expectedResponseType, timeout = 30000) {
+        return new Promise((resolve, reject) => {
+            if (!this.websocket) {
+                reject(new Error('WebSocket is not initialized'));
+                return;
+            }
+            const requestId = `req_${++this.requestCounter}_${Date.now()}`;
+            // Add requestId to the message if it doesn't have one
+            const messageWithId = { ...message, requestId };
+            // Parse multiple message types separated by pipe
+            const messageTypes = expectedResponseType.split('|').map(type => type.trim());
+            // Store the pending request
+            this.pendingRequests.set(requestId, {
+                resolve,
+                reject,
+                messageTypes,
+                requestId
+            });
+            // Set timeout
+            const timeoutId = setTimeout(() => {
+                if (this.pendingRequests.has(requestId)) {
+                    this.pendingRequests.delete(requestId);
+                    reject(new Error(`Request timeout after ${timeout}ms for message types: ${expectedResponseType}`));
+                }
+            }, timeout);
+            // Override resolve to clear timeout
+            const originalResolve = resolve;
+            const wrappedResolve = (value) => {
+                clearTimeout(timeoutId);
+                originalResolve(value);
+            };
+            // Update the stored request with wrapped resolve
+            const request = this.pendingRequests.get(requestId);
+            request.resolve = wrappedResolve;
+            // Send the message
+            this.websocket.send(JSON.stringify(messageWithId));
+        });
+    }
+    /**
+     * Send a message without waiting for response
+     */
+    send(message) {
+        if (!this.websocket) {
+            throw new Error('WebSocket is not initialized');
+        }
+        this.websocket.send(JSON.stringify(message));
+    }
+    /**
+     * Get the WebSocket instance
+     */
+    getWebSocket() {
+        return this.websocket;
+    }
+    /**
+     * Clean up all pending requests
+     */
+    cleanup() {
+        for (const [id, request] of this.pendingRequests.entries()) {
+            request.reject(new Error('WebSocket connection closed'));
+        }
+        this.pendingRequests.clear();
+    }
+}
+exports.MessageManager = MessageManager;
+exports.default = new MessageManager();

package/dist/{modules → core}/websocket.d.ts

@@ -1,4 +1,5 @@
 import WebSocket from 'ws';
+import { MessageManager } from './messageManager';
 /**
  * Class representing a WebSocket connection.
  */
@@ -22,6 +23,10 @@ declare class cbws {
      * @throws {Error} If the WebSocket is not open.
      */
     get getWebsocket(): WebSocket;
+    /**
+     * Get the message manager instance
+     */
+    get messageManager(): MessageManager;
 }
 declare const _default: cbws;
 export default _default;

package/dist/{modules → core}/websocket.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const ws_1 = __importDefault(require("ws"));
 const fs_1 = __importDefault(require("fs"));
 const js_yaml_1 = __importDefault(require("js-yaml"));
+const messageManager_1 = __importDefault(require("./messageManager"));
 /**
  * Class representing a WebSocket connection.
  */
@@ -60,16 +61,13 @@ class cbws {
                 reject(error);
             });
             this.websocket.on('open', () => {
-                // if (this.websocket) {
-                //     this.websocket.send(JSON.stringify({
-                //         "type": "sendMessage",
-                //         "message": initialMessage
-                //     }));
-                //     resolve(this.websocket);
-                // }
+                // Initialize the message manager with this websocket
+                messageManager_1.default.initialize(this.websocket);
+                resolve(this.websocket);
             });
-            this.websocket.on('message', (data) => {
-                // Handle incoming WebSocket messages here.
+            this.websocket.on('close', () => {
+                // Clean up pending requests when connection closes
+                messageManager_1.default.cleanup();
             });
         });
     }
@@ -86,5 +84,11 @@ class cbws {
             return this.websocket;
         }
     }
+    /**
+     * Get the message manager instance
+     */
+    get messageManager() {
+        return messageManager_1.default;
+    }
 }
 exports.default = new cbws();

package/dist/index.d.ts

@@ -34,7 +34,7 @@ declare class Codebolt {
             success: boolean;
             result: any;
         }>;
-        writeToFile: (relPath: string, newContent: string) => Promise<unknown>;
+        writeToFile: (relPath: string, newContent: string) => Promise<any>;
     };
     git: {
         init: (path: string) => Promise<any>;
@@ -53,10 +53,10 @@ declare class Codebolt {
         inference: (message: string, llmrole: string) => Promise<import("@codebolt/types").LLMResponse>;
     };
     browser: {
-        newPage: () => Promise<unknown>;
+        newPage: () => Promise<any>;
         getUrl: () => Promise<import("@codebolt/types").UrlResponse>;
         goToPage: (url: string) => Promise<import("@codebolt/types").GoToPageResponse>;
-        screenshot: () => Promise<unknown>;
+        screenshot: () => Promise<any>;
         getHTML: () => Promise<import("@codebolt/types").HtmlReceived>;
         getMarkdown: () => Promise<import("@codebolt/types").GetMarkdownResponse>;
         getPDF: () => void;
@@ -66,16 +66,33 @@ declare class Codebolt {
         getBrowserInfo: () => Promise<any>;
         extractText: () => Promise<import("@codebolt/types").ExtractTextResponse>;
         close: () => void;
-        scroll: (direction: string, pixels: string) => Promise<unknown>;
-        type: (elementid: string, text: string) => Promise<unknown>;
-        click: (elementid: string) => Promise<unknown>;
-        enter: () => Promise<unknown>;
-        search: (elementid: string, query: string) => Promise<unknown>;
+        scroll: (direction: string, pixels: string) => Promise<any>;
+        type: (elementid: string, text: string) => Promise<any>;
+        click: (elementid: string) => Promise<any>;
+        enter: () => Promise<any>;
+        search: (elementid: string, query: string) => Promise<any>;
     };
     chat: {
         getChatHistory: () => Promise<import("@codebolt/types").ChatMessage[]>;
         setRequestHandler: (handler: (request: any, response: (data: any) => void) => void | Promise<void>) => void;
-        onActionMessage: () => {
+        sendMessage: (message: string, payload: any) => void;
+        waitforReply: (message: string) => Promise<import("@codebolt/types").UserMessage>;
+        processStarted: (onStopClicked?: ((message: any) => void) | undefined) => {
+            stopProcess: () => void;
+            cleanup: () => void;
+        } | {
+            stopProcess: () => void;
+            cleanup?: undefined;
+        };
+        stopProcess: () => void;
+        processFinished: () => void;
+        sendConfirmationRequest: (confirmationMessage: string, buttons?: string[], withFeedback?: boolean) => Promise<string>;
+        askQuestion: (question: string, buttons?: string[], withFeedback?: boolean) => Promise<string>;
+        sendNotificationEvent: (notificationMessage: string, type: "debug" | "git" | "planner" | "browser" | "editor" | "terminal" | "preview") => void;
+    };
+    terminal: {
+        eventEmitter: {
+            cleanup?: (() => void) | undefined;
             [EventEmitter.captureRejectionSymbol]?<K>(error: Error, event: string | symbol, ...args: any[]): void;
             addListener<K_1>(eventName: string | symbol, listener: (...args: any[]) => void): any;
             on<K_2>(eventName: string | symbol, listener: (...args: any[]) => void): any;
@@ -93,37 +110,11 @@ declare class Codebolt {
             prependOnceListener<K_11>(eventName: string | symbol, listener: (...args: any[]) => void): any;
             eventNames(): (string | symbol)[];
         };
-        sendMessage: (message: string, payload: any) => void;
-        waitforReply: (message: string) => Promise<import("@codebolt/types").UserMessage>;
-        processStarted: () => {
-            event: {
-                [EventEmitter.captureRejectionSymbol]?<K>(error: Error, event: string | symbol, ...args: any[]): void;
-                addListener<K_1>(eventName: string | symbol, listener: (...args: any[]) => void): any;
-                on<K_2>(eventName: string | symbol, listener: (...args: any[]) => void): any;
-                once<K_3>(eventName: string | symbol, listener: (...args: any[]) => void): any;
-                removeListener<K_4>(eventName: string | symbol, listener: (...args: any[]) => void): any;
-                off<K_5>(eventName: string | symbol, listener: (...args: any[]) => void): any;
-                removeAllListeners(eventName?: string | symbol | undefined): any;
-                setMaxListeners(n: number): any;
-                getMaxListeners(): number;
-                listeners<K_6>(eventName: string | symbol): Function[];
-                rawListeners<K_7>(eventName: string | symbol): Function[];
-                emit<K_8>(eventName: string | symbol, ...args: any[]): boolean;
-                listenerCount<K_9>(eventName: string | symbol, listener?: Function | undefined): number;
-                prependListener<K_10>(eventName: string | symbol, listener: (...args: any[]) => void): any;
-                prependOnceListener<K_11>(eventName: string | symbol, listener: (...args: any[]) => void): any;
-                eventNames(): (string | symbol)[];
-            };
-            stopProcess: () => void;
-        };
-        stopProcess: () => void;
-        processFinished: () => void;
-        sendConfirmationRequest: (confirmationMessage: string, buttons?: string[], withFeedback?: boolean) => Promise<string>;
-        askQuestion: (question: string, buttons?: string[], withFeedback?: boolean) => Promise<string>;
-        sendNotificationEvent: (notificationMessage: string, type: "debug" | "git" | "planner" | "browser" | "editor" | "terminal" | "preview") => void;
-    };
-    terminal: {
-        eventEmitter: {
+        executeCommand: (command: string, returnEmptyStringOnSuccess?: boolean) => Promise<any>;
+        executeCommandRunUntilError: (command: string, executeInMain?: boolean) => Promise<import("@codebolt/types").CommandError>;
+        sendManualInterrupt(): Promise<import("@codebolt/types").TerminalInterruptResponse>;
+        executeCommandWithStream(command: string, executeInMain?: boolean): {
+            cleanup?: (() => void) | undefined;
             [EventEmitter.captureRejectionSymbol]?<K>(error: Error, event: string | symbol, ...args: any[]): void;
             addListener<K_1>(eventName: string | symbol, listener: (...args: any[]) => void): any;
             on<K_2>(eventName: string | symbol, listener: (...args: any[]) => void): any;
@@ -141,13 +132,9 @@ declare class Codebolt {
             prependOnceListener<K_11>(eventName: string | symbol, listener: (...args: any[]) => void): any;
             eventNames(): (string | symbol)[];
         };
-        executeCommand: (command: string, returnEmptyStringOnSuccess?: boolean) => Promise<unknown>;
-        executeCommandRunUntilError: (command: string, executeInMain?: boolean) => Promise<import("@codebolt/types").CommandError>;
-        sendManualInterrupt(): Promise<import("@codebolt/types").TerminalInterruptResponse>;
-        executeCommandWithStream(command: string, executeInMain?: boolean): EventEmitter<[never]>;
     };
     codeutils: {
-        getJsTree: (filePath?: string | undefined) => Promise<unknown>;
+        getJsTree: (filePath?: string | undefined) => Promise<any>;
         getAllFilesAsMarkDown: () => Promise<string>;
         performMatch: (matcherDefinition: object, problemPatterns: any[], problems: any[]) => Promise<import("@codebolt/types").MatchProblemResponse>;
         getMatcherList: () => Promise<import("@codebolt/types").GetMatcherListTreeResponse>;
@@ -161,10 +148,7 @@ declare class Codebolt {
         screenshot: () => void;
         goToPage: (url: string) => void;
         scroll: (direction: string) => void;
-        click: (id: string) => Promise<unknown>;
-        type: (id: string, text: string) => Promise<unknown>;
-        enter: () => void;
-        crawl: (query: string) => Promise<unknown>;
+        click: (id: string) => Promise<any>;
     };
     search: {
         init: (engine?: string) => void;
@@ -192,7 +176,7 @@ declare class Codebolt {
         getProjectPath: () => Promise<import("@codebolt/types").GetProjectPathResponse>;
         getRepoMap: (message: any) => Promise<import("@codebolt/types").GetProjectPathResponse>;
         runProject: () => void;
-        getEditorFileStatus: () => Promise<unknown>;
+        getEditorFileStatus: () => Promise<any>;
     };
     dbmemory: {
         addKnowledge: (key: string, value: any) => Promise<import("@codebolt/types").MemorySetResponse>;
@@ -241,7 +225,6 @@ declare class Codebolt {
         getEnabledToolBoxes: () => Promise<any>;
         getLocalToolBoxes: () => Promise<any>;
         getMentionedToolBoxes: (userMessage: import("./utils").UserMessage) => Promise<any>;
-        getAvailableToolBoxes: () => Promise<any>;
         searchAvailableToolBoxes: (query: string) => Promise<any>;
         listToolsFromToolBoxes: (toolBoxes: string[]) => Promise<any>;
         configureToolBox: (name: string, config: any) => Promise<any>;
@@ -260,6 +243,12 @@ declare class Codebolt {
     utils: {
         editFileAndApplyDiff: (filePath: string, diff: string, diffIdentifier: string, prompt: string, applyModel?: string | undefined) => Promise<any>;
     };
+    /**
+     * Sets up a listener for incoming messages with a direct handler function.
+     * @param {Function} handler - The handler function to call when a message is received.
+     * @returns {void}
+     */
+    onMessage(handler: (userMessage: any) => void | Promise<void> | any | Promise<any>): void;
 }
-declare const _default: Codebolt;
-export default _default;
+declare const codebolt: Codebolt;
+export default codebolt;

package/dist/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const websocket_1 = __importDefault(require("./modules/websocket"));
+const websocket_1 = __importDefault(require("./core/websocket"));
 const fs_1 = __importDefault(require("./modules/fs"));
 const llm_1 = __importDefault(require("./modules/llm"));
 const terminal_1 = __importDefault(require("./modules/terminal"));
@@ -29,7 +29,7 @@ const ws_1 = __importDefault(require("ws"));
 const history_1 = require("./modules/history");
 const tools_1 = __importDefault(require("./modules/tools"));
 const agent_1 = __importDefault(require("./modules/agent"));
-const editFile_1 = __importDefault(require("./utils/editFile"));
+const utils_1 = __importDefault(require("./modules/utils"));
 /**
  * @class Codebolt
  * @description This class provides a unified interface to interact with various modules.
@@ -65,7 +65,7 @@ class Codebolt {
         this.chatSummary = history_1.chatSummary;
         this.tools = tools_1.default;
         this.agent = agent_1.default;
-        this.utils = editFile_1.default;
+        this.utils = utils_1.default;
         websocket_1.default.initializeWebSocket();
         this.websocket = websocket_1.default.getWebsocket;
     }
@@ -92,5 +92,50 @@ class Codebolt {
             });
         });
     }
+    /**
+     * Sets up a listener for incoming messages with a direct handler function.
+     * @param {Function} handler - The handler function to call when a message is received.
+     * @returns {void}
+     */
+    onMessage(handler) {
+        const waitForConnection = () => {
+            if (websocket_1.default.messageManager) {
+                const handleUserMessage = async (response) => {
+                    if (response.type === "messageResponse") {
+                        try {
+                            const result = await handler(response);
+                            // Send processStoped with optional message
+                            const message = {
+                                "type": "processStoped"
+                            };
+                            // If handler returned data, include it as message
+                            if (result !== undefined && result !== null) {
+                                message.message = result;
+                            }
+                            websocket_1.default.messageManager.send(message);
+                        }
+                        catch (error) {
+                            console.error('Error in user message handler:', error);
+                            // Send processStoped even if there's an error
+                            websocket_1.default.messageManager.send({
+                                "type": "processStoped",
+                                "error": error instanceof Error ? error.message : "Unknown error occurred"
+                            });
+                        }
+                    }
+                };
+                websocket_1.default.messageManager.on('message', handleUserMessage);
+            }
+            else {
+                setTimeout(waitForConnection, 100);
+            }
+        };
+        waitForConnection();
+    }
 }
-exports.default = new Codebolt();
+const codebolt = new Codebolt();
+// For ES6 modules (import)
+exports.default = codebolt;
+// For CommonJS compatibility (require)
+module.exports = codebolt;
+module.exports.default = codebolt;

package/dist/modules/agent.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FilterUsing = exports.Agents = exports.AgentLocation = void 0;
-const websocket_1 = __importDefault(require("./websocket"));
+const websocket_1 = __importDefault(require("../core/websocket"));
 var AgentLocation;
 (function (AgentLocation) {
     AgentLocation["ALL"] = "all";
@@ -30,23 +30,15 @@ const codeboltAgent = {
      * @returns {Promise<AgentResponse>} A promise that resolves with the agent details.
      */
     findAgent: (task, maxResult = 1, agents = [], agentLocaltion = AgentLocation.ALL, getFrom) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "agentEvent",
-                "action": "findAgent",
-                "task": task,
-                "agents": agents, // for filter in vector db
-                "maxResult": maxResult,
-                "location": agentLocaltion,
-                "getFrom": getFrom
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                const response = JSON.parse(data);
-                if (response.type === "findAgentByTaskResponse") {
-                    resolve(response); // Resolve the Promise with the agent details
-                }
-            });
-        });
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "agentEvent",
+            "action": "findAgent",
+            "task": task,
+            "agents": agents, // for filter in vector db
+            "maxResult": maxResult,
+            "location": agentLocaltion,
+            "getFrom": getFrom
+        }, "findAgentByTaskResponse");
     },
     /**
      * Starts an agent for the specified task.
@@ -54,58 +46,34 @@ const codeboltAgent = {
      * @returns {Promise<void>} A promise that resolves when the agent has been successfully started.
      */
     startAgent: (agentId, task) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "agentEvent",
-                "action": "startAgent",
-                "agentId": agentId,
-                "task": task
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                const response = JSON.parse(data);
-                if (response.type === "taskCompletionResponse" && response.agentId === agentId) {
-                    resolve(response); // Resolve the Promise when the agent has been successfully started
-                }
-            });
-        });
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "agentEvent",
+            "action": "startAgent",
+            "agentId": agentId,
+            "task": task
+        }, "taskCompletionResponse");
     },
     /**
      * Lists all available agents.
      * @returns {Promise<any>} A promise that resolves with the list of agents.
      */
     getAgentsList: (type = Agents.DOWNLOADED) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "agentEvent",
-                "action": "listAgents",
-                "agentType": type,
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                const response = JSON.parse(data);
-                if (response.type === "listAgentsResponse") {
-                    resolve(response); // Resolve the Promise with the list of agents
-                }
-            });
-        });
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "agentEvent",
+            "action": "listAgents",
+            "agentType": type,
+        }, "listAgentsResponse");
     },
     /**
      * Lists all available agents.
      * @returns {Promise<any>} A promise that resolves with the list of agents.
      */
     getAgentsDetail: (agentList = []) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "agentEvent",
-                "action": "agentsDetail",
-                "agentList": agentList
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                const response = JSON.parse(data);
-                if (response.type === "listAgentsResponse") {
-                    resolve(response); // Resolve the Promise with the list of agents
-                }
-            });
-        });
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "agentEvent",
+            "action": "agentsDetail",
+            "agentList": agentList
+        }, "listAgentsResponse");
     }
 };
 exports.default = codeboltAgent;

package/dist/modules/browser.d.ts

@@ -6,7 +6,7 @@ declare const cbbrowser: {
     /**
      * Opens a new page in the browser.
      */
-    newPage: () => Promise<unknown>;
+    newPage: () => Promise<any>;
     /**
      * Retrieves the current URL of the browser's active page.
      * @returns {Promise<UrlResponse>} A promise that resolves with the URL.
@@ -21,7 +21,7 @@ declare const cbbrowser: {
     /**
      * Takes a screenshot of the current page.
      */
-    screenshot: () => Promise<unknown>;
+    screenshot: () => Promise<any>;
     /**
      * Retrieves the HTML content of the current page.
      * @returns {Promise<HtmlReceived>} A promise that resolves with the HTML content.
@@ -72,32 +72,32 @@ declare const cbbrowser: {
      * @param {string} pixels - The number of pixels to scroll.
      * @returns {Promise<any>} A promise that resolves when the scroll action is complete.
      */
-    scroll: (direction: string, pixels: string) => Promise<unknown>;
+    scroll: (direction: string, pixels: string) => Promise<any>;
     /**
      * 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.
      * @returns {Promise<any>} A promise that resolves when the typing action is complete.
      */
-    type: (elementid: string, text: string) => Promise<unknown>;
+    type: (elementid: string, text: string) => Promise<any>;
     /**
      * Clicks on a specified element on the page.
      * @param {string} elementid - The ID of the element to click.
      * @returns {Promise<any>} A promise that resolves when the click action is complete.
      */
-    click: (elementid: string) => Promise<unknown>;
+    click: (elementid: string) => Promise<any>;
     /**
      * Simulates the Enter key press on the current page.
      * @returns {Promise<any>} A promise that resolves when the Enter action is complete.
      */
-    enter: () => Promise<unknown>;
+    enter: () => Promise<any>;
     /**
      * 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.
      * @returns {Promise<any>} A promise that resolves with the search results.
      */
-    search: (elementid: string, query: string) => Promise<unknown>;
+    search: (elementid: string, query: string) => Promise<any>;
 };
 export default cbbrowser;
 /***