rpremote 0.2.0 → 0.4.0

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

@@ -8,16 +8,21 @@ module Rpremote
     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
 
@@ -52,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])
@@ -71,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],
@@ -91,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),

data/lib/rpremote/flash_command.rb

@@ -33,7 +33,10 @@ module Rpremote
       }
       OptionParser.new do |parser|
         parser.on("--cache DIR") { |value| options[:cache_dir] = value }
-        parser.on("--firmware FILE") { |value| options[:firmware] = value }
+        parser.on("--firmware FILE") do |value|
+          options[:firmware] = value
+          options[:firmware_explicit] = true
+        end
         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 }

data/lib/rpremote/flasher.rb

@@ -36,30 +36,57 @@ module Rpremote
       raise ArgumentError, "timeout must be positive" unless @timeout.positive?
     end
 
-    def flash(uf2_path, mount: nil, port: nil)
+    def flash(uf2_path, mount: nil, port: nil, wait_for_port: true)
       validate_firmware!(uf2_path)
       target = find_mount(mount)
       destination = File.join(target, File.basename(uf2_path))
       copy_firmware(uf2_path, destination)
       wait_until("BOOTSEL drive to disappear") { !mount_probe.call(target) }
+      return Result.new(mount: target, destination: destination, port: nil) unless wait_for_port
+
       detected_port = wait_until("R2P2 serial port to appear") { detect_port(port) }
       Result.new(mount: target, destination: destination, port: detected_port)
     end
 
     def find_mount(explicit_mount = nil)
-      return validate_mount!(File.expand_path(explicit_mount)) if explicit_mount
+      mounted = find_mounted(explicit_mount)
+      return mounted if mounted
 
-      matches = Dir.glob(File.join(volumes_root, "*")).select do |path|
-        Dir.exist?(path) && valid_target?(path)
+      raise MountNotFoundError,
+            "Pico 2 BOOTSEL drive not found; reconnect it while holding BOOTSEL or use --mount DIR"
+    end
+
+    def find_mounted(explicit_mount = nil)
+      if explicit_mount
+        path = File.expand_path(explicit_mount)
+        return unless Dir.exist?(path)
+
+        return validate_mount!(path)
+      end
+
+      matches = bootsel_mounts
+      return if matches.empty?
+      return matches.first if matches.one?
+
+      raise MountNotFoundError, "multiple Pico 2 BOOTSEL drives found; use --mount DIR"
+    end
+
+    def wait_for_mount(mount: nil)
+      if mount
+        path = File.expand_path(mount)
+        return wait_until("Pico 2 BOOTSEL drive to appear") do
+          next unless Dir.exist?(path)
+          next unless valid_target?(path)
+
+          path
+        end
       end
-      case matches.length
-      when 0
-        raise MountNotFoundError,
-              "Pico 2 BOOTSEL drive not found; reconnect it while holding BOOTSEL or use --mount DIR"
-      when 1
+
+      wait_until("Pico 2 BOOTSEL drive to appear") do
+        matches = bootsel_mounts
+        raise MountNotFoundError, "multiple Pico 2 BOOTSEL drives found; use --mount DIR" if matches.length > 1
+
         matches.first
-      else
-        raise MountNotFoundError, "multiple Pico 2 BOOTSEL drives found; use --mount DIR"
       end
     end
 
@@ -90,8 +117,19 @@ module Rpremote
       false
     end
 
+    def bootsel_mounts
+      Dir.glob(File.join(volumes_root, "*")).select do |path|
+        Dir.exist?(path) && valid_target?(path)
+      end
+    end
+
     def copy_firmware(source, destination)
       FileUtils.copy_file(source, destination)
+    rescue Errno::ENXIO
+      # RP2350 may reboot and detach its BOOTSEL volume before macOS finishes
+      # closing the destination. The disappearance and serial reconnect checks
+      # in #flash determine whether the transfer actually completed.
+      nil
     rescue SystemCallError => e
       raise Error, "failed to copy UF2 firmware: #{e.message}"
     end

data/lib/rpremote/help.rb

