@nimbus-sh/core 0.1.0

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

@@ -0,0 +1,99 @@
+import type { Command } from '../types.js';
+
+interface DnsAnswer {
+  name: string;
+  type: number;
+  TTL: number;
+  data: string;
+}
+
+interface DnsResponse {
+  Status: number;
+  Answer?: DnsAnswer[];
+  Question?: Array<{ name: string; type: number }>;
+}
+
+const TYPE_MAP: Record<number, string> = {
+  1: 'A',
+  2: 'NS',
+  5: 'CNAME',
+  6: 'SOA',
+  15: 'MX',
+  16: 'TXT',
+  28: 'AAAA',
+};
+
+const command: Command = async (ctx) => {
+  let queryType = 'A';
+  let domain: string | undefined;
+
+  for (const arg of ctx.args) {
+    if (arg.startsWith('-') || arg.startsWith('+')) continue;
+    const upper = arg.toUpperCase();
+    if (['A', 'AAAA', 'CNAME', 'MX', 'NS', 'TXT', 'SOA'].includes(upper)) {
+      queryType = upper;
+    } else {
+      domain = arg;
+    }
+  }
+
+  if (!domain) {
+    ctx.stderr.write('dig: missing domain\n');
+    ctx.stderr.write('Usage: dig [type] domain\n');
+    return 1;
+  }
+
+  const url = `https://dns.google/resolve?name=${encodeURIComponent(domain)}&type=${queryType}`;
+
+  try {
+    const response = await fetch(url, {
+      headers: { Accept: 'application/dns-json' },
+      signal: ctx.signal,
+    });
+
+    if (!response.ok) {
+      ctx.stderr.write(`dig: DNS query failed (HTTP ${response.status})\n`);
+      return 1;
+    }
+
+    const data: DnsResponse = await response.json();
+
+    ctx.stdout.write(`; <<>> Lifo dig <<>> ${queryType} ${domain}\n`);
+    ctx.stdout.write(`;; Got answer:\n`);
+    ctx.stdout.write(`;; ->>HEADER<<- status: ${data.Status === 0 ? 'NOERROR' : 'NXDOMAIN'}\n`);
+    ctx.stdout.write(`\n`);
+
+    if (data.Question && data.Question.length > 0) {
+      ctx.stdout.write(`;; QUESTION SECTION:\n`);
+      for (const q of data.Question) {
+        ctx.stdout.write(`;${q.name}.\t\tIN\t${TYPE_MAP[q.type] ?? q.type}\n`);
+      }
+      ctx.stdout.write(`\n`);
+    }
+
+    if (data.Answer && data.Answer.length > 0) {
+      ctx.stdout.write(`;; ANSWER SECTION:\n`);
+      for (const ans of data.Answer) {
+        const typeName = TYPE_MAP[ans.type] ?? String(ans.type);
+        ctx.stdout.write(`${ans.name}.\t${ans.TTL}\tIN\t${typeName}\t${ans.data}\n`);
+      }
+      ctx.stdout.write(`\n`);
+    } else {
+      ctx.stdout.write(`;; No answers found.\n\n`);
+    }
+
+    ctx.stdout.write(`;; SERVER: dns.google\n`);
+    return 0;
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    if (msg.includes('Failed to fetch') || msg.includes('NetworkError')) {
+      ctx.stderr.write(`dig: connection to DNS server failed\n`);
+      ctx.stderr.write(`Note: This may be a CORS restriction or network issue.\n`);
+    } else {
+      ctx.stderr.write(`dig: ${msg}\n`);
+    }
+    return 1;
+  }
+};
+
+export default command;

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

