@nimbus-sh/core 0.1.0

package/src/substrate/lifo/commands/net/netstat.ts

@@ -0,0 +1,106 @@
+import type { Command } from '../types.js';
+import type { Kernel } from '../../kernel/index.js';
+
+/**
+ * netstat - Print network connections, routing tables, interface statistics
+ * Usage: netstat [-r] [-i] [-a]
+ */
+export function createNetstatCommand(kernel: Kernel): Command {
+  return async (ctx) => {
+    const args = ctx.args;
+
+    // Parse flags
+    let showRouting = false;
+    let showInterfaces = false;
+    let showAll = false;
+
+    for (const arg of args) {
+      if (arg === '-r') {
+        showRouting = true;
+      } else if (arg === '-i') {
+        showInterfaces = true;
+      } else if (arg === '-a') {
+        showAll = true;
+      } else if (arg.startsWith('-')) {
+        // Support combined flags like -ri
+        if (arg.includes('r')) showRouting = true;
+        if (arg.includes('i')) showInterfaces = true;
+        if (arg.includes('a')) showAll = true;
+      }
+    }
+
+    // If no flags, show connections
+    if (!showRouting && !showInterfaces) {
+      showAll = true;
+    }
+
+    let output = '';
+
+    // Show routing table
+    if (showRouting) {
+      output += 'Kernel IP routing table\n';
+      output += kernel.networkStack.getRoutingTableString() + '\n';
+      if (showInterfaces || showAll) {
+        output += '\n';
+      }
+    }
+
+    // Show interfaces
+    if (showInterfaces) {
+      output += 'Kernel Interface table\n';
+      output += 'Iface      MTU    RX-OK  RX-ERR  TX-OK  TX-ERR  Flags\n';
+
+      const interfaces = kernel.networkStack.getAllInterfaces();
+      for (const iface of interfaces) {
+        const name = iface.name.padEnd(10);
+        const mtu = iface.mtu.toString().padStart(6);
+        const rxOk = iface.stats.rxPackets.toString().padStart(7);
+        const rxErr = iface.stats.rxErrors.toString().padStart(7);
+        const txOk = iface.stats.txPackets.toString().padStart(7);
+        const txErr = iface.stats.txErrors.toString().padStart(7);
+        const flags = iface.state === 'up' ? 'UP' : 'DOWN';
+
+        output += `${name} ${mtu} ${rxOk} ${rxErr} ${txOk} ${txErr} ${flags}\n`;
+      }
+
+      if (showAll) {
+        output += '\n';
+      }
+    }
+
+    // Show connections
+    if (showAll) {
+      output += 'Active Internet connections\n';
+      output += 'Proto Local Address          Foreign Address        State\n';
+
+      const sockets = kernel.networkStack.getAllSockets();
+      let hasConnections = false;
+
+      // Show NetworkStack sockets
+      for (const socket of sockets) {
+        output += socket.toString() + '\n';
+        hasConnections = true;
+      }
+
+      // Also show portRegistry connections (Node.js HTTP servers)
+      if (kernel.portRegistry) {
+        const ports = Array.from(kernel.portRegistry.keys()).sort((a, b) => a - b);
+        for (const port of ports) {
+          const proto = 'TCP  ';
+          const local = `127.0.0.1:${port}`.padEnd(22);
+          const remote = '*:*'.padEnd(22);
+          const state = 'LISTEN';
+          output += `${proto} ${local} ${remote} ${state}\n`;
+          hasConnections = true;
+        }
+      }
+
+      if (!hasConnections) {
+        output += '(No connections)\n';
+      }
+    }
+
+    ctx.stdout.write(output);
+    return 0;
+  };
+}

package/src/substrate/lifo/commands/net/ping.ts

