mychron 0.3.2

data/lib/mychron/discovery/detector.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+module MyChron
+  module Discovery
+    class Detector
+      include Logging
+
+      attr_reader :interface, :subnet, :local_ip
+
+      def initialize(interface: nil, subnet: nil)
+        @interface = interface
+        @subnet = subnet
+        @local_ip = nil
+        @config = MyChron.config
+
+        detect_network_info unless @subnet
+      end
+
+      # Run full discovery
+      # Returns discovery result hash
+      def run(scan_ports: nil, probe_http: true)
+        scan_ports ||= @config.scan_ports
+        scan_ports = Array(scan_ports)
+
+        log_info("Network discovery started on #{@subnet} (#{@interface}), scanning #{scan_ports.length} ports")
+
+        result = {
+          timestamp: Time.now.utc.iso8601,
+          local_ip: @local_ip,
+          interface: @interface,
+          subnet: @subnet,
+          discovered_hosts: [],
+          likely_candidates: [],
+          wifi_aps: []
+        }
+
+        # Step 1: Discover hosts via ARP
+        arp = Network::ARP.new(interface: @interface)
+        hosts = arp.discover
+
+        log_info("ARP discovery complete: #{hosts.length} hosts")
+
+        result[:discovered_hosts] = hosts.map do |h|
+          { ip: h[:ip], mac: h[:mac], vendor: h[:vendor], hostname: h[:hostname] }
+        end
+
+        # Step 2: Scan WiFi APs (for AP mode detection)
+        result[:wifi_aps] = scan_wifi_aps
+
+        # Step 3: Port scan each host
+        scanner = Network::Scanner.new(timeout: @config.scan_timeout)
+        http_probe = Network::HttpProbe.new(timeout: @config.http_timeout)
+        scorer = Scorer.new
+
+        candidates = []
+
+        hosts.each do |host|
+          log_debug("Scanning #{host[:ip]}")
+
+          # Port scan
+          ports = scanner.scan(host[:ip], ports: scan_ports)
+
+          candidate = host.merge(ports: ports)
+
+          # Check for WiFi AP match
+          candidate[:wifi_ap_match] = result[:wifi_aps].any? do |ap|
+            ap[:ssid]&.downcase&.include?("aim") ||
+              ap[:ssid]&.downcase&.include?("myc")
+          end
+
+          # HTTP probe if enabled and web port is open
+          if probe_http
+            web_ports = ports.select { |p, v| v[:open] && [80, 443, 8080].include?(p) }.keys
+            web_ports.each do |port|
+              probe_result = http_probe.probe(host[:ip], port: port)
+              candidate[:http_probe] = probe_result
+              break if probe_result[:reachable]
+            end
+          end
+
+          # Score the candidate
+          scored = scorer.score(candidate)
+          candidate = candidate.merge(
+            score: scored[:score],
+            reasons: scored[:reasons],
+            is_likely: scored[:is_likely]
+          )
+
+          open_ports = ports.select { |_, v| v[:open] }.keys
+          log_info("Scanned #{host[:ip]} (#{host[:mac]}): ports=#{open_ports}, score=#{scored[:score]}, reasons=#{scored[:reasons]}")
+
+          candidates << candidate
+        end
+
+        # Sort by score descending
+        result[:likely_candidates] = candidates
+          .select { |c| c[:score] > 0 }
+          .sort_by { |c| -c[:score] }
+          .map do |c|
+            {
+              ip: c[:ip],
+              mac: c[:mac],
+              score: c[:score],
+              reasons: c[:reasons],
+              is_likely: c[:is_likely],
+              ports: format_ports(c[:ports]),
+              http_probe: c[:http_probe]
+            }
+          end
+
+        log_info("Discovery complete: #{hosts.length} hosts, #{result[:likely_candidates].length} candidates")
+
+        result
+      end
+
+      # Quick scan for a specific IP
+      def probe_host(ip, scan_ports: nil)
+        scan_ports ||= @config.scan_ports
+
+        scanner = Network::Scanner.new(timeout: @config.scan_timeout)
+        http_probe = Network::HttpProbe.new(timeout: @config.http_timeout)
+        scorer = Scorer.new
+
+        ports = scanner.scan(ip, ports: scan_ports)
+
+        candidate = {
+          ip: ip,
+          mac: nil,
+          ports: ports
+        }
+
+        # HTTP probe
+        web_ports = ports.select { |p, v| v[:open] && [80, 443, 8080].include?(p) }.keys
+        web_ports.each do |port|
+          probe_result = http_probe.probe(ip, port: port)
+          candidate[:http_probe] = probe_result
+          break if probe_result[:reachable]
+        end
+
+        scored = scorer.score(candidate)
+        candidate.merge(
+          score: scored[:score],
+          reasons: scored[:reasons],
+          is_likely: scored[:is_likely],
+          ports: format_ports(ports)
+        )
+      end
+
+      private
+
+      def detect_network_info
+        info = Network::ARP.detect_subnet
+        return unless info
+
+        @interface = info[:interface]
+        @subnet = info[:subnet]
+        @local_ip = info[:local_ip]
+      end
+
+      def scan_wifi_aps
+        aps = []
+
+        if Network::ARP.macos?
+          aps = scan_wifi_macos
+        else
+          aps = scan_wifi_linux
+        end
+
+        aps.select { |ap| ap[:ssid]&.downcase&.match?(/aim|myc/) }
+      end
+
+      def scan_wifi_macos
+        airport_path = "/System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources/airport"
+        return [] unless File.exist?(airport_path)
+
+        output, status = Open3.capture2(airport_path, "-s")
+        return [] unless status.success?
+
+        aps = []
+        output.each_line.with_index do |line, idx|
+          next if idx == 0 # Skip header
+
+          # Format: SSID BSSID RSSI CHANNEL HT CC SECURITY
+          parts = line.strip.split(/\s+/)
+          next if parts.length < 2
+
+          aps << { ssid: parts[0], bssid: parts[1] }
+        end
+        aps
+      end
+
+      def scan_wifi_linux
+        # Try nmcli first
+        output, status = Open3.capture2("nmcli", "-t", "-f", "SSID,BSSID", "device", "wifi", "list")
+        return [] unless status.success?
+
+        aps = []
+        output.each_line do |line|
+          parts = line.strip.split(":")
+          next if parts.length < 2
+
+          aps << { ssid: parts[0], bssid: parts[1..-1].join(":") }
+        end
+        aps
+      rescue Errno::ENOENT
+        # nmcli not available, try iwlist
+        scan_wifi_iwlist
+      end
+
+      def scan_wifi_iwlist
+        # Find wireless interface
+        interfaces = Dir["/sys/class/net/*/wireless"].map { |p| p.split("/")[-2] }
+        return [] if interfaces.empty?
+
+        iface = interfaces.first
+        output, status = Open3.capture2("sudo", "iwlist", iface, "scan")
+        return [] unless status.success?
+
+        aps = []
+        current_bssid = nil
+
+        output.each_line do |line|
+          if line.include?("Address:")
+            current_bssid = line.split("Address:").last.strip
+          elsif line.include?("ESSID:")
+            ssid = line.split("ESSID:").last.strip.tr('"', "")
+            aps << { ssid: ssid, bssid: current_bssid } if current_bssid
+          end
+        end
+        aps
+      rescue StandardError
+        []
+      end
+
+      def format_ports(ports)
+        ports.transform_values do |v|
+          { open: v[:open], banner: v[:banner] }
+        end.select { |_, v| v[:open] }
+      end
+    end
+  end
+end

