rble 0.7.0

data/lib/rble/cli/monitor.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require_relative 'characteristic_helpers'
+
+module RBLE
+  module CLI
+    class Monitor
+      include CharacteristicHelpers
+
+      def initialize(options)
+        @options = options
+        @formatter = options["json"] ? Formatters::Json.new : Formatters::Text.new
+        @address = options["address"]
+        @characteristic_uuid = options["characteristic"]
+        @timeout = options["timeout"] || 10
+        @reconnect = options["reconnect"] || false
+        @stop = false
+      end
+
+      def execute
+        if @reconnect
+          reconnect_loop
+        else
+          single_session
+        end
+      rescue RBLE::DeviceNotFoundError => e
+        $stderr.puts "Error: #{e.message}"
+        $stderr.puts "Run `rble scan` first to discover nearby devices."
+        exit 1
+      rescue RBLE::Error => e
+        $stderr.puts "Error: #{e.message}"
+        exit 1
+      end
+
+      private
+
+      # Run a single monitor session: connect, subscribe, stream until stop or disconnect.
+      def single_session
+        connection = connect_and_discover(@address, timeout: @timeout)
+
+        begin
+          char = find_characteristic(connection, @characteristic_uuid)
+
+          unless char.subscribable?
+            $stderr.puts "Error: Characteristic #{@characteristic_uuid} does not support notifications."
+            $stderr.puts "Supported: #{char.flags.join(', ')}"
+            exit 1
+          end
+
+          stream_notifications(connection, char)
+        ensure
+          connection.disconnect if connection.connected?
+        end
+      end
+
+      # Reconnect loop: retry single_session on connection errors until @stop is set.
+      def reconnect_loop
+        loop do
+          begin
+            single_session
+          rescue RBLE::DeviceNotFoundError
+            raise # No retry for device not found
+          rescue RBLE::ConnectionTimeoutError, RBLE::ConnectionFailed, RBLE::Error => e
+            break if @stop
+
+            $stderr.puts "Error: #{e.message}"
+            $stderr.puts "Reconnecting in 2s..."
+            interruptible_sleep(2)
+            next
+          end
+
+          break if @stop
+
+          $stderr.puts "Device disconnected."
+          $stderr.puts "Reconnecting in 2s..."
+          interruptible_sleep(2)
+        end
+      end
+
+      # Sleep in short intervals, checking @stop flag for responsiveness
+      # @param seconds [Numeric] Total sleep duration
+      def interruptible_sleep(seconds)
+        intervals = (seconds / 0.1).ceil
+        intervals.times do
+          break if @stop
+          sleep 0.1
+        end
+      end
+
+      # Subscribe and stream notifications until @stop flag or disconnect.
+      def stream_notifications(connection, char)
+        name = resolve_char_name(char.uuid)
+        char_display_name = RBLE::GATT::UUIDDatabase.resolve(char.uuid, type: :characteristic)
+
+        $stderr.puts "Subscribing to #{name}..."
+
+        char.subscribe do |value|
+          timestamp = Time.now
+          formatted = format_value(char.uuid, value)
+          @formatter.monitor_value(
+            address: @address,
+            uuid: char.uuid,
+            name: char_display_name,
+            raw: value,
+            formatted: formatted,
+            timestamp: timestamp
+          )
+        end
+
+        $stderr.puts "Subscribed, waiting for notifications..."
+
+        prev_handler = trap("INT") { @stop = true }
+
+        begin
+          while !@stop && connection.connected?
+            sleep 0.1
+          end
+
+          unless connection.connected?
+            $stderr.puts "Device disconnected." unless @stop
+          end
+        ensure
+          trap("INT", prev_handler || "DEFAULT")
+          char.unsubscribe if connection.connected?
+        end
+      end
+    end
+  end
+end