@@ -0,0 +1,90 @@
+import type { Command } from '../types.js';
+import type { Kernel } from '../../kernel/index.js';
+
+/**
+ * forward - Forward a virtual port to the host browser
+ * Usage: forward <port>
+ * Example: forward 3000
+ */
+export function createForwardCommand(kernel: Kernel): Command {
+	return async (ctx) => {
+		if (ctx.args.length === 0) {
+			ctx.stdout.write('Usage: forward <port>\n');
+			ctx.stdout.write('Example: forward 3000\n');
+			ctx.stdout.write('\nCurrently forwarded ports:\n');
+
+			const forwarded = kernel.portBridge.getForwardedPorts();
+			if (forwarded.length === 0) {
+				ctx.stdout.write('  (none)\n');
+			} else {
+				for (const { virtual } of forwarded) {
+					const hasHandler = kernel.portRegistry.has(virtual);
+					const status = hasHandler ? '\x1b[32m●\x1b[0m' : '\x1b[33m○\x1b[0m';
+					ctx.stdout.write(`  ${status} ${virtual} -> /api/proxy/${virtual}/\n`);
+				}
+			}
+			ctx.stdout.write('\nLegend: \x1b[32m●\x1b[0m active  \x1b[33m○\x1b[0m registered (no handler)\n');
+			return 0;
+		}
+
+		const port = parseInt(ctx.args[0], 10);
+		if (isNaN(port) || port < 1 || port > 65535) {
+			ctx.stderr.write(`forward: invalid port number: ${ctx.args[0]}\n`);
+			return 1;
+		}
+
+		// Check if port has a handler
+		const hasHandler = kernel.portRegistry.has(port);
+		if (!hasHandler) {
+			ctx.stdout.write(`\x1b[33m⚠\x1b[0m Warning: No service detected on port ${port}\n`);
+			ctx.stdout.write(`  The port will be forwarded, but requests will fail until a server starts.\n`);
+			ctx.stdout.write(`  This is useful for Vite/webpack dev servers that may not be fully tracked.\n\n`);
+		}
+
+		// Forward the port
+		kernel.portBridge.forward(port);
+
+		ctx.stdout.write(`\x1b[32m✓\x1b[0m Port ${port} forwarded successfully!\n\n`);
+		ctx.stdout.write(`  Virtual port: ${port}\n`);
+		ctx.stdout.write(`  Access URL:   \x1b[36m/api/proxy/${port}/\x1b[0m\n\n`);
+		ctx.stdout.write(`You can now access this server from your browser:\n`);
+		ctx.stdout.write(`  curl http://localhost:3000/api/proxy/${port}/\n`);
+		ctx.stdout.write(`  Or open in browser: http://localhost:3000/api/proxy/${port}/\n\n`);
+
+		if (hasHandler) {
+			ctx.stdout.write(`\x1b[32m●\x1b[0m Server is active and ready\n`);
+		} else {
+			ctx.stdout.write(`\x1b[33m○\x1b[0m Waiting for server to start on port ${port}\n`);
+		}
+
+		return 0;
+	};
+}
+
+/**
+ * unforward - Stop forwarding a virtual port
+ * Usage: unforward <port>
+ */
+export function createUnforwardCommand(kernel: Kernel): Command {
+	return async (ctx) => {
+		if (ctx.args.length === 0) {
+			ctx.stderr.write('Usage: unforward <port>\n');
+			return 1;
+		}
+
+		const port = parseInt(ctx.args[0], 10);
+		if (isNaN(port) || port < 1 || port > 65535) {
+			ctx.stderr.write(`unforward: invalid port number: ${ctx.args[0]}\n`);
+			return 1;
+		}
+
+		const success = kernel.portBridge.unforward(port);
+		if (success) {
+			ctx.stdout.write(`Port ${port} unforwarded\n`);
+			return 0;
+		} else {
+			ctx.stderr.write(`unforward: port ${port} is not forwarded\n`);
+			return 1;
+		}
+	};
+}

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