data/lib/mychron/discovery/scorer.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module MyChron
+  module Discovery
+    class Scorer
+      include Logging
+
+      # Scoring weights
+      WEIGHTS = {
+        wifi_ap_match: 50,       # WiFi AP SSID matches AiM-MYC6-*
+        mychron_data_port: 40,   # TCP port 2000 open (MyChron data protocol)
+        mac_oui_match: 30,       # MAC vendor matches AiM OUI (confirmed)
+        espressif_mac: 20,       # Espressif OUI (MyChron uses ESP32)
+        http_server: 20,         # HTTP server responds
+        aim_banner: 10,          # Banner contains AiM indicators
+        mdns_service: 5,         # mDNS service discovered
+        common_port: 5,          # Common service ports open (80, 8080)
+        unusual_port: 3          # Unusual ports open (suggests embedded device)
+      }.freeze
+
+      # Ports that suggest embedded device
+      EMBEDDED_PORTS = [5000, 6000, 7000, 9000] + (10_000..10_100).to_a
+
+      def initialize; end
+
+      # Score a candidate based on available evidence
+      # Returns { score:, reasons: [], is_likely: bool }
+      def score(candidate)
+        score = 0
+        reasons = []
+
+        # WiFi AP match (highest confidence)
+        if candidate[:wifi_ap_match]
+          score += WEIGHTS[:wifi_ap_match]
+          reasons << "wifi_ap_match"
+        end
+
+        # MAC OUI match (confirmed AiM)
+        if candidate[:is_aim]
+          score += WEIGHTS[:mac_oui_match]
+          reasons << "mac_oui_match"
+        end
+
+        # Espressif MAC (MyChron uses ESP32 WiFi)
+        if candidate[:is_espressif]
+          score += WEIGHTS[:espressif_mac]
+          reasons << "espressif_mac"
+        end
+
+        # HTTP probe results
+        if candidate[:http_probe]
+          http = candidate[:http_probe]
+
+          if http[:reachable]
+            score += WEIGHTS[:http_server]
+            reasons << "http_server"
+
+            if http[:aim_score] && http[:aim_score] > 0
+              score += http[:aim_score]
+              reasons << "aim_indicators:#{http[:aim_indicators].join(',')}"
+            end
+          end
+        end
+
+        # Port scan results
+        if candidate[:ports]
+          open_ports = candidate[:ports].select { |_, v| v[:open] }.keys
+
+          # MyChron TCP data port (strongest network signal)
+          if open_ports.include?(2000)
+            score += WEIGHTS[:mychron_data_port]
+            reasons << "mychron_data_port"
+          end
+
+          # Common web ports
+          if open_ports.intersect?([80, 443, 8080])
+            score += WEIGHTS[:common_port]
+            reasons << "common_ports"
+          end
+
+          # Embedded device ports
+          embedded_open = open_ports & EMBEDDED_PORTS
+          if embedded_open.any?
+            score += WEIGHTS[:unusual_port] * [embedded_open.length, 5].min
+            reasons << "embedded_ports:#{embedded_open.join(',')}"
+          end
+
+          # Check banners for AiM indicators
+          candidate[:ports].each do |port, info|
+            next unless info[:open] && info[:banner]
+
+            banner_lower = info[:banner].downcase
+            if %w[aim mychron racestudio].any? { |ind| banner_lower.include?(ind) }
+              score += WEIGHTS[:aim_banner]
+              reasons << "banner_match:#{port}"
+            end
+          end
+        end
+
+        {
+          score: score,
+          reasons: reasons,
+          is_likely: score >= 30  # Threshold for "likely" candidate
+        }
+      end
+
+      # Compare two candidates, return the better one
+      def compare(a, b)
+        score_a = score(a)[:score]
+        score_b = score(b)[:score]
+        score_a >= score_b ? a : b
+      end
+
+      # Sort candidates by score descending
+      def rank(candidates)
+        candidates.map do |c|
+          scored = score(c)
+          c.merge(score: scored[:score], reasons: scored[:reasons], is_likely: scored[:is_likely])
+        end.sort_by { |c| -c[:score] }
+      end
+    end
+  end
+end

