@codebolt/codeboltjs 2.0.4 → 2.0.5

package/dist/modules/task.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("./websocket"));
+const websocket_1 = __importDefault(require("../core/websocket"));
 // import {AddTaskResponse,GetTasksResponse,UpdateTasksResponse } from '@codebolt/types';
 /**
  * Manages task operations via WebSocket communication.
@@ -15,39 +15,23 @@ const taskplaner = {
      * @returns {Promise<AddTaskResponse>} A promise that resolves with the response from the add task event.
      */
     addTask: async (task) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "taskEvent",
-                "action": "addTask",
-                message: {
-                    "task": task
-                }
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                const response = JSON.parse(data);
-                if (response.type === "addTaskResponse") {
-                    resolve(response); // Resolve the promise with the response data from adding the task
-                }
-            });
-        });
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "taskEvent",
+            "action": "addTask",
+            message: {
+                "task": task
+            }
+        }, "addTaskResponse");
     },
     /**
      * Retrieves all tasks using a WebSocket message.
      * @returns {Promise<GetTasksResponse>} A promise that resolves with the response from the get tasks event.
      */
     getTasks: async () => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "taskEvent",
-                "action": "getTasks"
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                const response = JSON.parse(data);
-                if (response.type === "getTasksResponse") {
-                    resolve(response); // Resolve the promise with the response data from retrieving tasks
-                }
-            });
-        });
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "taskEvent",
+            "action": "getTasks"
+        }, "getTasksResponse");
     },
     /**
      * Updates an existing task using a WebSocket message.
@@ -55,21 +39,13 @@ const taskplaner = {
      * @returns {Promise<UpdateTasksResponse>} A promise that resolves with the response from the update task event.
      */
     updateTask: async (task) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "taskEvent",
-                "action": "updateTask",
-                message: {
-                    "task": task
-                }
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                const response = JSON.parse(data);
-                if (response.type === "updateTaskResponse") {
-                    resolve(response); // Resolve the promise with the response data from updating the task
-                }
-            });
-        });
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "taskEvent",
+            "action": "updateTask",
+            message: {
+                "task": task
+            }
+        }, "updateTaskResponse");
     }
 };
 exports.default = taskplaner;

package/dist/modules/terminal.d.ts

@@ -5,6 +5,7 @@ import { CommandError, TerminalInterruptResponse } from '@codebolt/types';
  * CustomEventEmitter class that extends the Node.js EventEmitter class.
  */
 declare class CustomEventEmitter extends EventEmitter {
+    cleanup?: () => void;
 }
 /**
  * A module for executing commands in a terminal-like environment via WebSocket.
@@ -19,7 +20,7 @@ declare const cbterminal: {
      * @param {string} command - The command to be executed.
      * @returns {Promise<CommandOutput|CommandError>} A promise that resolves with the command's output, error, or finish signal.
      */
-    executeCommand: (command: string, returnEmptyStringOnSuccess?: boolean) => Promise<unknown>;
+    executeCommand: (command: string, returnEmptyStringOnSuccess?: boolean) => Promise<any>;
     /**
      * Executes a given command and keeps running until an error occurs.
      * Listens for messages from the WebSocket and resolves the promise when an error is encountered.
@@ -41,6 +42,6 @@ declare const cbterminal: {
      * @param {string} command - The command to be executed.
      * @returns {EventEmitter} A promise that streams the output data during command execution.
      */
-    executeCommandWithStream(command: string, executeInMain?: boolean): EventEmitter;
+    executeCommandWithStream(command: string, executeInMain?: boolean): CustomEventEmitter;
 };
 export default cbterminal;

package/dist/modules/terminal.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("./websocket"));
+const websocket_1 = __importDefault(require("../core/websocket"));
 const events_1 = require("events");
 /**
  * CustomEventEmitter class that extends the Node.js EventEmitter class.
@@ -24,20 +24,11 @@ const cbterminal = {
      * @returns {Promise<CommandOutput|CommandError>} A promise that resolves with the command's output, error, or finish signal.
      */
     executeCommand: async (command, returnEmptyStringOnSuccess = false) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "executeCommand",
