@codebolt/codeboltjs 2.0.3 → 2.0.5

package/{modules → 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;
 /***

package/dist/modules/browser.js

@@ -0,0 +1,211 @@
+"use strict";
+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("../core/websocket"));
+/**
+ * A module for interacting with a browser through WebSockets.
+ */
+const cbbrowser = {
+    /**
+     * Opens a new page in the browser.
+     */
+    newPage: () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "browserEvent",
+            action: 'newPage'
+        }, "newPageResponse");
+    },
+    /**
+     * Retrieves the current URL of the browser's active page.
+     * @returns {Promise<UrlResponse>} A promise that resolves with the URL.
+     */
+    getUrl: () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "browserEvent",
+            action: 'getUrl'
+        }, "getUrlResponse");
+    },
+    /**
+     * Navigates to a specified URL.
+     * @param {string} url - The URL to navigate to.
+     * @returns {Promise<GoToPageResponse>} A promise that resolves when navigation is complete.
+     */
+    goToPage: (url) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "browserEvent",
+            action: 'goToPage',
+            url
+        }, "goToPageResponse");
+    },
+    /**
+     * Takes a screenshot of the current page.
+     */
+    screenshot: () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "browserEvent",
+            action: 'screenshot'
+        }, "screenshotResponse");
+    },
+    /**
+     * Retrieves the HTML content of the current page.
+     * @returns {Promise<HtmlReceived>} A promise that resolves with the HTML content.
+     */
+    getHTML: () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "browserEvent",
+            action: 'getHTML'
+        }, "htmlReceived");
+    },
+    /**
+     * Retrieves the Markdown content of the current page.
+     * @returns {Promise<GetMarkdownResponse>} A promise that resolves with the Markdown content.
+     */
+    getMarkdown: () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "browserEvent",
+            action: 'getMarkdown'
+        }, "getMarkdownResponse");
+    },
+    /**
+     * Retrieves the PDF content of the current page.
+     *
+     */
+    getPDF: () => {
+        websocket_1.default.messageManager.send({
+            "type": "browserEvent",
+            action: 'getPDF'
+        });
+    },
+    /**
+     * Converts the PDF content of the current page to text.
+     */
+    pdfToText: () => {
+        websocket_1.default.messageManager.send({
+            "type": "browserEvent",
+            action: 'pdfToText'
+        });
+    },
+    /**
+     * Retrieves the content of the current page.
+     *  @returns {Promise<GetContentResponse>} A promise that resolves with the content.
+     */
+    getContent: () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "browserEvent",
+            action: 'getContent'
+        }, "getContentResponse");
+    },
+    /**
+     * Retrieves the snapshot of the current page.
+     *  @returns {Promise<GetContentResponse>} A promise that resolves with the content.
+     */
+    getSnapShot: () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "browserEvent",
+            action: 'getSnapShot'
+        }, "getSnapShotResponse");
+    },
+    /**
+     * Retrieves browser info like height width scrollx scrolly of the current page.
+     *  @returns {Promise<GetContentResponse>} A promise that resolves with the content.
+     */
+    getBrowserInfo: () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "browserEvent",
+            action: 'getBrowserInfo'
+        }, "getBrowserInfoResponse");
+    },
+    /**
+     * Extracts text from the current page.
+     *  @returns {Promise<ExtractTextResponse>} A promise that resolves with the extracted text.
+     *
+     */
+    extractText: () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "browserEvent",
+            action: 'extractText'
+        }, "extractTextResponse");
+    },
+    /**
+     * Closes the current page.
+     */
+    close: () => {
+        websocket_1.default.messageManager.send({
+            "type": "browserEvent",
+            action: 'close'
+        });
+    },
+    /**
+     * 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.
+     * @returns {Promise<any>} A promise that resolves when the scroll action is complete.
+     */
+    scroll: (direction, pixels) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "browserEvent",
+            action: 'scroll',
+            direction,
+            pixels
+        }, "scrollResponse");
+    },
+    /**
+     * 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, text) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "browserEvent",
+            action: 'type',
+            text,
+            elementid
+        }, "typeResponse");
+    },
+    /**
+     * 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) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "browserEvent",
+            action: 'click',
+            elementid
+        }, "clickResponse");
+    },
+    /**
+     * Simulates the Enter key press on the current page.
+     * @returns {Promise<any>} A promise that resolves when the Enter action is complete.
+     */
+    enter: () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "browserEvent",
+            action: 'enter'
+        }, "EnterResponse");
+    },
+    /**
+     * 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, query) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "browserEvent",
+            action: 'search',
+            elementid,
+            query
+        }, "searchResponse");
+    }
+};
+exports.default = cbbrowser;
+/***
+
+start_browser(objective: string, url: string, previous_command: string, browser_content: string) {
+    cbbrowser.newPage();
+}
+ */ 

