mychron 0.3.2

data/lib/mychron/network/arp.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+module MyChron
+  module Network
+    class ARP
+      # Known AiM MAC OUI prefixes
+      # MyChron uses Espressif (ESP32) WiFi chips
+      AIM_OUI_PREFIXES = [
+        "88:57:21",  # Espressif Inc. - confirmed MyChron 6
+      ].freeze
+
+      # Espressif OUI prefixes (common in IoT devices)
+      ESPRESSIF_OUIS = %w[
+        24:0a:c4 24:6f:28 24:b2:de 30:ae:a4 3c:61:05 3c:71:bf
+        40:f5:20 48:3f:da 4c:11:ae 54:5a:a6 5c:cf:7f 60:01:94
+        68:c6:3a 70:03:9f 7c:9e:bd 80:7d:3a 84:0d:8e 84:cc:a8
+        84:f3:eb 88:57:21 8c:aa:b5 90:38:0c 94:b5:55 94:b9:7e
+        98:cd:ac 98:f4:ab a0:20:a6 a4:7b:9d a4:cf:12 ac:0b:fb
+        ac:67:b2 b4:e6:2d bc:dd:c2 c4:4f:33 c4:5b:be c8:2b:96
+        cc:50:e3 d8:a0:1d d8:bf:c0 dc:4f:22 e0:98:06 e8:68:e7
+        ec:94:cb f0:08:d1 f4:cf:a2 fc:f5:c4
+      ].freeze
+
+      attr_reader :interface
+
+      def initialize(interface: nil)
+        @interface = interface
+      end
+
+      # Discover hosts on local network via ARP table
+      # Returns array of { ip:, mac:, vendor: }
+      def discover
+        hosts = []
+
+        if macos?
+          hosts = parse_macos_arp
+        else
+          hosts = parse_linux_arp
+        end
+
+        hosts.map do |host|
+          host[:vendor] = lookup_vendor(host[:mac])
+          host[:is_aim] = aim_device?(host[:mac])
+          host[:is_espressif] = espressif_device?(host[:mac])
+          host
+        end
+      end
+
+      # Get subnet info from system
+      def self.detect_subnet
+        if macos?
+          detect_subnet_macos
+        else
+          detect_subnet_linux
+        end
+      end
+
+      def self.macos?
+        RUBY_PLATFORM.include?("darwin")
+      end
+
+      def macos?
+        self.class.macos?
+      end
+
+      private
+
+      def parse_macos_arp
+        output, status = Open3.capture2("arp", "-a")
+        return [] unless status.success?
+
+        hosts = []
+        output.each_line do |line|
+          # Format: ? (192.168.1.1) at aa:bb:cc:dd:ee:ff on en0 ifscope [ethernet]
+          match = line.match(/\((\d+\.\d+\.\d+\.\d+)\)\s+at\s+([0-9a-f:]+)/i)
+          next unless match
+
+          ip = match[1]
+          mac = normalize_mac(match[2])
+          next if mac == "(incomplete)" || mac.nil? || mac.empty?
+
+          hosts << { ip: ip, mac: mac, hostname: nil }
+        end
+        hosts
+      end
+
+      def parse_linux_arp
+        # Try ip neigh first (modern), fall back to arp -a
+        hosts = parse_ip_neigh
+        return hosts unless hosts.empty?
+
+        parse_arp_a_linux
+      end
+
+      def parse_ip_neigh
+        output, status = Open3.capture2("ip", "neigh")
+        return [] unless status.success?
+
+        hosts = []
+        output.each_line do |line|
+          # Format: 192.168.1.1 dev eth0 lladdr aa:bb:cc:dd:ee:ff REACHABLE
+          parts = line.split
+          next if parts.length < 5
+
+          ip = parts[0]
+          next unless valid_ipv4?(ip)
+
+          lladdr_idx = parts.index("lladdr")
+          next unless lladdr_idx
+
+          mac = normalize_mac(parts[lladdr_idx + 1])
+          next if mac.nil? || mac.empty?
+
+          hosts << { ip: ip, mac: mac, hostname: nil }
+        end
+        hosts
+      end
+
+      def parse_arp_a_linux
+        output, status = Open3.capture2("arp", "-a")
+        return [] unless status.success?
+
+        hosts = []
+        output.each_line do |line|
+          # Format varies, but typically: hostname (ip) at mac [ether] on iface
+          match = line.match(/\((\d+\.\d+\.\d+\.\d+)\)\s+at\s+([0-9a-f:]+)/i)
+          next unless match
+
+          ip = match[1]
+          mac = normalize_mac(match[2])
+          next if mac.nil? || mac.empty?
+
+          hosts << { ip: ip, mac: mac, hostname: nil }
+        end
+        hosts
+      end
+
+      def normalize_mac(mac)
+        return nil if mac.nil?
+        return nil if mac == "(incomplete)"
+
+        # Split by common separators and normalize each octet
+        parts = mac.downcase.split(/[:\-.]/)
+
+        # If split worked (should have 6 parts for MAC)
+        if parts.length == 6
+          # Pad each octet to 2 digits
+          normalized = parts.map { |p| p.rjust(2, "0") }.join(":")
+          return normalized if normalized.match?(/^([0-9a-f]{2}:){5}[0-9a-f]{2}$/)
+        end
+
+        # Fallback: remove all non-hex, must be 12 chars
+        clean = mac.gsub(/[^0-9a-f]/i, "").downcase
+        return nil if clean.length != 12
+
+        clean.chars.each_slice(2).map(&:join).join(":")
+      end
+
+      def valid_ipv4?(ip)
+        parts = ip.split(".")
+        return false unless parts.length == 4
+
+        parts.all? { |p| p.to_i.between?(0, 255) && p == p.to_i.to_s }
+      end
+
+      def lookup_vendor(mac)
+        return "Unknown" if mac.nil?
+
+        # OUI lookup could be implemented with a database
+        # For now, return Unknown
+        "Unknown"
+      end
+
+      def aim_device?(mac)
+        return false if mac.nil?
+
+        oui = mac[0..7] # First 3 octets (aa:bb:cc)
+        AIM_OUI_PREFIXES.include?(oui)
+      end
+
+      def espressif_device?(mac)
+        return false if mac.nil?
+
+        oui = mac[0..7]
+        ESPRESSIF_OUIS.include?(oui)
+      end
+
+      def self.detect_subnet_macos
+        # Get default route interface
+        output, status = Open3.capture2("route", "get", "default")
+        return nil unless status.success?
+
+        iface_match = output.match(/interface:\s*(\S+)/)
+        return nil unless iface_match
+
+        interface = iface_match[1]
+
+        # Get IP and netmask for interface
+        ifconfig_out, ifconfig_status = Open3.capture2("ifconfig", interface)
+        return nil unless ifconfig_status.success?
+
+        ip_match = ifconfig_out.match(/inet\s+(\d+\.\d+\.\d+\.\d+)\s+netmask\s+(0x[0-9a-f]+)/i)
+        return nil unless ip_match
+
+        ip = ip_match[1]
+        netmask_hex = ip_match[2]
+
+        # Convert hex netmask to CIDR
+        netmask_int = netmask_hex.to_i(16)
+        cidr = netmask_int.to_s(2).count("1")
+
+        # Calculate network address
+        ip_addr = IPAddr.new("#{ip}/#{cidr}")
+        subnet = "#{ip_addr.to_s}/#{cidr}"
+
+        {
+          interface: interface,
+          local_ip: ip,
+          subnet: subnet,
+          netmask: cidr
+        }
+      end
+
+      def self.detect_subnet_linux
+        # Get default route
+        output, status = Open3.capture2("ip", "route", "get", "1.1.1.1")
+        return nil unless status.success?
+
+        # Parse: 1.1.1.1 via 192.168.1.1 dev eth0 src 192.168.1.100
+        src_match = output.match(/src\s+(\d+\.\d+\.\d+\.\d+)/)
+        dev_match = output.match(/dev\s+(\S+)/)
+        return nil unless src_match && dev_match
+
+        local_ip = src_match[1]
+        interface = dev_match[1]
+
+        # Get subnet from ip addr
+        addr_out, addr_status = Open3.capture2("ip", "-4", "addr", "show", interface)
+        return nil unless addr_status.success?
+
+        cidr_match = addr_out.match(/inet\s+(\d+\.\d+\.\d+\.\d+)\/(\d+)/)
+        return nil unless cidr_match
+
+        cidr = cidr_match[2].to_i
+        ip_addr = IPAddr.new("#{local_ip}/#{cidr}")
+        subnet = "#{ip_addr.to_s}/#{cidr}"
+
+        {
+          interface: interface,
+          local_ip: local_ip,
+          subnet: subnet,
+          netmask: cidr
+        }
+      end
+    end
+  end
+end

