rpremote 0.1.0 → 0.3.0

data/lib/rpremote/builder.rb

@@ -4,15 +4,17 @@ require "rbconfig"
 require "fileutils"
 require "rubygems/version"
 require_relative "mrbgems"
+require_relative "picoruby_source_patch"
 
 module Rpremote
   class Builder
     class Error < Rpremote::Error; end
 
-    def initialize(root: Dir.pwd, runner: nil, mrbgems_class: Mrbgems)
+    def initialize(root: Dir.pwd, runner: nil, mrbgems_class: Mrbgems, source_patcher: nil)
       @root = File.expand_path(root)
       @runner = runner || method(:run_command)
       @mrbgems_class = mrbgems_class
+      @source_patcher = source_patcher || method(:patch_source)
     end
 
     def build(output: $stdout, error: $stderr, **options)
@@ -23,6 +25,7 @@ module Rpremote
       Language.validate!(target.language)
 
       source_dir = source_for(target)
+      source_patcher.call(source_dir, target.language_version)
       environment = {
         "RPREMOTE_LANGUAGE" => target.language,
         "RPREMOTE_LANGUAGE_VERSION" => target.language_version,
@@ -61,7 +64,11 @@ module Rpremote
 
     private
 
-    attr_reader :root, :runner, :mrbgems_class
+    attr_reader :root, :runner, :mrbgems_class, :source_patcher
+
+    def patch_source(source, version)
+      PicoRubySourcePatch.new(version: version).apply(source)
+    end
 
     def add_mrbgems_environment!(environment, options, source_dir, output)
       definition = mrbgems_definition(options[:mrbgems])

data/lib/rpremote/cli.rb

@@ -2,12 +2,17 @@
 
 require "optparse"
 require_relative "build_command"
+require_relative "bootsel_command"
+require_relative "config_show"
 require_relative "dfu_command"
+require_relative "deploy_command"
 require_relative "flash_command"
 require_relative "help"
 require_relative "mrbgems_command"
+require_relative "recursive_copy"
 require_relative "setup_command"
 
+# rubocop:disable Metrics/ClassLength
 module Rpremote
   class CLI
     def self.start(argv = ARGV, config: Config, **options)
@@ -36,6 +41,8 @@ module Rpremote
       @config_class = config
       @config_filename, config_required = config.extract_option!(args)
       command = args.shift
+      return show_help(command, args) if Help.requested?(command, args)
+
       @config_options = config.load_command(command, filename: config_filename, required: config_required)
       dispatch(command, args)
       0
@@ -46,6 +53,11 @@ module Rpremote
     attr_reader :stdout, :stderr, :serial, :device, :flasher,
                 :config_class, :config_filename, :config_options
 
+    def show_help(command, args)
+      stdout.puts(Help.command_text(command, args))
+      0
+    end
+
     def dispatch(command, args)
       case command
       when nil, "help", "--help", "-h"
@@ -54,7 +66,9 @@ module Rpremote
         stdout.puts(Rpremote::VERSION)
       when "ports"
         ports(args)
-      when "setup", "flash", "build", "dfu", "mrbgems"
+      when "config"
+        config_command(args)
+      when "setup", "flash", "build", "bootsel", "deploy", "dfu", "mrbgems"
         project_command(command, args)
       when "run", "monitor", "repl", "exec", "reset", "fs"
         remote_command(command, args)
@@ -66,21 +80,28 @@ module Rpremote
     def project_command(command, args)
       case command
       when "setup"
-        SetupCommand.run(
-          args,
-          defaults: config_options,
-          config: config_class,
-          config_filename: config_filename,
-          output: stdout
-        )
+        SetupCommand.run(args, defaults: config_options, config: config_class, config_filename: config_filename, output: stdout)
       when "flash"
         FlashCommand.run(args, defaults: config_options, output: stdout, flasher: flasher)
       when "build"
         BuildCommand.run(args, defaults: config_options, output: stdout, error: stderr)
-      when "dfu"
-        DfuCommand.run(
-          args, defaults: config_options, output: stdout, services: { serial: serial, device: device }
+      when "bootsel"
+        BootselCommand.run(
+          args,
+          defaults: config_options,
+          output: stdout,
+          services: { flasher: flasher, serial: serial, device: device }
+        )
+      when "deploy"
+        DeployCommand.run(
+          args,
+          defaults: config_options,
+          output: stdout,
+          error: stderr,
+          services: { flasher: flasher, serial: serial, device: device }
         )
+      when "dfu"
+        DfuCommand.run(args, defaults: config_options, output: stdout, services: { serial: serial, device: device })
       when "mrbgems"
         MrbgemsCommand.run(args, output: stdout)
       end
@@ -108,12 +129,22 @@ module Rpremote
       end
     end
 
+    def config_command(args)
+      subcommand = args.shift
+      raise ArgumentError, "unknown config command: #{subcommand || "(none)"}" unless subcommand == "show"
+
+      ConfigShow.run(args, defaults: config_options, output: stdout)
+    end
+
     def fs(args)
       subcommand = args.shift
+      recursive = subcommand == "cp" && (args.delete("--recursive") || args.delete("-r"))
       options = parse_connection_options(args)
       case subcommand
       when "cp"
-        copy(args, options)
+        copy(args, options, recursive: recursive)
+      when "push"
+        copy(args, options, recursive: true, command: "push")
       when "cat"
         cat(args, options)
       when "ls", "rm", "mkdir"
@@ -124,12 +155,14 @@ module Rpremote
     end
 
     def run_file(args)
+      reset_on_timeout = !args.delete("--reset-on-timeout").nil?
       options = parse_connection_options(args)
       raise ArgumentError, "usage: rpremote run FILE [options]" unless args.length == 1
 
       source = args.first
-      data = File.binread(source)
-      stdout.write(execute_temporary(data, options))
+      source = File.join(source, "main.rb") if File.directory?(source)
+      data = prepend_mrbgem_requires(File.binread(source))
+      execute_temporary(data, options, output: stdout, reset_on_timeout: reset_on_timeout)
     rescue Errno::ENOENT => e
       raise ArgumentError, e.message
     end
@@ -138,15 +171,32 @@ module Rpremote
       options = parse_connection_options(args)
       raise ArgumentError, "usage: rpremote exec CODE [options]" unless args.length == 1
 
-      stdout.write(execute_temporary(args.first, options))
+      execute_temporary(prepend_mrbgem_requires(args.first), options, output: stdout)
     end
 
-    def execute_temporary(data, options)
+    def execute_temporary(data, options, output: nil, reset_on_timeout: false)
       Language.validate!(options[:language])
       port_path = device.main_port(options[:port])
       serial.open(port_path, baud: options[:baud]) do |port|
-        Runner.new(port, timeout: options[:timeout]).run(data)
+        runner = Runner.new(port, timeout: options[:timeout])
+        output ? runner.run(data, output: output, diagnostics: stderr) : runner.run(data, diagnostics: stderr)
       end
+    rescue Shell::TimeoutError => e
+      reset_after_run_timeout(port_path, options, e) if reset_on_timeout
+      raise
+    end
+
+    def reset_after_run_timeout(port_path, options, timeout_error)
+      stderr.puts("rpremote: run timed out; resetting R2P2: #{port_path}")
+      Resetter.new(serial: serial, timeout: options[:timeout]).reset(port_path, baud: options[:baud])
+      stderr.puts("rpremote: reset R2P2 after run timeout: #{port_path}")
+    rescue Rpremote::Error, IOError, SystemCallError => e
+      raise Shell::TimeoutError,
+            "#{timeout_error.message}; automatic reset failed: #{e.message}"
+    end
+
+    def prepend_mrbgem_requires(data)
+      Mrbgems.new(cwd: Dir.pwd).prepend_requires(data)
     end
 
     def interactive(args, repl: false)
@@ -195,15 +245,15 @@ module Rpremote
       options
     end
 
-    def copy(args, options)
-      raise ArgumentError, "usage: rpremote fs cp SOURCE DESTINATION [options]" unless args.length == 2
+    def copy(args, options, recursive: false, command: "cp")
+      usage = command == "push" ? "rpremote fs push LOCAL_DIR :/REMOTE_DIR" : "rpremote fs cp SOURCE DESTINATION"
+      raise ArgumentError, "usage: #{usage} [options]" unless args.length == 2
 
       source, destination = args
       source_remote = RemotePath.remote?(source)
       destination_remote = RemotePath.remote?(destination)
-      if source_remote == destination_remote
-        raise ArgumentError, "exactly one cp path must be remote (prefix remote paths with :)"
-      end
+      raise ArgumentError, "exactly one cp path must be remote (prefix remote paths with :)" if source_remote == destination_remote
+      return RecursiveCopy.new(output: stdout, serial: serial, device: device).call(source, destination, options) if recursive
 
       if source_remote
         data = with_modem(options) { |modem| modem.download(RemotePath.unwrap(source)) }
@@ -230,6 +280,7 @@ module Rpremote
       raise ArgumentError, usage unless args.length == 1
 
       path = RemotePath.validate(args.first)
+      stdout.puts("deleting remote path permanently: #{path}") if command == "rm"
       output = with_shell(options) do |shell|
         shell.execute("#{command} #{Shell.quote_argument(path)}")
       end
@@ -265,3 +316,4 @@ module Rpremote
     end
   end
 end
+# rubocop:enable Metrics/ClassLength

data/lib/rpremote/config.rb

@@ -21,6 +21,8 @@ module Rpremote
     COMMAND_OPTIONS = {
       "setup" => %i[cache language language_version],
       "build" => %i[cache language language_version board firmware mrbgems],
+      "bootsel" => %i[mount port baud timeout],
+      "deploy" => %i[cache language language_version board firmware mrbgems mount port baud timeout],
       "dfu" => %i[cache language language_version port baud timeout],
       "flash" => %i[cache language language_version board firmware mount port timeout],
       "run" => %i[port baud timeout language],
@@ -29,6 +31,7 @@ module Rpremote
       "monitor" => %i[port baud timeout],
       "repl" => %i[port baud timeout],
       "fs" => %i[port baud timeout],
+      "config" => OPTION_TYPES.keys,
       "ports" => [],
       "mrbgems" => []
     }.freeze

data/lib/rpremote/config_show.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "optparse"
+require_relative "picomodem"
+require_relative "serial"
+require_relative "target"
+
+module Rpremote
+  class ConfigShow
+    def self.run(args, defaults:, output:)
+      new(defaults: defaults, output: output).run(args)
+    end
+
+    def initialize(defaults:, output:)
+      @defaults = defaults
+      @output = output
+    end
+
+    def run(args)
+      options = effective_options
+      parser = option_parser(options)
+      parser.parse!(args)
+      raise ArgumentError, "usage: rpremote config show [options]" unless args.empty?
+      raise ArgumentError, "--baud must be positive" unless options[:baud].positive?
+      raise ArgumentError, "--timeout must be positive" unless options[:timeout].positive?
+
+      print_options(options)
+    end
+
+    private
+
+    attr_reader :defaults, :output
+
+    def effective_options
+      {
+        language: defaults.fetch(:language, Target::DEFAULT_LANGUAGE),
+        language_version: defaults.fetch(:language_version, Target::DEFAULT_LANGUAGE_VERSION),
+        board: defaults.fetch(:board, Target::DEFAULT_BOARD),
+        cache: defaults.fetch(:cache, Target::DEFAULT_CACHE_DIR),
+        firmware: defaults[:firmware],
+        mrbgems: defaults[:mrbgems],
+        mount: defaults[:mount],
+        port: defaults[:port],
+        baud: defaults.fetch(:baud, Serial::BAUD_RATE),
+        timeout: defaults.fetch(:timeout, PicoModem::DEFAULT_TIMEOUT)
+      }
+    end
+
+    def option_parser(options)
+      OptionParser.new do |opts|
+        opts.on("--language LANGUAGE") { |value| options[:language] = value }
+        opts.on("--language-version VERSION") { |value| options[:language_version] = value }
+        opts.on("--board BOARD") { |value| options[:board] = value }
+        opts.on("--cache DIR") { |value| options[:cache] = value }
+        opts.on("--firmware FILE") { |value| options[:firmware] = value }
+        opts.on("--mrbgems FILE") { |value| options[:mrbgems] = value }
+        opts.on("--no-mrbgems") { options[:mrbgems] = false }
+        opts.on("--mount DIR") { |value| options[:mount] = value }
+        opts.on("--port PORT") { |value| options[:port] = value }
+        opts.on("--baud RATE", Integer) { |value| options[:baud] = value }
+        opts.on("--timeout SECONDS", Float) { |value| options[:timeout] = value }
+      end
+    end
+
+    def print_options(options)
+      target = Target.new(
+        language: options[:language],
+        language_version: options[:language_version],
+        board: options[:board],
+        cache_dir: options[:cache],
+        firmware: options[:firmware]
+      )
+      output.puts("language=#{target.language}")
+      output.puts("language_version=#{target.language_version}")
+      output.puts("board=#{target.board}")
+      output.puts("cache=#{target.cache_dir}")
+      output.puts("firmware=#{target.firmware_path}")
+      output.puts("mrbgems=#{mrbgems_value(options[:mrbgems])}")
+      output.puts("mount=#{options[:mount] || "auto"}")
+      output.puts("port=#{options[:port] || "auto"}")
+      output.puts("baud=#{options[:baud]}")
+      output.puts("timeout=#{options[:timeout]}")
+    end
+
+    def mrbgems_value(value)
+      return "false" if value == false
+
+      value || "auto"
+    end
+  end
+end

data/lib/rpremote/deploy_command.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require "optparse"
+require_relative "bootsel_command"
+require_relative "recursive_copy"
+
+module Rpremote
+  class DeployCommand
+    SHELL_READY_TIMEOUT = 2.0
+    RETRY_INTERVAL = 0.25
+
+    class Error < Rpremote::Error; end
+
+    # The command intentionally keeps the six deployment stages visible in execution order.
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def self.run(args, defaults:, output: $stdout, error: $stderr, services: {})
+      options = parse_options(args, defaults)
+      raise ArgumentError, "usage: rpremote deploy PATH [options]" unless args.length == 1
+
+      project = File.expand_path(args.first)
+      library, remote_library, source = project_files(project)
+      Language.validate!(options[:language])
+
+      builder = services.fetch(:builder) { Builder.new }
+      flasher = services.fetch(:flasher, Flasher)
+      serial = services.fetch(:serial, Serial)
+      device = services.fetch(:device, Device)
+      runner = services.fetch(:runner, Runner)
+      target_options = options.slice(:language, :language_version, :board, :cache_dir, :firmware)
+      firmware_path = Target.new(**target_options).firmware_path(root: Dir.pwd)
+
+      output.puts("deploy build: #{firmware_path}")
+      builder.build(
+        **target_options,
+        mrbgems: options[:mrbgems],
+        output: output,
+        error: error
+      )
+
+      flash_service = flasher.new(timeout: options[:timeout])
+      bootsel_mount = resolve_bootsel_mount(options, flash_service, output, services)
+
+      mount = options[:mount] || "an automatically detected RP2350 BOOTSEL volume"
+      output.puts("deploy flash: #{firmware_path} to #{mount}; this replaces persistent board firmware")
+      result = flash_service.flash(
+        firmware_path,
+        mount: bootsel_mount,
+        port: options[:port]
+      )
+
+      connection_options = options.merge(port: result.port)
+      output.puts("deploy connect: waiting for R2P2 Shell on #{result.port}")
+      wait_for_shell(
+        port: result.port, baud: options[:baud], timeout: options[:timeout], serial: serial,
+        shell: services.fetch(:shell, Shell),
+        sleeper: services.fetch(:sleeper) { ->(seconds) { sleep(seconds) } },
+        clock: services.fetch(:clock) { -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) } }
+      )
+      output.puts("deploy connect: ready on #{result.port}")
+
+      if File.directory?(library)
+        output.puts("deploy push: #{library} -> :#{remote_library}")
+        recursive_copy = services.fetch(:recursive_copy) do
+          RecursiveCopy.new(output: output, serial: serial, device: device)
+        end
+        recursive_copy.call(library, ":#{remote_library}", connection_options)
+      else
+        output.puts("deploy push: skipped; directory not found: #{library}")
+      end
+
+      output.puts("deploy run: #{source} on #{result.port}")
+      source_data = prepend_mrbgem_requires(File.binread(source), options[:mrbgems])
+      run_output = serial.open(result.port, baud: options[:baud]) do |port|
+        runner.new(port, timeout: options[:timeout]).run(
+          source_data, output: output, cleanup: false, remote_path: Runner::DEPLOY_REMOTE_PATH
+        )
+      end
+      output.puts("deploy run: completed; output bytes: #{run_output.to_s.bytesize}")
+    rescue Errno::ENOENT => e
+      raise ArgumentError, e.message
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+    def self.project_files(project)
+      raise ArgumentError, "project directory not found: #{project}" unless File.directory?(project)
+
+      name = File.basename(project)
+      library = File.join(project, "lib", name)
+      source = File.join(project, "main.rb")
+      raise ArgumentError, "project entry file not found: #{source}" unless File.file?(source)
+
+      [library, File.join("/lib", name), source]
+    end
+    private_class_method :project_files
+
+    def self.prepend_mrbgem_requires(source, definition)
+      return source if definition == false
+
+      Mrbgems.new(path: definition || Mrbgems::DEFAULT_PATH, cwd: Dir.pwd).prepend_requires(source)
+    end
+    private_class_method :prepend_mrbgem_requires
+
+    def self.wait_for_shell(context)
+      port = context.fetch(:port)
+      baud = context.fetch(:baud)
+      timeout = context.fetch(:timeout)
+      serial = context.fetch(:serial)
+      shell = context.fetch(:shell)
+      sleeper = context.fetch(:sleeper)
+      clock = context.fetch(:clock)
+      deadline = clock.call + timeout
+      loop do
+        serial.open(port, baud:) do |connection|
+          remaining = deadline - clock.call
+          raise Shell::TimeoutError, "R2P2 Shell is not ready" unless remaining.positive?
+
+          shell.new(connection, timeout: [remaining, SHELL_READY_TIMEOUT].min).synchronize!
+        end
+        return
+      rescue Serial::ConfigurationError, Shell::TimeoutError, IOError, SystemCallError
+        raise Error, "timed out waiting for R2P2 Shell after flash" if clock.call >= deadline
+
+        sleeper.call(RETRY_INTERVAL)
+      end
+    end
+    private_class_method :wait_for_shell
+
+    def self.resolve_bootsel_mount(options, flash_service, output, services)
+      mounted = flash_service.find_mounted(options[:mount])
+      if mounted
+        output.puts("deploy bootsel: already mounted at #{mounted}; skipping serial reset")
+        return mounted
+      end
+
+      port = options[:port] || "an automatically detected R2P2 port"
+      output.puts("deploy bootsel: requesting USB BOOTSEL mode through #{port}")
+      BootselCommand.enter(
+        mount: options[:mount], port: options[:port], baud: options[:baud], timeout: options[:timeout],
+        output: output, services: services.slice(:flasher, :serial, :device, :shell)
+      )
+    end
+    private_class_method :resolve_bootsel_mount
+
+    def self.parse_options(args, defaults)
+      options = default_options(defaults)
+      option_parser(options).parse!(args)
+      validate_options!(options)
+      options
+    end
+    private_class_method :parse_options
+
+    def self.default_options(defaults)
+      {
+        language: defaults.fetch(:language, Target::DEFAULT_LANGUAGE),
+        language_version: defaults.fetch(:language_version, Target::DEFAULT_LANGUAGE_VERSION),
+        board: defaults.fetch(:board, Target::DEFAULT_BOARD),
+        cache_dir: defaults.fetch(:cache, Target::DEFAULT_CACHE_DIR),
+        firmware: defaults[:firmware],
+        mrbgems: defaults[:mrbgems],
+        mount: defaults[:mount],
+        port: defaults[:port],
+        baud: defaults.fetch(:baud, Serial::BAUD_RATE),
+        timeout: defaults.fetch(:timeout, Flasher::DEFAULT_TIMEOUT)
+      }
+    end
+    private_class_method :default_options
+
+    def self.option_parser(options)
+      OptionParser.new do |parser|
+        parser.on("--language LANGUAGE") { |value| options[:language] = value }
+        parser.on("--language-version VERSION") { |value| options[:language_version] = value }
+        parser.on("--board BOARD") { |value| options[:board] = value }
+        parser.on("--cache DIR") { |value| options[:cache_dir] = value }
+        parser.on("--firmware FILE") { |value| options[:firmware] = value }
+        parser.on("--mrbgems FILE") { |value| options[:mrbgems] = value }
+        parser.on("--no-mrbgems") { options[:mrbgems] = false }
+        parser.on("--mount DIR") { |value| options[:mount] = value }
+        parser.on("--port PORT") { |value| options[:port] = value }
+        parser.on("--baud RATE", Integer) { |value| options[:baud] = value }
+        parser.on("--timeout SECONDS", Float) { |value| options[:timeout] = value }
+      end
+    end
+    private_class_method :option_parser
+
+    def self.validate_options!(options)
+      raise ArgumentError, "--baud must be positive" unless options[:baud].positive?
+      raise ArgumentError, "--timeout must be positive" unless options[:timeout].positive?
+    end
+    private_class_method :validate_options!
+  end
+end