package/{modules → dist/modules}/chat.d.ts

@@ -1,12 +1,5 @@
-/// <reference types="node" />
-import { EventEmitter } from 'events';
 import { ChatMessage, UserMessage } from '@codebolt/types';
 type RequestHandler = (request: any, response: (data: any) => void) => Promise<void> | void;
-/**
- * CustomEventEmitter class that extends the Node.js EventEmitter class.
- */
-declare class CustomEventEmitter extends EventEmitter {
-}
 /**
  * Chat module to interact with the WebSocket server.
  */
@@ -21,15 +14,6 @@ declare const cbchat: {
      * @param handler The async handler function
      */
     setRequestHandler: (handler: RequestHandler) => void;
-    /**
-     * Sets up a listener for incoming WebSocket messages and emits a custom event when a message is received.
-     * @returns {EventEmitter} The event emitter used for emitting custom events.
-     */
-    /**
- * Sets up a listener for incoming WebSocket messages and emits a custom event when a message is received.
- * @returns {EventEmitter} The event emitter used for emitting custom events.
- */
-    onActionMessage: () => CustomEventEmitter;
     /**
      * Sends a message through the WebSocket connection.
      * @param {string} message - The message to be sent.
@@ -42,12 +26,16 @@ declare const cbchat: {
      */
     waitforReply: (message: string) => Promise<UserMessage>;
     /**
-     * Notifies the server that a process has started and sets up an event listener for stopProcessClicked events.
-     * @returns An object containing the event emitter and a stopProcess method.
+     * Notifies the server that a process has started and sets up a listener for stopProcessClicked events.
+     * @param {Function} onStopClicked - Callback function to handle stop process events.
+     * @returns An object containing a stopProcess method.
      */
-    processStarted: () => {
-        event: CustomEventEmitter;
+    processStarted: (onStopClicked?: (message: any) => void) => {
+        stopProcess: () => void;
+        cleanup: () => void;
+    } | {
         stopProcess: () => void;
+        cleanup?: undefined;
     };
     /**
      * Stops the ongoing process.

package/dist/modules/chat.js

@@ -0,0 +1,162 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// chat.ts
+const websocket_1 = __importDefault(require("../core/websocket"));
+/**
+ * Chat module to interact with the WebSocket server.
+ */
+const cbchat = {
+    /**
+     * Retrieves the chat history from the server.
+     * @returns {Promise<ChatMessage[]>} A promise that resolves with an array of ChatMessage objects representing the chat history.
+     */
+    getChatHistory: () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "getChatHistory"
+        }, "getChatHistoryResponse");
+    },
+    /**
+     * Sets a global request handler for all incoming messages
+     * @param handler The async handler function
+     */
+    setRequestHandler: (handler) => {
+        const waitForConnection = () => {
+            const setupHandler = () => {
+                if (websocket_1.default.messageManager) {
+                    websocket_1.default.messageManager.on('message', async (request) => {
+                        try {
+                            await handler(request, (responseData) => {
+                                websocket_1.default.messageManager.send({
+                                    type: `processStoped`,
+                                    ...responseData
+                                });
+                            });
+                        }
+                        catch (error) {
+                            console.error('Error handling request:', error);
+                        }
+                    });
+                }
+                else {
+                    setTimeout(setupHandler, 100);
+                }
+            };
+            setupHandler();
+        };
+        waitForConnection();
+    },
+    /**
+     * Sends a message through the WebSocket connection.
+     * @param {string} message - The message to be sent.
+     */
+    sendMessage: (message, payload) => {
+        websocket_1.default.messageManager.send({
+            "type": "sendMessage",
+            "message": message,
+            payload
+        });
+    },
+    /**
+     * Waits for a reply to a sent message.
+     * @param {string} message - The message for which a reply is expected.
+     * @returns {Promise<UserMessage>} A promise that resolves with the reply.
+     */
+    waitforReply: (message) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "waitforReply",
+            "message": message
+        }, "waitFormessageResponse");
+    },
+    /**
+     * Notifies the server that a process has started and sets up a listener for stopProcessClicked events.
+     * @param {Function} onStopClicked - Callback function to handle stop process events.
+     * @returns An object containing a stopProcess method.
+     */
+    processStarted: (onStopClicked) => {
+        // Send the process started message
+        websocket_1.default.messageManager.send({
+            "type": "processStarted"
+        });
+        // Register event listener for WebSocket messages if callback provided
+        if (onStopClicked) {
+            const handleStopMessage = (message) => {
+                if (message.type === 'stopProcessClicked') {
+                    onStopClicked(message);
+                }
+            };
+            websocket_1.default.messageManager.on('message', handleStopMessage);
+            // Return an object that includes the stopProcess method and cleanup
+            return {
+                stopProcess: () => {
+                    websocket_1.default.messageManager.send({
+                        "type": "processStoped"
+                    });
+                },
+                cleanup: () => {
+                    websocket_1.default.messageManager.removeListener('message', handleStopMessage);
+                }
+            };
+        }
+        // Return an object that includes the stopProcess method
+        return {
+            stopProcess: () => {
+                websocket_1.default.messageManager.send({
+                    "type": "processStoped"
+                });
+            }
+        };
+    },
+    /**
+     * Stops the ongoing process.
+     * Sends a specific message to the server to stop the process.
+     */
+    stopProcess: () => {
+        websocket_1.default.messageManager.send({
+            "type": "processStoped"
+        });
+    },
+    /**
+   * Stops the ongoing process.
+   * Sends a specific message to the server to stop the process.
+   */
+    processFinished: () => {
+        websocket_1.default.messageManager.send({
+            "type": "processFinished"
+        });
+    },
+    /**
+     * Sends a confirmation request to the server with two options: Yes or No.
+     * @returns {Promise<string>} A promise that resolves with the server's response.
+     */
+    sendConfirmationRequest: (confirmationMessage, buttons = [], withFeedback = false) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "confirmationRequest",
+            "message": confirmationMessage,
+            buttons: buttons,
+            withFeedback
+        }, "confirmationResponse|feedbackResponse");
+    },
+    askQuestion: (question, buttons = [], withFeedback = false) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "confirmationRequest",
+            "message": question,
+            buttons: buttons,
+            withFeedback
+        }, "confirmationResponse|feedbackResponse");
+    },
+    /**
+ * Sends a notification event to the server.
+ * @param {string} notificationMessage - The message to be sent in the notification.
+ */
+    sendNotificationEvent: (notificationMessage, type) => {
+        websocket_1.default.messageManager.send({
+            "type": "notificationEvent",
+            "message": notificationMessage,
+            "eventType": type
+        });
+    },
+};
+exports.default = cbchat;