data/lib/mychron/errors.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module MyChron
+  # Base error class for all MyChron errors
+  class Error < StandardError; end
+
+  # Raised when unable to connect to the device
+  class ConnectionError < Error; end
+
+  # Raised when the protocol communication fails
+  class ProtocolError < Error; end
+
+  # Raised when an operation times out
+  class TimeoutError < Error; end
+
+  # Raised when no sessions are found on the device
+  class NoSessionsError < Error; end
+
+  # Raised when a file download fails
+  class DownloadError < Error; end
+
+  # Raised when device discovery fails
+  class DiscoveryError < Error; end
+
+  # Raised when the device is not reachable
+  class DeviceNotFoundError < Error; end
+end

data/lib/mychron/logging.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module MyChron
+  # Logging module that integrates with Rails.logger when available
+  # Falls back to a null logger for silent library operation
+  module Logging
+    class << self
+      # Get the current logger instance
+      # Auto-detects Rails.logger if available
+      def logger
+        @logger ||= detect_logger
+      end
+
+      # Set a custom logger
+      # @param logger [Logger] A Logger-compatible instance
+      def logger=(logger)
+        @logger = logger
+      end
+
+      # Reset to auto-detection
+      def reset!
+        @logger = nil
+      end
+
+      private
+
+      def detect_logger
+        if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+          Rails.logger
+        else
+          # Silent by default for library use
+          # Users can set MyChron::Logging.logger = Logger.new(STDOUT) if needed
+          null_logger
+        end
+      end
+
+      def null_logger
+        Logger.new(IO::NULL)
+      end
+    end
+
+    # Instance method to access logger from including classes
+    def logger
+      MyChron::Logging.logger
+    end
+
+    # Log at debug level
+    def log_debug(message, context = {})
+      logger.debug { format_message(message, context) }
+    end
+
+    # Log at info level
+    def log_info(message, context = {})
+      logger.info { format_message(message, context) }
+    end
+
+    # Log at warn level
+    def log_warn(message, context = {})
+      logger.warn { format_message(message, context) }
+    end
+
+    # Log at error level
+    def log_error(message, context = {})
+      logger.error { format_message(message, context) }
+    end
+
+    private
+
+    def format_message(message, context)
+      if context.empty?
+        "[MyChron] #{message}"
+      else
+        "[MyChron] #{message} #{context.inspect}"
+      end
+    end
+  end
+end

