@codebolt/codeboltjs 1.1.76 → 1.1.78

package/src/modules/state.ts

@@ -0,0 +1,69 @@
+import cbws from './websocket';
+import {ApplicationState,AddToAgentStateResponse,GetAgentStateResponse } from '@codebolt/types';
+
+const cbstate = {
+    /**
+     * Retrieves the current application state from the server via WebSocket.
+     * @returns {Promise<ApplicationState>} A promise that resolves with the application state.
+     */
+    getApplicationState: async (): Promise<ApplicationState> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "getAppState",
+                
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "getAppStateResponse") {
+                    resolve(response); // Resolve the Promise with the response data
+                }
+            });
+        });
+    },
+    /**
+     * Adds a key-value pair to the agent's state on the server via WebSocket.
+     * @param {string} key - The key to add to the agent's state.
+     * @param {string} value - The value associated with the key.
+     * @returns {Promise<AddToAgentStateResponse>} A promise that resolves with the response to the addition request.
+     */
+    addToAgentState: async (key: string, value: string): Promise<AddToAgentStateResponse> => {
+      return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "agentStateEvent",
+                "action":"addToAgentState",
+                payload:{
+                    key,
+                    value
+                }
+                
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "addToAgentStateResponse") {
+                    resolve(response); // Resolve the Promise with the response data
+                }
+            });
+        });  
+    },
+    /**
+     * Retrieves the current state of the agent from the server via WebSocket.
+     * @returns {Promise<GetAgentStateResponse>} A promise that resolves with the agent's state.
+     */
+    getAgentState: async (): Promise<GetAgentStateResponse> => {
+       return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "agentStateEvent",
+                "action":"getAgentState",
+                
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "getAgentStateResponse") {
+                    resolve(response); // Resolve the Promise with the response data
+                }
+            });
+        });  
+    }
+};
+
+export default cbstate;

package/src/modules/task.ts

@@ -0,0 +1,73 @@
+import cbws from './websocket';
+// import {AddTaskResponse,GetTasksResponse,UpdateTasksResponse } from '@codebolt/types';
+/**
+ * Manages task operations via WebSocket communication.
+ */
+const taskplaner = {
+    /**
+     * Adds a task using a WebSocket message.
+     * @param {string} task - The task to be added.
+     * @returns {Promise<AddTaskResponse>} A promise that resolves with the response from the add task event.
+     */
+    addTask: async (task: string): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "taskEvent",
+                "action":"addTask",
+                message:{
+                    "task": task
+                }
+               
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "addTaskResponse") {
+                    resolve(response); // Resolve the promise with the response data from adding the task
+                }
+            });
+        });
+    },
+    /**
+     * Retrieves all tasks using a WebSocket message.
+     * @returns {Promise<GetTasksResponse>} A promise that resolves with the response from the get tasks event.
+     */
+    getTasks: async (): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type":"taskEvent",
+                "action": "getTasks"
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "getTasksResponse") {
+                    resolve(response); // Resolve the promise with the response data from retrieving tasks
+                }
+            });
+        });
+    },
+    
+    /**
+     * Updates an existing task using a WebSocket message.
+     * @param {string} task - The updated task information.
+     * @returns {Promise<UpdateTasksResponse>} A promise that resolves with the response from the update task event.
+     */
+    updateTask: async ( task: string): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "taskEvent",
+                "action": "updateTask",
+                message: {
+                    "task": task
+                }
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "updateTaskResponse") {
+                    resolve(response); // Resolve the promise with the response data from updating the task
+                }
+            });
+        });
+    }
+};
+
+export default taskplaner;

package/src/modules/terminal.ts