data/lib/mychron/network/http_probe.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+
+module MyChron
+  module Network
+    class HttpProbe
+      DEFAULT_ENDPOINTS = ["/", "/api/", "/sessions/", "/data/", "/info"].freeze
+      AIM_INDICATORS = %w[aim mychron racestudio telemetry session].freeze
+
+      attr_reader :timeout
+
+      def initialize(timeout: 5)
+        @timeout = timeout
+      end
+
+      # Probe HTTP server at given IP and port
+      # Returns { status:, headers:, body_preview:, aim_score: }
+      def probe(ip, port: 80, endpoints: DEFAULT_ENDPOINTS)
+        base_url = port == 443 ? "https://#{ip}" : "http://#{ip}:#{port}"
+
+        results = {
+          reachable: false,
+          base_url: base_url,
+          endpoints: {},
+          aim_score: 0,
+          aim_indicators: []
+        }
+
+        endpoints.each do |endpoint|
+          result = probe_endpoint(base_url, endpoint)
+          results[:endpoints][endpoint] = result
+
+          if result[:status]
+            results[:reachable] = true
+
+            # Check for AiM indicators
+            indicators = check_aim_indicators(result)
+            unless indicators.empty?
+              results[:aim_indicators].concat(indicators)
+              results[:aim_score] += indicators.length * 10
+            end
+          end
+        end
+
+        results[:aim_indicators].uniq!
+        results
+      end
+
+      # Quick check if HTTP is available
+      def reachable?(ip, port: 80)
+        result = probe_endpoint("http://#{ip}:#{port}", "/")
+        !result[:status].nil?
+      end
+
+      private
+
+      def probe_endpoint(base_url, path)
+        uri = URI.join(base_url, path)
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.open_timeout = @timeout
+        http.read_timeout = @timeout
+        http.use_ssl = (uri.scheme == "https")
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE if http.use_ssl?
+
+        request = Net::HTTP::Get.new(uri)
+        request["User-Agent"] = "MyChron-Discovery/#{MyChron::VERSION}"
+
+        response = http.request(request)
+
+        {
+          status: response.code.to_i,
+          headers: response.to_hash,
+          body_preview: response.body&.slice(0, 500),
+          content_type: response["content-type"],
+          server: response["server"]
+        }
+      rescue Errno::ECONNREFUSED, Errno::ETIMEDOUT, Errno::EHOSTUNREACH,
+             Errno::ENOTCONN, Errno::ECONNRESET, Errno::ENETUNREACH,
+             Errno::EPIPE, Errno::ECONNABORTED, IOError,
+             Net::OpenTimeout, Net::ReadTimeout, SocketError,
+             OpenSSL::SSL::SSLError => e
+        {
+          status: nil,
+          error: e.class.name,
+          message: e.message
+        }
+      end
+
+      def check_aim_indicators(result)
+        indicators = []
+
+        # Check headers
+        server = result[:server]&.downcase
+        if server
+          AIM_INDICATORS.each do |indicator|
+            indicators << "server:#{indicator}" if server.include?(indicator)
+          end
+        end
+
+        # Check body
+        body = result[:body_preview]&.downcase
+        if body
+          AIM_INDICATORS.each do |indicator|
+            indicators << "body:#{indicator}" if body.include?(indicator)
+          end
+        end
+
+        # Check content type
+        ct = result[:content_type]&.downcase
+        if ct&.include?("json")
+          indicators << "json_api"
+        end
+
+        indicators
+      end
+    end
+  end
+end

