nep-cli 0.2.1 → 0.2.3

package/bin/index.js

@@ -18,8 +18,8 @@ const fs = require('fs');
 const zmqc = require("zeromq/v5-compat");
 
 const PORT_MASTER_INFO = 50001; // Default port for master info
-const PORT_IMAGES = 50060;
-const PORT_JSON = 50080;
+const PORT_SERVER = 50050;
+
 
 
 program
@@ -78,7 +78,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,109 +121,173 @@ var onRegisteredTopic = function (node_request, topic_register, topic) {
 }
 
 
-var onResetTopic = function (node_request) {
-
-  var topic = node_request["topic"]
-  nep_configuration["current_port"] = Math.max(nep_configuration["current_port"], node_request["port"] + 2);
-
-  if (node_request["socket"] === "publisher" || node_request["socket"] === "subscriber") {
-    // Create new broker for many2many communication
-    if (node_request["mode"] === "many2many") {
-      restartBroker(node_request["topic"], node_request["port"]);
-    }
-
-    if ("msg_type" in node_request) {
-      topic_register[topic] = { "port": node_request["port"], "socket": node_request["socket"], 'ip': nep_configuration["IP"], "mode": node_request["mode"], "msg_type": node_request["msg_type"] }
-    }
-    else {
-      topic_register[topic] = { "port": node_request["port"], "socket": node_request["socket"], 'ip': nep_configuration["IP"], "mode": node_request["mode"], "msg_type": "json" }
-    }
-
-    topic_register[topic]["nodes"] = [];
-  }
-
-}
+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 restartBroker = function (topic, port) {
-  try {
-    var broker = new nep.Broker(nep_configuration["IP"], port + 1, port)
-    //var brokersubex = new BrokerBridgeSUBEX(conf["IP"],IP_EXTERNAL, conf["current_port"] , conf["current_port"])
-    // Add broker defined to list of brokers
-    nep_configuration["brokers"][topic] = broker
-  } catch (error) {
-    console.log("NEP ERROR: ports " + String(port) + " and " + String(port + 1) + " not avaliable")
+  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;
+      }
+    }
   }
-}
 
-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"] }
-  }
-  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" }
@@ -239,27 +304,16 @@ var updatePID = function (node_request, topic_register, topic) {
 }
 
 
-var restartTopics = function (node_request) {
-  console.log(node_request)
-  // Get topic name
-  var topic = String(node_request['topic'])
-
-  console.log(" --- Reset topic : *" + topic + "* ---")
-  // Create new broker
-  onResetTopic(node_request);
-  onUpdateTopicList(topic_register)
-}
-
-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')) {
@@ -269,7 +323,7 @@ const processMsg = (json_msg, nodes_register, topic_register) => {
         }
       }
     } else {
-      console.log(`--- New Node *${node}* ---`);
+      console.log(`NODE: *${node}* was registered`);
     }
   }
 
@@ -279,14 +333,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);
   }
 };
