@codebolt/codeboltjs 1.1.70 → 1.1.73

package/modules/state.js

@@ -1,68 +0,0 @@
-"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 cbstate = {
-    /**
-     * Retrieves the current application state from the server via WebSocket.
-     * @returns {Promise<ApplicationState>} A promise that resolves with the application state.
-     */
-    getApplicationState: async () => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "getAppState",
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                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, value) => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "agentStateEvent",
-                "action": "addToAgentState",
-                payload: {
-                    key,
-                    value
-                }
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                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 () => {
-        return new Promise((resolve, reject) => {
-            websocket_1.default.getWebsocket.send(JSON.stringify({
-                "type": "agentStateEvent",
-                "action": "getAgentState",
-            }));
-            websocket_1.default.getWebsocket.on('message', (data) => {
-                const response = JSON.parse(data);
-                if (response.type === "getAgentStateResponse") {
-                    resolve(response); // Resolve the Promise with the response data
-                }
-            });
-        });
-    }
-};
-exports.default = cbstate;

package/modules/task.d.ts

@@ -1,23 +0,0 @@
-/**
- * Manages task operations via WebSocket communication.
- */
-declare 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: (task: string) => Promise<any>;
-    /**
-     * Retrieves all tasks using a WebSocket message.
-     * @returns {Promise<GetTasksResponse>} A promise that resolves with the response from the get tasks event.
-     */
-    getTasks: () => Promise<any>;
-    /**
-     * 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: (task: string) => Promise<any>;
-};
-export default taskplaner;

package/modules/task.js

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

package/modules/terminal.d.ts

@@ -1,46 +0,0 @@
-/// <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

@@ -1,108 +0,0 @@
-"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

@@ -1,19 +0,0 @@
-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

@@ -1,56 +0,0 @@
-"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

@@ -1,33 +0,0 @@
-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

@@ -1,103 +0,0 @@
-"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

@@ -1,27 +0,0 @@
-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

@@ -1,88 +0,0 @@
-"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}`);
-        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();