data/lib/mychron/monitor/watcher.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module MyChron
+  module Monitor
+    class Watcher
+      include Logging
+
+      attr_reader :subnet, :interface, :local_ip
+      attr_reader :known_candidates, :best_candidate
+
+      def initialize(subnet: nil, interface: nil)
+        @subnet = subnet
+        @interface = interface
+        @local_ip = nil
+        @config = MyChron.config
+        @running = false
+        @known_candidates = {}
+        @best_candidate = nil
+
+        detect_network_info unless @subnet
+      end
+
+      # Start watching loop
+      def start(interval: nil)
+        interval ||= @config.watch_interval
+        @running = true
+
+        log_info("Watch started on #{@subnet} (#{@interface}), interval: #{interval}s")
+
+        trap("INT") { stop }
+        trap("TERM") { stop }
+
+        detector = Discovery::Detector.new(interface: @interface, subnet: @subnet)
+
+        while @running
+          begin
+            check_cycle(detector)
+          rescue StandardError => e
+            log_error("Watch error: #{e.message}")
+          end
+
+          sleep(interval) if @running
+        end
+
+        log_info("Watch stopped")
+      end
+
+      # Stop watching
+      def stop
+        @running = false
+      end
+
+      # One-shot probe of specific IP
+      def probe(ip)
+        detector = Discovery::Detector.new(interface: @interface, subnet: @subnet)
+        result = detector.probe_host(ip)
+
+        log_info("Probe #{ip}: score=#{result[:score]}, likely=#{result[:is_likely]}, ports=#{result[:ports].keys}")
+
+        result
+      end
+
+      # Attempt download handshake (dry-run)
+      def download_attempt(ip, dry_run: true)
+        log_info("Download attempt for #{ip} (dry_run=#{dry_run})")
+
+        # First, probe the host
+        result = probe(ip)
+
+        unless result[:is_likely]
+          log_warn("#{ip} is unlikely candidate (score=#{result[:score]})")
+          return { success: false, reason: "unlikely_candidate", probe: result }
+        end
+
+        # Try to identify protocol
+        protocol = identify_protocol(ip, result)
+
+        log_info("Protocol identified for #{ip}: #{protocol}")
+
+        if dry_run
+          return {
+            success: true,
+            dry_run: true,
+            protocol: protocol,
+            probe: result,
+            message: "Dry run complete. Would attempt #{protocol} download."
+          }
+        end
+
+        # Actual download would go here
+        { success: false, reason: "download_not_implemented", protocol: protocol }
+      end
+
+      private
+
+      def detect_network_info
+        info = Network::ARP.detect_subnet
+        return unless info
+
+        @interface = info[:interface]
+        @subnet = info[:subnet]
+        @local_ip = info[:local_ip]
+      end
+
+      def check_cycle(detector)
+        log_debug("Check cycle started")
+
+        # Quick ARP check
+        arp = Network::ARP.new(interface: @interface)
+        hosts = arp.discover
+
+        current_ips = hosts.map { |h| h[:ip] }
+        known_ips = @known_candidates.keys
+
+        # Detect new hosts
+        new_ips = current_ips - known_ips
+        lost_ips = known_ips - current_ips
+
+        # Log lost candidates
+        lost_ips.each do |ip|
+          candidate = @known_candidates.delete(ip)
+          if candidate && candidate[:is_likely]
+            log_info("Candidate lost: #{ip} (mac=#{candidate[:mac]}, score=#{candidate[:score]})")
+          end
+        end
+
+        # Probe new hosts
+        new_ips.each do |ip|
+          host = hosts.find { |h| h[:ip] == ip }
+          next unless host
+
+          result = detector.probe_host(ip, scan_ports: quick_ports)
+
+          @known_candidates[ip] = result.merge(mac: host[:mac])
+
+          if result[:is_likely]
+            log_info("Candidate detected: #{ip} (mac=#{host[:mac]}, score=#{result[:score]}, reasons=#{result[:reasons]})")
+
+            # Update best candidate
+            if @best_candidate.nil? || result[:score] > @best_candidate[:score]
+              @best_candidate = result.merge(ip: ip, mac: host[:mac])
+            end
+          end
+        end
+
+        log_debug("Check cycle complete: #{hosts.length} hosts, #{new_ips.length} new, #{lost_ips.length} lost")
+      end
+
+      def quick_ports
+        # Smaller port set for quick checks
+        [21, 22, 80, 443, 8080, 5000, 7000, 9000, 10000, 10080]
+      end
+
+      def identify_protocol(ip, probe_result)
+        open_ports = probe_result[:ports].keys
+
+        return "ftp" if open_ports.include?(21)
+        return "http" if open_ports.intersect?([80, 8080])
+        return "https" if open_ports.include?(443)
+
+        "unknown"
+      end
+    end
+  end
+end