data/lib/rble/cli/pair.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module RBLE
+  module CLI
+    # IO handler for interactive terminal prompts during pairing
+    class TerminalIOHandler
+      def display(msg)
+        $stderr.puts msg
+      end
+
+      def prompt(msg)
+        $stderr.print msg
+        $stdin.gets&.strip
+      end
+
+      def confirm(msg)
+        $stderr.print msg
+        response = $stdin.gets&.strip&.downcase
+        response == 'y' || response == 'yes'
+      end
+    end
+
+    # Null IO handler for JSON mode (no interactive prompts on stdout)
+    class NullIOHandler
+      def display(_msg); end
+
+      def prompt(_msg)
+        nil
+      end
+
+      def confirm(_msg)
+        false
+      end
+    end
+
+    class Pair
+      SECURITY_CAPABILITY_MAP = {
+        "low" => "NoInputNoOutput",
+        "medium" => "DisplayYesNo",
+        "high" => "KeyboardDisplay"
+      }.freeze
+
+      def initialize(options)
+        @options = options
+        @formatter = options["json"] ? Formatters::Json.new : Formatters::Text.new
+        @address = options["address"]
+        @timeout = options["timeout"] || 30
+        @security = options["security"]
+        @force = options["force"] || false
+      end
+
+      def execute
+        if @security && !SECURITY_CAPABILITY_MAP.key?(@security)
+          $stderr.puts "Error: Invalid security level '#{@security}'. Use: #{SECURITY_CAPABILITY_MAP.keys.join(', ')}"
+          exit 1
+        end
+
+        backend = RBLE::Backend.for_platform
+        device_path = backend.device_path_for_address(@address)
+
+        if device_path.nil?
+          $stderr.puts "Error: Device #{@address} not found."
+          $stderr.puts "Run `rble scan` first to discover nearby devices."
+          exit 1
+        end
+
+        io_handler = @options["json"] ? NullIOHandler.new : TerminalIOHandler.new
+        capability = SECURITY_CAPABILITY_MAP[@security]
+
+        $stderr.puts "Pairing with #{@address}..."
+        result = backend.pair_device(
+          device_path,
+          io_handler: io_handler,
+          force: @force,
+          capability: capability,
+          timeout: @timeout
+        )
+
+        case result
+        when :paired
+          $stderr.puts "Bonded successfully"
+          @formatter.pair_result(success: true, address: @address, message: "Bonded successfully")
+        when :already_paired
+          $stderr.puts "Device already paired"
+          @formatter.pair_result(success: true, address: @address, message: "Already paired")
+        end
+      rescue RBLE::DeviceNotFoundError => e
+        $stderr.puts "Error: #{e.message}"
+        $stderr.puts "Run `rble scan` first to discover nearby devices."
+        exit 1
+      rescue RBLE::AuthenticationError
+        $stderr.puts "Error: Pairing rejected by device. Ensure device is in pairing mode and try again."
+        exit 1
+      rescue RBLE::ConnectionFailed
+        $stderr.puts "Error: Connection failed. Device may be out of range."
+        exit 1
+      rescue RBLE::Error => e
+        $stderr.puts "Error: #{e.message}"
+        exit 1
+      end
+    end
+  end
+end

data/lib/rble/cli/paired.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RBLE
+  module CLI
+    class Paired
+      def initialize(options)
+        @options = options
+        @formatter = options["json"] ? Formatters::Json.new : Formatters::Text.new
+      end
+
+      def execute
+        backend = RBLE::Backend.for_platform
+        devices = backend.bonded_devices
+
+        @formatter.paired_list(devices)
+      rescue RBLE::Error => e
+        $stderr.puts "Error: #{e.message}"
+        exit 1
+      end
+    end
+  end
+end

