netsweep 1.0.1 → 1.1.0

package/dist/index.js

@@ -5220,6 +5220,187 @@ function checkPort(host, port, timeout = 1000) {
   });
 }
 
+// src/scanners/wifi.ts
+async function getWifiInfo() {
+  let output = await exec("/System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources/airport -I");
+  if (output) {
+    return parseAirportOutput(output);
+  }
+  output = await exec("system_profiler SPAirPortDataType");
+  if (output) {
+    return parseSystemProfilerOutput(output);
+  }
+  return null;
+}
+function parseAirportOutput(output) {
+  const getValue = (key) => {
+    const match = output.match(new RegExp(`^\\s*${key}:\\s*(.+)$`, "m"));
+    return match ? match[1].trim() : "";
+  };
+  const ssid = getValue("SSID");
+  if (!ssid) {
+    return null;
+  }
+  const channel = parseInt(getValue("channel"), 10) || 0;
+  const signal = parseInt(getValue("agrCtlRSSI"), 10) || 0;
+  const noise = parseInt(getValue("agrCtlNoise"), 10) || 0;
+  const txRate = parseInt(getValue("lastTxRate"), 10) || 0;
+  return {
+    ssid,
+    bssid: getValue("BSSID"),
+    signal,
+    noise,
+    channel,
+    band: getBandFromChannel(channel),
+    txRate,
+    security: getValue("link auth") || "Unknown"
+  };
+}
+function parseSystemProfilerOutput(output) {
+  const currentNetMatch = output.match(/Current Network Information:\s*\n\s*(.+?):\s*\n([\s\S]*?)(?=\n\s+Other Local Wi-Fi Networks:|$)/);
+  if (!currentNetMatch) {
+    return null;
+  }
+  const ssid = currentNetMatch[1].trim();
+  const networkInfo = currentNetMatch[2];
+  const getValue = (key) => {
+    const match = networkInfo.match(new RegExp(`${key}:\\s*(.+)`, "i"));
+    return match ? match[1].trim() : "";
+  };
+  const channelStr = getValue("Channel");
+  const channelMatch = channelStr.match(/(\d+)\s*\((\d+)GHz/);
+  const channel = channelMatch ? parseInt(channelMatch[1], 10) : 0;
+  const bandGhz = channelMatch ? channelMatch[2] : "2.4";
+  const signalNoiseStr = getValue("Signal / Noise");
+  const signalMatch = signalNoiseStr.match(/(-?\d+)\s*dBm\s*\/\s*(-?\d+)\s*dBm/);
+  const signal = signalMatch ? parseInt(signalMatch[1], 10) : 0;
+  const noise = signalMatch ? parseInt(signalMatch[2], 10) : 0;
+  const txRate = parseInt(getValue("Transmit Rate"), 10) || 0;
+  return {
+    ssid,
+    bssid: "",
+    signal,
+    noise,
+    channel,
+    band: bandGhz === "5" ? "5 GHz" : bandGhz === "6" ? "6 GHz" : "2.4 GHz",
+    txRate,
+    security: getValue("Security") || "Unknown"
+  };
+}
+function getBandFromChannel(channel) {
+  if (channel >= 36 && channel <= 177) {
+    return "5 GHz";
+  } else if (channel > 177) {
+    return "6 GHz";
+  }
+  return "2.4 GHz";
+}
+function getSignalQuality(signal) {
+  if (signal >= -50)
+    return "Excellent";
+  if (signal >= -60)
+    return "Good";
+  if (signal >= -70)
+    return "Fair";
+  return "Weak";
+}
+
+// src/scanners/isp.ts
+async function getIspInfo() {
+  try {
+    const response = await fetch("http://ip-api.com/json");
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    return {
+      isp: data.isp || "Unknown",
+      asn: data.as ? data.as.split(" ")[0] : "Unknown",
+      country: data.country || "Unknown",
+      city: data.city || "Unknown",
+      lat: data.lat || 0,
+      lon: data.lon || 0
+    };
+  } catch {
+    return null;
+  }
+}
+function formatCoordinates(lat, lon) {
+  const latDir = lat >= 0 ? "N" : "S";
+  const lonDir = lon >= 0 ? "E" : "W";
+  return `${Math.abs(lat).toFixed(4)}° ${latDir}, ${Math.abs(lon).toFixed(4)}° ${lonDir}`;
+}
+
+// src/scanners/traceroute.ts
+async function runTraceroute(target = "1.1.1.1") {
+  const output = await exec(`traceroute -n -q 1 -m 15 ${target}`);
+  if (!output) {
+    return [];
+  }
+  const hops = [];
+  const lines = output.split(`
+`);
+  for (const line of lines) {
+    const match = line.match(/^\s*(\d+)\s+([\d.]+|\*)\s+([\d.]+)\s*ms/);
+    if (match) {
+      const hop = parseInt(match[1], 10);
+      const ip = match[2];
+      const latency = parseFloat(match[3]);
+      if (ip !== "*") {
+        hops.push({
+          hop,
+          ip,
+          latency
+        });
+      }
+    }
+  }
+  return hops;
+}
+function getMaxLatency(hops) {
+  if (hops.length === 0)
+    return 0;
+  return Math.max(...hops.map((h) => h.latency));
+}
+
+// src/scanners/health.ts
+var ENDPOINTS = [
+  { name: "Google", url: "https://www.google.com" },
+  { name: "Cloudflare", url: "https://1.1.1.1" },
+  { name: "GitHub", url: "https://github.com" },
+  { name: "AWS", url: "https://aws.amazon.com" }
+];
+async function checkEndpoint(name, url) {
+  const start = Date.now();
+  try {
+    const controller = new AbortController;
+    const timeoutId = setTimeout(() => controller.abort(), 5000);
+    const response = await fetch(url, {
+      method: "HEAD",
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    const latency = Date.now() - start;
+    return {
+      name,
+      url,
+      status: response.ok ? "up" : "down",
+      latency
+    };
+  } catch {
+    return {
+      name,
+      url,
+      status: "down",
+      latency: Date.now() - start
+    };
+  }
+}
+async function checkInternetHealth() {
+  const results = await Promise.all(ENDPOINTS.map(({ name, url }) => checkEndpoint(name, url)));
+  return results;
+}
+
 // node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
 var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
@@ -6516,11 +6697,14 @@ function formatLatency(ms) {
 function padRight(str, len) {
   return str.length >= len ? str.slice(0, len) : str + " ".repeat(len - str.length);
 }
+function padLeft(str, len) {
+  return str.length >= len ? str.slice(0, len) : " ".repeat(len - str.length) + str;
+}
 
 // src/ui/output.ts
 var BOX_WIDTH = 62;
 function header() {
-  console.log(boxen(source_default.bold.cyan("  NETPROBE - Network Diagnostics  "), {
+  console.log(boxen(source_default.bold.cyan("  NETSWEEP - Network Diagnostics  "), {
     padding: 0,
     margin: { top: 1, bottom: 0, left: 0, right: 0 },
     borderStyle: "round",
@@ -6617,6 +6801,53 @@ function truncate(str, len) {
 function stripAnsi2(str) {
   return str.replace(/\x1B\[[0-9;]*m/g, "");
 }
+function wifiSection(info) {
+  const quality = getSignalQuality(info.signal);
+  const qualityColor = quality === "Excellent" ? source_default.green : quality === "Good" ? source_default.yellow : source_default.red;
+  section("WIFI", [
+    `${source_default.gray("SSID:")}         ${source_default.white(info.ssid)}`,
+    `${source_default.gray("Signal:")}       ${source_default.white(`${info.signal} dBm`)} (${qualityColor(quality)})`,
+    `${source_default.gray("Noise:")}        ${source_default.white(`${info.noise} dBm`)}`,
+    `${source_default.gray("Channel:")}      ${source_default.white(`${info.channel}`)} (${source_default.white(info.band)})`,
+    `${source_default.gray("Tx Rate:")}      ${source_default.white(`${info.txRate} Mbps`)}`
+  ]);
+}
+function ispSection(info) {
+  section("ISP & LOCATION", [
+    `${source_default.gray("ISP:")}          ${source_default.white(info.isp)}`,
+    `${source_default.gray("ASN:")}          ${source_default.white(info.asn)}`,
+    `${source_default.gray("Location:")}     ${source_default.white(`${info.city}, ${info.country}`)}`,
+    `${source_default.gray("Coordinates:")}  ${source_default.white(formatCoordinates(info.lat, info.lon))}`
+  ]);
+}
+function tracerouteSection(hops, target) {
+  if (hops.length === 0) {
+    section(`TRACEROUTE (to ${target})`, [
+      source_default.gray("No hops recorded")
+    ]);
+    return;
+  }
+  const maxLatency = getMaxLatency(hops);
+  const maxBarWidth = 30;
+  const lines = hops.map((hop) => {
+    const hopNum = padLeft(String(hop.hop), 3);
+    const ip = padRight(hop.ip, 16);
+    const latency = padLeft(`${hop.latency.toFixed(1)}ms`, 8);
+    const barWidth = Math.ceil(hop.latency / maxLatency * maxBarWidth);
+    const bar = source_default.cyan("█".repeat(Math.max(1, barWidth)));
+    return `${source_default.white(hopNum)}  ${source_default.white(ip)}${source_default.white(latency)}   ${bar}`;
+  });
+  section(`TRACEROUTE (to ${target})`, lines);
+}
+function healthSection(checks) {
+  const lines = checks.map((check) => {
+    const name = padRight(check.name, 14);
+    const status = check.status === "up" ? source_default.green("✓") : source_default.red("✗");
+    const latency = check.status === "up" ? `${check.latency}ms` : "timeout";
+    return `${source_default.white(name)}${status}  ${source_default.white(latency)}`;
+  });
+  section("INTERNET HEALTH", lines);
+}
 function outputJson(results) {
   console.log(JSON.stringify(results, null, 2));
 }
@@ -7483,6 +7714,44 @@ async function scan(options) {
       results.ports = await scanPorts(results.gateway);
     } catch {}
   }
+  if (options.wifi) {
+    if (!options.json) {
+      updateSpinner("Getting WiFi info...");
+    }
+    try {
+      const wifi = await getWifiInfo();
+      if (wifi) {
+        results.wifi = wifi;
+      }
+    } catch {}
+  }
+  if (options.isp) {
+    if (!options.json) {
+      updateSpinner("Getting ISP info...");
+    }
+    try {
+      const isp = await getIspInfo();
+      if (isp) {
+        results.isp = isp;
+      }
+    } catch {}
+  }
+  if (options.trace) {
+    if (!options.json) {
+      updateSpinner("Running traceroute...");
+    }
+    try {
+      results.traceroute = await runTraceroute();
+    } catch {}
+  }
+  if (options.health) {
+    if (!options.json) {
+      updateSpinner("Checking internet health...");
+    }
+    try {
+      results.health = await checkInternetHealth();
+    } catch {}
+  }
   stopSpinner();
   if (options.json) {
     outputJson(results);
@@ -7500,33 +7769,53 @@ async function scan(options) {
     if (results.ports !== undefined && results.gateway) {
       portsSection(results.ports, results.gateway);
     }
+    if (results.wifi) {
+      wifiSection(results.wifi);
+    }
+    if (results.isp) {
+      ispSection(results.isp);
+    }
+    if (results.traceroute) {
+      tracerouteSection(results.traceroute, "1.1.1.1");
+    }
+    if (results.health) {
+      healthSection(results.health);
+    }
   }
 }
 
 // src/index.ts
 var args = process.argv.slice(2);
-if (args.includes("--help") || args.includes("-h")) {
+if (args.includes("--help")) {
   console.log(`
-  ${"\x1B[36m"}netprobe${"\x1B[0m"} - Network Swiss Army Knife
+  ${"\x1B[36m"}netsweep${"\x1B[0m"} - Network Swiss Army Knife
 
-  ${"\x1B[1m"}Usage:${"\x1B[0m"} netprobe [options]
+  ${"\x1B[1m"}Usage:${"\x1B[0m"} netsweep [options]
 
   ${"\x1B[1m"}Options:${"\x1B[0m"}
     --all, -a         Run all scans (default)
     --devices, -d     Only scan for devices
     --speed, -s       Only run speed test
     --ports, -p       Only scan gateway ports
+    --wifi, -w        Show WiFi info
+    --isp, -i         Show ISP & geolocation
+    --trace, -r       Run traceroute to 1.1.1.1
+    --health          Check internet health
     --target, -t <ip> Scan specific IP for ports
     --json            Output as JSON
-    --help, -h        Show help
+    --help            Show help
 
   ${"\x1B[1m"}Examples:${"\x1B[0m"}
-    netprobe              Full network scan
-    netprobe -d           List network devices only
-    netprobe -s           Speed test only
-    netprobe -p           Scan gateway ports
-    netprobe -p -t 192.168.0.7   Scan ports on specific host
-    netprobe --json       Output results as JSON
+    netsweep              Full network scan
+    netsweep -d           List network devices only
+    netsweep -s           Speed test only
+    netsweep -p           Scan gateway ports
+    netsweep -w           Show WiFi signal info
+    netsweep --isp        Show ISP and location
+    netsweep --trace      Run traceroute
+    netsweep --health     Check major services
+    netsweep -p -t 192.168.0.7   Scan ports on specific host
+    netsweep --json       Output results as JSON
 `);
   process.exit(0);
 }
@@ -7535,12 +7824,16 @@ var targetIndex = args.findIndex((a) => a === "-t" || a === "--target");
 if (targetIndex !== -1 && args[targetIndex + 1]) {
   target = args[targetIndex + 1];
 }
-var hasSpecificFlags = args.includes("-d") || args.includes("--devices") || args.includes("-s") || args.includes("--speed") || args.includes("-p") || args.includes("--ports");
+var hasSpecificFlags = args.includes("-d") || args.includes("--devices") || args.includes("-s") || args.includes("--speed") || args.includes("-p") || args.includes("--ports") || args.includes("-w") || args.includes("--wifi") || args.includes("-i") || args.includes("--isp") || args.includes("-r") || args.includes("--trace") || args.includes("--health");
 var runAll = args.includes("-a") || args.includes("--all") || !hasSpecificFlags;
 await scan({
   devices: runAll || args.includes("-d") || args.includes("--devices"),
   speed: runAll || args.includes("-s") || args.includes("--speed"),
   ports: runAll || args.includes("-p") || args.includes("--ports"),
+  wifi: runAll || args.includes("-w") || args.includes("--wifi"),
+  isp: runAll || args.includes("-i") || args.includes("--isp"),
+  trace: runAll || args.includes("-r") || args.includes("--trace"),
+  health: runAll || args.includes("--health"),
   json: args.includes("--json"),
   target
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "netsweep",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Network Swiss Army Knife - CLI tool for comprehensive network diagnostics",
   "type": "module",
   "bin": {