@@ -9,9 +9,14 @@ module Rpremote
       build: "rpremote build [--language LANGUAGE] [--language-version VERSION] [--board BOARD] " \
              "[--firmware FILE] [--cache DIR] [--mrbgems FILE|--no-mrbgems]",
       build_clean: "rpremote build clean",
+      bootsel: "rpremote bootsel [--reset-flash-memory] [--mount DIR] [--port PORT] [--baud RATE] [--timeout SEC]",
+      deploy: "rpremote deploy PATH [--language LANGUAGE] [--language-version VERSION] [--board BOARD] " \
+              "[--firmware FILE] [--cache DIR] [--mrbgems FILE|--no-mrbgems] [--mount DIR] " \
+              "[--port PORT] [--baud RATE] [--timeout SEC]",
       dfu_app: "rpremote dfu app FILE [--type ruby|rite] [--port PORT] [--baud RATE] [--timeout SEC]",
       dfu_compile: "rpremote dfu compile FILE [--output FILE] [--language LANGUAGE] [--language-version VERSION] [--cache DIR]",
       dfu_status: "rpremote dfu status [--port PORT] [--baud RATE] [--timeout SEC]",
+      dfu_remove: "rpremote dfu remove [--port PORT] [--baud RATE] [--timeout SEC]",
       mrbgems: "rpremote mrbgems SUBCOMMAND [--file FILE] [--lockfile FILE]",
       flash: "rpremote flash [--firmware FILE] [--language LANGUAGE] [--language-version VERSION] " \
              "[--board BOARD] [--cache DIR] [--mount DIR] [--port PORT] [--timeout SEC]",
@@ -19,12 +24,13 @@ module Rpremote
                    "[--cache DIR] [--firmware FILE] [--mrbgems FILE|--no-mrbgems] [--mount DIR] " \
                    "[--port PORT] [--baud RATE] [--timeout SEC]",
       ports: "rpremote ports",
-      run: "rpremote run FILE [--port PORT] [--baud RATE] [--timeout SEC] [--language LANGUAGE]",
+      run: "rpremote run FILE [--port PORT] [--baud RATE] [--timeout SEC] [--reset-on-timeout] [--language LANGUAGE]",
       monitor: "rpremote monitor [--port PORT] [--baud RATE] [--timeout SEC]",
       repl: "rpremote repl [--port PORT] [--baud RATE] [--timeout SEC]",
       exec: "rpremote exec CODE [--port PORT] [--baud RATE] [--timeout SEC] [--language LANGUAGE]",
       reset: "rpremote reset [--port PORT] [--baud RATE] [--timeout SEC]",
-      fs_cp: "rpremote fs cp SOURCE DESTINATION [--port PORT] [--baud RATE] [--timeout SEC]",
+      fs_cp: "rpremote fs cp SOURCE DESTINATION [--recursive] [--port PORT] [--baud RATE] [--timeout SEC]",
+      fs_push: "rpremote fs push LOCAL_DIR :/REMOTE_DIR [--port PORT] [--baud RATE] [--timeout SEC]",
       fs_cat: "rpremote fs cat :/REMOTE/PATH [--port PORT] [--baud RATE] [--timeout SEC]",
       fs_ls: "rpremote fs ls :/REMOTE/PATH [--port PORT] [--baud RATE] [--timeout SEC]",
       fs_rm: "rpremote fs rm :/REMOTE/PATH [--port PORT] [--baud RATE] [--timeout SEC]",
@@ -38,9 +44,12 @@ module Rpremote
         #{COMMAND_USAGE.fetch(:setup)}
         #{COMMAND_USAGE.fetch(:build)}
         #{COMMAND_USAGE.fetch(:build_clean)}
+        #{COMMAND_USAGE.fetch(:bootsel)}
+        #{COMMAND_USAGE.fetch(:deploy)}
         #{COMMAND_USAGE.fetch(:dfu_app)}
         #{COMMAND_USAGE.fetch(:dfu_compile)}
         #{COMMAND_USAGE.fetch(:dfu_status)}
