nep-cli 0.2.4 → 0.2.6

package/bin/index.js

@@ -9,6 +9,7 @@ var nep_configuration = { current_port: 50200, IP: "0.0.0.0", brokers: {} }
 const { exec } = require('child_process');
 const { AutoComplete } = require('enquirer');
 
+
 const open = require('open'); // Import the 'open' package
 
 const express = require('express');
@@ -17,10 +18,44 @@ const socketIo = require('socket.io');
 const fs = require ('fs');
 const zmqc = require("zeromq/v5-compat");
 
+
 const PORT_MASTER_INFO = 50001; // Default port for master info
 const PORT_SERVER = 50050;
 
 
+const JSON5 = require('json5');
+
+// --- helpers local to this command (do NOT change selectTopic) ---
+function normalizeResults(results) {
+  if (!Array.isArray(results?.input)) return results;
+  const normalized = results.input.map(item => {
+    if (typeof item === 'string') return item;
+    if (item && typeof item === 'object') {
+      // prefer common fields; last fallback prints the whole object as JSON
+      return item.topic || item.name || item.path || item.id || JSON.stringify(item);
+    }
+    return String(item);
+  });
+  return { ...results, input: normalized };
+}
+
+function inferTypeFromSuffix(topic, allowed) {
+  const last = String(topic).split('/').pop().toLowerCase();
+  return allowed.includes(last) ? last : null; // infer only; do NOT strip from topic
+}
+
+function parseFlexibleJSON(src) { try { return JSON.parse(src); } catch { return JSON5.parse(src); } }
+
+
+async function readAllFromStdin() {
+  return await new Promise((resolve, reject) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', chunk => data += chunk);
+    process.stdin.on('end', () => resolve(data.trim()));
+    process.stdin.on('error', reject);
+  });
+}
 
 program
   .version(version)
