@codebolt/codeboltjs 1.1.14 → 1.1.17

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,37 @@ 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.
+     */
+    executeCommandRunUnitlInterrupt: (command: string) => Promise<any>;
+    /**
+     * Sends a manual interrupt signal to the terminal.
+     *
+     * @returns {void}
+     */
+    sendManualInterrupt(): 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,92 @@ 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.
+     */
+    executeCommandRunUnitlInterrupt: async (command) => {
+        return new Promise((resolve, reject) => {
+            websocket_1.default.getWebsocket.send(JSON.stringify({
+                "type": "executeCommandRunUnitlInterrupt",
+                "message": command,
+            }));
+            websocket_1.default.getWebsocket.on('message', (data) => {
+                const response = JSON.parse(data);
+                if (response.type === "terminalInterruptResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * Sends a manual interrupt signal to the terminal.
+     *
+     * @returns {void}
+     */
+    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 {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.14",
+  "version": "1.1.17",
   "description": "",
   "keywords": [],
   "author": "",

package/src/modules/task.ts

@@ -45,6 +45,7 @@ const taskplaner = {
             });
         });
     },
+    
     /**
      * Updates an existing task using a WebSocket message.
      * @param {string} task - The updated task information.

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,100 @@ 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.
+     */
+    executeCommandRunUnitlInterrupt: async (command: string): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            cbws.getWebsocket.send(JSON.stringify({
+                "type": "executeCommandRunUnitlInterrupt",
+                "message": command,
+            }));
+            cbws.getWebsocket.on('message', (data: string) => {
+                const response = JSON.parse(data);
+                if (response.type === "terminalInterruptResponse") {
+                    resolve(response);
+                }
+            });
+        });
+    },
+    /**
+     * Sends a manual interrupt signal to the terminal.
+     *
+     * @returns {void}
+     */
+    sendManualInterrupt(): Promise<any>  {
+       
+        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 {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;