-                "message": command,
-                returnEmptyStringOnSuccess
-            }));
-            let result = "";
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                const response = JSON.parse(data);
-                if (response.type === "commandError" || response.type === "commandFinish") {
-                    resolve(response);
-                }
-            });
-        });
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "executeCommand",
+            "message": command,
+            returnEmptyStringOnSuccess
+        }, "commandError|commandFinish");
     },
     /**
      * Executes a given command and keeps running until an error occurs.
@@ -47,19 +38,11 @@ const cbterminal = {
      * @returns {Promise<CommandError>} A promise that resolves when an error occurs during command execution.
      */
     executeCommandRunUntilError: async (command, executeInMain = false) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "executeCommandRunUntilError",
-                "message": command,
-                executeInMain
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                const response = JSON.parse(data);
-                if (response.type === "commandError") {
-                    resolve(response);
-                }
-            });
-        });
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "executeCommandRunUntilError",
+            "message": command,
+            executeInMain
+        }, "commandError");
     },
     /**
      * Sends a manual interrupt signal to the terminal.
@@ -67,17 +50,9 @@ const cbterminal = {
      * @returns {Promise<TerminalInterruptResponse>}
      */
     sendManualInterrupt() {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "sendInterruptToTerminal"
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                const response = JSON.parse(data);
-                if (response.type === "terminalInterrupted") {
-                    resolve(response);
-                }
-            });
-        });
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "sendInterruptToTerminal"
+        }, "terminalInterrupted");
     },
     /**
      * Executes a given command and streams the output.
@@ -88,20 +63,34 @@ const cbterminal = {
      */
     executeCommandWithStream(command, executeInMain = false) {
         // Send the process started message
-        websocket_1.default.getWebsocket.send(JSON.stringify({
+        websocket_1.default.messageManager.send({
             "type": "executeCommandWithStream",
             "message": command,
             executeInMain
-        }));
-        // Register event listener for WebSocket messages
-        websocket_1.default.getWebsocket.on('message', (data) => {
-            const response = JSON.parse(data);
+        });
+        // Listen for streaming messages through the message manager
+        const handleStreamMessage = (response) => {
             if (response.type === "commandOutput" || response.type === "commandError" || response.type === "commandFinish") {
                 this.eventEmitter.emit(response.type, response);
             }
-        });
-        // Return an object that includes the event emitter and the stopProcess method
-        return this.eventEmitter;
+        };
+        websocket_1.default.messageManager.on('message', handleStreamMessage);
+        // Create a new event emitter instance for this stream
+        const streamEmitter = new CustomEventEmitter();
+        // Forward events from the main emitter to the stream emitter
+        const forwardEvent = (eventType) => {
+            this.eventEmitter.on(eventType, (data) => {
+                streamEmitter.emit(eventType, data);
+            });
+        };
+        forwardEvent('commandOutput');
+        forwardEvent('commandError');
+        forwardEvent('commandFinish');
+        // Add a cleanup method to remove the listener
+        streamEmitter.cleanup = () => {
+            websocket_1.default.messageManager.removeListener('message', handleStreamMessage);
+        };
+        return streamEmitter;
     }
 };
 exports.default = cbterminal;

package/dist/modules/tokenizer.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("./websocket"));
+const websocket_1 = __importDefault(require("../core/websocket"));
 /**
  * Tokenizer module for handling token-related operations.
  */
@@ -14,21 +14,13 @@ const tokenizer = {
      * @returns {Promise<AddTokenResponse>} A promise that resolves with the response from the add token event.
      */
     addToken: async (key) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "tokenizerEvent",
-                "action": "addToken",
-                "message": {
-                    item: key
-                },
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                const response = JSON.parse(data);
-                if (response.type === "addTokenResponse") {
-                    resolve(response);
-                }
-            });
-        });
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "tokenizerEvent",
+            "action": "addToken",
+            "message": {
+                item: key
+            },
+        }, "addTokenResponse");
     },
     /**
      * Retrieves a token from the system via WebSocket.
@@ -36,21 +28,13 @@ const tokenizer = {
      * @returns {Promise<GetTokenResponse>} A promise that resolves with the response from the get token event.
      */
     getToken: async (key) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "tokenizerEvent",