@@ -297,6 +351,10 @@ function startShowServer(port, topic, ip) {
   const io = socketIo(server);
   const path = require('path');
 
+  // Serve static files from node_modules
+  app.use(express.static(path.join(__dirname)));
+
+
   const node = new nep.Node("nep-cli-sub");
   const config = node.hybrid(ip)
 
@@ -330,6 +388,7 @@ function startJsonServer(port, topic, ip, msg_type = "json") {
   const server = http.createServer(app);
   const io = socketIo(server);
   const path = require('path');
+  app.use(express.static(path.join(__dirname)));
 
   const node = new nep.Node("nep-cli-sub");
   const config = node.hybrid(ip)
@@ -364,76 +423,83 @@ function startJsonServer(port, topic, ip, msg_type = "json") {
 }
 
 
-program
-  .command('app')
-  .description('Open NEP+ App')
-  .action(() => {
-    // Get the username of the logged-in user
-    const username = os.userInfo().username;
+const createRequester = (master_ip, port) => {
+  const requester = new zmq.Request();
+  requester.connect(`tcp://${master_ip}:${port}`);
+  return requester;
+};
 
-    // 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}`;
+const sendRequest = async (requester, msg) => {
+  const message = JSON.stringify(msg);
+  await requester.send(message);
+  const [result] = await requester.receive();
+  return JSON.parse(result.toString());
+};
 
-    // 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}`);
+const selectTopic = async (results, topic) => {
+  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);
+  }
+};
+
+const selectIndex = async (index, maxIndex = 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();
 
+    return index;
+  } catch (error) {
+    process.exit(1);
+  }
+};
 
-program
-  .command('open [programName]')
-  .description('Open a NEP+ GUI')
-  .action(async (programName) => {
-    const programs = ['cameras', 'hxri'];
+const selectMsgType = async (allowedFormats, msg_type, topic) => {
+  try {
+    var msgType = topic.split('/').pop();
+    if (msgType && msgType !== topic) {
+      msg_type = msgType;
+    }
 
-    // If a program name is provided as an argument, use it; otherwise, show autocomplete
-    if (!programName) {
+    if (!msg_type || !allowedFormats.includes(msg_type)) {
       const autoComplete = new AutoComplete({
-        name: 'program',
-        message: 'Select a program:',
-        choices: programs,
+        name: 'msg_type',
+        message: !msg_type ? 'Select a message type:' : `Select a valid format:`,
+        choices: allowedFormats,
       });
-      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();
+      msg_type = await autoComplete.run();
     }
+    return msg_type;
+  } 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}`);
-    });
-  });
+const openSub = (master_ip, topic, msg_type, callback) => {
+  const node = new nep.Node("nep-cli-sub");
+  const conf = node.hybrid(master_ip);
+  const sub = node.new_sub(topic, msg_type, callback, conf);
+};
 
 
 program
   .command('master')
-  .description('Start NEP master in localhost')
+  .description('Start master for managing NEP+ topics')
   .action(async () => {
     try {
       var node = new nep.Node("nep-cli");
@@ -452,7 +518,7 @@ program
 
 program
   .command('topics')
-  .description('Get list of NEP+ topics')
+  .description('Displays the list of NEP+ topics')
   .action(async () => {
     const master_ip = "127.0.0.1";
     const TIMEOUT_DURATION = 5000; // Timeout duration in milliseconds
@@ -503,141 +569,118 @@ program
     await getTopics(); // Call the function to get topics
   });
 
-  program
-    .command('show <topic> <msg_type> [index]')
-    .description('Show images published to a NEP+ topic in the default browser')
-    .action(async (topic, msg_type, index = 0) => {
-      const ip = "127.0.0.1";
-      const topicid = `${topic}`;
-      const port = PORT_IMAGES + parseInt(index);
-
-      const allowedFormats = ["json", "images", "dictionary"];
-      if (!allowedFormats.includes(msg_type)) {
-        console.error(`Format '${msg_type}' no allowed. Allowed formats are: ${allowedFormats.join(', ')}`);
-        return;
-      }
+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. '
+  )
+  .action(async (topic, index) => {
+    const ip = "127.0.0.1";
 
-      if(msg_type === "images"){
+    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);
+    var msg_type = await selectMsgType(allowedFormats, msg_type, topic);
+    index = await selectIndex(index);
+
+    const topicid = `${index}: ${topic}`;
+    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);
       }
-      else if (msg_type === "json" || msg_type === "dictionary")
-      {
+      else if (msg_type === "json" || msg_type === "dictionary") {
         open(`http://localhost:${port}/?port=${port}&topic=${encodeURIComponent(topicid)}`);
         startJsonServer(port, topic, ip, msg_type);
       }
-    });
 
-program
-  .command('echo <topic> <msg_type>')
-  .description('Subscribe to a NEP+ topic and display raw string messages')
-  .action(async (topic, msg_type) => {
-
-
-
-    const allowedFormats = ["json", "msgpack", "bytes", "images", "dictionary", "string"];
-    if (!allowedFormats.includes(msg_type)) {
-      console.error(`Format '${msg_type}' no allowed. Allowed formats are: ${allowedFormats.join(', ')}`);
-      return;
+    }
+    else {
+      console.log("Index must be between 0 and 49");
     }
 
-    var opensub = function (master_ip = "127.0.0.1", msg_type) {
-      var callback = function (msg) {
-        var date = new Date();
-        var dateString = date.toISOString();
-        console.log(dateString);
+  });
 
-        if (msg.length > 10000) {
-          console.log("the message is too long to be displayed");
-        } else {
-          console.log(msg);
-        }
-      };
 
-      var node = new nep.Node("nep-cli-sub");
-      var conf = node.hybrid(master_ip);
-      sub = node.new_sub(topic, msg_type, callback, conf);
-    };
+program
+  .command('echo [topic]')
+  .description('Subscribe to a NEP+ topic and display raw string messages')
+  .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" });
 
-    var master_ip = "127.0.0.1";
-    async function run() {
-      var requester = new zmq.Request();
-      requester.connect("tcp://" + master_ip + ":" + PORT_MASTER_INFO);
+    topic = await selectTopic(results, topic);
+    msg_type = await selectMsgType(allowedFormats, msg_type, topic);
 
-      let msg = { "input": "topics" };
-      var message = JSON.stringify(msg);
-      await requester.send(message);
-      const [result] = await requester.receive();
-      var results = JSON.parse(result.toString());
+    const callback = (msg) => {
+      const date = new Date();
+      const dateString = date.toISOString();
+      console.log(dateString);
 
-      if (results["state"] === "failure") {
-        console.log("Topic is not registered");
+      if (msg.length > 10000) {
+        console.log("the message is too long to be displayed");
       } else {
-        console.log("");
-        if (results["input"].includes(topic)) {
-          opensub(master_ip, msg_type);
-        } else {
-          console.log("Topic is not registered");
-        }
+        console.log(msg);
       }
-    }
+    };
 
-    run();
+    openSub(master_ip, topic, msg_type, callback);
   });
 
 program