data/lib/rpremote/dfu_command.rb

@@ -4,20 +4,25 @@ require "optparse"
 
 module Rpremote
   class DfuCommand
-    DEFAULT_TIMEOUT = 10.0
+    DEFAULT_TIMEOUT = 20.0
     TYPES = { ".rb" => "RUBY", ".mrb" => "RITE" }.freeze
 
     def self.run(args, defaults:, output: $stdout, services: {})
-      default_services = { serial: Serial, device: Device, modem: PicoModem, runner: Runner, compiler: DfuCompiler }
+      default_services = {
+        serial: Serial, device: Device, modem: PicoModem, runner: Runner,
+        compiler: DfuCompiler
+      }
       services = default_services.merge(services)
       subcommand = args.shift
       case subcommand
       when "app" then stage(args, defaults, output, services)
       when "compile" then compile(args, defaults, output, services[:compiler])
       when "status" then status(args, defaults, output, services)
+      when "remove" then remove(args, defaults, output, services)
       else
         raise ArgumentError,
-              "usage: rpremote dfu app FILE [options], dfu compile FILE [options], or dfu status [options]"
+              "usage: rpremote dfu app FILE [options], dfu compile FILE [options], " \
+              "dfu status [options], or dfu remove [options]"
       end
     end
 
@@ -30,6 +35,8 @@ module Rpremote
       type = options[:type] || type_for(source)
       port_path = services[:device].main_port(options[:port])
       verify_rite_version!(data, port_path, options, services) if type == "RITE"
