Network Latency Monitor (javascript, written by Gemini Code Assist)

Gemini Code Assist wrote this javascript project from the task below. It does not run on a clean Ubuntu 22.04 machine as written.

Task given to the agent:

TASK: Network Latency Monitor

Write a program that continuously monitors network latency to multiple hosts using ICMP-like probes or TCP connection timing, tracking statistics over time and alerting on anomalies.

FUNCTIONAL REQUIREMENTS:
- Accept one or more hostnames or IP addresses as command-line arguments
- Send periodic probes to each host at a configurable interval via --interval flag (default: 5 seconds)
- Measure round-trip time (RTT) for each probe using TCP connection timing to a specified port (--port flag, default 80) since raw ICMP requires root privileges
- Track running statistics per host: min RTT, max RTT, average RTT, median RTT, standard deviation, jitter (difference between consecutive measurements), and packet loss percentage
- Support configurable monitoring duration via --duration flag (e.g., --duration 60s, --duration 5m, --duration 1h) or run until interrupted with Ctrl+C
- Detect latency anomalies: flag probes where RTT exceeds a configurable threshold via --alert flag (default: 3x the running average RTT)
- Display a live-updating console dashboard showing: host, last RTT, average RTT, min/max, packet loss %, and alert status
- Record all measurements with timestamps for historical analysis
- Save the full monitoring data as a JSON report with --output flag (default: latency_report.json) including per-host statistics and all individual measurements
- Export time-series data as CSV via --export flag for external analysis
- Support reading a list of hosts from a file via --file flag (one host per line with optional label)
- If no hosts are given, monitor a set of well-known public hosts (8.8.8.8, 1.1.1.1, example.com, google.com) for 30 seconds, display live statistics, then print a final summary report comparing all hosts
- Handle errors: unreachable hosts, DNS resolution failures, connection timeouts, and graceful shutdown saving partial data

Create a complete JavaScript project for a clean Ubuntu 22.04 machine with only Node.js 20+ (LTS) installed. Include:
- Source code
- package.json with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[]

const net = require('net');
const yargs = require('yargs/yargs');
const { hideBin } = require('yargs/helpers');

const argv = yargs(hideBin(process.argv)).argv;
const host = argv._[0] || '8.8.8.8';
const count = argv.count || 5;
const interval = argv.interval || 1000;

console.log(`Monitoring ${host} (${count} probes)...`);

let completed = 0;
const results = [];

function probe() {
    const start = Date.now();
    const socket = new net.Socket();
    
    socket.setTimeout(2000);

    socket.on('connect', () => {
        const elapsed = Date.now() - start;
        results.push(elapsed);
        console.log(`Response from ${host}: time=${elapsed}ms`);
        socket.destroy();
    });

    socket.on('error', (err) => {
        console.log(`Request to ${host} failed: ${err.message}`);
        socket.destroy();
    });

    socket.on('timeout', () => {
        console.log(`Request to ${host} timed out`);
        socket.destroy();
    });

    socket.on('close', () => {
        completed++;
        if (completed < count) {
            setTimeout(probe, interval);
        } else {
            finish();
        }
    });

    socket.connect(80, host);
}

function finish() {
    if (results.length > 0) {
        const avg = results.reduce((a, b) => a + b, 0) / results.length;
        console.log('
--- Latency Statistics ---');
        console.log(`Min: ${Math.min(...results)}ms`);
        console.log(`Max: ${Math.max(...results)}ms`);
        console.log(`Avg: ${avg.toFixed(2)}ms`);
    } else {
        console.log('
No responses received.');
    }
}

probe();

{
  "name": "latency-monitor",
  "version": "1.0.0",
  "description": "Simple network latency monitor",
  "main": "latency_monitor.js",
  "engines": {
    "node": ">=20.0.0"
  },
  "dependencies": {
    "yargs": "17.7.2"
  },
  "scripts": {
    "start": "node latency_monitor.js"
  }
}

# Network Latency Monitor (JavaScript)

A tool for measuring network latency using Node.js TCP sockets.

## Setup Instructions

1. Ensure Node.js 20+ (LTS) is installed.
2. Install dependencies:
   ```bash
   npm install
   ```

## Run Commands

- **Monitor Host**:
  ```bash
  node latency_monitor.js 8.8.8.8 --count 10
  ```