@@ -0,0 +1,74 @@
+import type { Command } from '../types.js';
+import { waitForAbortOrTimeout } from '../signal.js';
+
+const command: Command = async (ctx) => {
+  let count = 4;
+  let host: string | undefined;
+
+  const args = ctx.args;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '-c') {
+      count = parseInt(args[++i] ?? '4', 10);
+      if (isNaN(count) || count < 1) count = 4;
+    } else if (!arg.startsWith('-')) {
+      host = arg;
+    }
+  }
+
+  if (!host) {
+    ctx.stderr.write('ping: missing host\n');
+    ctx.stderr.write('Usage: ping [-c count] host\n');
+    return 1;
+  }
+
+  // Build URL for HEAD request
+  let url = host;
+  if (!url.startsWith('http://') && !url.startsWith('https://')) {
+    url = 'https://' + url;
+  }
+
+  ctx.stdout.write(`PING ${host}: ${count} requests\n`);
+
+  const times: number[] = [];
+  let failures = 0;
+
+  for (let i = 0; i < count; i++) {
+    if (ctx.signal.aborted) break;
+
+    const start = performance.now();
+    try {
+      await fetch(url, { method: 'HEAD', signal: ctx.signal });
+      const elapsed = performance.now() - start;
+      times.push(elapsed);
+      ctx.stdout.write(`Response from ${host}: time=${elapsed.toFixed(1)}ms\n`);
+    } catch {
+      const elapsed = performance.now() - start;
+      if (ctx.signal.aborted) break;
+      failures++;
+      ctx.stdout.write(`Request to ${host}: timeout (${elapsed.toFixed(1)}ms)\n`);
+    }
+
+    if (i < count - 1 && !ctx.signal.aborted) {
+      await waitForAbortOrTimeout(ctx.signal, 1_000);
+    }
+  }
+
+  // Statistics
+  const total = times.length + failures;
+  const loss = total > 0 ? ((failures / total) * 100).toFixed(0) : '0';
+
+  ctx.stdout.write(`\n--- ${host} ping statistics ---\n`);
+  ctx.stdout.write(`${total} packets transmitted, ${times.length} received, ${loss}% packet loss\n`);
+
+  if (times.length > 0) {
+    const min = Math.min(...times);
+    const max = Math.max(...times);
+    const avg = times.reduce((a, b) => a + b, 0) / times.length;
+    ctx.stdout.write(`rtt min/avg/max = ${min.toFixed(1)}/${avg.toFixed(1)}/${max.toFixed(1)} ms\n`);
+  }
+
+  return failures === total ? 1 : 0;
+};
+
+export default command;

package/src/substrate/lifo/commands/net/ports.ts

@@ -0,0 +1,45 @@
+import type { Command } from '../types.js';
+import type { Kernel } from '../../kernel/index.js';
+
+/**
+ * ports - List all ports in the portRegistry with details
+ * Usage: ports
+ */
+export function createPortsCommand(kernel: Kernel): Command {
+	return async (ctx) => {
+		// Debug: Show kernel info
+		const hasRegistry = !!kernel.portRegistry;
+		const registrySize = hasRegistry ? kernel.portRegistry.size : 0;
+
+		ctx.stdout.write(`\x1b[90m[Debug] Kernel has portRegistry: ${hasRegistry}\x1b[0m\n`);
+		ctx.stdout.write(`\x1b[90m[Debug] Registry size: ${registrySize}\x1b[0m\n`);
+		ctx.stdout.write(`\x1b[90m[Debug] Registry instance: ${kernel.portRegistry ? 'Map' : 'undefined'}\x1b[0m\n\n`);
+
+		const ports = Array.from(kernel.portRegistry.entries()).sort((a, b) => a[0] - b[0]);
+
+		if (ports.length === 0) {
+			ctx.stdout.write('No ports registered in portRegistry\n');
+			ctx.stdout.write('\nDiagnostic steps:\n');
+			ctx.stdout.write('  1. Run: node test-server.js\n');
+			ctx.stdout.write('  2. Look for "[lifo-http] Server listening on port 3000"\n');
+			ctx.stdout.write('  3. Run: ports (in the SAME tab)\n');
+			ctx.stdout.write('  4. If still empty, there may be an error during server creation\n');
+			return 0;
+		}
+
+		ctx.stdout.write('Registered ports in portRegistry:\n\n');
+		ctx.stdout.write('Port   Handler   Description\n');
+		ctx.stdout.write('-----  --------  -----------\n');
+
+		for (const [port, handler] of ports) {
+			const handlerStr = '\x1b[32m✓\x1b[0m    ';
+			const handlerType = typeof handler;
+			const desc = `Active (handler: ${handlerType})`;
+			ctx.stdout.write(`${String(port).padEnd(6)} ${handlerStr}  ${desc}\n`);
+		}
+
+		ctx.stdout.write(`\nTotal: ${ports.length} port(s)\n`);
+		ctx.stdout.write(`\nAccess: curl localhost:PORT or /api/proxy/PORT/ in browser\n`);
+		return 0;
+	};
+}