data/lib/rble/cli/read.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative 'characteristic_helpers'
+
+module RBLE
+  module CLI
+    class Read
+      include CharacteristicHelpers
+
+      def initialize(options)
+        @options = options
+        @formatter = options["json"] ? Formatters::Json.new : Formatters::Text.new
+        @address = options["address"]
+        @characteristic_uuid = options["characteristic"]
+        @timeout = options["timeout"] || 10
+      end
+
+      def execute
+        connection = connect_and_discover(@address, timeout: @timeout)
+
+        begin
+          char = find_characteristic(connection, @characteristic_uuid)
+
+          unless char.readable?
+            $stderr.puts "Error: Characteristic #{@characteristic_uuid} does not support read."
+            $stderr.puts "Supported: #{char.flags.join(', ')}"
+            exit 1
+          end
+
+          name = resolve_char_name(char.uuid)
+          $stderr.puts "Reading #{name}..."
+          raw_value = char.read
+          formatted = format_value(char.uuid, raw_value)
+
+          @formatter.read_value(
+            address: @address,
+            uuid: char.uuid,
+            name: RBLE::GATT::UUIDDatabase.resolve(char.uuid, type: :characteristic),
+            raw: raw_value,
+            formatted: formatted
+          )
+        ensure
+          connection.disconnect if connection.connected?
+        end
+      rescue RBLE::DeviceNotFoundError => e
+        $stderr.puts "Error: #{e.message}"
+        $stderr.puts "Run `rble scan` first to discover nearby devices."
+        exit 1
+      rescue RBLE::Error => e
+        $stderr.puts "Error: #{e.message}"
+        exit 1
+      end
+    end
+  end
+end

data/lib/rble/cli/scan.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module RBLE
+  module CLI
+    class Scan
+      def initialize(options)
+        @options = options
+        @formatter = options["json"] ? Formatters::Json.new : Formatters::Text.new
+        @advertisement_count = 0
+        @seen_addresses = Set.new
+        @start_time = nil
+      end
+
+      def execute
+        scanner = RBLE::Scanner.new(
+          timeout: @options["timeout"],
+          active: !@options["passive"],
+          allow_duplicates: true
+        )
+
+        prev_handler = trap("INT") { scanner.stop }
+
+        @advertisement_count = 0
+        @seen_addresses = Set.new
+        @start_time = Time.now
+
+        begin
+          scanner.start do |device|
+            next unless matches_filters?(device)
+
+            @advertisement_count += 1
+            is_new = @seen_addresses.add?(device.address)
+            next if @options["unique"] && !is_new
+
+            @formatter.device(device)
+          end
+        rescue RBLE::Error => e
+          handle_error(e)
+        ensure
+          trap("INT", prev_handler || "DEFAULT")
+        end
+
+        duration = (Time.now - @start_time).round(1)
+        device_count = @seen_addresses.size
+        $stderr.puts "Discovered #{device_count} device#{'s' unless device_count == 1} " \
+                     "(#{@advertisement_count} advertisement#{'s' unless @advertisement_count == 1}) " \
+                     "in #{duration}s"
+
+        if @options["timeout"] && @advertisement_count.zero? && has_filters?
+          $stderr.puts "No devices found matching filters"
+        end
+      end
+
+      private
+
+      def matches_filters?(device)
+        if @options["name"]
+          return false unless device.name
+          return false unless device.name.downcase.include?(@options["name"].downcase)
+        end
+
+        if @options["rssi"]
+          return false unless device.rssi
+          return false unless device.rssi >= @options["rssi"]
+        end
+
+        true
+      end
+
+      def has_filters?
+        @options["name"] || @options["rssi"]
+      end
+
+      def handle_error(error)
+        $stderr.puts "Error: #{error.message}"
+
+        if @options["verbose"]
+          $stderr.puts error.recovery_hint if error.respond_to?(:recovery_hint)
+          $stderr.puts error.backtrace.join("\n") if error.backtrace
+        end
+
+        exit 1
+      end
+    end
+  end
+end