data/lib/mychron/network/scanner.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module MyChron
+  module Network
+    class Scanner
+      DEFAULT_PORTS = [21, 22, 80, 443, 8080, 5000, 6000, 7000, 9000] + (10_000..10_100).to_a
+
+      attr_reader :timeout, :use_nmap
+
+      def initialize(timeout: 0.5, use_nmap: nil)
+        @timeout = timeout
+        @use_nmap = use_nmap.nil? ? nmap_available? : use_nmap
+      end
+
+      # Scan a single host for open ports
+      # Returns hash of { port => { open: bool, banner: string|nil } }
+      def scan(ip, ports: DEFAULT_PORTS)
+        if @use_nmap
+          scan_with_nmap(ip, ports)
+        else
+          scan_with_ruby(ip, ports)
+        end
+      end
+
+      # Quick check if any common ports are open
+      def quick_scan(ip, ports: [80, 443, 8080, 21, 22])
+        results = scan(ip, ports: ports)
+        results.select { |_, v| v[:open] }
+      end
+
+      # Check if a single port is open
+      def port_open?(ip, port)
+        result = scan(ip, ports: [port])
+        result[port]&.fetch(:open, false)
+      end
+
+      private
+
+      def nmap_available?
+        _, status = Open3.capture2("which", "nmap")
+        status.success?
+      end
+
+      def scan_with_nmap(ip, ports)
+        port_str = ports.join(",")
+
+        # -sT: TCP connect scan (no root required)
+        # -sV: Version detection for banners
+        # --open: Only show open ports
+        # -T4: Aggressive timing
+        cmd = ["nmap", "-sT", "-sV", "--open", "-T4", "-p", port_str, ip]
+
+        output, status = Open3.capture2(*cmd)
+        return {} unless status.success?
+
+        parse_nmap_output(output, ports)
+      end
+
+      def parse_nmap_output(output, all_ports)
+        results = all_ports.each_with_object({}) do |port, hash|
+          hash[port] = { open: false, banner: nil }
+        end
+
+        output.each_line do |line|
+          # Format: 80/tcp   open  http    Apache httpd 2.4.41
+          match = line.match(/^(\d+)\/tcp\s+open\s+(\S+)\s*(.*)/)
+          next unless match
+
+          port = match[1].to_i
+          service = match[2]
+          version = match[3].strip
+
+          banner = version.empty? ? service : "#{service} #{version}"
+          results[port] = { open: true, banner: banner }
+        end
+
+        results
+      end
+
+      def scan_with_ruby(ip, ports)
+        results = {}
+        mutex = Mutex.new
+
+        # Process in batches to avoid too many concurrent connections
+        ports.each_slice(20) do |port_batch|
+          threads = port_batch.map do |port|
+            Thread.new do
+              Thread.current.report_on_exception = false
+              begin
+                result = check_port(ip, port)
+                mutex.synchronize { results[port] = result }
+              rescue StandardError => e
+                mutex.synchronize { results[port] = { open: false, banner: nil, error: e.message } }
+              end
+            end
+          end
+
+          # Wait for batch to complete
+          threads.each(&:join)
+        end
+
+        results
+      end
+
+      def check_port(ip, port)
+        socket = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+        sockaddr = Socket.sockaddr_in(port, ip)
+
+        begin
+          socket.connect_nonblock(sockaddr)
+          banner = grab_banner(socket)
+          { open: true, banner: banner }
+        rescue IO::WaitWritable, IO::EINPROGRESSWaitWritable
+          # Connection in progress, wait for socket to become writable
+          if IO.select(nil, [socket], nil, @timeout)
+            begin
+              # Check if connection succeeded
+              socket.connect_nonblock(sockaddr)
+              banner = grab_banner(socket)
+              { open: true, banner: banner }
+            rescue Errno::EISCONN
+              # Already connected - success
+              banner = grab_banner(socket)
+              { open: true, banner: banner }
+            rescue Errno::EALREADY
+              # Still connecting, wait a bit more
+              sleep(0.1)
+              begin
+                socket.connect_nonblock(sockaddr)
+                { open: true, banner: nil }
+              rescue Errno::EISCONN
+                { open: true, banner: nil }
+              rescue StandardError
+                { open: false, banner: nil }
+              end
+            rescue Errno::ECONNREFUSED, Errno::ETIMEDOUT, Errno::EHOSTUNREACH,
+                   Errno::ENOTCONN, Errno::ECONNRESET
+              { open: false, banner: nil }
+            end
+          else
+            { open: false, banner: nil }
+          end
+        rescue Errno::ECONNREFUSED, Errno::ETIMEDOUT, Errno::EHOSTUNREACH,
+               Errno::ENETUNREACH, Errno::ECONNRESET
+          { open: false, banner: nil }
+        ensure
+          socket.close rescue nil
+        end
+      end
+
+      def grab_banner(socket)
+        # Try to read banner with short timeout
+        socket.read_nonblock(1024)
+      rescue IO::WaitReadable
+        if IO.select([socket], nil, nil, 0.5)
+          begin
+            socket.read_nonblock(1024)
+          rescue StandardError
+            nil
+          end
+        end
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end