@codebolt/codeboltjs 1.1.76 → 1.1.78

package/src/modules/crawler.ts

@@ -0,0 +1,121 @@
+import cbws from './websocket';
+
+/**
+ * A module for controlling a web crawler through WebSocket messages.
+ */
+const cbcrawler = {
+    /**
+     * Starts the crawler.
+     */
+    start: () => {
+       cbws.getWebsocket.send(JSON.stringify({
+            "type": "crawlerEvent",
+            action: 'start'
+        }));
+    },
+    /**
+     * Takes a screenshot using the crawler.
+     */
+    screenshot: () => {
+       cbws.getWebsocket.send(JSON.stringify({
+            "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: string) => {
+       cbws.getWebsocket.send(JSON.stringify({
+            "type": "crawlerEvent",
+            action: 'goToPage',
+            url
+        }));
+    },
+    /**
+     * Scrolls the crawler in a specified direction.
+     * @param direction - The direction to scroll ('up', 'down', 'left', 'right').
+     */
+    scroll: (direction: string) => {
+       cbws.getWebsocket.send(JSON.stringify({
+            "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: string) => {
+        return new Promise((resolve, reject) => {
+           cbws.getWebsocket.send(JSON.stringify({
+                "type": "crawlerEvent",
+                action: 'click',
+                id
+            }));
+           cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.event === "clickFinished") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * 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) => {
+        return new Promise((resolve, reject) => {
+           cbws.getWebsocket.send(JSON.stringify({
+                "type": "crawlerEvent",
+                action: 'type',
+                id,
+                text
+            }));
+           cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.event === "typeFinished") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * Simulates the Enter key press using the crawler.
+     */
+    enter: () => {
+       cbws.getWebsocket.send(JSON.stringify({
+            "type": "crawlerEvent",
+            action: 'enter'
+        }));
+    },
+    /**
+     * Initiates a crawl process.
+     */
+    crawl: (query:string) => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "crawlerEvent",
+                "action": 'crawl',
+                "message":{
+                    query
+                }
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "crawlResponse") {
+                    resolve(response); // Resolve the Promise with the response data
+                } 
+            });
+        });
+  
+    }
+};
+
+export default cbcrawler;

package/src/modules/dbmemory.ts

@@ -0,0 +1,52 @@
+import cbws from './websocket';
+import {MemorySetResponse,MemoryGetResponse  } from '@codebolt/types';
+
+/**
+ * A module for handling in-memory database operations via WebSocket.
+ */
+const dbmemory = {
+    /**
+     * Adds a key-value pair to the in-memory database.
+     * @param {string} key - The key under which to store the value.
+     * @param {any} value - The value to be stored.
+     * @returns {Promise<MemorySetResponse>} A promise that resolves with the response from the memory set event.
+     */
+    addKnowledge: (key: string, value: any): Promise<MemorySetResponse> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "memoryEvent",
+                'action': 'set',
+                key,
+                value
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "memorySetResponse") {
+                    resolve(response); // Resolve the Promise with the response data
+                }
+            });
+        });
+    },
+    /**
+     * Retrieves a value from the in-memory database by key.
+     * @param {string} key - The key of the value to retrieve.
+     * @returns {Promise<MemoryGetResponse>} A promise that resolves with the response from the memory get event.
+     */
+    getKnowledge: (key: string): Promise<MemoryGetResponse> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "memoryEvent",
+                'action': 'get',
+                key
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "memoryGetResponse") {
+                    resolve(response); // Resolve the Promise with the response data
+                }
+            });
+        });
+    }
+};
+
+export default dbmemory;

package/src/modules/debug.ts

@@ -0,0 +1,68 @@
+import cbws from './websocket';
+import {DebugAddLogResponse,OpenDebugBrowserResponse } from '@codebolt/types';
+export enum logType{
+    info="info",
+    error="error",
+    warning="warning"
+}
+
+
+export const debug={
+    /**
+     * Sends a log message to the debug websocket and waits for a response.
+     * @param {string} log - The log message to send.
+     * @param {logType} type - The type of the log message (info, error, warning).
+     * @returns {Promise<DebugAddLogResponse>} A promise that resolves with the response from the debug event.
+     */
+    debug:(log:string,type:logType):Promise<DebugAddLogResponse>=> {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "debugEvent",
+                "action":"addLog",
+                message:{
+                   log,
+                   type
+                }
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "debugEventResponse") {
+                    resolve(response); // Resolve the Promise with the response data
+                }
+            })
+        })
+      
+
+    },
+    /**
+     * Requests to open a debug browser at the specified URL and port.
+     * @param {string} url - The URL where the debug browser should be opened.
+     * @param {number} port - The port on which the debug browser will listen.
+     * @returns {Promise<OpenDebugBrowserResponse>} A promise that resolves with the response from the open debug browser event.
+     */
+    openDebugBrowser:(url:string,port:number):Promise<OpenDebugBrowserResponse>=>{
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "debugEvent",
+                "action":"openDebugBrowser",
+                message:{
+                   url,
+                   port
+                }
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "openDebugBrowserResponse") {
+                    resolve(response); // Resolve the Promise with the response data
+                }
+            })
+        })
+       
+    }
+}
+
+
+export default debug;
+
+
+

package/src/modules/docutils.ts

@@ -0,0 +1,18 @@
+/**
+ * A module for document utility functions.
+ */
+const cbdocutils = {
+    /**
+     * Converts a PDF document to text.
+     * @param pdf_path - The file path to the PDF document to be converted.
+     * @returns {Promise<string>} A promise that resolves with the converted text.
+     */
+    pdf_to_text: (pdf_path: any): Promise<string> => {
+        // Implementation would go here
+        return new Promise((resolve, reject) => {
+            // PDF to text conversion logic
+        });
+    }
+};
+
+export default cbdocutils;