+      output.puts("staging DFU #{type.downcase} app (#{data.bytesize} bytes): #{source} -> inactive slot on #{port_path}; " \
+                  "this changes the staged boot application")
       services[:serial].open(port_path, baud: options[:baud]) do |port|
         services[:modem].new(port, timeout: options[:timeout]).dfu(data, type: type)
       end
@@ -50,7 +57,7 @@ module Rpremote
     private_class_method :compile
 
     def self.status(args, defaults, output, services)
-      options = parse_app_options(args, defaults)
+      options = parse_connection_options(args, defaults)
       raise ArgumentError, "usage: rpremote dfu status [options]" unless args.empty?
 
       port_path = services[:device].main_port(options[:port])
@@ -69,6 +76,45 @@ module Rpremote
     end
     private_class_method :status
 
+    def self.remove(args, defaults, output, services)
+      options = parse_connection_options(args, defaults)
+      raise ArgumentError, "usage: rpremote dfu remove [options]" unless args.empty?
+
+      port_path = services[:device].main_port(options[:port])
+      code = <<~'RUBY'
+        require "dfu"
+        # A confirmed DFU launcher may have returned after leaving a Sandbox
+        # worker alive. Stop known Processing workers before waiting for the
+        # Shell prompt; deleting their source files does not stop RAM tasks.
+        begin
+          $imu_processing_stream.close if $imu_processing_stream
+          $imu_processing_stream = nil
+        rescue Exception
+          $imu_processing_stream = nil
+        end
+        begin
+          $mpu6050_processing_stream.close if $mpu6050_processing_stream
+          $mpu6050_processing_stream = nil
+        rescue Exception
+          $mpu6050_processing_stream = nil
+        end
+        DFU::Meta.recover
+        DFU::Meta.save(DFU::Meta.deep_copy(DFU::Meta::DEFAULT))
+        %w[a b].each do |slot|
+          %w[rb mrb].each do |ext|
+            path = "#{ENV['HOME']}/app_#{slot}.#{ext}"
+            File.unlink(path) if File.exist?(path)
+          end
+        end
+      RUBY
+      output.puts("removing all DFU boot applications from #{port_path}; this permanently clears both A/B slots")
+      services[:serial].open(port_path, baud: options[:baud]) do |port|
+        services[:runner].new(port, timeout: options[:timeout]).run(code)
+      end
+      output.puts("removed all DFU boot applications; run `rpremote reset` to stop the running application")
+    end
+    private_class_method :remove
+
     def self.parse_app_options(args, defaults)
       options = {
         port: defaults[:port],
@@ -89,6 +135,24 @@ module Rpremote
     end
     private_class_method :parse_app_options
 
+    def self.parse_connection_options(args, defaults)
+      options = {
+        port: defaults[:port],
+        baud: defaults.fetch(:baud, Serial::BAUD_RATE),
+        timeout: defaults.fetch(:timeout, DEFAULT_TIMEOUT)
+      }
+      OptionParser.new do |parser|
+        parser.on("--port PORT") { |value| options[:port] = value }
+        parser.on("--baud RATE", Integer) { |value| options[:baud] = value }
+        parser.on("--timeout SECONDS", Float) { |value| options[:timeout] = value }
+      end.parse!(args)
+      raise ArgumentError, "--baud must be positive" unless options[:baud].positive?
+      raise ArgumentError, "--timeout must be positive" unless options[:timeout].positive?
+
+      options
+    end
+    private_class_method :parse_connection_options
+
     def self.parse_compile_options(args, defaults)
       options = {
         language: defaults.fetch(:language, Target::DEFAULT_LANGUAGE),
@@ -122,9 +186,7 @@ module Rpremote
 
     def self.verify_rite_version!(data, port_path, options, services)
       bytecode_version = data.byteslice(0, 8)
-      unless bytecode_version&.match?(/\ARITE\d{4}\z/)
-        raise ArgumentError, "DFU RITE app must start with a RITE bytecode header"
-      end
+      raise ArgumentError, "DFU RITE app must start with a RITE bytecode header" unless bytecode_version&.match?(/\ARITE\d{4}\z/)
 
       picoruby_version = services[:serial].open(port_path, baud: options[:baud]) do |port|
         services[:runner].new(port, timeout: options[:timeout]).run("p PICORUBY_VERSION")[/\d+\.\d+\.\d+/]