@codebolt/codeboltjs 1.1.13 → 1.1.16

package/index.js

@@ -21,6 +21,7 @@ const project_1 = __importDefault(require("./modules/project"));
 const git_1 = __importDefault(require("./modules/git"));
 const dbmemory_1 = __importDefault(require("./modules/dbmemory"));
 const state_1 = __importDefault(require("./modules/state"));
+const task_1 = __importDefault(require("./modules/task"));
 const ws_1 = __importDefault(require("ws"));
 /**
  * @class Codebolt
@@ -50,6 +51,7 @@ class Codebolt {
         this.project = project_1.default;
         this.dbmemory = dbmemory_1.default;
         this.cbstate = state_1.default;
+        this.taskplaner = task_1.default;
         this.websocket = websocket_1.default.getWebsocket;
     }
     /**

package/modules/state.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Retrieves the application state asynchronously.
+ * @returns {Promise<any>} A promise that resolves with the application state.
+ */
 declare const cbstate: {
     getApplicationState: () => Promise<any>;
 };

package/modules/state.js

@@ -4,6 +4,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const websocket_1 = __importDefault(require("./websocket"));
+/**
+ * Retrieves the application state asynchronously.
+ * @returns {Promise<any>} A promise that resolves with the application state.
+ */
 const cbstate = {
     getApplicationState: async () => {
         return new Promise((resolve, reject) => {

package/modules/task.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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<any>} 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<any>} 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<any>} A promise that resolves with the response from the update task event.
+     */
+    updateTask: (task: string) => Promise<any>;
+};
+export default taskplaner;

package/modules/task.js

@@ -0,0 +1,74 @@
+"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"));
+/**
+ * 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<any>} 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<any>} 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<any>} 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,7 +1,15 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+/**
+ * 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
@@ -11,5 +19,31 @@ declare const cbterminal: {
      * @returns {Promise<any>} A promise that resolves with the command's output, error, or finish signal.
      */
     executeCommand: (command: string) => 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.
+     *
+     * @param {string} command - The command to be executed.
+     * @returns {Promise<any>} A promise that resolves when an error occurs during command execution.
+     */
+    executeCommandRunUntilError: (command: string) => Promise<any>;
+    /**
+     * Executes a given command and keeps running until interrupted.
+     * Listens for messages from the WebSocket and resolves the promise when an interruption signal is received.
+     *
+     * @param {string} command - The command to be executed.
+     * @returns {Promise<any>} A promise that resolves when an interruption signal is received during command execution.
+     */
+    executeCommandRunUnitlIntrupt: (command: string) => Promise<any>;
+    /**
+     * 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 {Promise<any>} A promise that streams the output data during command execution.
+     */
+    executeCommandWithStream(command: string): {
+        event: CustomEventEmitter;
+    };
 };
 export default cbterminal;

package/modules/terminal.js

@@ -4,10 +4,17 @@ var __importDefault = (this && this.__importDefault) || function (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
@@ -29,6 +36,74 @@ const cbterminal = {
                 }
             });
         });
+    },
+    /**
+     * 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<any>} A promise that resolves when an error occurs during command execution.
+     */
+    executeCommandRunUntilError: async (command) => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "executeCommandRunUntilError",
+                "message": command,
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                const response = JSON.parse(data);
+                if (response.type === "commandError") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * Executes a given command and keeps running until interrupted.
+     * Listens for messages from the WebSocket and resolves the promise when an interruption signal is received.
+     *
+     * @param {string} command - The command to be executed.
+     * @returns {Promise<any>} A promise that resolves when an interruption signal is received during command execution.
+     */
+    executeCommandRunUnitlIntrupt: async (command) => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "executeCommandRunUnitlIntrupt",
+                "message": command,
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                const response = JSON.parse(data);
+                if (response.type === "terminalIntruptResponse") {
+                    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 {Promise<any>} A promise that streams the output data during command execution.
+     */
+    executeCommandWithStream(command) {
+        // Send the process started message
+        websocket_1.default.getWebsocket.send(JSON.stringify({
+            "type": "executeCommandWithStream",
+            "message": command,
+        }));
+        // 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")
+                // Emit a custom event based on the message type
+                this.eventEmitter.emit("serverEvents", response.response);
+        });
+        // Return an object that includes the event emitter and the stopProcess method
+        return {
+            event: this.eventEmitter
+        };
     }
 };
 exports.default = cbterminal;

package/package.json

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

package/src/index.ts

@@ -15,9 +15,11 @@ import cboutputparsers from './modules/outputparsers';
 import cbproject from './modules/project';
 import git from './modules/git';
 import dbmemory from './modules/dbmemory';
-import cbstate from './modules/state'
+import cbstate from './modules/state';
+import task from './modules/task';
 import WebSocket from 'ws';
 
+
 /**
  * @class Codebolt
  * @description This class provides a unified interface to interact with various modules.
@@ -70,7 +72,6 @@ class Codebolt {
     start_browser(objective:string, url:string, previous_command:string, browser_content:string) {
         cbbrowser.newPage();
     }
-
     websocket: WebSocket | null = null;
     fs = cbfs;
     git=git;
@@ -89,6 +90,7 @@ class Codebolt {
     project = cbproject;
     dbmemory = dbmemory;
     cbstate=cbstate;
+    taskplaner=task
 }
 
 // export default new Codebolt();

package/src/modules/state.ts

@@ -1,6 +1,9 @@
 import cbws from './websocket';
 
-
+/**
+ * Retrieves the application state asynchronously.
+ * @returns {Promise<any>} A promise that resolves with the application state.
+ */
 const cbstate = {
     getApplicationState: async (): Promise<any> => {
         return new Promise((resolve, reject) => {
@@ -19,4 +22,3 @@ const cbstate = {
 };
 
 export default cbstate;
-

package/src/modules/task.ts

@@ -0,0 +1,73 @@
+import cbws from './websocket';
+
+/**
+ * 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<any>} 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<any>} 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<any>} 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

@@ -1,9 +1,15 @@
 import cbws from './websocket';
+import { EventEmitter } from 'events';
 
+/**
+ * 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.
@@ -26,6 +32,81 @@ const cbterminal = {
                 }
             });
         });
+    },
+
+    /**
+     * 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<any>} A promise that resolves when an error occurs during command execution.
+     */
+    executeCommandRunUntilError: async (command: string): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "executeCommandRunUntilError",
+                "message": command,
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if ( response.type === "commandError") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+
+    /**
+     * Executes a given command and keeps running until interrupted.
+     * Listens for messages from the WebSocket and resolves the promise when an interruption signal is received.
+     *
+     * @param {string} command - The command to be executed.
+     * @returns {Promise<any>} A promise that resolves when an interruption signal is received during command execution.
+     */
+    executeCommandRunUnitlIntrupt: async (command: string): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "executeCommandRunUnitlIntrupt",
+                "message": command,
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "terminalIntruptResponse") {
+                    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 {Promise<any>} A promise that streams the output data during command execution.
+     */
+    executeCommandWithStream(command: string) {
+         // Send the process started message
+         cbws.getWebsocket.send(JSON.stringify({
+            "type": "executeCommandWithStream",
+            "message": command,
+        }));
+        // 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") 
+            // Emit a custom event based on the message type
+            this.eventEmitter.emit("serverEvents", response.response);
+        });
+
+        // Return an object that includes the event emitter and the stopProcess method
+        return {
+            event: this.eventEmitter
+        };
     }
+   
+
+ 
 };
 export default cbterminal;