data/lib/rble/cli/show.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'rble/gatt/uuid_database'
+require_relative 'characteristic_helpers'
+
+module RBLE
+  module CLI
+    class Show
+      include CharacteristicHelpers
+
+      def initialize(options)
+        @options = options
+        @formatter = options["json"] ? Formatters::Json.new : Formatters::Text.new
+        @address = options["address"]
+        @timeout = options["timeout"] || 10
+      end
+
+      def execute
+        backend = RBLE::Backend.for_platform
+        connection = connect_with_retry(@address, timeout: @timeout)
+
+        begin
+          $stderr.puts "Discovering services..."
+          connection.discover_services
+          services = connection.services
+
+          $stderr.puts "Found #{services.size} service#{'s' unless services.size == 1}"
+
+          tree_data = build_tree_data(@address, connection, services, backend)
+          @formatter.show_tree(tree_data)
+        ensure
+          connection.disconnect if connection.connected?
+        end
+      rescue RBLE::DeviceNotFoundError => e
+        $stderr.puts "Error: #{e.message}"
+        $stderr.puts "Run `rble scan` first to discover nearby devices."
+        exit 1
+      rescue RBLE::Error => e
+        $stderr.puts "Error: #{e.message}"
+        exit 1
+      end
+
+      private
+
+      def build_tree_data(address, connection, services, backend)
+        device_name = begin
+          backend.device_name(connection.device_path)
+        rescue StandardError
+          nil
+        end
+
+        service_data = services.map do |service|
+          resolved_service = RBLE::GATT::UUIDDatabase.resolve(service.uuid, type: :service)
+
+          chars = service.characteristics.map do |char|
+            resolved_char = RBLE::GATT::UUIDDatabase.resolve(char.uuid, type: :characteristic)
+
+            descriptors = extract_descriptors(char)
+
+            {
+              uuid: char.uuid,
+              resolved_name: resolved_char,
+              properties: char.flags,
+              handle: extract_handle(char.path),
+              descriptors: descriptors
+            }
+          end
+
+          {
+            uuid: service.uuid,
+            resolved_name: resolved_service,
+            primary: service.primary,
+            characteristics: chars
+          }
+        end
+
+        total_chars = service_data.sum { |s| s[:characteristics].size }
+
+        {
+          address: address,
+          name: device_name,
+          services: service_data,
+          total_characteristics: total_chars
+        }
+      end
+
+      def extract_descriptors(char)
+        return [] unless char.respond_to?(:descriptors) && char.descriptors
+
+        char.descriptors.map do |desc|
+          resolved_desc = RBLE::GATT::UUIDDatabase.resolve(desc[:uuid], type: :descriptor)
+          {
+            uuid: desc[:uuid],
+            resolved_name: resolved_desc,
+            handle: extract_handle(desc[:path])
+          }
+        end
+      end
+
+      def extract_handle(path)
+        return nil unless path
+
+        if path =~ /([0-9a-fA-F]{4})\z/
+          "0x#{Regexp.last_match(1).upcase}"
+        end
+      end
+    end
+  end
+end

data/lib/rble/cli/status.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RBLE
+  module CLI
+    class Status
+      def initialize(options)
+        @options = options
+        @formatter = options["json"] ? Formatters::Json.new : Formatters::Text.new
+      end
+
+      def execute
+        backend = Backend.for_platform
+        adapter_name = @options["adapter"] || backend.default_adapter_name
+        info = backend.adapter_info(adapter_name)
+        @formatter.status(info)
+      rescue RBLE::AdapterNotFoundError
+        $stderr.puts "No Bluetooth adapter found. Run `rble doctor` to diagnose."
+        exit 1
+      rescue RBLE::Error => e
+        $stderr.puts "Error: #{e.message}"
+        exit 1
+      end
+    end
+  end
+end

data/lib/rble/cli/unpair.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RBLE
+  module CLI
+    class Unpair
+      def initialize(options)
+        @options = options
+        @formatter = options["json"] ? Formatters::Json.new : Formatters::Text.new
+        @address = options["address"]
+      end
+
+      def execute
+        backend = RBLE::Backend.for_platform
+        device_path = backend.device_path_for_address(@address)
+
+        if device_path.nil?
+          $stderr.puts "Device not paired"
+          @formatter.pair_result(success: true, address: @address, message: "Not paired")
+          return
+        end
+
+        $stderr.puts "Removing pairing for #{@address}..."
+        result = backend.unpair_device(device_path)
+
+        case result
+        when :unpaired
+          $stderr.puts "Pairing removed"
+          @formatter.pair_result(success: true, address: @address, message: "Pairing removed")
+        when :not_paired
+          $stderr.puts "Device not paired"
+          @formatter.pair_result(success: true, address: @address, message: "Not paired")
+        end
+      rescue RBLE::Error => e
+        $stderr.puts "Error: #{e.message}"
+        exit 1
+      end
+    end
+  end
+end