package/src/substrate/lifo/commands/net/route.ts

@@ -0,0 +1,153 @@
+import type { Command } from '../types.js';
+import type { NetworkStack } from '../../kernel/network/index.js';
+import type { Kernel } from '../../kernel/index.js';
+
+/**
+ * route - Show/manipulate IP routing table
+ * Usage: route [-n] [add|del] [destination] [gw gateway] [dev interface]
+ */
+export function createRouteCommand(kernel: Kernel): Command {
+  return async (ctx) => {
+    const args = ctx.args;
+
+    // No arguments: show routing table
+    if (args.length === 0 || args[0] === '-n') {
+      const table = kernel.networkStack.getRoutingTableString();
+      ctx.stdout.write(table + '\n');
+      return 0;
+    }
+
+    const command = args[0];
+
+    switch (command) {
+      case 'add':
+        return addRoute(ctx, args.slice(1), kernel.networkStack);
+
+      case 'del':
+      case 'delete':
+        return deleteRoute(ctx, args.slice(1), kernel.networkStack);
+
+      default:
+        ctx.stderr.write('Usage: route [-n] [add|del] [destination] [gw gateway] [dev interface]\n');
+        return 1;
+    }
+  };
+}
+
+/**
+ * Add route to routing table
+ */
+function addRoute(
+  ctx: { stdout: { write: (s: string) => void }; stderr: { write: (s: string) => void } },
+  args: string[],
+  networkStack: NetworkStack
+): number {
+  if (args.length < 2) {
+    ctx.stderr.write('Usage: route add <destination> [gw <gateway>] dev <interface>\n');
+    return 1;
+  }
+
+  let destination = args[0];
+  let gateway: string | undefined;
+  let iface: string | undefined;
+  let metric = 0;
+
+  // Parse arguments
+  let i = 1;
+  while (i < args.length) {
+    const arg = args[i];
+
+    if (arg === 'gw') {
+      gateway = args[i + 1];
+      i += 2;
+    } else if (arg === 'dev') {
+      iface = args[i + 1];
+      i += 2;
+    } else if (arg === 'metric') {
+      metric = parseInt(args[i + 1], 10) || 0;
+      i += 2;
+    } else {
+      i++;
+    }
+  }
+
+  if (!iface) {
+    ctx.stderr.write('route: interface required (use "dev <interface>")\n');
+    return 1;
+  }
+
+  // Handle special destinations
+  if (destination === 'default') {
+    destination = '0.0.0.0/0';
+  } else if (!destination.includes('/')) {
+    destination += '/32'; // Single host
+  }
+
+  try {
+    networkStack.addRoute({
+      destination,
+      gateway,
+      interface: iface,
+      metric,
+      namespace: 'default',
+    });
+
+    ctx.stdout.write(`Route added: ${destination} via ${gateway || '*'} dev ${iface}\n`);
+    return 0;
+  } catch (error) {
+    ctx.stderr.write(`route: ${error instanceof Error ? error.message : String(error)}\n`);
+    return 1;
+  }
+}
+
+/**
+ * Delete route from routing table
+ */
+function deleteRoute(
+  ctx: { stdout: { write: (s: string) => void }; stderr: { write: (s: string) => void } },
+  args: string[],
+  networkStack: NetworkStack
+): number {
+  if (args.length < 2) {
+    ctx.stderr.write('Usage: route del <destination> dev <interface>\n');
+    return 1;
+  }
+
+  let destination = args[0];
+  let iface: string | undefined;
+
+  // Parse arguments
+  let i = 1;
+  while (i < args.length) {
+    const arg = args[i];
+
+    if (arg === 'dev') {
+      iface = args[i + 1];
+      i += 2;
+    } else {
+      i++;
+    }
+  }
+
+  if (!iface) {
+    ctx.stderr.write('route: interface required (use "dev <interface>")\n');
+    return 1;
+  }
+
+  // Handle special destinations
+  if (destination === 'default') {
+    destination = '0.0.0.0/0';
+  } else if (!destination.includes('/')) {
+    destination += '/32';
+  }
+
+  const removed = networkStack.removeRoute(destination, iface);
+
+  if (removed) {
+    ctx.stdout.write(`Route deleted: ${destination} dev ${iface}\n`);
+    return 0;
+  } else {
+    ctx.stderr.write(`route: no such route\n`);
+    return 1;
+  }
+}