+        #{COMMAND_USAGE.fetch(:dfu_remove)}
         #{COMMAND_USAGE.fetch(:mrbgems).sub("SUBCOMMAND", "check|list|lock|update")}
         #{COMMAND_USAGE.fetch(:flash)}
         #{COMMAND_USAGE.fetch(:config_show)}
@@ -51,6 +60,7 @@ module Rpremote
         #{COMMAND_USAGE.fetch(:exec)}
         #{COMMAND_USAGE.fetch(:reset)}
         #{COMMAND_USAGE.fetch(:fs_cp)}
+        #{COMMAND_USAGE.fetch(:fs_push)}
         #{COMMAND_USAGE.fetch(:fs_cat)}
         #{COMMAND_USAGE.fetch(:fs_ls)}
         #{COMMAND_USAGE.fetch(:fs_rm)}
@@ -66,11 +76,11 @@ module Rpremote
         --language-version VERSION
                           use R2P2/PicoRuby 4.0.3 or 3.4.2 (default: 4.0.3)
         --cache DIR       use another project cache directory
-        --mrbgems FILE    use an explicit Mrbgems definition during build
-        --no-mrbgems      build without the automatically detected Mrbgems
+        --mrbgems FILE    use an explicit Mrbgems definition during build or deploy
+        --no-mrbgems      build or deploy without the automatically detected Mrbgems
         --board BOARD
                           select pico2 or pico2_w (default: pico2)
-        --firmware FILE   build to, or flash from, this UF2 path
+        --firmware FILE   build to, or deploy or flash from, this UF2 path
         --language LANGUAGE
                           select the remote language (default: picoruby)
         --config FILE     use another configuration file
@@ -93,6 +103,8 @@ module Rpremote
       case command
       when "setup" then setup_text
       when "build" then args.first == "clean" ? build_clean_text : build_text
+      when "bootsel" then bootsel_text
+      when "deploy" then deploy_text
       when "dfu" then dfu_text(args.first)
       when "mrbgems" then mrbgems_text(args.first)
       when "flash" then flash_text
@@ -112,7 +124,7 @@ module Rpremote
       <<~HELP
         Usage: #{COMMAND_USAGE.fetch(:setup)}
 
-        Creates config/setting.json when it does not exist, then downloads and prepares PicoRuby source.
+        Creates config/setting.json when it does not exist, then downloads and prepares PicoRuby source and the official Raspberry Pi nuke_universal.uf2 firmware.
         Options: --language LANGUAGE (picoruby), --language-version VERSION (4.0.3), --cache DIR (firmware), --force.
         This changes the project configuration and source cache but does not connect to a board.
       HELP
@@ -136,15 +148,40 @@ module Rpremote
       HELP
     end
 
+    def self.deploy_text
+      <<~HELP
+        Usage: #{COMMAND_USAGE.fetch(:deploy)}
+
+        Builds the selected custom UF2, enters BOOTSEL when needed, flashes the firmware, and waits for the R2P2 Shell to become ready.
+        If PATH/lib/NAME exists, it copies it to :/lib/NAME, where NAME is the final component of PATH. It then runs PATH/main.rb and preserves its Shell job, so hardware output remains active until the next command.
+        The stages run in order and stop at the first failure. Flashing replaces persistent board firmware.
+        deploy requires PicoRuby 4.x firmware (currently 4.0.3).
+        Options combine build, BOOTSEL, flash, library-copy, and run settings. The first install of firmware with automatic BOOTSEL still requires holding BOOTSEL.
+      HELP
+    end
+
+    def self.bootsel_text
+      <<~HELP
+        Usage: #{COMMAND_USAGE.fetch(:bootsel)}
+
+        Asks the running R2P2 firmware to restart as an RP2350 BOOTSEL USB volume, then waits for that volume to appear.
+        By default it does not write firmware. This requires firmware built by a current rpremote; use physical BOOTSEL once to install it first.
+        --reset-flash-memory copies the official Raspberry Pi nuke_universal.uf2 in BOOTSEL mode and erases all external flash memory.
+        After resetting flash memory, wait for BOOTSEL to reappear and run `rpremote flash` to install R2P2 again.
+      HELP
+    end
+
     def self.dfu_text(subcommand)
       return dfu_app_text if subcommand == "app"
       return dfu_compile_text if subcommand == "compile"
       return dfu_status_text if subcommand == "status"
