@superdangerous/app-framework 4.9.0

package/src/services/networkService.ts

@@ -0,0 +1,351 @@
+/**
+ * Network Service
+ * Detects and manages network interfaces
+ */
+
+import os from "os";
+import fs from "fs";
+import net from "net";
+
+interface NetworkAddress {
+  address: string;
+  family: string;
+  internal: boolean;
+}
+
+interface NetworkInterface {
+  name: string;
+  addresses: NetworkAddress[];
+}
+
+interface BindingOption {
+  label: string;
+  value: string;
+  description: string;
+  interface: string;
+}
+
+interface NetworkInfo {
+  hostname: string;
+  primaryIp: string | null;
+  interfaces: NetworkInterface[];
+  bindingOptions: BindingOption[];
+}
+
+class NetworkService {
+  /**
+   * Get all available network interfaces with their addresses
+   */
+  getNetworkInterfaces(): NetworkInterface[] {
+    const interfaces = os.networkInterfaces();
+    const result: NetworkInterface[] = [];
+
+    for (const [name, addresses] of Object.entries(interfaces)) {
+      if (!addresses) continue;
+
+      const validAddresses = addresses
+        .filter((addr) => addr.family === "IPv4" && !addr.internal)
+        .map((addr) => ({
+          address: addr.address,
+          family: addr.family,
+          internal: addr.internal,
+        }));
+
+      if (validAddresses.length > 0) {
+        result.push({
+          name,
+          addresses: validAddresses,
+        });
+      }
+    }
+
+    // Always include localhost option
+    result.unshift({
+      name: "localhost",
+      addresses: [
+        {
+          address: "127.0.0.1",
+          family: "IPv4",
+          internal: true,
+        },
+      ],
+    });
+
+    // Always include all interfaces option
+    result.unshift({
+      name: "all",
+      addresses: [
+        {
+          address: "0.0.0.0",
+          family: "IPv4",
+          internal: false,
+        },
+      ],
+    });
+
+    return result;
+  }
+
+  /**
+   * Get a formatted list of binding options for UI
+   */
+  getBindingOptions(): BindingOption[] {
+    const interfaces = this.getNetworkInterfaces();
+    const options: BindingOption[] = [];
+
+    // Always add default binding options first
+    options.push({
+      value: "0.0.0.0",
+      label: "All interfaces",
+      description: "Listen on all available network interfaces",
+      interface: "all",
+    });
+
+    options.push({
+      value: "127.0.0.1",
+      label: "Localhost only",
+      description: "Only accessible from this machine",
+      interface: "localhost",
+    });
+
+    // Add specific interface options (excluding duplicates of the default options)
+    for (const iface of interfaces) {
+      for (const addr of iface.addresses) {
+        // Skip if this address is already in our default options
+        if (addr.address === "0.0.0.0" || addr.address === "127.0.0.1") {
+          continue;
+        }
+
+        options.push({
+          label: `${iface.name} (${addr.address})`,
+          value: addr.address,
+          description: `Accept connections on ${iface.name} network interface`,
+          interface: iface.name,
+        });
+      }
+    }
+
+    return options;
+  }
+
+  /**
+   * Get the current machine's primary IP address
+   */
+  getPrimaryIpAddress(): string | null {
+    const interfaces = this.getNetworkInterfaces();
+
+    // Look for the first non-localhost, non-all interface
+    for (const iface of interfaces) {
+      if (iface.name === "localhost" || iface.name === "all") continue;
+
+      for (const addr of iface.addresses) {
+        if (!addr.internal && addr.family === "IPv4") {
+          return addr.address;
+        }
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Validate if an IP address is valid for binding
+   */
+  isValidBindingAddress(address: string): boolean {
+    // Check for special addresses
+    if (address === "0.0.0.0" || address === "127.0.0.1") {
+      return true;
+    }
+
+    // Check if it's one of the machine's interfaces
+    const interfaces = this.getNetworkInterfaces();
+    for (const iface of interfaces) {
+      for (const addr of iface.addresses) {
+        if (addr.address === address) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Format network information for display
+   */
+  getNetworkInfo(): NetworkInfo {
+    const hostname = os.hostname();
+    const primaryIp = this.getPrimaryIpAddress();
+    const interfaces = this.getNetworkInterfaces();
+
+    return {
+      hostname,
+      primaryIp,
+      interfaces: interfaces.filter(
+        (i) => i.name !== "all" && i.name !== "localhost",
+      ),
+      bindingOptions: this.getBindingOptions(),
+    };
+  }
+
+  /**
+   * Check if running in Docker container
+   */
+  isDocker(): boolean {
+    try {
+      // Check for .dockerenv file
+      // fs already imported at top
+      if (fs.existsSync("/.dockerenv")) {
+        return true;
+      }
+
+      // Check cgroup for docker
+      const cgroup = fs.readFileSync("/proc/self/cgroup", "utf8");
+      return cgroup.includes("docker");
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get recommended binding address based on environment
+   */
+  getRecommendedBindingAddress(): string {
+    if (this.isDocker()) {
+      // In Docker, bind to all interfaces
+      return "0.0.0.0";
+    }
+
+    if (process.env.NODE_ENV === "production") {
+      // In production, bind to primary IP
+      return this.getPrimaryIpAddress() || "0.0.0.0";
+    }
+
+    // In development, bind to localhost
+    return "127.0.0.1";
+  }
+
+  /**
+   * Parse connection string (host:port)
+   */
+  parseConnectionString(
+    connectionString: string,
+  ): { host: string; port: number } | null {
+    const parts = connectionString.split(":");
+    if (parts.length !== 2) return null;
+
+    const host = parts[0];
+    const port = parseInt(parts[1], 10);
+
+    if (isNaN(port) || port < 1 || port > 65535) return null;
+
+    return { host, port };
+  }
+
+  /**
+   * Format connection URL
+   */
+  formatConnectionUrl(
+    protocol: string,
+    host: string,
+    port: number,
+    path: string = "",
+  ): string {
+    // Handle IPv6 addresses
+    const formattedHost = host.includes(":") ? `[${host}]` : host;
+    return `${protocol}://${formattedHost}:${port}${path}`;
+  }
+
+  /**
+   * Get network latency to a host
+   */
+  async getLatency(
+    host: string,
+    timeout: number = 5000,
+  ): Promise<number | null> {
+    const start = Date.now();
+
+    return new Promise((resolve) => {
+      // net already imported at top
+      const socket = new net.Socket();
+
+      const timer = setTimeout(() => {
+        socket.destroy();
+        resolve(null);
+      }, timeout);
+
+      socket.connect(80, host, () => {
+        clearTimeout(timer);
+        socket.destroy();
+        resolve(Date.now() - start);
+      });
+
+      socket.on("error", () => {
+        clearTimeout(timer);
+        resolve(null);
+      });
+    });
+  }
+
+  /**
+   * Check if a host is reachable
+   */
+  async isHostReachable(
+    host: string,
+    port: number,
+    timeout: number = 5000,
+  ): Promise<boolean> {
+    return new Promise((resolve) => {
+      // net already imported at top
+      const socket = new net.Socket();
+
+      const timer = setTimeout(() => {
+        socket.destroy();
+        resolve(false);
+      }, timeout);
+
+      socket.connect(port, host, () => {
+        clearTimeout(timer);
+        socket.destroy();
+        resolve(true);
+      });
+
+      socket.on("error", () => {
+        clearTimeout(timer);
+        resolve(false);
+      });
+    });
+  }
+
+  /**
+   * Get network statistics
+   */
+  getNetworkStats(): Record<string, any> {
+    const interfaces = os.networkInterfaces();
+    const stats: Record<string, any> = {};
+
+    for (const [name, addresses] of Object.entries(interfaces)) {
+      if (!addresses) continue;
+
+      stats[name] = {
+        ipv4: addresses.filter((a) => a.family === "IPv4").length,
+        ipv6: addresses.filter((a) => a.family === "IPv6").length,
+        internal: addresses.some((a) => a.internal),
+      };
+    }
+
+    return stats;
+  }
+}
+
+// Singleton instance
+let networkService: NetworkService | null = null;
+
+export function getNetworkService(): NetworkService {
+  if (!networkService) {
+    networkService = new NetworkService();
+  }
+  return networkService;
+}
+
+export default NetworkService;