package/src/substrate/lifo/commands/net/tunnel-v2.ts

@@ -0,0 +1,183 @@
+import type { Command } from '../types.js';
+import type { Kernel } from '../../kernel/index.js';
+import { WebSocketTunnel } from '../../kernel/network/tunnel/WebSocketTunnel.js';
+import { waitForAbort } from '../signal.js';
+
+/**
+ * tunnel - WebSocket-based tunnel for host machine access
+ *
+ * Creates a WebSocket tunnel that connects the virtual network to an external
+ * tunnel server, enabling host machine access to virtual HTTP servers.
+ *
+ * Usage:
+ *   tunnel [--server=ws://localhost:3005] [-v]
+ *
+ * Access from host:
+ *   http://localhost:3005/3000/ → Port 3000 inside Lifo
+ */
+
+interface TunnelOptions {
+	server: string;
+	port: number | null;
+	verbose: boolean;
+}
+
+function parseArgs(args: string[]): TunnelOptions | { help: true } {
+	let server = 'ws://localhost:3005';
+	let port: number | null = null;
+	let verbose = false;
+
+	for (let i = 0; i < args.length; i++) {
+		if (args[i] === '--help' || args[i] === '-h') {
+			return { help: true };
+		} else if (args[i].startsWith('--server=')) {
+			server = args[i].slice('--server='.length);
+		} else if (args[i] === '--server' && args[i + 1]) {
+			server = args[++i];
+		} else if (args[i].startsWith('--port=')) {
+			port = parseInt(args[i].slice('--port='.length), 10);
+		} else if ((args[i] === '--port' || args[i] === '-p') && args[i + 1]) {
+			port = parseInt(args[++i], 10);
+		} else if (args[i] === '-v' || args[i] === '--verbose') {
+			verbose = true;
+		}
+	}
+
+	return { server, port, verbose };
+}
+
+export function createTunnelCommandV2(kernel: Kernel): Command {
+	return async (ctx) => {
+		const options = parseArgs(ctx.args);
+
+		// Handle --help
+		if ('help' in options && options.help) {
+			ctx.stdout.write(`Usage: tunnel [options]
+
+Expose Lifo HTTP servers through a WebSocket tunnel
+
+Options:
+  --server <url>    Tunnel server URL (default: ws://localhost:3005)
+  --port, -p <num>  Default port (routes all requests to this port)
+  -v, --verbose     Verbose logging
+  -h, --help        Show this help
+
+Examples:
+  # Path-based routing (default):
+  tunnel
+  # Access: http://localhost:3005/3000/ → Port 3000
+  #         http://localhost:3005/8080/ → Port 8080
+
+  # Default port mode (for Vite, webpack-dev-server, etc.):
+  tunnel --port 5173
+  # Access: http://localhost:3005/ → Port 5173
+
+Without --port, uses path-based routing:
+  http://localhost:3005/3000/         → Port 3000 inside Lifo
+  http://localhost:3005/8080/api      → Port 8080, path /api
+  http://localhost:3005/3000/users    → Port 3000, path /users
+
+With --port 5173:
+  http://localhost:3005/              → Port 5173, path /
+  http://localhost:3005/src/main.ts   → Port 5173, path /src/main.ts
+  (Perfect for Vite dev server!)\n`);
+			return 0;
+		}
+
+		const { server, port: defaultPort, verbose } = options as TunnelOptions;
+
+		function log(message: string) {
+			if (verbose) {
+				ctx.stdout.write(`[tunnel] ${message}\n`);
+			}
+		}
+
+		// Check if tunnel already exists
+		const existingTunnel = kernel.networkStack.getTunnel('wst0');
+		if (existingTunnel) {
+			ctx.stderr.write('Tunnel already active. Use Ctrl+C to stop it first.\n');
+			return 1;
+		}
+
+		// Create WebSocket tunnel
+		const tunnelId = kernel.networkStack.getNextTunnelId();
+		const tunnel = new WebSocketTunnel(
+			tunnelId,
+			server,
+			kernel.networkStack,
+			kernel.portRegistry,
+			'default',
+			defaultPort
+		);
+
+		ctx.stdout.write(`Connecting to tunnel server at ${server}...\n`);
+		log('Creating WebSocket tunnel');
+
+		try {
+			// Add tunnel to network stack
+			kernel.networkStack.addTunnel('wst0', tunnel);
+
+			// Bring tunnel up (connects WebSocket)
+			await tunnel.up();
+
+			ctx.stdout.write(`✓ Connected to tunnel server\n`);
+
+			const httpUrl = server.replace('ws://', 'http://').replace('wss://', 'https://');
+
+			if (defaultPort) {
+				ctx.stdout.write(`Tunnel ready — all traffic → port ${defaultPort}\n`);
+				ctx.stdout.write(`  Open: ${httpUrl}\n`);
+			} else {
+				ctx.stdout.write(`Tunnel ready at ${httpUrl}\n`);
+
+				// Show active ports
+				const ports = tunnel.getActivePorts();
+				if (ports.length === 0) {
+					ctx.stdout.write('\nNo active servers to tunnel\n');
+					ctx.stdout.write('Start a server first: node server.js\n');
+				} else {
+					ctx.stdout.write(`\nTunneling ${ports.length} server(s):\n`);
+					for (const port of ports) {
+						ctx.stdout.write(`  - Port ${port}: ${httpUrl}/${port}/\n`);
+					}
+				}
+			}
+
+			ctx.stdout.write('\nPress Ctrl+C to stop tunnel\n\n');
+
+			log('Tunnel is active');
+
+			// Monitor connection status
+			const checkInterval = setInterval(() => {
+				if (!tunnel.isConnected()) {
+					log('Connection lost, reconnecting...');
+				} else {
+					log('Connection active');
+				}
+			}, verbose ? 10000 : 60000);
+
+			await waitForAbort(ctx.signal);
+			clearInterval(checkInterval);
+
+			ctx.stdout.write('\nShutting down tunnel...\n');
+			await tunnel.down();
+			await kernel.networkStack.removeTunnel('wst0');
+			ctx.stdout.write('Tunnel closed\n');
+
+			return 0;
+		} catch (error) {
+			const msg = error instanceof Error ? error.message : String(error);
+			ctx.stderr.write(`tunnel: ${msg}\n`);
+
+			// Cleanup on error
+			try {
+				await tunnel.down();
+				await kernel.networkStack.removeTunnel('wst0');
+			} catch {
+				// Ignore cleanup errors
+			}
+
+			return 1;
+		}
+	};
+}