package/{modules → dist/modules}/codeutils.d.ts

@@ -8,7 +8,7 @@ declare const cbcodeutils: {
      * @param {string} filePath - The path of the file to retrieve the JS tree for.
      * @returns {Promise<GetJsTreeResponse>} A promise that resolves with the JS tree response.
      */
-    getJsTree: (filePath?: string) => Promise<unknown>;
+    getJsTree: (filePath?: string) => Promise<any>;
     /**
      * Retrieves all files as Markdown.
      * @returns {Promise<string>} A promise that resolves with the Markdown content of all files.

package/dist/modules/codeutils.js

@@ -0,0 +1,89 @@
+"use strict";
+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("../core/websocket"));
+/**
+ * A utility module for working with code.
+ */
+const cbcodeutils = {
+    /**
+     * Retrieves a JavaScript tree structure for a given file path.
+     * @param {string} filePath - The path of the file to retrieve the JS tree for.
+     * @returns {Promise<GetJsTreeResponse>} A promise that resolves with the JS tree response.
+     */
+    getJsTree: (filePath) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "settingEvent",
+            "action": "getProjectPath"
+        }, "getProjectPathResponse");
+        // return new Promise(async (resolve, reject) => {
+        //     cbws.messageManager.send({
+        //         "type": "codeEvent",
+        //         "action": "getJsTree",
+        //         payload: {
+        //             filePath
+        //         }
+        //     });
+        //     cbws.getWebsocket.on('message', (data: string) => {
+        //         const response = JSON.parse(data);
+        //         if (response.type === "getJsTreeResponse") {
+        //             resolve(response); // Resolve the Promise with the response data
+        //         }
+        //     });
+        // });
+    },
+    /**
+     * Retrieves all files as Markdown.
+     * @returns {Promise<string>} A promise that resolves with the Markdown content of all files.
+     */
+    getAllFilesAsMarkDown: () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "codeEvent",
+            "action": "getAllFilesMarkdown"
+        }, "getAllFilesMarkdownResponse");
+    },
+    /**
+     * Performs a matching operation based on the provided matcher definition and problem patterns.
+     * @param {object} matcherDefinition - The definition of the matcher.
+     * @param {Array} problemPatterns - The patterns to match against.
+     * @param {Array} problems - The list of problems.
+     * @returns {Promise<MatchProblemResponse>} A promise that resolves with the matching problem response.
+     */
+    performMatch: (matcherDefinition, problemPatterns, problems) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "codeEvent",
+            "action": "performMatch",
+            payload: {
+                matcherDefinition,
+                problemPatterns,
+            }
+        }, "getgetJsTreeResponse");
+    },
+    /**
+     * Retrieves the list of matchers.
+     * @returns {Promise<GetMatcherListTreeResponse>} A promise that resolves with the list of matchers response.
+     */
+    getMatcherList: () => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "codeEvent",
+            "action": "getMatcherList",
+        }, "getMatcherListTreeResponse");
+    },
+    /**
+     * Retrieves details of a match.
+     * @param {string} matcher - The matcher to retrieve details for.
+     * @returns {Promise<getMatchDetail>} A promise that resolves with the match detail response.
+     */
+    matchDetail: (matcher) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "codeEvent",
+            "action": "getMatchDetail",
+            payload: {
+                match: matcher
+            }
+        }, "matchDetailTreeResponse");
+    }
+};
+exports.default = cbcodeutils;

