nep-cli 0.2.2 → 0.2.4

package/bin/index.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 const { program } = require('commander');
 const { version } = require('../package.json');
@@ -14,7 +14,7 @@ const open = require('open'); // Import the 'open' package
 const express = require('express');
 const http = require('http');
 const socketIo = require('socket.io');
-const fs = require('fs');
+const fs = require ('fs');
 const zmqc = require("zeromq/v5-compat");
 
 const PORT_MASTER_INFO = 50001; // Default port for master info
@@ -26,6 +26,7 @@ program
   .version(version)
   .description('NEP-CLI')
 
+
 program
   .command('ip')
   .description('Display current Wi-Fi and Ethernet IP addresses of this computer')
@@ -78,7 +79,8 @@ class MasterLocal {
         const reply = new zmq.Reply
         await reply.bind(address)
         for await (const [node_request] of reply) {
-          await reply.send(processMsg(node_request, nodes_register, topic_register))
+          var msg = await processMsg(node_request.toString(), nodes_register, topic_register)
+          await reply.send(msg)
         }
       }
       run()
@@ -120,77 +122,173 @@ var onRegisteredTopic = function (node_request, topic_register, topic) {
 }
 
 
+var onNewTopic = async function (node_request, topic_register) {
+  // Assign new ports
+  nep_configuration["current_port"] += 2;
 
-var onNewTopic = function (node_request, topic_register) {
+  // Topic must be a string
+  var topic = String(node_request['topic']);
+  var msg = {};
 
-  // Asign new ports
-  nep_configuration["current_port"] = nep_configuration["current_port"] + 2
-  // Topic must be an string
-  topic = String(node_request['topic'])
-  var msg = {}
   // If publisher or subscriber
   if (node_request["socket"] === "publisher" || node_request["socket"] === "subscriber") {
     // Create new broker for many2many communication
     if (node_request["mode"] === "many2many") {
-      createBroker(topic);
-      msg = m2mResponse(node_request, topic_register, topic);
+      await createBroker(topic);
+      msg = ManyToManyResponse(node_request, topic_register, topic);
     }
   }
-  else if (node_request["socket"] === "surveyor" || node_request["socket"] === "respondent") {
-    msg = surveyResponse(node_request, topic_register, topic)
-  }
+
+  // If client or server
   else if (node_request["socket"] === "client" || node_request["socket"] === "server") {
-    msg = csResponse(node_request, topic_register, topic)
+    msg = csResponse(node_request, topic_register, topic);
   }
+
   // Key for related nodes
-  topic_register[topic]["nodes"] = {}
+  topic_register[topic]["nodes"] = {};
+
   // Set PID of node
   updatePID(node_request, topic_register, topic);
 
-  if ("language" in node_request) {
-
-    if (node_request["language"] == "C++") {
-      msg.port = msg.port.toString();
-    }
-
+  // If the language is C++, convert the port to a string
+  if (node_request["language"] === "C++") {
+    msg.port = msg.port.toString();
   }
 
-  return msg
+  return msg;
 }
 
 
-var createBroker = function (topic) {
-  try {
-    var broker = new Broker(nep_configuration["IP"], nep_configuration["current_port"] + 1, nep_configuration["current_port"])
-    //var brokersubex = new BrokerBridgeSUBEX(conf["IP"],IP_EXTERNAL, conf["current_port"] , conf["current_port"])
+class Broker {
+  constructor(IP, PORT_XPUB, PORT_XSUB, topic) {
+    this.pubListener = "tcp://" + IP + ":" + String(PORT_XPUB);
+    this.subListener = "tcp://" + IP + ":" + String(PORT_XSUB);
+    this.hwm = 1000;
+    this.verbose = 0;
+    this.topic = topic;
 
-    // Add broker defined to list of brokers
-    nep_configuration["brokers"][topic] = broker
-  } catch (error) {
-    // console.log("NEP ERROR: ports " + String(nep_configuration["current_port"]) + " and " + String(nep_configuration["current_port"] + 1) + " not avaliable")
-    nep_configuration["current_port"] = nep_configuration["current_port"] + 2
-    var broker = new nep.Broker(nep_configuration["IP"], nep_configuration["current_port"] + 1, nep_configuration["current_port"])
-    // Add broker defined to list of brokers
-    nep_configuration["brokers"][topic] = broker
+    // Use ZMQ version 5
+    this.zmqc = require("zeromq/v5-compat");
   }
-}
-
 
-var m2mResponse = function (node_request, topic_register, topic) {
-  if ("msg_type" in node_request) {
-    topic_register[topic] = { "port": nep_configuration["current_port"], "socket": node_request["socket"], 'ip': nep_configuration["IP"], "mode": node_request["mode"], "msg_type": node_request["msg_type"] }
+  bindSockets() {
+    try {
+      // The xsub listener is where pubs connect to
+      this.subSock = this.zmqc.socket('xsub');
+      this.subSock.bind(this.subListener);
+
+      // The xpub listener is where subs connect to
+      this.pubSock = this.zmqc.socket('xpub');
+      this.pubSock.setsockopt(this.zmqc.ZMQ_SNDHWM, this.hwm);
+
+      // By default xpub only signals new subscriptions
+      // Settings it to verbose = 1 , will signal on every new subscribe
+      this.pubSock.setsockopt(this.zmqc.ZMQ_XPUB_VERBOSE, this.verbose);
+      this.pubSock.bind(this.pubListener);
+      return true;
+    } catch (error) {
+      if (error.code === 'EADDRINUSE') {
+        throw new Error(`Port ${this.pubListener.split(':')[2]} or ${this.subListener.split(':')[2]} is in use.`);
+      } else {
+        console.error(error);
+        return false;
+      }
+    }
   }
-  else {
-    topic_register[topic] = { "port": nep_configuration["current_port"], "socket": node_request["socket"], 'ip': nep_configuration["IP"], "mode": node_request["mode"], "msg_type": "json" }
+
+  start() {
+    // When we receive data on subSock , it means someone is publishing
+    this.subSock.on('message', (data) => {
+      // We just relay it to the pubSock, so subscribers can receive it
+      this.pubSock.send(data);
+    });
+
+    // When Pubsock receives a message , it's subscribe requests
+    this.pubSock.on('message', (data) => {
+      // The data is a slow Buffer
+      // The first byte is the subscribe (1) /unsubscribe flag (0)
+      var type = data[0] === 0 ? 'unsubscribe' : 'subscribe';
+      // The channel name is the rest of the buffer
+      var channel = data.slice(1).toString();
+      console.log(type + ' :' + this.topic);
+      // We send it to subSock, so it knows to what channels to listen to
+      this.subSock.send(data);
+    });
+    console.log("BROKER: " + "XPUB: " + String(this.pubListener) + " - bind , XSUB: " + String(this.subListener) + " - bind");
   }
-  return { 'topic': topic, 'port': nep_configuration["current_port"], 'mode': node_request["mode"], 'ip': nep_configuration["IP"], 'socket': node_request["socket"], "state": "success" }
 }
 
-var surveyResponse = function (node_request, topic_register, topic) {
-  topic_register[topic] = { "port": nep_configuration["current_port"], "socket": node_request["socket"], 'ip': nep_configuration["IP"] }
-  return { 'topic': topic, 'port': nep_configuration["current_port"], 'ip': nep_configuration["IP"], 'socket': node_request["socket"], "state": "success" }
+function checkPort(port) {
+  return new Promise((resolve) => {
+    const sock = new zmq.Publisher;
+    sock.bind(`tcp://127.0.0.1:${port}`)
+      .then(() => {
+        sock.unbind(`tcp://127.0.0.1:${port}`);
+        resolve(false); // Puerto disponible
+      })
+      .catch((err) => {
+        if (err.code === 'EADDRINUSE') {
+          resolve(true); // Puerto en uso
+        } else {
+          console.error(err);
+        }
+      });
+  });
+}
+
+var createBroker = async function (topic) {
+  var bindResult = false;
+  do {
+    var portInUse = await checkPort(nep_configuration["current_port"]);
+    var nextPortInUse = await checkPort(nep_configuration["current_port"] + 1);
+    if (portInUse || nextPortInUse) {
+      console.log(`LOG: Port ${nep_configuration["current_port"]} in use: ${portInUse}, Port ${nep_configuration["current_port"] + 1} in use: ${nextPortInUse}`);
+      nep_configuration["current_port"] += 2;
+      continue;
+    }
+
+    var broker = new Broker(nep_configuration["IP"], nep_configuration["current_port"] + 1, nep_configuration["current_port"], topic);
+    bindResult = broker.bindSockets();
+    if (bindResult) {
+      broker.start();
+      nep_configuration["brokers"][topic] = broker;
+    }
+  } while (!bindResult);
+}
+
+
+/**
+ * Generate a response for many-to-many communication.
+ * @param {Object} node_request - The request from the node.
+ * @param {Object} topic_register - The register of topics.
+ * @param {string} topic - The topic of the request.
+ * @return {Object} The response to be sent back to the node.
+ */
+var ManyToManyResponse = function (node_request, topic_register, topic) {
+  // If the request contains a message type, use it. Otherwise, default to "json".
+  var msg_type = "msg_type" in node_request ? node_request["msg_type"] : "json";
+
+  // Register the topic with the current port, socket, IP, mode, and message type.
+  topic_register[topic] = {
+    "port": nep_configuration["current_port"],
+    "socket": node_request["socket"],
+    'ip': nep_configuration["IP"],
+    "mode": node_request["mode"],
+    "msg_type": msg_type
+  };
+
+  // Return the response with the topic, port, mode, IP, socket, and a success state.
+  return {
+    'topic': topic,
+    'port': nep_configuration["current_port"],
+    'mode': node_request["mode"],
+    'ip': nep_configuration["IP"],
+    'socket': node_request["socket"],
+    "state": "success"
+  };
 }
 
+
 var csResponse = function (node_request, topic_register, topic) {
   topic_register[topic] = { "port": nep_configuration["current_port"], "socket": node_request["socket"], 'ip': nep_configuration["IP"], "msg_type": "json" }
   return { 'topic': topic, 'port': nep_configuration["current_port"], 'ip': nep_configuration["IP"], 'socket': node_request["socket"], "state": "success" }
@@ -207,16 +305,16 @@ var updatePID = function (node_request, topic_register, topic) {
 }
 
 
-const processMsg = (json_msg, nodes_register, topic_register) => {
+const processMsg = async (json_msg, nodes_register, topic_register) => {
   const node_request = JSON.parse(json_msg);
   const { node, socket, topic, pid } = node_request;
-  console.log(`NEP: Node request - node: ${node}, socket: ${socket}, topic: ${topic}`);
+  console.log(`\n --- REQUEST: node: ${node}, socket: ${socket}, topic: ${topic} ---`);
 
   // Check node status
   if (node) {
     // Kill previous node with the same name
     if (node in nodes_register) {
-      console.log(`--- Node *${node}* already defined ---`);
+      console.log(`NODE: *${node}* already registered`);
       const current_pid = nodes_register[node];
       if (pid !== current_pid) {
         if (!node.startsWith('nep-cli')) {
@@ -226,7 +324,7 @@ const processMsg = (json_msg, nodes_register, topic_register) => {
         }
       }
     } else {
-      console.log(`--- New Node *${node}* ---`);
+      console.log(`NODE: *${node}* was registered`);
     }
   }
 
@@ -236,14 +334,14 @@ const processMsg = (json_msg, nodes_register, topic_register) => {
   // Check topic status
   const topicStr = String(topic);
   if (topicStr in topic_register) {
-    console.log(`--- Topic *${topicStr}* already registered ---`);
+    console.log(`TOPIC: *${topicStr}* already registered ---`);
     // Send information of topic already defined
     const response = onRegisteredTopic(node_request, topic_register, topicStr);
     return JSON.stringify(response);
   } else {
-    console.log(`--- New topic: *${topicStr}* ---`);
+    console.log(`TOPIC: *${topicStr}* was registered`);
     // Create new broker
-    const response = onNewTopic(node_request, topic_register);
+    const response = await onNewTopic(node_request, topic_register);
     return JSON.stringify(response);
   }
 };
@@ -340,45 +438,57 @@ const sendRequest = async (requester, msg) => {
 };
 
 const selectTopic = async (results, topic) => {
-  if (!topic || !results["input"].includes(topic)) {
-    const autoComplete = new AutoComplete({
-      name: 'topic',
-      message: !topic ? 'Select a topic:' : 'Invalid topic. Select a valid topic:',
-      choices: results["input"],
-    });
-    topic = await autoComplete.run();
+  try {
+    if (!topic || !results["input"].includes(topic)) {
+      const autoComplete = new AutoComplete({
+        name: 'topic',
+        message: !topic ? 'Select a topic:' : 'Invalid topic. Select a valid topic:',
+        choices: results["input"],
+      });
+      topic = await autoComplete.run();
+    }
+    return topic;
+  } catch (error) {
+    process.exit(1);
   }
-  return topic;
 };
 
 const selectIndex = async (index, maxIndex = 9) => {
-  const choices = ["0","1","2","3","4","5","6","7","8","9"];
+  try {
+    const choices = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"];
 
-  const autoComplete = new AutoComplete({
-    name: 'index',
-    message: !index ? 'Select a index:' : 'Invalid index. Select a valid index:',
-    choices: choices,
-  });
-  index = await autoComplete.run();
+    const autoComplete = new AutoComplete({
+      name: 'index',
+      message: !index ? 'Select a index:' : 'Invalid index. Select a valid index:',
+      choices: choices,
+    });
+    index = await autoComplete.run();
 
-  return index;
+    return index;
+  } catch (error) {
+    process.exit(1);
+  }
 };
 
 const selectMsgType = async (allowedFormats, msg_type, topic) => {
-  var msgType = topic.split('/').pop();
-  if (msgType && msgType !== topic) {
-    msg_type = msgType;
-  }
+  try {
+    var msgType = topic.split('/').pop();
+    if (msgType && msgType !== topic) {
+      msg_type = msgType;
+    }
 
-  if (!msg_type || !allowedFormats.includes(msg_type)) {
-    const autoComplete = new AutoComplete({
-      name: 'msg_type',
-      message: !msg_type ? 'Select a message type:' : `Select a valid format:`,
-      choices: allowedFormats,
-    });
-    msg_type = await autoComplete.run();
+    if (!msg_type || !allowedFormats.includes(msg_type)) {
+      const autoComplete = new AutoComplete({
+        name: 'msg_type',
+        message: !msg_type ? 'Select a message type:' : `Select a valid format:`,
+        choices: allowedFormats,
+      });
+      msg_type = await autoComplete.run();
+    }
+    return msg_type;
+  } catch (error) {
+    process.exit(1);
   }
-  return msg_type;
 };
 
 const openSub = (master_ip, topic, msg_type, callback) => {
@@ -388,123 +498,9 @@ const openSub = (master_ip, topic, msg_type, callback) => {
 };
 
 
-program
-  .command('app')
-  .description('Open NEP+ App')
-  .action(() => {
-    // Get the username of the logged-in user
-    const username = os.userInfo().username;
-
-    // Specify the path to the executable
-    const appFolderName = 'nepplus-app';
-    const executableName = 'nepplus-app.exe';
-    const executablePath = `C:\\Users\\${username}\\AppData\\Local\\Programs\\${appFolderName}\\${executableName}`;
-
-    // Run the executable with proper escaping
-    exec(`"${executablePath}"`, (error, stdout, stderr) => {
-      if (error) {
-        console.error(`Error: ${error.message}`);
-        return;
-      }
-      console.log(`stdout: ${stdout}`);
-      console.error(`stderr: ${stderr}`);
-    });
-  });
-
-
-  program
-  .command('publish <topic> <message>')
-  .description('Publish a message to a NEP+ topic')
-  .action((topic, message) => {
-
-    var openpub = function (master_ip = "127.0.0.1") {
-
-      var pubFunction = function () {
-
-        var msg = message.replace(/'/g, '"')
-        console.log(JSON.parse(msg))
-        pub.publish(JSON.parse(msg))
-        console.log("Message published")
-
-        process.exit(1)
-      }
-
-
-      var node = new nep.Node("nep-cli-pub")
-      var pub = node.new_pub(topic, "json")
-      setTimeout(pubFunction, 1000)
-    }
-
-    async function run() {
-      var requester = new zmq.Request;
-      var master_ip = "127.0.0.1"
-
-      requester.connect("tcp://" + master_ip + ":" + PORT_MASTER_INFO);
-
-      let msg = { "input": "topics" }
-      var message = JSON.stringify(msg);
-      await requester.send(message)
-      const [result] = await requester.receive()
-      var results = JSON.parse(result.toString())
-      //console.log(results);
-      if (results["input"].includes(topic)) {
-        console.log("")
-        openpub(master_ip)
-      }
-      else {
-        console.log("Topic is not registered");
-      }
-    }
-    run()
-  });
-
-
-program
-  .command('open [programName]')
-  .description('Open a NEP+ GUI')
-  .action(async (programName) => {
-    const programs = ['cameras', 'hxri'];
-
-    // If a program name is provided as an argument, use it; otherwise, show autocomplete
-    if (!programName) {
-      const autoComplete = new AutoComplete({
-        name: 'program',
-        message: 'Select a program:',
-        choices: programs,
-      });
-      programName = await autoComplete.run();
-    } else if (!programs.includes(programName)) {
-      const autoComplete = new AutoComplete({
-        name: 'program',
-        message: 'Invalid program name. Select a valid program:',
-        choices: programs,
-      });
-      programName = await autoComplete.run();
-    }
-
-    // Get the username of the logged-in user
-    const username = os.userInfo().username;
-
-    // Specify the path to the executable
-    const appFolderName = 'nepplus' + "-" + programName;
-    const executableName = 'nepplus' + "-" + `${programName}.exe`;
-    const executablePath = `C:\\Users\\${username}\\AppData\\Local\\Programs\\${appFolderName}\\${executableName}`;
-
-    // Run the executable with proper escaping
-    exec(`"${executablePath}"`, (error, stdout, stderr) => {
-      if (error) {
-        console.error(`Error: ${error.message}`);
-        return;
-      }
-      console.log(`stdout: ${stdout}`);
-      console.error(`stderr: ${stderr}`);
-    });
-  });
-
-
 program
   .command('master')
-  .description('Fetches and displays the list of NEP+ topics from the NEP master')
+  .description('Start master for managing NEP+ topics')
   .action(async () => {
     try {
       var node = new nep.Node("nep-cli");
@@ -520,7 +516,6 @@ program
     }
   });
 
-
 program
   .command('topics')
   .description('Displays the list of NEP+ topics')
@@ -574,11 +569,12 @@ program
     await getTopics(); // Call the function to get topics
   });
 
+
 program
   .command('show [topic] [index]')
   .description('Displays messages published to a specified NEP+ topic in the default browser. ' +
-               'The [index] parameter specifies the index of the message to display and must be a number between 0 and 49. '
-               )
+    'The [index] parameter specifies the port index of the server that is connected to the web browser for displaying messages. It must be a number between 0 and 49'
+  )
   .action(async (topic, index) => {
     const ip = "127.0.0.1";
 
@@ -593,13 +589,12 @@ program
     index = await selectIndex(index);
 
     const topicid = `${index}: ${topic}`;
-    if(parseInt(index) < 50)
-    {
+    if (parseInt(index) < 50) {
       const port = PORT_SERVER + parseInt(index);
       console.log(PORT_SERVER)
       console.log(index)
       console.log(PORT_SERVER + parseInt(index))
-  
+
       if (msg_type === "images") {
         open(`http://localhost:${port}/?port=${port}&topic=${encodeURIComponent(topicid)}`);
         startShowServer(port, topic, ip);
@@ -613,7 +608,7 @@ program
     else {
       console.log("Index must be between 0 and 49");
     }
-  
+
   });
 
 
@@ -719,6 +714,327 @@ program
 
   });
 
+program
+  .command('delay [topic]')
+  .description('Monitor the delay between messages of a NEP+ topic')
+  .action(async (topic, msg_type) => {
+    const allowedFormats = ["json", "msgpack", "bytes", "images", "dictionary", "string"];
+    const master_ip = "127.0.0.1";
+
+    const requester = createRequester(master_ip, PORT_MASTER_INFO);
+    const results = await sendRequest(requester, { "input": "topics" });
+
+    topic = await selectTopic(results, topic);
+    msg_type = await selectMsgType(allowedFormats, msg_type, topic);
+
+    let lastTimestamp = null; // Store timestamp of the last received message
+
+    const callback = function (msg) {
+      const date = new Date();
+      const timestamp = date.getTime();
+
+      if (lastTimestamp !== null) {
+        const delay = timestamp - lastTimestamp;
+        console.log("Delay:", delay.toFixed(2), "ms");
+      }
+
+      lastTimestamp = timestamp;
+    };
+
+    openSub(master_ip, topic, msg_type, callback);
+  });
+
+program
+  .command('bw [topic]')
+  .description('Monitor the bandwidth used by a NEP+ topic')
+  .action(async (topic, msg_type) => {
+    const allowedFormats = ["json", "msgpack", "bytes", "images", "dictionary", "string"];
+    const master_ip = "127.0.0.1";
+
+    const requester = createRequester(master_ip, PORT_MASTER_INFO);
+    const results = await sendRequest(requester, { "input": "topics" });
+
+    topic = await selectTopic(results, topic);
+    msg_type = await selectMsgType(allowedFormats, msg_type, topic);
+
+    let totalBytes = 0; // Store total bytes received
+
+    const callback = function (msg) {
+      let strMsg;
+
+      if (typeof msg === 'string') {
+        strMsg = msg;
+      } else if (Buffer.isBuffer(msg)) {
+        strMsg = msg.toString('utf8');
+      } else {
+        // Convert JSON to string
+        strMsg = JSON.stringify(msg);
+      }
+
+      const bytes = Buffer.byteLength(strMsg, 'utf8');
+      totalBytes += bytes;
+    };
+
+    setInterval(() => {
+      console.log("Bandwidth:", (totalBytes / (1024 * 1024)).toFixed(2), "MB");
+      totalBytes = 0; // Reset total bytes for the next interval
+    }, 1000);
+
+    openSub(master_ip, topic, msg_type, callback);
+  });
+
+
+program
+  .command('publish <topic> <message>')
+  .description('Publish a message to a NEP+ topic (only JSON messages are supported)')
+  .action((topic, message) => {
+
+    var openpub = function (master_ip = "127.0.0.1") {
+
+      var pubFunction = function () {
+
+        var msg = message.replace(/'/g, '"')
+        console.log(JSON.parse(msg))
+        pub.publish(JSON.parse(msg))
+        console.log("Message published")
+
+        process.exit(1)
+      }
+
+
+      var node = new nep.Node("nep-cli-pub")
+      var pub = node.new_pub(topic, "json")
+      setTimeout(pubFunction, 1000)
+    }
+
+    async function run() {
+      var requester = new zmq.Request;
+      var master_ip = "127.0.0.1"
+
+      requester.connect("tcp://" + master_ip + ":" + PORT_MASTER_INFO);
+
+      let msg = { "input": "topics" }
+      var message = JSON.stringify(msg);
+      await requester.send(message)
+      const [result] = await requester.receive()
+      var results = JSON.parse(result.toString())
+      //console.log(results);
+      if (results["input"].includes(topic)) {
+        console.log("")
+        openpub(master_ip)
+      }
+      else {
+        console.log("Topic is not registered");
+      }
+    }
+    run()
+  });
+
+
+const { Input } = require('enquirer');
+
+const selectTimeout = async (defaultTimeout = 1000) => {
+  try {
+    const prompt = new Input({
+      name: 'timeout',
+      message: 'Enter the timeout in milliseconds:',
+      initial: defaultTimeout,
+      validate: value => /^\d+$/.test(value) ? true : 'Timeout must be a number'
+    });
+
+    const timeout = await prompt.run();
+    return Number(timeout);
+  } catch (error) {
+    process.exit(1);
+  }
+};
+
+program
+  .command('record [topic]')
+  .description('Record messages from a NEP+ topic to a file')
+  .action(async (topic) => {
+    const allowedFormats = ["json", "msgpack", "bytes", "images", "dictionary", "string"];
+    const master_ip = "127.0.0.1";
+    var msg_type = "";
+    var timeout = 10000;
+
+    const requester = createRequester(master_ip, PORT_MASTER_INFO);
+    const results = await sendRequest(requester, { "input": "topics" });
+
+    topic = await selectTopic(results, topic);
+    msg_type = await selectMsgType(allowedFormats, msg_type, topic);
+    timeout = await selectTimeout(timeout);
+
+    const date = new Date();
+    const timestamp = date.toISOString().replace(/:/g, '-');
+    const writeStream = fs.createWriteStream(`${topic.replace('/', '_')}_bag_${timestamp}.json`);
+
+    let lastTimestamp = null;
+
+    const callback = function (msg) {
+      const timestamp = Date.now();
+      const delay = lastTimestamp !== null ? timestamp - lastTimestamp : 0;
+      lastTimestamp = timestamp;
+
+      const record = { msg, delay };
+      writeStream.write(JSON.stringify(record) + '\n');
+    };
+
+
+    setTimeout(() => {
+      writeStream.end();
+      console.log('Recording stopped and file saved.');
+      process.exit();
+    }, timeout);
+
+    openSub(master_ip, topic, msg_type, callback);
+    setTimeout(() => {
+      console.log('\nRecording has started. Press Ctrl+C to stop and save the file');
+    }, 1000);
+
+    process.on('SIGINT', () => {
+      writeStream.end();
+      console.log('Recording stopped and file saved.');
+      process.exit();
+    });
+  });
+
+
+
+
+const readline = require('readline');
+const e = require('express');
+
+program
+  .command('play <bagfile> <topic>')
+  .description('Play messages from a bag file to a NEP+ topic')
+  .action(async (bagfile, topic) => {
+    const allowedFormats = ["json", "msgpack", "bytes", "images", "dictionary", "string"];
+    const master_ip = "127.0.0.1";
+
+    const requester = createRequester(master_ip, PORT_MASTER_INFO);
+    const results = await sendRequest(requester, { "input": "topics" });
+
+    topic = await selectTopic(results, topic);
+
+    const node = new nep.Node("nep-cli-pub");
+    const pub = node.new_pub(topic, "json");
+
+    const readInterface = readline.createInterface({
+      input: fs.createReadStream(bagfile),
+      console: false
+    });
+
+    let records = [];
+
+    readInterface.on('line', function (line) {
+      const record = JSON.parse(line);
+      records.push(record);
+    });
+
+    readInterface.on('close', function () {
+      let index = 0;
+
+      setTimeout(() => {
+        console.log("\nPublishing messages from bag file. Press Ctrl+C to stop.");
+      }, 500);
+
+
+      function publishNext() {
+        if (index < records.length) {
+          const record = records[index];
+          pub.publish(record.msg);
+          index++;
+          let delay = 0;
+          if (index < records.length) {
+            delay = records[index].delay;
+          }
+          setTimeout(publishNext, delay);
+        } else {
+          process.exit();
+        }
+      }
+
+      publishNext();
+    });
+  });
+
+
+
+program
+  .command('app')
+  .description('Open NEP+ App (only if installed)')
+  .action(() => {
+    // Get the username of the logged-in user
+    const username = os.userInfo().username;
+
+    // Specify the path to the executable
+    const appFolderName = 'nepplus-app';
+    const executableName = 'nepplus-app.exe';
+    const executablePath = `C:\\Users\\${username}\\AppData\\Local\\Programs\\${appFolderName}\\${executableName}`;
+
+    // Run the executable with proper escaping
+    exec(`"${executablePath}"`, (error, stdout, stderr) => {
+      if (error) {
+        console.error(`Error: ${error.message}`);
+        return;
+      }
+      console.log(`stdout: ${stdout}`);
+      console.error(`stderr: ${stderr}`);
+    });
+  });
+
+
+program
+  .command('open [programName]')
+  .description('Open a NEP+ GUIs (only if installed)')
+  .action(async (programName) => {
+    const programs = ['cameras', 'hxri'];
+
+    // If a program name is provided as an argument, use it; otherwise, show autocomplete
+    if (!programName) {
+      try {
+        const autoComplete = new AutoComplete({
+          name: 'program',
+          message: 'Select a program:',
+          choices: programs,
+        });
+        programName = await autoComplete.run();
+      } catch (error) {
+        process.exit(1);
+      }
+    } else if (!programs.includes(programName)) {
+
+      try {
+        const autoComplete = new AutoComplete({
+          name: 'program',
+          message: 'Invalid program name. Select a valid program:',
+          choices: programs,
+        });
+        programName = await autoComplete.run();
+      } catch (error) {
+        process.exit(1);
+      }
+    }
+
+    // Get the username of the logged-in user
+    const username = os.userInfo().username;
+
+    // Specify the path to the executable
+    const appFolderName = 'nepplus' + "-" + programName;
+    const executableName = 'nepplus' + "-" + `${programName}.exe`;
+    const executablePath = `C:\\Users\\${username}\\AppData\\Local\\Programs\\${appFolderName}\\${executableName}`;
+
+    // Run the executable with proper escaping
+    exec(`"${executablePath}"`, (error, stdout, stderr) => {
+      if (error) {
+        console.error(`Error: ${error.message}`);
+        return;
+      }
+      console.log(`stdout: ${stdout}`);
+      console.error(`stderr: ${stderr}`);
+    });
+  });
 
 program
   .command('docs')