feat: add macOS and Linux cross-platform support

Add platform abstraction for ping and traceroute commands,
handling different flags, output formats, and regex patterns
per OS. Update forge config with macOS/Linux ZIP maker.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: dbfx

forge.config.ts

@@ -29,7 +29,7 @@ const config: ForgeConfig = {
       setupIcon: path.resolve(__dirname, 'build', 'icon.ico'),
       iconUrl: 'https://raw.githubusercontent.com/dbfx/modern-win-mtr/main/build/icon.ico',
     }),
-    new MakerZIP({}),
+    new MakerZIP({}, ['darwin', 'linux']),
   ],
   plugins: [
     new VitePlugin({

src/main/services/persistent-ping.ts

@@ -1,14 +1,7 @@
 import { spawn, ChildProcess } from 'child_process';
 import { EventEmitter } from 'events';
+import { getPersistentPingArgs, PING_RTT_REGEX, PING_TIMEOUT_REGEX } from './platform';
 
-const REPLY_REGEX = /time[<=](\d+)ms/i;
-const TIMEOUT_REGEX = /Request timed out|General failure|Destination .* unreachable/i;
-
-/**
- * A long-lived ping process that continuously pings a target using `ping -t`.
- * Emits 'result' events with the RTT (number) or null (timeout/failure).
- * Avoids the overhead of spawning a new process for every ping round.
- */
 export class PersistentPing extends EventEmitter {
   private child: ChildProcess | null = null;
   private ip: string;
@@ -22,28 +15,25 @@ export class PersistentPing extends EventEmitter {
   }
 
   start(): void {
-    this.child = spawn('ping', ['-t', '-w', String(this.timeout), this.ip], {
-      windowsHide: true,
-    });
+    const { command, args } = getPersistentPingArgs(this.ip, this.timeout);
+    this.child = spawn(command, args, { windowsHide: true });
 
     this.child.stdout?.on('data', (data: Buffer) => {
       this.buffer += data.toString();
       const lines = this.buffer.split(/\r?\n/);
       this.buffer = lines.pop() || '';
 
       for (const line of lines) {
-        const match = line.match(REPLY_REGEX);
+        const match = line.match(PING_RTT_REGEX);
         if (match) {
-          this.emit('result', parseInt(match[1], 10));
-        } else if (TIMEOUT_REGEX.test(line)) {
+          this.emit('result', Math.round(parseFloat(match[1])));
+        } else if (PING_TIMEOUT_REGEX.test(line)) {
           this.emit('result', null);
         }
       }
     });
 
-    this.child.on('error', () => {
-      // Process failed to start — nothing we can do
-    });
+    this.child.on('error', () => {});
 
     this.child.on('close', () => {
       this.child = null;

src/main/services/platform.ts

@@ -0,0 +1,66 @@
+const isWin = process.platform === 'win32';
+
+export function getPersistentPingArgs(ip: string, timeout: number): { command: string; args: string[] } {
+  if (isWin) {
+    // ping -t = continuous, -w = timeout in ms
+    return { command: 'ping', args: ['-t', '-w', String(timeout), ip] };
+  }
+  // macOS/Linux: no -t flag; use huge count for continuous. -W = timeout in seconds (min 1)
+  const timeoutSec = Math.max(1, Math.ceil(timeout / 1000));
+  return { command: 'ping', args: ['-c', '1000000', '-W', String(timeoutSec), ip] };
+}
+
+export function getTracerouteArgs(target: string, maxHops: number): { command: string; args: string[] } {
+  if (isWin) {
+    return { command: 'tracert', args: ['-d', '-w', '1000', '-h', String(maxHops), target] };
+  }
+  // macOS/Linux: traceroute -n (no DNS), -w 1 (timeout), -m maxHops
+  return { command: 'traceroute', args: ['-n', '-w', '1', '-m', String(maxHops), target] };
+}
+
+// Windows: time<=1ms  or  time=12ms
+// macOS:   time=1.234 ms
+export const PING_RTT_REGEX = isWin
+  ? /time[<=](\d+)ms/i
+  : /time=(\d+(?:\.\d+)?)\s*ms/i;
+
+export const PING_TIMEOUT_REGEX = isWin
+  ? /Request timed out|General failure|Destination .* unreachable/i
+  : /Request timeout|100(\.0)?% packet loss|Host Unreachable|No route to host/i;
+
+// Windows tracert output:
+//   1     3 ms     1 ms     2 ms  192.168.50.1
+//   3     *        *        *     Request timed out.
+// macOS traceroute output:
+//   1  192.168.50.1  1.234 ms  0.987 ms  1.012 ms
+//   3  * * *
+export const TRACEROUTE_HOP_REGEX = isWin
+  ? /^\s*(\d+)\s+([\d<]+\s*ms|\*)\s+([\d<]+\s*ms|\*)\s+([\d<]+\s*ms|\*)\s*([\d.]+)?\s*/
+  : /^\s*(\d+)\s+(?:(\d[\d.]*)\s+[\d.]+\s*ms|\*)/;
+
+export function parseTracerouteHop(line: string): { hopNumber: number; ip: string | null } | null {
+  if (isWin) {
+    const match = line.match(
+      /^\s*(\d+)\s+([\d<]+\s*ms|\*)\s+([\d<]+\s*ms|\*)\s+([\d<]+\s*ms|\*)\s*([\d.]+)?\s*/,
+    );
+    if (!match) return null;
+    return { hopNumber: parseInt(match[1], 10), ip: match[5] || null };
+  }
+
+  // macOS: "  1  192.168.1.1  1.234 ms  ..."  or  "  3  * * *"
+  const match = line.match(/^\s*(\d+)\s+(\d[\d.]+)\s+[\d.]+\s*ms/);
+  if (match) {
+    return { hopNumber: parseInt(match[1], 10), ip: match[2] };
+  }
+  const timeoutMatch = line.match(/^\s*(\d+)\s+\*/);
+  if (timeoutMatch) {
+    return { hopNumber: parseInt(timeoutMatch[1], 10), ip: null };
+  }
+  return null;
+}
+
+export function isTraceComplete(line: string): boolean {
+  if (isWin) return line.includes('Trace complete');
+  // macOS traceroute just ends — no explicit "complete" message
+  return false;
+}

src/main/services/traceroute.ts

@@ -1,13 +1,7 @@
 import { spawn } from 'child_process';
 import { DiscoveredHop } from '../../shared/types';
 import dns from 'dns';
-
-// Match hop lines — the IP at the end is optional (timeouts have none)
-// Examples:
-//   1     3 ms     1 ms     2 ms  192.168.50.1
-//   3     *        *        *     Request timed out.
-//  12     *        *        *     Request timed out.
-const HOP_REGEX = /^\s*(\d+)\s+([\d<]+\s*ms|\*)\s+([\d<]+\s*ms|\*)\s+([\d<]+\s*ms|\*)\s*([\d.]+)?\s*/;
+import { getTracerouteArgs, parseTracerouteHop, isTraceComplete } from './platform';
 
 // How many consecutive timeouts after a real hop before we stop early
 const MAX_CONSECUTIVE_TIMEOUTS = 5;
@@ -31,9 +25,8 @@ export function runTraceroute(
   let foundAnyIp = false;
 
   const sanitized = target.replace(/[;&|`$(){}[\]!#]/g, '');
-  const child = spawn('tracert', ['-d', '-w', '1000', '-h', String(maxHops), sanitized], {
-    windowsHide: true,
-  });
+  const { command, args } = getTracerouteArgs(sanitized, maxHops);
+  const child = spawn(command, args, { windowsHide: true });
 
   signal?.addEventListener('abort', () => {
     child.kill();
@@ -49,24 +42,20 @@ export function runTraceroute(
   const processLine = (line: string) => {
     if (completed) return;
 
-    // Detect "Trace complete" to end
-    if (line.includes('Trace complete')) {
+    if (isTraceComplete(line)) {
       finish();
       return;
     }
 
-    const match = line.match(HOP_REGEX);
-    if (!match) return;
-
-    const hopNumber = parseInt(match[1], 10);
-    const ip = match[5] || null;
+    const parsed = parseTracerouteHop(line);
+    if (!parsed) return;
 
-    const hop: DiscoveredHop = { hopNumber, ip };
+    const hop: DiscoveredHop = { hopNumber: parsed.hopNumber, ip: parsed.ip };
     hops.push(hop);
     callbacks.onHop(hop);
 
     // Track consecutive timeouts to stop early
-    if (ip) {
+    if (parsed.ip) {
       foundAnyIp = true;
       consecutiveTimeouts = 0;
     } else {
@@ -108,7 +97,7 @@ export function runTraceroute(
   });
 
   child.on('error', (err) => {
-    callbacks.onError(`Failed to start tracert: ${err.message}`);
+    callbacks.onError(`Failed to start traceroute: ${err.message}`);
   });
 }