package/{modules → dist/modules}/crawler.d.ts

@@ -25,21 +25,6 @@ declare const cbcrawler: {
      * @param id - The ID of the element to be clicked.
      * @returns {Promise<any>} A promise that resolves when the click action is complete.
      */
-    click: (id: string) => Promise<unknown>;
-    /**
-     * Types the provided text into an element with the specified ID.
-     * @param id - The ID of the element where text will be typed.
-     * @param text - The text to type into the element.
-     * @returns {Promise<any>} A promise that resolves when the type action is complete.
-     */
-    type: (id: string, text: string) => Promise<unknown>;
-    /**
-     * Simulates the Enter key press using the crawler.
-     */
-    enter: () => void;
-    /**
-     * Initiates a crawl process.
-     */
-    crawl: (query: string) => Promise<unknown>;
+    click: (id: string) => Promise<any>;
 };
 export default cbcrawler;

package/dist/modules/crawler.js

@@ -0,0 +1,64 @@
+"use strict";
+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("../core/websocket"));
+/**
+ * A module for controlling a web crawler through WebSocket messages.
+ */
+const cbcrawler = {
+    /**
+     * Starts the crawler.
+     */
+    start: () => {
+        websocket_1.default.messageManager.send({
+            "type": "crawlerEvent",
+            action: 'start'
+        });
+    },
+    /**
+     * Takes a screenshot using the crawler.
+     */
+    screenshot: () => {
+        websocket_1.default.messageManager.send({
+            "type": "crawlerEvent",
+            action: 'screenshot'
+        });
+    },
+    /**
+     * Directs the crawler to navigate to a specified URL.
+     * @param url - The URL for the crawler to navigate to.
+     */
+    goToPage: (url) => {
+        websocket_1.default.messageManager.send({
+            "type": "crawlerEvent",
+            action: 'goToPage',
+            url
+        });
+    },
+    /**
+     * Scrolls the crawler in a specified direction.
+     * @param direction - The direction to scroll ('up', 'down', 'left', 'right').
+     */
+    scroll: (direction) => {
+        websocket_1.default.messageManager.send({
+            "type": "crawlerEvent",
+            action: 'scroll',
+            direction
+        });
+    },
+    /**
+     * Simulates a click event on an element with the specified ID.
+     * @param id - The ID of the element to be clicked.
+     * @returns {Promise<any>} A promise that resolves when the click action is complete.
+     */
+    click: (id) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "crawlerEvent",
+            action: 'click',
+            id
+        }, "crawlResponse");
+    }
+};
+exports.default = cbcrawler;