-                "action": "getToken",
-                "message": {
-                    item: key
-                },
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                const response = JSON.parse(data);
-                if (response.type === "getTokenResponse") {
-                    resolve(response);
-                }
-            });
-        });
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "tokenizerEvent",
+            "action": "getToken",
+            "message": {
+                item: key
+            },
+        }, "getTokenResponse");
     }
 };
 exports.default = tokenizer;

package/dist/modules/tools.d.ts

@@ -23,12 +23,6 @@ declare const codeboltMCP: {
      * @returns Promise with the mentioned toolboxes
      */
     getMentionedToolBoxes: (userMessage: UserMessage) => Promise<any>;
-    /**
-     * Gets all available toolboxes.
-     *
-     * @returns Promise with all available toolboxes data
-     */
-    getAvailableToolBoxes: () => Promise<any>;
     /**
      * Searches for available toolboxes matching a query.
      *

package/dist/modules/tools.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("./websocket"));
+const websocket_1 = __importDefault(require("../core/websocket"));
 /**
  * Object containing methods for interacting with Codebolt MCP (Model Context Protocol) tools.
  * Provides functionality to discover, list, and execute tools.
@@ -15,26 +15,10 @@ const codeboltMCP = {
      * @returns Promise with the enabled toolboxes data
      */
     getEnabledToolBoxes: () => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "codebolttools",
-                "action": "getEnabledToolBoxes"
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "getEnabledToolBoxesResponse") {
-                        resolve(response.data);
-                    }
-                }
-                catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            websocket_1.default.getWebsocket.on('error', (error) => {
-                reject(error);
-            });
-        });
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "codebolttools",
+            "action": "getEnabledToolBoxes"
+        }, "getEnabledToolBoxesResponse");
     },
     /**
      * Gets the list of locally available toolboxes.
@@ -42,26 +26,10 @@ const codeboltMCP = {
      * @returns Promise with the local toolboxes data
      */
     getLocalToolBoxes: () => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "codebolttools",
-                "action": "getLocalToolBoxes"
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "getLocalToolBoxesResponse") {
-                        resolve(response.data);
-                    }
-                }
-                catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            websocket_1.default.getWebsocket.on('error', (error) => {
-                reject(error);
-            });
-        });
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "codebolttools",
+            "action": "getLocalToolBoxes"
+        }, "getLocalToolBoxesResponse");
     },
     /**
      * Gets toolboxes mentioned in a user message.
@@ -70,36 +38,10 @@ const codeboltMCP = {
      * @returns Promise with the mentioned toolboxes
      */
     getMentionedToolBoxes: (userMessage) => {
-        return new Promise((resolve, reject) => {
-            resolve(userMessage.mentionedMCPs);
-        });
-    },
-    /**
-     * Gets all available toolboxes.
-     *
-     * @returns Promise with all available toolboxes data
-     */
-    getAvailableToolBoxes: () => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "codebolttools",
-                "action": "getAvailableToolBoxes"
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "getAvailableToolBoxesResponse") {
-                        resolve(response.data);
-                    }
-                }
-                catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            websocket_1.default.getWebsocket.on('error', (error) => {
-                reject(error);
-            });
-        });
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "codebolttools",
+            "action": "getAvailableToolBoxes"
+        }, "getAvailableToolBoxesResponse");
     },
     /**
      * Searches for available toolboxes matching a query.
@@ -108,27 +50,11 @@ const codeboltMCP = {
      * @returns Promise with matching toolboxes data
      */
     searchAvailableToolBoxes: (query) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "codebolttools",