@@ -0,0 +1,182 @@
+import type { Command } from '../types.js';
+import type { Kernel } from '../../kernel/index.js';
+
+/**
+ * host - DNS lookup and /etc/hosts management
+ *
+ * Usage:
+ *   host <hostname>              - DNS lookup
+ *   host list                    - List /etc/hosts entries
+ *   host add <hostname> <ip>     - Add entry to /etc/hosts
+ *   host remove <hostname>       - Remove entry from /etc/hosts
+ *   host reload                  - Reload /etc/hosts into DNS
+ */
+export function createHostCommand(kernel: Kernel): Command {
+  return async (ctx) => {
+    const args = ctx.args;
+
+    if (args.length === 0) {
+      ctx.stderr.write(`Usage: host <hostname>              - DNS lookup
+       host list                    - List /etc/hosts entries
+       host add <hostname> <ip>     - Add entry to /etc/hosts
+       host remove <hostname>       - Remove entry from /etc/hosts
+       host reload                  - Reload /etc/hosts into DNS\n`);
+      return 1;
+    }
+
+    const subcommand = args[0];
+
+    // List /etc/hosts entries
+    if (subcommand === 'list') {
+      try {
+        const content = ctx.vfs.readFileString('/etc/hosts');
+        ctx.stdout.write(content);
+        if (!content.endsWith('\n')) {
+          ctx.stdout.write('\n');
+        }
+        return 0;
+      } catch {
+        ctx.stderr.write('host: cannot read /etc/hosts\n');
+        return 1;
+      }
+    }
+
+    // Add entry to /etc/hosts
+    if (subcommand === 'add') {
+      if (args.length < 3) {
+        ctx.stderr.write('host: add requires <hostname> <ip>\n');
+        return 1;
+      }
+
+      const hostname = args[1];
+      const ip = args[2];
+
+      // Validate IP address format (basic validation)
+      const ipv4Regex = /^(\d{1,3}\.){3}\d{1,3}$/;
+      const ipv6Regex = /^([0-9a-fA-F]{0,4}:){2,7}[0-9a-fA-F]{0,4}$/;
+
+      if (!ipv4Regex.test(ip) && !ipv6Regex.test(ip)) {
+        ctx.stderr.write(`host: invalid IP address: ${ip}\n`);
+        return 1;
+      }
+
+      try {
+        // Read current hosts file
+        let content = '';
+        try {
+          content = ctx.vfs.readFileString('/etc/hosts');
+        } catch {
+          // File doesn't exist, will create
+        }
+
+        // Check if entry already exists
+        const lines = content.split('\n');
+        const exists = lines.some(line => {
+          const trimmed = line.trim();
+          if (trimmed.startsWith('#') || !trimmed) return false;
+          const parts = trimmed.split(/\s+/);
+          return parts.slice(1).includes(hostname);
+        });
+
+        if (exists) {
+          ctx.stderr.write(`host: entry for ${hostname} already exists\n`);
+          return 1;
+        }
+
+        // Add new entry
+        const newLine = `${ip}\t${hostname}`;
+        const newContent = content.trim() + '\n' + newLine + '\n';
+
+        ctx.vfs.writeFile('/etc/hosts', newContent);
+
+        // Reload DNS
+        kernel.networkStack.getDNS().loadHostsFile(newContent);
+
+        ctx.stdout.write(`Added: ${newLine}\n`);
+        return 0;
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        ctx.stderr.write(`host: ${msg}\n`);
+        return 1;
+      }
+    }
+
+    // Remove entry from /etc/hosts
+    if (subcommand === 'remove') {
+      if (args.length < 2) {
+        ctx.stderr.write('host: remove requires <hostname>\n');
+        return 1;
+      }
+
+      const hostname = args[1];
+
+      try {
+        const content = ctx.vfs.readFileString('/etc/hosts');
+        const lines = content.split('\n');
+
+        // Remove lines containing the hostname
+        const newLines = lines.filter(line => {
+          const trimmed = line.trim();
+          if (trimmed.startsWith('#') || !trimmed) return true;
+          const parts = trimmed.split(/\s+/);
+          return !parts.slice(1).includes(hostname);
+        });
+
+        if (newLines.length === lines.length) {
+          ctx.stderr.write(`host: no entry found for ${hostname}\n`);
+          return 1;
+        }
+
+        const newContent = newLines.join('\n');
+        ctx.vfs.writeFile('/etc/hosts', newContent);
+
+        // Reload DNS
+        kernel.networkStack.getDNS().loadHostsFile(newContent);
+
+        ctx.stdout.write(`Removed entry for: ${hostname}\n`);
+        return 0;
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        ctx.stderr.write(`host: ${msg}\n`);
+        return 1;
+      }
+    }
+
+    // Reload /etc/hosts
+    if (subcommand === 'reload') {
+      try {
+        const content = ctx.vfs.readFileString('/etc/hosts');
+        kernel.networkStack.getDNS().loadHostsFile(content);
+        ctx.stdout.write('Reloaded /etc/hosts\n');
+        return 0;
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        ctx.stderr.write(`host: ${msg}\n`);
+        return 1;
+      }
+    }
+
+    // DNS lookup (default)
+    const hostname = subcommand;
+
+    try {
+      // First try to lookup in cache/hosts
+      const dns = kernel.networkStack.getDNS();
+      const cached = dns.getHost(hostname);
+
+      if (cached) {
+        ctx.stdout.write(`${hostname} has address ${cached}\n`);
+        return 0;
+      }
+
+      // Try full DNS resolution
+      const ip = await kernel.networkStack.resolveHostname(hostname);
+      ctx.stdout.write(`${hostname} has address ${ip}\n`);
+      return 0;
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      ctx.stderr.write(`host: ${msg}\n`);
+      return 1;
+    }
+  };
+}

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

