@johannes-berggren/netprobe 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Johannes Berggren
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,122 @@
+# netprobe
+
+Network Swiss Army Knife - A single command for comprehensive network diagnostics.
+
+```
+╭──────────────────────────────────╮
+│  NETPROBE - Network Diagnostics  │
+╰──────────────────────────────────╯
+┌─ CONNECTION ────────────────────────────────────────────────┐
+│  Interface:    Wi-Fi (en0)                                   │
+│  Local IP:     192.168.0.31                                  │
+│  Gateway:      192.168.0.1                                   │
+│  External IP:  85.123.45.67                                  │
+│  DNS:          1.1.1.1, 8.8.8.8                              │
+└──────────────────────────────────────────────────────────────┘
+┌─ SPEED ─────────────────────────────────────────────────────┐
+│  ↓ Download:   245.3 Mbps                                    │
+│  ↑ Upload:     48.7 Mbps                                     │
+│  Latency:      12ms (jitter: 2.3ms)                          │
+└──────────────────────────────────────────────────────────────┘
+┌─ DEVICES (4 found) ─────────────────────────────────────────┐
+│ IP              │ MAC                │ Vendor       │ Name   │
+├─────────────────┼────────────────────┼──────────────┼────────┤
+│ 192.168.0.1     │ F0:81:75:22:32:22  │ Sagemcom     │ -      │
+│ 192.168.0.7     │ 00:17:88:2E:09:31  │ Philips      │ -      │
+│ 192.168.0.31    │ 80:A9:97:35:64:71  │ Apple        │ This Mac│
+└─────────────────┴────────────────────┴──────────────┴────────┘
+┌─ GATEWAY PORTS (192.168.0.1) ───────────────────────────────┐
+│  53/tcp    DNS       OPEN                                    │
+│  80/tcp    HTTP      OPEN                                    │
+└──────────────────────────────────────────────────────────────┘
+```
+
+## Features
+
+- **Connection Info** - Local IP, gateway, external IP, DNS servers
+- **Device Discovery** - Find all devices on your network via ARP with vendor identification
+- **Speed Test** - Download/upload speeds and latency via Cloudflare
+- **Port Scanner** - Scan common ports on any host
+- **Beautiful Output** - Clean terminal UI with colors and tables
+- **JSON Output** - Pipe results to other tools
+
+## Installation
+
+### Using Bun (recommended)
+
+```bash
+# Run directly without installing
+bunx @jberggren/netprobe
+
+# Or install globally
+bun install -g @jberggren/netprobe
+netprobe
+```
+
+### Using npm
+
+```bash
+# Run directly
+npx @jberggren/netprobe
+
+# Or install globally
+npm install -g @jberggren/netprobe
+netprobe
+```
+
+### From source
+
+```bash
+git clone https://github.com/jberggren/netprobe.git
+cd netprobe
+bun install
+bun link
+netprobe
+```
+
+## Usage
+
+```bash
+# Full network scan (connection, speed, devices, ports)
+netprobe
+
+# Individual scans
+netprobe -d          # Devices only
+netprobe -s          # Speed test only
+netprobe -p          # Gateway ports only
+
+# Scan specific host
+netprobe -p -t 192.168.0.7
+
+# JSON output for scripting
+netprobe --json
+netprobe -d --json | jq '.devices[] | select(.vendor == "Apple")'
+```
+
+## Options
+
+| Flag | Short | Description |
+|------|-------|-------------|
+| `--all` | `-a` | Run all scans (default) |
+| `--devices` | `-d` | Scan for network devices |
+| `--speed` | `-s` | Run speed test |
+| `--ports` | `-p` | Scan gateway ports |
+| `--target <ip>` | `-t` | Scan specific IP for ports |
+| `--json` | | Output as JSON |
+| `--help` | `-h` | Show help |
+
+## Requirements
+
+- **Bun** >= 1.0 or **Node.js** >= 18
+- **macOS** (Linux support coming soon)
+
+## How it works
+
+- **Connection**: Uses `ipconfig`, `netstat`, and ipify.org API
+- **Devices**: Parses the ARP table with MAC vendor lookup (1000+ vendors)
+- **Speed**: Tests against Cloudflare's speed test endpoints
+- **Ports**: TCP connect scan on common service ports
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@johannes-berggren/netprobe",
+  "version": "1.0.0",
+  "description": "Network Swiss Army Knife - CLI tool for comprehensive network diagnostics",
+  "type": "module",
+  "bin": {
+    "netprobe": "./src/index.ts"
+  },
+  "scripts": {
+    "start": "bun run src/index.ts",
+    "dev": "bun run --watch src/index.ts"
+  },
+  "keywords": [
+    "network",
+    "diagnostics",
+    "cli",
+    "speed-test",
+    "port-scanner",
+    "arp",
+    "devices",
+    "terminal"
+  ],
+  "author": "Johannes Berggren",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Johannes-Berggren/netprobe.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Johannes-Berggren/netprobe/issues"
+  },
+  "homepage": "https://github.com/Johannes-Berggren/netprobe#readme",
+  "engines": {
+    "node": ">=18",
+    "bun": ">=1.0"
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "boxen": "^7.1.1",
+    "cli-table3": "^0.6.3",
+    "ora": "^8.0.1"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  }
+}