-  .command('hz <topic> <msg_type>')
-  .description('Monitor the publishing rate of a NEP+ topic in localhost')
+  .command('hz [topic]')
+  .description('Monitor the publishing rate of a NEP+ topic')
   .action(async (topic, msg_type) => {
-    const interfaces = os.networkInterfaces();
-    const master_ip = "127.0.0.1"; // Change to the appropriate master IP
+    const allowedFormats = ["json", "msgpack", "bytes", "images", "dictionary", "string"];
+    const master_ip = "127.0.0.1";
 
-    const opensub = function () {
-      const timestamps = []; // To store message timestamps
+    const requester = createRequester(master_ip, PORT_MASTER_INFO);
+    const results = await sendRequest(requester, { "input": "topics" });
+    const timestamps = []; // Store timestamps of received messages
 
-      const callback = function (msg) {
-        const date = new Date();
-        const timestamp = date.getTime();
+    topic = await selectTopic(results, topic);
+    msg_type = await selectMsgType(allowedFormats, msg_type, topic);
 
-        timestamps.push(timestamp);
+    const callback = function (msg) {
+      const date = new Date();
+      const timestamp = date.getTime();
 
-        // Remove timestamps older than ten seconds
-        const tenSecondsAgo = timestamp - 10000;
-        while (timestamps[0] < tenSecondsAgo) {
-          timestamps.shift();
-        }
-      };
+      timestamps.push(timestamp);
 
-      const allowedFormats = ["json", "msgpack", "bytes", "images", "dictionary", "string"];
-      if (!allowedFormats.includes(msg_type)) {
-        console.error(`Format '${msg_type}' no allowed. Allowed formats are: ${allowedFormats.join(', ')}`);
-        return;
+      // Remove timestamps older than ten seconds
+      const tenSecondsAgo = timestamp - 10000;
+      while (timestamps[0] < tenSecondsAgo) {
+        timestamps.shift();
       }
-      const node = new nep.Node("nep-cli-sub");
-      const conf = node.hybrid(master_ip);
-
-      console.log("Topic:", topic)
-      console.log("Message type:", msg_type)
+    };
 
-      const sub = node.new_sub(topic, msg_type, callback, conf);
+    setInterval(() => {
+      // Calculate statistics for the last 10 seconds
+      const now = Date.now();
+      const tenSecondsAgo = now - 10000;
+      const recentTimestamps = timestamps.filter((ts) => ts > tenSecondsAgo);
+      const rate = recentTimestamps.length / 10; // Messages per second for a 10-second window
+
+      console.log("Average rate:", rate.toFixed(2), "Hz");
+      console.log("Min:", (10 / Math.max(rate, 0.1)).toFixed(2), "s");
+      console.log("Max:", (10 / Math.min(rate, 10)).toFixed(2), "s");
+      console.log("Std dev:", calculateStdDev(recentTimestamps, now).toFixed(2), "s");
+      console.log("Window:", recentTimestamps.length);
       console.log("");
+    }, 1000);
 
-      setInterval(() => {
-        // Calculate statistics for the last 10 seconds
-        const now = Date.now();
-        const tenSecondsAgo = now - 10000;
-        const recentTimestamps = timestamps.filter((ts) => ts > tenSecondsAgo);
-        const rate = recentTimestamps.length / 10; // Messages per second for a 10-second window
-
-        console.log("Average rate:", rate.toFixed(2), "Hz");
-        console.log("Min:", (10 / Math.max(rate, 0.1)).toFixed(2), "s");
-        console.log("Max:", (10 / Math.min(rate, 10)).toFixed(2), "s");
-        console.log("Std dev:", calculateStdDev(recentTimestamps, now).toFixed(2), "s");
-        console.log("Window:", recentTimestamps.length);
-        console.log("");
-      }, 1000);
-    };
 
     const calculateStdDev = (timestamps) => {
       if (timestamps.length < 2) {
@@ -666,33 +709,330 @@ program
       return stdDeviation;
     };
 
+    openSub(master_ip, topic, msg_type, callback);
 
-    async function run() {
-      const requester = new zmq.Request();
-      requester.connect(`tcp://${master_ip}:${PORT_MASTER_INFO}`);
+  });
+
+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 msg = { "input": "topics" };
-      const message = JSON.stringify(msg);
-      await requester.send(message);
-      const [result] = await requester.receive();
-      const results = JSON.parse(result.toString());
+    const requester = createRequester(master_ip, PORT_MASTER_INFO);
+    const results = await sendRequest(requester, { "input": "topics" });
 
-      if (results["state"] === "failure") {
-        console.log("Topic is not registered, use *nep topics* to see the list of avaliable 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 {
-        console.log("");
-        if (results["input"].includes(topic)) {
-          opensub();
+        // 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] [msg_type] [timeout]')
+  .description('Record messages from a NEP+ topic to a file')
+  .action(async (topic, msg_type, timeout = 60000) => {
+    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);
+    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 {
-          console.log("Topic is not registered, use *nep topics* to see the list of avaliable topics");
+          process.exit();
         }
       }
-    }
 
-    run();
+      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')
   .description('Open the NEP+ documentation in the default browser')