@@ -32,37 +67,76 @@ program
   .description('Display current Wi-Fi and Ethernet IP addresses of this computer')
   .action(() => {
     try {
-      // subsitude by interfaces = nep.getNetworkInterfaces --> {"wifi":wifiInterfaces, "eth":ethernetInterface}
       const platform = os.platform();
-      let wifiInterfaces, ethernetInterface;
-
-      if (platform === 'linux') {
-        wifiInterfaces = Object.keys(os.networkInterfaces()).filter(ifname => /^(wlan|wlp|wl|en)\d*$/i.test(ifname));
-        ethernetInterface = Object.keys(os.networkInterfaces()).find(ifname => /^(eth|enp|eno)\d*$/i.test(ifname));
-      } else if (platform === 'win32') {
-        wifiInterfaces = Object.keys(os.networkInterfaces()).filter(ifname => /^(Wireless|Wi-Fi)/i.test(ifname));
-        ethernetInterface = Object.keys(os.networkInterfaces()).find(ifname => /^Ethernet/i.test(ifname));
-      } else if (platform === 'darwin') {
-        wifiInterfaces = Object.keys(os.networkInterfaces()).filter(ifname => /^en\d*$/i.test(ifname));
-        ethernetInterface = Object.keys(os.networkInterfaces()).find(ifname => /^en\d*$/i.test(ifname));
-      } else {
-        console.log('Unsupported operating system.');
-        return;
+      const names = Object.keys(os.networkInterfaces());
+
+      // Name patterns (broad & locale-friendly)
+      const PATS = {
+        wifi: [
+          /wi-?fi/i, /wireless/i, /wlan/i,
+          /ワイヤレス/i, /無線/i
+        ],
+        eth: [
+          /ethernet/i, /イーサネット/i, /有線/i, /lan/i,
+          /^eth\d+/i, /^enp\d+/i, /^eno\d+/i, /^en\d+$/i // Linux/mac
+        ],
+      };
+
+      // Helper: get IPv4 addresses for a given interface name
+      const ipv4s = (ifname) =>
+        (os.networkInterfaces()[ifname] || [])
+          .filter(a => a.family === 'IPv4' && !a.internal)
+          .map(a => a.address);
+
+      // Matchers
+      const matchAny = (str, regexes) => regexes.some(r => r.test(str));
+
+      // Candidate sets
+      let wifiIfs = names.filter(n => matchAny(n, PATS.wifi));
+      let ethIfs  = names.filter(n => matchAny(n, PATS.eth));
+
+      // Windows special: accept numbered “Ethernet 2 / イーサネット 2”
+      if (platform === 'win32') {
+        const winEthWide = /^(Ethernet|イーサネット)(\s*\d+)?$/i;
+        const winWiFiWide = /^(Wi-?Fi|Wireless|WLAN|ワイヤレス|無線)(\s*\d+)?$/i;
+        ethIfs = [...new Set([...ethIfs, ...names.filter(n => winEthWide.test(n))])];
+        wifiIfs = [...new Set([...wifiIfs, ...names.filter(n => winWiFiWide.test(n))])];
       }
 
-      wifiInterfaces.forEach(wifiInterface => {
-        const ipAddress = nep.getIPAddress(wifiInterface);
-        nep.printIPAddress(`Wi-Fi (${wifiInterface})`, ipAddress);
+      // Print Wi-Fi(s)
+      let printed = false;
+      wifiIfs.forEach(ifn => {
+        const addrs = ipv4s(ifn);
+        addrs.forEach(ip => {
+          printed = true;
+          nep.printIPAddress(`Wi-Fi (${ifn})`, ip);
+        });
       });
 
-      nep.printIPAddress('Ethernet', nep.getIPAddress(ethernetInterface));
-    } catch (error) {
-      console.error('An error occurred:', error.message);
+      // Print Ethernet(s)
+      ethIfs.forEach(ifn => {
+        const addrs = ipv4s(ifn);
+        addrs.forEach(ip => {
+          printed = true;
+          nep.printIPAddress(`Ethernet (${ifn})`, ip);
+        });
+      });
+
+      // Fallback: if nothing matched, dump all non-internal IPv4s
+      if (!printed) {
+        names.forEach(ifn => {
+          const addrs = ipv4s(ifn);
+          addrs.forEach(ip => nep.printIPAddress(`${ifn}`, ip));
+        });
+      }
+    } catch (err) {
+      console.error('An error occurred:', err.message);
     }
   });
 
 
 
+
 // Node saved here
 var nodes_register = {};
 // ----------- Main variables ---------------
@@ -578,7 +652,7 @@ program
   .action(async (topic, index) => {
     const ip = "127.0.0.1";
 
-    const allowedFormats = ["json", "msgpack", "bytes", "images", "dictionary", "string"];
+    const allowedFormats = ["json", "msgpack", "bytes", "images", "dictionary"];
     const master_ip = "127.0.0.1";
 
     const requester = createRequester(master_ip, PORT_MASTER_INFO);
@@ -599,7 +673,7 @@ program
         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" || msg_type === "msgpack") {
         open(`http://localhost:${port}/?port=${port}&topic=${encodeURIComponent(topicid)}`);
         startJsonServer(port, topic, ip, msg_type);
       }
@@ -783,52 +857,167 @@ program
     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) => {
+  .command('pub <topic>')
+  .description(
+    'Publish JSON/JSON5 to a NEP+ topic.\n\n' +
+    'Input can come from --json, --file, or piped stdin.\n\n' +
+    'Examples:\n' +
+    '  nep pub test/json --json "{value:1, txt:\'hello\'}"\n' +
+    '  nep pub test/json --file payload.json5\n' +
+    '  echo {value:1, txt:"hello"} | nep pub test/json\n'
+  )
+  .option('-j, --json <text>', 'JSON/JSON5 string (allows single quotes, unquoted keys)')
+  .option('-f, --file <path>', 'Read payload from a file')
+  .option('--pretty', 'Pretty-print parsed JSON before publishing')
+  .action(async (topic, opts) => {
+    try {
+      let text = null;
 
-    var openpub = function (master_ip = "127.0.0.1") {
+      if (opts.json && opts.file) {
+        console.error('Please provide only one of --json or --file (or use stdin).');
+        process.exit(2);
+      }
 
-      var pubFunction = function () {
+      if (opts.json) {
+        text = opts.json;
+      } else if (opts.file) {
+        text = fs.readFileSync(opts.file, 'utf8');
+      } else if (!process.stdin.isTTY) {
+        text = await readAllFromStdin(); // supports: echo {...} | nep pubj test
+      } else {
+        console.error('No input provided. Use --json, --file, or pipe data via stdin.');
+        process.exit(2);
+      }
 
-        var msg = message.replace(/'/g, '"')
-        console.log(JSON.parse(msg))
-        pub.publish(JSON.parse(msg))
-        console.log("Message published")
+      let payload;
+      try {
+        payload = parseFlexibleJSON(text);
+      } catch (err) {
+        console.error('Failed to parse input as JSON/JSON5:');
+        console.error(err.message);
+        process.exit(2);
+      }
 
-        process.exit(1)
+      if (opts.pretty) {
+        console.log('Parsed payload:');
+        console.log(JSON.stringify(payload, null, 2));
       }
 
+      const node = new nep.Node('nep-cli-pubj');
+      const pub  = node.new_pub(topic, 'json');
 
-      var node = new nep.Node("nep-cli-pub")
-      var pub = node.new_pub(topic, "json")
-      setTimeout(pubFunction, 1000)
+      // give a moment for transport to connect
+      setTimeout(() => {
+        pub.publish(payload);
+        console.log('Message published to', topic);
+        process.exit(0);
+      }, 500);
+    } catch (e) {
+      console.error('Error:', e.message);
+      process.exit(1);
     }
+  });
 
-    async function run() {
-      var requester = new zmq.Request;
-      var master_ip = "127.0.0.1"
+  
+program
+  .command('publish [topic] [message...]')
+  .description(
+    'Publish to a registered NEP+ topic.\n\n' +
+    'Examples:\n' +
+    '  nep publish                     # select topic & type, then enter payload\n' +
+    '  nep publish test/json "{number:1, txt:\'hello\'}"   # publishes TO topic "test/json"\n'
+  )
+  .action(async (topicArg, messageParts) => {
+    const allowedFormats = ["json", "msgpack", "bytes", "images", "dictionary", "string"];
+    const master_ip = "127.0.0.1";
 
-      requester.connect("tcp://" + master_ip + ":" + PORT_MASTER_INFO);
+    // 1) Fetch topics from master
+    const requester = createRequester(master_ip, PORT_MASTER_INFO);
+    const resultsRaw = await sendRequest(requester, { "input": "topics" });
 
-      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");
+    // 2) Normalize ONLY for this command (leave selectTopic untouched elsewhere)
+    const results = normalizeResults(resultsRaw);
+    console.log(results);
+
+    // 3) Let the user select a registered topic (reuses your existing selectTopic)
+    const selectedTopic = await selectTopic(results, topicArg);
+
+  
+
+    // 5) Determine message type
+    let msg_type = inferTypeFromSuffix(selectedTopic, allowedFormats);
+    if (!msg_type) {
+      msg_type = await selectMsgType(allowedFormats, null, selectedTopic);
+    }
+
+    // 6) Acquire payload (CLI arg or prompt)
+    let messageText = Array.isArray(messageParts) ? messageParts.join(' ') : (messageParts || '');
+    if (!messageText || messageText.trim() === '') {
+      const prompt = new Input({
+        name: 'payload',
+        message:
+          msg_type === 'string' ? 'Enter STRING payload:'
+          : msg_type === 'bytes' ? 'Enter BYTES payload (base64-encoded):'
+          : `Enter ${msg_type.toUpperCase()} payload (JSON/JSON5 allowed):`
+      });
+      messageText = await prompt.run();
+    }
+    const src = messageText.trim();
+
+    // 7) Build payload by type
+    let payload;
+    try {
+      if (msg_type === 'string') {
+        payload = src;
+      } else if (msg_type === 'bytes') {
+        payload = Buffer.from(src, 'base64');
+      } else {
+        // json / dictionary / msgpack / images → parse as JSON/JSON5
+        payload = parseFlexibleJSON(src);
       }
+    } catch (e) {
+      console.error('Failed to parse payload. Tip: use `nep pubj` for stdin/files.\n', e.message);
+      process.exit(2);
     }
-    run()
+
+    // 8) Publish to the EXACT selected topic (no stripping of suffix)
+    const node = new nep.Node('nep-cli-pub');
+    const conf = node.hybrid(master_ip);
+    const pub  = node.new_pub(selectedTopic, msg_type, conf);
+
+    setTimeout(() => {
+      pub.publish(payload);
+      console.log(`Published to "${selectedTopic}" as ${msg_type}`);
+      process.exit(0);
+    }, 500);
   });
+  
+program
+.command('test [master_ip]')
+.description('Publish "hello world" to the specified IP. If no IP is provided, the default is 127.0.0.1')
+.action((master_ip = "127.0.0.1") => {
+
+  var openpub = function (master_ip) {
+
+    var pubFunction = function () {
+
+      var msg = { "message": "hello world" }
+      console.log("Messgae published: " + JSON.stringify(msg) + " to " + master_ip) 
+      pub.publish(msg)
+
+      process.exit(1)
+    }
+
+    var node = new nep.Node("nep-cli-test")
+    const conf = node.hybrid(master_ip);
+    var pub = node.new_pub("test", "json", conf)
+    setTimeout(pubFunction, 1000)
+  }
+
+  openpub(master_ip)
+
+});
 
 
 const { Input } = require('enquirer');

package/package.json

@@ -1,21 +1,21 @@
 {
   "name": "nep-cli",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "main": "./lib/nep.js",
   "bin": {
-    "nep": "./bin/index.js"
+    "nep": "bin/index.js"
   },
   "keywords": [],
   "author": "Enrique Coronado <enriquecoronadozu@gmail.com> (https://enriquecoronadozu.github.io/NEP/)",
   "license": "ISC",
   "dependencies": {
-    "commander": "^11.0.0",
+    "commander": "^14.0.3",
     "enquirer": "^2.4.1",
     "express": "^4.18.2",
-    "nep-js": "^0.3.8",
+    "json5": "^2.2.3",
+    "nep-js": "^0.4.0",
     "open": "7.4.2",
-    "socket.io": "^4.7.2",
-    "zeromq": "6.0.0-beta.19"
+    "socket.io": "4.8.3",
+    "zeromq": "6.5.0"
   }
 }
-