-                "action": "searchAvailableToolBoxes",
-                "query": query
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "searchAvailableToolBoxesResponse") {
-                        resolve(response.data);
-                    }
-                }
-                catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            websocket_1.default.getWebsocket.on('error', (error) => {
-                reject(error);
-            });
-        });
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "codebolttools",
+            "action": "searchAvailableToolBoxes",
+            "query": query
+        }, "searchAvailableToolBoxesResponse");
     },
     /**
      * Lists all tools from the specified toolboxes.
@@ -137,27 +63,11 @@ const codeboltMCP = {
      * @returns Promise with tools from the specified toolboxes
      */
     listToolsFromToolBoxes: (toolBoxes) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "codebolttools",
-                "action": "listToolsFromToolBoxes",
-                "toolBoxes": toolBoxes
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "listToolsFromToolBoxesResponse") {
-                        resolve(response.data);
-                    }
-                }
-                catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            websocket_1.default.getWebsocket.on('error', (error) => {
-                reject(error);
-            });
-        });
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "codebolttools",
+            "action": "listToolsFromToolBoxes",
+            "toolBoxes": toolBoxes
+        }, "listToolsFromToolBoxesResponse");
     },
     /**
      * Configures a specific toolbox with provided configuration.
@@ -167,28 +77,12 @@ const codeboltMCP = {
      * @returns Promise with the configuration result
      */
     configureToolBox: (name, config) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "codebolttools",
-                "action": "configureToolBox",
-                "mcpName": name,
-                "config": config
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "configureToolBoxResponse") {
-                        resolve(response.data);
-                    }
-                }
-                catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            websocket_1.default.getWebsocket.on('error', (error) => {
-                reject(error);
-            });
-        });
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "codebolttools",
+            "action": "configureToolBox",
+            "mcpName": name,
+            "config": config
+        }, "configureToolBoxResponse");
     },
     /**
      * Gets detailed information about specific tools.
@@ -197,27 +91,11 @@ const codeboltMCP = {
      * @returns Promise with detailed information about the tools
      */
     getTools: (tools) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "codebolttools",
-                "action": "getTools",
-                "toolboxes": tools
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "getToolsResponse") {
-                        resolve(response.data);
-                    }
-                }
-                catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            websocket_1.default.getWebsocket.on('error', (error) => {
-                reject(error);
-            });
-        });
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "codebolttools",
+            "action": "getTools",
+            "toolboxes": tools
+        }, "getToolsResponse");
     },
     /**
      * Executes a specific tool with provided parameters.
@@ -228,28 +106,12 @@ const codeboltMCP = {
      * @returns Promise with the execution result
      */
     executeTool: (toolbox, toolName, params) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "codebolttools",
-                "action": "executeTool",
-                "toolName": `${toolbox}--${toolName}`,
-                "params": params
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                try {
-                    const response = JSON.parse(data);
-                    if (response.type === "executeToolResponse") {
-                        resolve(response.data);
-                    }
-                }
-                catch (error) {
-                    reject(new Error("Failed to parse response"));
-                }
-            });
-            websocket_1.default.getWebsocket.on('error', (error) => {
-                reject(error);
-            });
-        });
-    },
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "codebolttools",
+            "action": "executeTool",
+            "toolName": `${toolbox}--${toolName}`,
+            "params": params
+        }, "executeToolResponse");
+    }
 };
 exports.default = codeboltMCP;

package/dist/modules/utils.js

@@ -0,0 +1,22 @@
+"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"));
+const cbutils = {
+    editFileAndApplyDiff: (filePath, diff, diffIdentifier, prompt, applyModel) => {
+        return websocket_1.default.messageManager.sendAndWaitForResponse({
+            "type": "fsEvent",
+            "action": "editFileAndApplyDiff",
+            message: {
+                filePath,
+                diff,
+                diffIdentifier,
+                prompt,
+                applyModel
+            }
+        }, "editFileAndApplyDiffResponse");
+    }
+};
+exports.default = cbutils;