+      return dfu_remove_text if subcommand == "remove"
 
       <<~HELP
         Usage: #{COMMAND_USAGE.fetch(:dfu_app)}
                #{COMMAND_USAGE.fetch(:dfu_compile)}
                #{COMMAND_USAGE.fetch(:dfu_status)}
+               #{COMMAND_USAGE.fetch(:dfu_remove)}
 
         Stages and inspects PicoModem DFU applications. Run `rpremote dfu SUBCOMMAND --help` for details.
       HELP
@@ -178,6 +215,16 @@ module Rpremote
       HELP
     end
 
+    def self.dfu_remove_text
+      <<~HELP
+        Usage: #{COMMAND_USAGE.fetch(:dfu_remove)}
+
+        Permanently removes the Ruby source and bytecode applications from both DFU A/B slots and resets their metadata.
+        Run `rpremote reset` afterward to stop the application already running in RAM. It does not remove /home/app.rb,
+        /home/app.mrb, other files, embedded mrbgems, or R2P2 firmware.
+      HELP
+    end
+
     def self.mrbgems_text(subcommand)
       action = subcommand || "check|list|lock|update"
       <<~HELP
@@ -217,8 +264,10 @@ module Rpremote
       <<~HELP
         Usage: #{COMMAND_USAGE.fetch(:run)}
 
-        Uploads FILE to R2P2, relays output, then removes the temporary remote file. Defaults are the automatic CDC 0 port,
-        115200 baud, 20 seconds, and picoruby. It exits nonzero when compatible R2P2 firmware reports a Ruby exception.
+        Uploads FILE to R2P2, or main.rb when FILE is a directory, relays output, then removes the temporary remote file. Defaults are the automatic CDC 0 port,
+        115200 baud, a 20-second idle timeout, and picoruby. Output from the running program resets the idle timeout.
+        It exits nonzero when compatible R2P2 firmware reports a Ruby exception.
+        --reset-on-timeout resets R2P2 after the run times out and the serial connection has closed.
       HELP
     end
 
@@ -227,7 +276,8 @@ module Rpremote
         Usage: #{COMMAND_USAGE.fetch(:exec)}
 
         Runs short Ruby CODE through a temporary remote file, then removes it. Defaults are the automatic CDC 0 port,
-        115200 baud, 20 seconds, and picoruby. It exits nonzero when compatible R2P2 firmware reports a Ruby exception.
+        115200 baud, a 20-second idle timeout, and picoruby. Output from the running program resets the idle timeout.
+        It exits nonzero when compatible R2P2 firmware reports a Ruby exception.
       HELP
     end
 
@@ -256,10 +306,11 @@ module Rpremote
     end
 
     def self.fs_text(subcommand)
-      return fs_subcommand_text(subcommand) if %w[cp cat ls rm mkdir].include?(subcommand)
+      return fs_subcommand_text(subcommand) if %w[cp push cat ls rm mkdir].include?(subcommand)
 
       <<~HELP
         Usage: #{COMMAND_USAGE.fetch(:fs_cp)}
+               #{COMMAND_USAGE.fetch(:fs_push)}
                #{COMMAND_USAGE.fetch(:fs_cat)}
                #{COMMAND_USAGE.fetch(:fs_ls)}
                #{COMMAND_USAGE.fetch(:fs_rm)}
@@ -274,7 +325,9 @@ module Rpremote
       effect = case subcommand
                when "rm" then "Deletes the remote path permanently."
                when "mkdir" then "Creates a remote directory."
-               else "Reads or transfers remote files."
+               when "cp" then "Transfers one file, or recursively uploads a local directory with --recursive."
+               when "push" then "Creates missing remote directories and recursively uploads a local directory."
+               else "Reads remote files."
                end
       <<~HELP
         Usage: #{usage}