@codebolt/codeboltjs 1.1.76 → 1.1.77

package/modules/terminal.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { CommandError, TerminalInterruptResponse } from '@codebolt/types';
+/**
+ * CustomEventEmitter class that extends the Node.js EventEmitter class.
+ */
+declare class CustomEventEmitter extends EventEmitter {
+}
+/**
+ * A module for executing commands in a terminal-like environment via WebSocket.
+ */
+declare const cbterminal: {
+    eventEmitter: 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: (command: string, returnEmptyStringOnSuccess?: boolean) => Promise<unknown>;
+    /**
+     * 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: (command: string, executeInMain?: boolean) => Promise<CommandError>;
+    /**
+     * Sends a manual interrupt signal to the terminal.
+     *
+     * @returns {Promise<TerminalInterruptResponse>}
+     */
+    sendManualInterrupt(): Promise<TerminalInterruptResponse>;
+    /**
+     * 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?: boolean): EventEmitter;
+};
+export default cbterminal;

package/modules/terminal.js

@@ -0,0 +1,108 @@
+"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("./websocket"));
+const events_1 = require("events");
+/**
+ * CustomEventEmitter class that extends the Node.js EventEmitter class.
+ */
+class CustomEventEmitter extends events_1.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, 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);
+                }
+            });
+        });
+    },
+    /**
+     * 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, 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);
+                }
+            });
+        });
+    },
+    /**
+     * Sends a manual interrupt signal to the terminal.
+     *
+     * @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);
+                }
+            });
+        });
+    },
+    /**
+     * 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, executeInMain = false) {
+        // Send the process started message
+        websocket_1.default.getWebsocket.send(JSON.stringify({
+            "type": "executeCommandWithStream",
+            "message": command,
+            executeInMain
+        }));
+        // Register event listener for WebSocket messages
+        websocket_1.default.getWebsocket.on('message', (data) => {
+            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;
+    }
+};
+exports.default = cbterminal;

package/modules/tokenizer.d.ts

@@ -0,0 +1,19 @@
+import { AddTokenResponse, GetTokenResponse } from '@codebolt/types';
+/**
+ * Tokenizer module for handling token-related operations.
+ */
+declare 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: (key: string) => Promise<AddTokenResponse>;
+    /**
+     * 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: (key: string) => Promise<GetTokenResponse>;
+};
+export default tokenizer;

package/modules/tokenizer.js

@@ -0,0 +1,56 @@
+"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("./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) => {
+        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);
+                }
+            });
+        });
+    },
+    /**
+     * 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) => {
+        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);
+                }
+            });
+        });
+    }
+};
+exports.default = tokenizer;

package/modules/vectordb.d.ts

@@ -0,0 +1,33 @@
+import { AddVectorItemResponse, GetVectorResponse, QueryVectorItemResponse } from '@codebolt/types';
+declare 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: (key: string) => Promise<GetVectorResponse>;
+    /**
+     * 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: (item: any) => Promise<AddVectorItemResponse>;
+    /**
+     * 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: (key: string) => Promise<QueryVectorItemResponse>;
+    /**
+     * 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: (items: [], dbPath: string) => Promise<QueryVectorItemResponse>;
+};
+export default VectorDB;

package/modules/vectordb.js

@@ -0,0 +1,103 @@
+"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("./websocket"));
+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) => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "vectordbEvent",
+                "action": "getVector",
+                "message": {
+                    item: key
+                },
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                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) => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "vectordbEvent",
+                "action": "addVectorItem",
+                "message": {
+                    item: item
+                },
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                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) => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "vectordbEvent",
+                "action": "queryVectorItem",
+                "message": {
+                    item: key
+                },
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                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) => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "vectordbEvent",
+                "action": "queryVectorItems",
+                "message": {
+                    items,
+                    dbPath
+                },
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                const response = JSON.parse(data);
+                if (response.type === "qeryVectorItemsResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+};
+exports.default = VectorDB;

package/modules/websocket.d.ts

@@ -0,0 +1,27 @@
+import WebSocket from 'ws';
+/**
+ * Class representing a WebSocket connection.
+ */
+declare class cbws {
+    websocket: WebSocket;
+    /**
+     * Constructs a new cbws instance and initializes the WebSocket connection.
+     */
+    constructor();
+    private getUniqueConnectionId;
+    private getInitialMessage;
+    /**
+     * 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 initializeWebSocket;
+    /**
+     * 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;
+}
+declare const _default: cbws;
+export default _default;

package/modules/websocket.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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"));
+/**
+ * Class representing a WebSocket connection.
+ */
+class cbws {
+    /**
+     * 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 ws_1.default(`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);
+        });
+    }
+    getUniqueConnectionId() {
+        try {
+            let fileContents = fs_1.default.readFileSync('./codeboltagent.yaml', 'utf8');
+            let data = js_yaml_1.default.load(fileContents);
+            return data.unique_connectionid;
+        }
+        catch (e) {
+            console.error('Unable to locate codeboltagent.yaml file.');
+            return '';
+        }
+    }
+    getInitialMessage() {
+        try {
+            let fileContents = fs_1.default.readFileSync('./codeboltagent.yaml', 'utf8');
+            let data = js_yaml_1.default.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.
+     */
+    async initializeWebSocket(initialMessage) {
+        return new Promise((resolve, reject) => {
+            this.websocket.on('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) => {
+                // 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() {
+        if (!this.websocket.OPEN) {
+            throw new Error('WebSocket is not open');
+        }
+        else {
+            return this.websocket;
+        }
+    }
+}
+exports.default = new cbws();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codebolt/codeboltjs",
-  "version": "1.1.76",
+  "version": "1.1.77",
   "description": "",
   "keywords": [],
   "author": "",