@@ -0,0 +1,114 @@
+import cbws from './websocket';
+import { EventEmitter } from 'events';
+import {CommandError,CommandFinish,CommandOutput,TerminalInterruptResponse,TerminalInterrupted } from '@codebolt/types';
+/**
+ * CustomEventEmitter class that extends the Node.js EventEmitter class.
+ */
+class CustomEventEmitter extends EventEmitter {}
+/**
+ * A module for executing commands in a terminal-like environment via WebSocket.
+ */
+const cbterminal = {
+    eventEmitter: new CustomEventEmitter(),
+
+    /**
+     * Executes a given command and returns the result.
+     * Listens for messages from the WebSocket that indicate the output, error, or finish state
+     * of the executed command and resolves the promise accordingly.
+     *
+     * @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: async (command:string, returnEmptyStringOnSuccess:boolean = false) => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "executeCommand",
+                "message": command,
+                returnEmptyStringOnSuccess
+            }));
+            let result = "";
+            cbws.getWebsocket.on('message', (data:string) => {
+                const response = JSON.parse(data);
+                if (response.type === "commandError" || response.type === "commandFinish" ) {
+                   resolve(response)
+                }
+            });
+        });
+    },
+
+    /**
+     * 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.
+     *
+     * @param {string} command - The command to be executed.
+     * @returns {Promise<CommandError>} A promise that resolves when an error occurs during command execution.
+     */
+    executeCommandRunUntilError: async (command: string,executeInMain=false): Promise<CommandError> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "executeCommandRunUntilError",
+                "message": command,
+                executeInMain
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if ( response.type === "commandError") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+
+  
+    /**
+     * Sends a manual interrupt signal to the terminal.
+     *
+     * @returns {Promise<TerminalInterruptResponse>} 
+     */
+    sendManualInterrupt(): Promise<TerminalInterruptResponse>  {
+       
+        return new Promise((resolve, reject) => {
+           cbws.getWebsocket.send(JSON.stringify({
+            "type": "sendInterruptToTerminal"
+        }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "terminalInterrupted") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+
+    /**
+     * Executes a given command and streams the output.
+     * Listens for messages from the WebSocket and streams the output data.
+     *
+     * @param {string} command - The command to be executed.
+     * @returns {EventEmitter} A promise that streams the output data during command execution.
+     */
+    executeCommandWithStream(command: string,executeInMain=false):EventEmitter {
+         // Send the process started message
+         cbws.getWebsocket.send(JSON.stringify({
+            "type": "executeCommandWithStream",
+            "message": command
+            ,executeInMain
+        }));
+        // Register event listener for WebSocket messages
+        cbws.getWebsocket.on('message', (data: string) => {
+            const response = JSON.parse(data);
+            console.log("Received message:", 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
+    
+    }
+   
+
+ 
+};
+export default cbterminal;

package/src/modules/tokenizer.ts

@@ -0,0 +1,56 @@
+import { AddTokenResponse, GetTokenResponse } from '@codebolt/types';
+import cbws from './websocket';
+
+/**
+ * Tokenizer module for handling token-related operations.
+ */
+const tokenizer = {
+  
+    /**
+     * Adds a token to the system via WebSocket.
+     * @param {string} key - The key associated with the token to be added.
+     * @returns {Promise<AddTokenResponse>} A promise that resolves with the response from the add token event.
+     */
+    addToken: async (key: string): Promise<AddTokenResponse> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type":"tokenizerEvent",
+                "action": "addToken",
+                "message": {
+                    item: key
+                },
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "addTokenResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+
+    /**
+     * Retrieves a token from the system via WebSocket.
+     * @param {string} key - The key associated with the token to be retrieved.
+     * @returns {Promise<GetTokenResponse>} A promise that resolves with the response from the get token event.
+     */
+    getToken: async (key: string): Promise<GetTokenResponse> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type":"tokenizerEvent",
+                "action": "getToken",
+                "message": {
+                    item: key
+                },
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "getTokenResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    }
+}
+
+export default tokenizer

package/src/modules/vectordb.ts

@@ -0,0 +1,102 @@
+import cbws from './websocket';
+import { AddVectorItemResponse,GetVectorResponse,QueryVectorItemResponse } from '@codebolt/types';
+const VectorDB = {
+    /**
+     * Retrieves a vector from the vector database based on the provided key.
+     *
+     * @param {string} key - The key of the vector to retrieve.
+     * @returns {Promise<GetVectorResponse>} A promise that resolves with the retrieved vector.
+     */
+    getVector: async (key: string): Promise<GetVectorResponse> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type":"vectordbEvent",
+                "action": "getVector",
+                "message": {
+                    item: key
+                },
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "getVectorResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+
+    /**
+     * Adds a new vector item to the vector database.
+     *
+
+     * @param {any} item - The item to add to the vector.
+     * @returns {Promise<AddVectorItemResponse>} A promise that resolves when the item is successfully added.
+     */
+    addVectorItem: async ( item: any): Promise<AddVectorItemResponse> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type":"vectordbEvent",
+                "action": "addVectorItem",
+                "message": {
+                    item: item
+                },
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "addVectorItemResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+
+    /**
+     * Queries a vector item from the vector database based on the provided key.
+     *
+     * @param {string} key - The key of the vector to query the item from.
+     * @returns {Promise<QueryVectorItemResponse>} A promise that resolves with the queried vector item.
+     */
+    queryVectorItem: async (key: string): Promise<QueryVectorItemResponse> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type":"vectordbEvent",
+                "action": "queryVectorItem",
+                "message": {
+                    item: key
+                },
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "qeryVectorItemResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * Queries a vector item from the vector database based on the provided key.
+     *
+     * @param {string} key - The key of the vector to query the item from.
+     * @returns {Promise<QueryVectorItemResponse>} A promise that resolves with the queried vector item.
+     */
+    queryVectorItems: async (items: [],dbPath:string): Promise<QueryVectorItemResponse> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type":"vectordbEvent",
+                "action": "queryVectorItems",
+                "message": {
+                    items,
+                    dbPath
+                },
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "qeryVectorItemsResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+};
+
+export default VectorDB;

package/src/modules/websocket.ts

@@ -0,0 +1,89 @@
+import WebSocket from 'ws';
+import fs from 'fs';
+import yaml from 'js-yaml';
+
+/**
+ * Class representing a WebSocket connection.
+ */
+class cbws {
+    websocket: WebSocket;
+
+    /**
+     * Constructs a new cbws instance and initializes the WebSocket connection.
+     */
+    constructor() {
+        const uniqueConnectionId = this.getUniqueConnectionId();
+        const initialMessage = this.getInitialMessage();
+        console.log(uniqueConnectionId)
+        this.websocket = new WebSocket(`ws://localhost:${process.env.SOCKET_PORT}/codebolt?id=${uniqueConnectionId}${process.env.Is_Dev ? '&dev=true' : ''}`);
+        this.initializeWebSocket(initialMessage).catch(error => {
+            console.error("WebSocket connection failed:", error);
+        });
+    }
+    private getUniqueConnectionId(): string {
+        try {
+            let fileContents = fs.readFileSync('./codeboltagent.yaml', 'utf8');
+            let data: any = yaml.load(fileContents);
+            return data.unique_connectionid;
+        } catch (e) {
+            console.error('Unable to locate codeboltagent.yaml file.');
+            return '';
+        }
+    }
+
+    private getInitialMessage(): string {
+        try {
+            let fileContents = fs.readFileSync('./codeboltagent.yaml', 'utf8');
+            let data: any = yaml.load(fileContents);
+            return data.initial_message;
+        } catch (e) {
+            console.error('Unable to locate codeboltagent.yaml file.');
+            return '';
+        }
+    }
+
+    /**
+     * Initializes the WebSocket by setting up event listeners and returning a promise that resolves
+     * when the WebSocket connection is successfully opened.
+     * @returns {Promise<WebSocket>} A promise that resolves with the WebSocket instance.
+     */
+    private async initializeWebSocket(initialMessage: string): Promise<WebSocket> {
+        return new Promise((resolve, reject) => {
+            this.websocket.on('error', (error: Error) => {
+                console.log('WebSocket error:', error);
+                reject(error);
+            });
+
+            this.websocket.on('open', () => {
+                console.log('WebSocket connected');
+                // if (this.websocket) {
+                //     this.websocket.send(JSON.stringify({
+                //         "type": "sendMessage",
+                //         "message": initialMessage
+                //     }));
+                //     resolve(this.websocket);
+                // }
+            });
+
+            this.websocket.on('message', (data: WebSocket.Data) => {
+                // Handle incoming WebSocket messages here.
+                // console.log('WebSocket message received:', data);
+            });
+        });
+    }
+
+    /**
+     * Getter for the WebSocket instance. Throws an error if the WebSocket is not open.
+     * @returns {WebSocket} The WebSocket instance.
+     * @throws {Error} If the WebSocket is not open.
+     */
+    get getWebsocket(): WebSocket {
+        if (!this.websocket.OPEN) {
+            throw new Error('WebSocket is not open');
+        } else {
+            return this.websocket;
+        }
+    }
+}
+
+export default new cbws();