package/src/modules/fs.ts

@@ -0,0 +1,263 @@
+import cbws from './websocket';
+import {CreateFileResponse,CreateFolderResponse,ReadFileResponse,UpdateFileResponse,DeleteFileResponse,DeleteFolderResponse} from  '@codebolt/types'
+/**
+ * @module cbfs
+ * @description This module provides functionality to interact with the filesystem.
+ */
+const cbfs = {
+    /**
+     * @function createFile
+     * @description Creates a new file.
+     * @param {string} fileName - The name of the file to create.
+     * @param {string} source - The source content to write into the file.
+     * @param {string} filePath - The path where the file should be created.
+     * @returns {Promise<CreateFileResponse>} A promise that resolves with the server response.
+     */
+    createFile: (fileName: string, source: string, filePath: string): Promise<CreateFileResponse> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type":"fsEvent",
+                "action": "createFile",
+                "message": {
+                    fileName,
+                    source,
+                    filePath
+                },
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "createFileResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * @function createFolder
+     * @description Creates a new folder.
+     * @param {string} folderName - The name of the folder to create.
+     * @param {string} folderPath - The path where the folder should be created.
+     * @returns {Promise<CreateFolderResponse>} A promise that resolves with the server response.
+     */
+    createFolder: (folderName: string, folderPath: string): Promise<CreateFolderResponse> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type":"fsEvent",
+                "action": "createFolder",
+                "message": {
+                    folderName,
+                    folderPath
+                },
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "createFolderResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * @function readFile
+     * @description Reads the content of a file.
+     * @param {string} filename - The name of the file to read.
+     * @param {string} filePath - The path of the file to read.
+     * @returns {Promise<ReadFileResponse>} A promise that resolves with the server response.
+     */
+    readFile: (filePath: string): Promise<ReadFileResponse> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type":"fsEvent",
+                "action": "readFile",
+                "message": {
+                    filePath
+                },
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "readFileResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * @function updateFile
+     * @description Updates the content of a file.
+     * @param {string} filename - The name of the file to update.
+     * @param {string} filePath - The path of the file to update.
+     * @param {string} newContent - The new content to write into the file.
+     * @returns {Promise<UpdateFileResponse>} A promise that resolves with the server response.
+     */
+    updateFile: (filename: string, filePath: string, newContent: string): Promise<UpdateFileResponse> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type":"fsEvent",
+                "action": "updateFile",
+                "message": {
+                    filename,
+                    filePath,
+                    newContent
+                },
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "commandOutput") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * @function deleteFile
+     * @description Deletes a file.
+     * @param {string} filename - The name of the file to delete.
+     * @param {string} filePath - The path of the file to delete.
+     * @returns {Promise<DeleteFileResponse>} A promise that resolves with the server response.
+     */
+    deleteFile: (filename: string, filePath: string): Promise<DeleteFileResponse> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type":"fsEvent",
+                "action": "deleteFile",
+                "message": {
+                    filename,
+                    filePath
+                },
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "deleteFileResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * @function deleteFolder
+     * @description Deletes a folder.
+     * @param {string} foldername - The name of the folder to delete.
+     * @param {string} folderpath - The path of the folder to delete.
+     * @returns {Promise<DeleteFolderResponse>} A promise that resolves with the server response.
+     */
+    deleteFolder: (foldername: string, folderpath: string): Promise<DeleteFolderResponse> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type":"fsEvent",
+                "action": "deleteFolder",
+                "message": {
+                    foldername,
+                    folderpath
+                },
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "deleteFolderResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * @function listFile
+     * @description Lists all files.
+     * @returns {Promise<FileListResponse>} A promise that resolves with the list of files.
+     */
+    listFile: (folderPath:string,isRecursive=false) => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "fsEvent",
+                "action": "fileList",
+                message:{
+                    folderPath,
+                    isRecursive
+                }
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "fileListResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * @function listCodeDefinitionNames
+     * @description Lists all code definition names in a given path.
+     * @param {string} path - The path to search for code definitions.
+     * @returns {Promise<{success: boolean, result: any}>} A promise that resolves with the list of code definition names.
+     */
+    listCodeDefinitionNames: (path: string): Promise<{success: boolean, result: any}> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "fsEvent",
+                "action": "listCodeDefinitionNames",
+                "message": {
+                    path
+                }
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "listCodeDefinitionNamesResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+
+    /**
+     * @function searchFiles
+     * @description Searches files in a given path using a regex pattern.
+     * @param {string} path - The path to search within.
+     * @param {string} regex - The regex pattern to search for.
+     * @param {string} filePattern - The file pattern to match files.
+     * @returns {Promise<{success: boolean, result: any}>} A promise that resolves with the search results.
+     */
+    searchFiles: (path: string, regex: string, filePattern: string): Promise<{success: boolean, result: any}> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "fsEvent",
+                "action": "searchFiles",
+                "message": {
+                    path,
+                    regex,
+                    filePattern
+                }
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "searchFilesResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * @function writeToFile
+     * @description Writes content to a file.
+     * @param {string} relPath - The relative path of the file to write to.
+     * @param {string} newContent - The new content to write into the file.
+     * @returns {Promise<{success: boolean, result: any}>} A promise that resolves with the write operation result.
+     */
+    writeToFile: (relPath:string, newContent:string) => {
+        return new Promise((resolve, reject) => {
+             cbws.getWebsocket.send(JSON.stringify({
+                "type": "fsEvent",
+                "action": "writeToFile",
+                "message": {
+                    relPath,
+                    newContent
+                }
+            }));
+             cbws.getWebsocket.on('message', (data:string) => {
+                const response = JSON.parse(data);
+                if (response.type === "writeToFileResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+  
+};
+
+export default cbfs;