package/src/commands/scan.ts

@@ -0,0 +1,107 @@
+import { getConnectionInfo } from '../scanners/connection';
+import { scanDevices } from '../scanners/devices';
+import { runSpeedTest } from '../scanners/speed';
+import { scanPorts } from '../scanners/ports';
+import {
+  header,
+  connectionSection,
+  speedSection,
+  devicesSection,
+  portsSection,
+  outputJson,
+  type ScanResults,
+} from '../ui/output';
+import { startSpinner, updateSpinner, stopSpinner } from '../ui/spinner';
+
+export interface ScanOptions {
+  devices: boolean;
+  speed: boolean;
+  ports: boolean;
+  json: boolean;
+  target?: string;
+}
+
+export async function scan(options: ScanOptions): Promise<void> {
+  const results: ScanResults = {};
+
+  // Always get connection info first (needed for other scans)
+  if (!options.json) {
+    startSpinner('Getting connection info...');
+  }
+
+  try {
+    results.connection = await getConnectionInfo();
+    results.gateway = options.target || results.connection.gateway;
+  } catch (error) {
+    stopSpinner();
+    if (!options.json) {
+      console.error('Failed to get connection info');
+    }
+    return;
+  }
+
+  // Run device scan
+  if (options.devices) {
+    if (!options.json) {
+      updateSpinner('Scanning for devices...');
+    }
+    try {
+      results.devices = await scanDevices(results.connection.localIP);
+    } catch {
+      // Continue with other scans
+    }
+  }
+
+  // Run speed test
+  if (options.speed) {
+    if (!options.json) {
+      updateSpinner('Running speed test...');
+    }
+    try {
+      results.speed = await runSpeedTest((stage) => {
+        if (!options.json) {
+          updateSpinner(stage);
+        }
+      });
+    } catch {
+      // Continue with other scans
+    }
+  }
+
+  // Run port scan
+  if (options.ports && results.gateway) {
+    if (!options.json) {
+      updateSpinner(`Scanning ports on ${results.gateway}...`);
+    }
+    try {
+      results.ports = await scanPorts(results.gateway);
+    } catch {
+      // Continue
+    }
+  }
+
+  stopSpinner();
+
+  // Output results
+  if (options.json) {
+    outputJson(results);
+  } else {
+    header();
+
+    if (results.connection) {
+      connectionSection(results.connection);
+    }
+
+    if (results.speed) {
+      speedSection(results.speed);
+    }
+
+    if (results.devices) {
+      devicesSection(results.devices);
+    }
+
+    if (results.ports !== undefined && results.gateway) {
+      portsSection(results.ports, results.gateway);
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,52 @@
+#!/usr/bin/env bun
+import { scan } from './commands/scan';
+
+const args = process.argv.slice(2);
+
+if (args.includes('--help') || args.includes('-h')) {
+  console.log(`
+  ${'\x1b[36m'}netprobe${'\x1b[0m'} - Network Swiss Army Knife
+
+  ${'\x1b[1m'}Usage:${'\x1b[0m'} netprobe [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
+    --target, -t <ip> Scan specific IP for ports
+    --json            Output as JSON
+    --help, -h        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
+`);
+  process.exit(0);
+}
+
+// Parse target option
+let target: string | undefined;
+const targetIndex = args.findIndex(a => a === '-t' || a === '--target');
+if (targetIndex !== -1 && args[targetIndex + 1]) {
+  target = args[targetIndex + 1];
+}
+
+// Determine which scans to run
+const hasSpecificFlags = args.includes('-d') || args.includes('--devices') ||
+                         args.includes('-s') || args.includes('--speed') ||
+                         args.includes('-p') || args.includes('--ports');
+
+const 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'),
+  json: args.includes('--json'),
+  target,
+});

package/src/scanners/connection.ts

@@ -0,0 +1,33 @@
+import { exec } from '../utils/exec';
+
+export interface ConnectionInfo {
+  interface: string;
+  localIP: string;
+  gateway: string;
+  externalIP: string;
+  dns: string[];
+}
+
+export async function getConnectionInfo(): Promise<ConnectionInfo> {
+  // Try to find the active interface
+  const [localIPEn0, localIPEn1, gateway, externalIP, dns] = await Promise.all([
+    exec('ipconfig getifaddr en0'),
+    exec('ipconfig getifaddr en1'),
+    exec("netstat -nr | grep default | head -1 | awk '{print $2}'"),
+    fetch('https://api.ipify.org', { signal: AbortSignal.timeout(5000) })
+      .then(r => r.text())
+      .catch(() => 'Unknown'),
+    exec("scutil --dns | grep 'nameserver\\[' | head -4 | awk '{print $3}'"),
+  ]);
+
+  const localIP = localIPEn0.trim() || localIPEn1.trim() || 'Unknown';
+  const interfaceName = localIPEn0.trim() ? 'Wi-Fi (en0)' : localIPEn1.trim() ? 'Ethernet (en1)' : 'Unknown';
+
+  return {
+    interface: interfaceName,
+    localIP,
+    gateway: gateway.trim() || 'Unknown',
+    externalIP: externalIP.trim(),
+    dns: dns.trim().split('\n').filter(Boolean),
+  };
+}

package/src/scanners/devices.ts

@@ -0,0 +1,76 @@
+import { exec } from '../utils/exec';
+import { lookupVendor } from '../utils/vendor';
+
+export interface Device {
+  ip: string;
+  mac: string;
+  vendor: string;
+  hostname?: string;
+  isCurrentDevice?: boolean;
+}
+
+// Normalize MAC address to have leading zeros (0:17:88 -> 00:17:88)
+function normalizeMac(mac: string): string {
+  return mac
+    .split(':')
+    .map(part => part.padStart(2, '0'))
+    .join(':')
+    .toUpperCase();
+}
+
+// Check if IP is a multicast or broadcast address
+function isSpecialAddress(ip: string): boolean {
+  const firstOctet = parseInt(ip.split('.')[0]);
+  // Filter multicast (224-239), broadcast (.255), and link-local (169.254)
+  if (firstOctet >= 224 && firstOctet <= 239) return true;
+  if (ip.endsWith('.255')) return true;
+  if (ip.startsWith('169.254.')) return true;
+  return false;
+}
+
+export async function scanDevices(localIP?: string): Promise<Device[]> {
+  // Get current device's MAC
+  const ifconfigOutput = await exec('ifconfig en0 | grep ether');
+  const currentMacMatch = ifconfigOutput.match(/ether\s+([0-9a-f:]+)/i);
+  const currentMac = currentMacMatch ? normalizeMac(currentMacMatch[1]) : '';
+
+  // Read ARP table
+  const arpOutput = await exec('arp -a');
+
+  // Parse: "? (192.168.0.1) at f0:81:75:22:32:22 on en0 [ethernet]"
+  // or: "hostname (192.168.0.1) at f0:81:75:22:32:22 on en0 [ethernet]"
+  const devices = arpOutput
+    .split('\n')
+    .filter(line => line.includes(' at ') && !line.includes('incomplete'))
+    .map(line => {
+      const ipMatch = line.match(/\(([0-9.]+)\)/);
+      const macMatch = line.match(/at ([0-9a-f:]+)/i);
+      const hostMatch = line.match(/^(\S+)\s+\(/);
+
+      if (!ipMatch || !macMatch) return null;
+
+      const ip = ipMatch[1];
+
+      // Skip multicast and broadcast addresses
+      if (isSpecialAddress(ip)) return null;
+
+      const mac = normalizeMac(macMatch[1]);
+      const isCurrentDevice = localIP === ip || mac === currentMac;
+
+      return {
+        ip,
+        mac,
+        vendor: lookupVendor(mac),
+        hostname: hostMatch?.[1] !== '?' ? hostMatch[1] : undefined,
+        isCurrentDevice,
+      };
+    })
+    .filter(Boolean) as Device[];
+
+  // Sort by IP numerically
+  return devices.sort((a, b) => {
+    const aNum = a.ip.split('.').reduce((acc, n, i) => acc + parseInt(n) * Math.pow(256, 3 - i), 0);
+    const bNum = b.ip.split('.').reduce((acc, n, i) => acc + parseInt(n) * Math.pow(256, 3 - i), 0);
+    return aNum - bNum;
+  });
+}

package/src/scanners/ports.ts

@@ -0,0 +1,66 @@
+import { connect, type Socket } from 'net';
+
+const COMMON_PORTS: Record<number, string> = {
+  21: 'FTP',
+  22: 'SSH',
+  23: 'Telnet',
+  25: 'SMTP',
+  53: 'DNS',
+  80: 'HTTP',
+  110: 'POP3',
+  143: 'IMAP',
+  443: 'HTTPS',
+  445: 'SMB',
+  548: 'AFP',
+  3306: 'MySQL',
+  3389: 'RDP',
+  5432: 'PostgreSQL',
+  5900: 'VNC',
+  8080: 'HTTP-Alt',
+  8443: 'HTTPS-Alt',
+};
+
+export interface PortResult {
+  port: number;
+  service: string;
+  open: boolean;
+}
+
+export async function scanPorts(
+  host: string,
+  ports = Object.keys(COMMON_PORTS).map(Number)
+): Promise<PortResult[]> {
+  const results = await Promise.all(
+    ports.map(port => checkPort(host, port))
+  );
+
+  return results
+    .filter(r => r.open)
+    .map(r => ({ ...r, service: COMMON_PORTS[r.port] || 'Unknown' }));
+}
+
+function checkPort(host: string, port: number, timeout = 1000): Promise<PortResult> {
+  return new Promise(resolve => {
+    const socket: Socket = connect({ host, port, timeout });
+
+    const cleanup = () => {
+      socket.removeAllListeners();
+      socket.destroy();
+    };
+
+    socket.on('connect', () => {
+      cleanup();
+      resolve({ port, service: '', open: true });
+    });
+
+    socket.on('error', () => {
+      cleanup();
+      resolve({ port, service: '', open: false });
+    });
+
+    socket.on('timeout', () => {
+      cleanup();
+      resolve({ port, service: '', open: false });
+    });
+  });
+}

package/src/scanners/speed.ts

@@ -0,0 +1,85 @@
+export interface SpeedResult {
+  download: number; // Mbps
+  upload: number; // Mbps
+  latency: number; // ms
+  jitter: number; // ms
+}
+
+export async function runSpeedTest(
+  onProgress?: (stage: string) => void
+): Promise<SpeedResult> {
+  // Latency test
+  onProgress?.('Testing latency...');
+  const latencies = await Promise.all([
+    pingHost('1.1.1.1'),
+    pingHost('8.8.8.8'),
+    pingHost('208.67.222.222'),
+  ]);
+  const validLatencies = latencies.filter(l => l > 0);
+  const latency = validLatencies.length > 0 ? average(validLatencies) : 0;
+  const jitter = validLatencies.length > 1 ? standardDeviation(validLatencies) : 0;
+
+  // Download test using Cloudflare's speed test endpoint
+  onProgress?.('Testing download...');
+  const downloadBytes = 10_000_000; // 10MB for faster results
+  const downloadStart = performance.now();
+
+  try {
+    const response = await fetch(`https://speed.cloudflare.com/__down?bytes=${downloadBytes}`, {
+      signal: AbortSignal.timeout(30000),
+    });
+    await response.arrayBuffer(); // Consume the response
+  } catch {
+    // If Cloudflare fails, return partial results
+    return { download: 0, upload: 0, latency, jitter };
+  }
+
+  const downloadTime = (performance.now() - downloadStart) / 1000;
+  const download = (downloadBytes * 8) / downloadTime / 1_000_000;
+
+  // Upload test
+  onProgress?.('Testing upload...');
+  const uploadData = new Uint8Array(5_000_000); // 5MB
+  const uploadStart = performance.now();
+
+  try {
+    await fetch('https://speed.cloudflare.com/__up', {
+      method: 'POST',
+      body: uploadData,
+      signal: AbortSignal.timeout(30000),
+    });
+  } catch {
+    return { download, upload: 0, latency, jitter };
+  }
+
+  const uploadTime = (performance.now() - uploadStart) / 1000;
+  const upload = (uploadData.length * 8) / uploadTime / 1_000_000;
+
+  return { download, upload, latency, jitter };
+}
+
+async function pingHost(host: string): Promise<number> {
+  const start = performance.now();
+  try {
+    await fetch(`https://${host}`, {
+      method: 'HEAD',
+      mode: 'no-cors',
+      signal: AbortSignal.timeout(5000),
+    });
+    return performance.now() - start;
+  } catch {
+    return 0;
+  }
+}
+
+function average(arr: number[]): number {
+  if (arr.length === 0) return 0;
+  return arr.reduce((a, b) => a + b, 0) / arr.length;
+}
+
+function standardDeviation(arr: number[]): number {
+  if (arr.length < 2) return 0;
+  const avg = average(arr);
+  const squareDiffs = arr.map(value => Math.pow(value - avg, 2));
+  return Math.sqrt(average(squareDiffs));
+}