@@ -0,0 +1,139 @@
+import type { Command } from '../types.js';
+import type { Kernel } from '../../kernel/index.js';
+
+/**
+ * ifconfig - Configure network interfaces
+ * Usage: ifconfig [interface] [options]
+ */
+export function createIfconfigCommand(kernel: Kernel): Command {
+  return async (ctx) => {
+    const args = ctx.args;
+
+    // No arguments: show all interfaces
+    if (args.length === 0) {
+      const interfaces = kernel.networkStack.getAllInterfaces();
+
+      if (interfaces.length === 0) {
+        ctx.stdout.write('No network interfaces\n');
+        return 0;
+      }
+
+      for (let i = 0; i < interfaces.length; i++) {
+        ctx.stdout.write(interfaces[i].toString());
+        if (i < interfaces.length - 1) {
+          ctx.stdout.write('\n\n');
+        } else {
+          ctx.stdout.write('\n');
+        }
+      }
+
+      return 0;
+    }
+
+    const ifaceName = args[0];
+    const iface = kernel.networkStack.getInterface(ifaceName);
+
+    // Just interface name: show that interface
+    if (args.length === 1) {
+      if (!iface) {
+        ctx.stderr.write(`ifconfig: ${ifaceName}: error fetching interface information: Device not found\n`);
+        return 1;
+      }
+
+      ctx.stdout.write(iface.toString() + '\n');
+      return 0;
+    }
+
+    // Interface configuration commands
+    const command = args[1];
+
+    switch (command) {
+      case 'up':
+        if (!iface) {
+          ctx.stderr.write(`ifconfig: ${ifaceName}: Device not found\n`);
+          return 1;
+        }
+        iface.up();
+        ctx.stdout.write(`Interface ${ifaceName} is up\n`);
+        return 0;
+
+      case 'down':
+        if (!iface) {
+          ctx.stderr.write(`ifconfig: ${ifaceName}: Device not found\n`);
+          return 1;
+        }
+        iface.down();
+        ctx.stdout.write(`Interface ${ifaceName} is down\n`);
+        return 0;
+
+      default:
+        // Try to parse as IP address
+        if (isValidIP(command)) {
+          if (!iface) {
+            // Create new interface if it doesn't exist
+            try {
+              const newIface = kernel.networkStack.createInterface(ifaceName, 'ethernet');
+              newIface.addAddress({
+                version: 4,
+                address: command,
+                subnet: args[2] ? parseNetmask(args[2]) : '24',
+              });
+              ctx.stdout.write(`Created interface ${ifaceName} with address ${command}\n`);
+              return 0;
+            } catch (error) {
+              ctx.stderr.write(`ifconfig: error creating interface: ${error instanceof Error ? error.message : String(error)}\n`);
+              return 1;
+            }
+          }
+
+          iface.addAddress({
+            version: 4,
+            address: command,
+            subnet: args[2] ? parseNetmask(args[2]) : '24',
+          });
+          ctx.stdout.write(`Added address ${command} to ${ifaceName}\n`);
+          return 0;
+        }
+
+        ctx.stderr.write(`ifconfig: unknown command: ${command}\n`);
+        return 1;
+    }
+  };
+}
+
+/**
+ * Check if string is valid IPv4 address
+ */
+function isValidIP(ip: string): boolean {
+  const parts = ip.split('.');
+  if (parts.length !== 4) return false;
+
+  return parts.every((part) => {
+    const num = parseInt(part, 10);
+    return !isNaN(num) && num >= 0 && num <= 255;
+  });
+}
+
+/**
+ * Parse netmask to CIDR prefix length
+ */
+function parseNetmask(mask: string): string {
+  // If already CIDR, return as is
+  if (!mask.includes('.')) {
+    return mask;
+  }
+
+  // Convert netmask to CIDR
+  const parts = mask.split('.');
+  if (parts.length !== 4) {
+    return '24'; // Default
+  }
+
+  let bits = 0;
+  for (const part of parts) {
+    const num = parseInt(part, 10);
+    bits += num.toString(2).split('1').length - 1;
+  }
+
+  return bits.toString();
+}