rpremote 0.1.0 → 0.2.0

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/dfu_command.rb

@@ -4,7 +4,7 @@ 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: {})
@@ -30,6 +30,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
@@ -122,9 +124,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+/]

data/lib/rpremote/flash_command.rb

@@ -9,12 +9,15 @@ module Rpremote
       raise ArgumentError, "flash does not accept arguments; use --firmware FILE" unless args.empty?
 
       target = Target.new(**options.slice(:language, :language_version, :board, :cache_dir, :firmware))
+      firmware_path = target.firmware_path(root: Dir.pwd)
+      mount = options[:mount] || "an automatically detected RP2350 BOOTSEL volume"
+      output.puts("flashing #{firmware_path} to #{mount}; this replaces persistent board firmware")
       result = flasher.new(timeout: options[:timeout]).flash(
-        target.firmware_path(root: Dir.pwd),
+        firmware_path,
         mount: options[:mount],
         port: options[:port]
       )
-      output.puts("flashed firmware #{File.basename(target.firmware_path)}: #{result.port}")
+      output.puts("flashed firmware #{File.basename(firmware_path)}: #{result.port}")
     end
 
     def self.parse_options(args, defaults)

data/lib/rpremote/flasher.rb

@@ -5,7 +5,7 @@ require "fileutils"
 module Rpremote
   class Flasher
     DEFAULT_VOLUMES_ROOT = "/Volumes"
-    DEFAULT_TIMEOUT = 10.0
+    DEFAULT_TIMEOUT = 20.0
     INFO_FILE = "INFO_UF2.TXT"
     UF2_BLOCK_SIZE = 512
     UF2_MAGIC_START0 = 0x0A324655

data/lib/rpremote/help.rb

@@ -1,35 +1,60 @@
 # frozen_string_literal: true
 
+# rubocop:disable Metrics/ModuleLength, Metrics/CyclomaticComplexity
+
 module Rpremote
   module Help
-    TEXT = <<~HELP
+    COMMAND_USAGE = {
+      setup: "rpremote setup [--language LANGUAGE] [--language-version VERSION] [--force] [--cache DIR]",
+      build: "rpremote build [--language LANGUAGE] [--language-version VERSION] [--board BOARD] " \
+             "[--firmware FILE] [--cache DIR] [--mrbgems FILE|--no-mrbgems]",
+      build_clean: "rpremote build clean",
+      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]",
+      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]",
+      config_show: "rpremote config show [--language LANGUAGE] [--language-version VERSION] [--board BOARD] " \
+                   "[--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]",
+      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_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]",
+      fs_mkdir: "rpremote fs mkdir :/REMOTE/PATH [--port PORT] [--baud RATE] [--timeout SEC]"
+    }.freeze
+
+    TEXT = <<~HELP.freeze
       rpremote - R2P2 remote control for Raspberry Pi Pico 2
 
       Usage:
-        rpremote setup [--language LANGUAGE] [--language-version VERSION] [--force] [--cache DIR]
-        rpremote build [--language LANGUAGE] [--language-version VERSION] [--board BOARD]
-                       [--firmware FILE] [--cache DIR]
-                       [--mrbgems FILE|--no-mrbgems]
-        rpremote build clean
-        rpremote dfu app FILE [--type ruby|rite] [--port PORT] [--baud RATE] [--timeout SEC]
-        rpremote dfu compile FILE [--output FILE] [--language picoruby]
-                             [--language-version VERSION] [--cache DIR]
-        rpremote dfu status [--port PORT] [--baud RATE] [--timeout SEC]
-        rpremote mrbgems check|list|lock|update [--file FILE] [--lockfile FILE]
-        rpremote flash [--firmware FILE] [--language LANGUAGE] [--language-version VERSION]
-                       [--board BOARD] [--cache DIR] [--mount DIR] [--port PORT] [--timeout SEC]
-        rpremote ports
-        rpremote run FILE [--port PORT] [--timeout SEC] [--language LANGUAGE]
-        rpremote monitor [--port PORT]
-        rpremote repl [--port PORT]
-        rpremote exec CODE [--port PORT] [--timeout SEC] [--language LANGUAGE]
-        rpremote reset [--port PORT]
-        rpremote fs cp FILE :/REMOTE/PATH [--port PORT]
-        rpremote fs cp :/REMOTE/PATH FILE [--port PORT]
-        rpremote fs cat :/REMOTE/PATH [--port PORT]
-        rpremote fs ls :/REMOTE/PATH [--port PORT]
-        rpremote fs rm :/REMOTE/PATH [--port PORT]
-        rpremote fs mkdir :/REMOTE/PATH [--port PORT]
+        #{COMMAND_USAGE.fetch(:setup)}
+        #{COMMAND_USAGE.fetch(:build)}
+        #{COMMAND_USAGE.fetch(:build_clean)}
+        #{COMMAND_USAGE.fetch(:dfu_app)}
+        #{COMMAND_USAGE.fetch(:dfu_compile)}
+        #{COMMAND_USAGE.fetch(:dfu_status)}
+        #{COMMAND_USAGE.fetch(:mrbgems).sub("SUBCOMMAND", "check|list|lock|update")}
+        #{COMMAND_USAGE.fetch(:flash)}
+        #{COMMAND_USAGE.fetch(:config_show)}
+        #{COMMAND_USAGE.fetch(:ports)}
+        #{COMMAND_USAGE.fetch(:run)}
+        #{COMMAND_USAGE.fetch(:monitor)}
+        #{COMMAND_USAGE.fetch(:repl)}
+        #{COMMAND_USAGE.fetch(:exec)}
+        #{COMMAND_USAGE.fetch(:reset)}
+        #{COMMAND_USAGE.fetch(:fs_cp)}
+        #{COMMAND_USAGE.fetch(:fs_cat)}
+        #{COMMAND_USAGE.fetch(:fs_ls)}
+        #{COMMAND_USAGE.fetch(:fs_rm)}
+        #{COMMAND_USAGE.fetch(:fs_mkdir)}
 
       `rpremote build clean` removes only the project's generated `build/` directory.
 
@@ -52,9 +77,211 @@ module Rpremote
         --mount DIR       use an explicit RP2350 BOOTSEL drive
         --port PORT       use an explicit R2P2 CDC 0 device
         --baud RATE       serial baud rate (default: 115200)
-        --timeout SEC     timeout in seconds (default: 10)
+        --timeout SEC     timeout in seconds (default: 20)
         -h, --help        show this help
         -V, --version     show the version
     HELP
+
+    def self.requested?(command, args)
+      %w[help --help -h].include?(command) || args.include?("--help") || args.include?("-h")
+    end
+
+    def self.command_text(command, args)
+      command = args.shift if command == "help"
+      return TEXT if command.nil? || %w[help --help -h].include?(command)
+
+      case command
+      when "setup" then setup_text
+      when "build" then args.first == "clean" ? build_clean_text : build_text
+      when "dfu" then dfu_text(args.first)
+      when "mrbgems" then mrbgems_text(args.first)
+      when "flash" then flash_text
+      when "config" then config_text(args.first)
+      when "ports" then ports_text
+      when "run" then run_text
+      when "exec" then exec_text
+      when "monitor" then monitor_text
+      when "repl" then repl_text
+      when "reset" then reset_text
+      when "fs" then fs_text(args.first)
+      else TEXT
+      end
+    end
+
+    def self.setup_text
+      <<~HELP
+        Usage: #{COMMAND_USAGE.fetch(:setup)}
+
+        Creates config/setting.json when it does not exist, then downloads and prepares PicoRuby source.
+        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
+    end
+
+    def self.build_text
+      <<~HELP
+        Usage: #{COMMAND_USAGE.fetch(:build)}
+
+        Builds a custom UF2 for the selected target. It writes generated files under build/ and the selected firmware path.
+        Options: --language LANGUAGE, --language-version VERSION, --board BOARD (pico2), --cache DIR (firmware),
+        --firmware FILE, --mrbgems FILE, --no-mrbgems. A project Mrbgems file is used automatically by default.
+      HELP
+    end
+
+    def self.build_clean_text
+      <<~HELP
+        Usage: #{COMMAND_USAGE.fetch(:build_clean)}
+
+        Removes only the project's generated build/ directory. It does not remove firmware/, Mrbgems, or Mrbgems.lock.
+      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"
+
+      <<~HELP
+        Usage: #{COMMAND_USAGE.fetch(:dfu_app)}
+               #{COMMAND_USAGE.fetch(:dfu_compile)}
+               #{COMMAND_USAGE.fetch(:dfu_status)}
+
+        Stages and inspects PicoModem DFU applications. Run `rpremote dfu SUBCOMMAND --help` for details.
+      HELP
+    end
+
+    def self.dfu_app_text
+      <<~HELP
+        Usage: #{COMMAND_USAGE.fetch(:dfu_app)}
+
+        Transfers a Ruby source or matching RITE bytecode application to the inactive DFU slot. The next R2P2 restart tries it.
+        Options default to the configured or automatically selected CDC 0 port, 115200 baud, and 20 seconds.
+        The transfer changes the staged boot application; use `rpremote reset` to restart and require DFU.confirm after a successful boot.
+      HELP
+    end
+
+    def self.dfu_compile_text
+      <<~HELP
+        Usage: #{COMMAND_USAGE.fetch(:dfu_compile)}
+
+        Compiles Ruby source to bytecode that matches the selected PicoRuby version. The output defaults beside FILE.
+        It requires prepared PicoRuby source and does not connect to a board.
+      HELP
+    end
+
+    def self.dfu_status_text
+      <<~HELP
+        Usage: #{COMMAND_USAGE.fetch(:dfu_status)}
+
+        Prints the active and candidate DFU A/B slots. Defaults are the configured or automatically selected CDC 0 port,
+        115200 baud, and 20 seconds. This command reads board state without changing it.
+      HELP
+    end
+
+    def self.mrbgems_text(subcommand)
+      action = subcommand || "check|list|lock|update"
+      <<~HELP
+        Usage: #{COMMAND_USAGE.fetch(:mrbgems).sub("SUBCOMMAND", action)}
+
+        Checks or lists build dependencies, writes a reproducible lock file, or updates locked GitHub commits.
+        `check` and `list` are read-only. `lock` writes Mrbgems.lock; `update` resolves new commits and rewrites it.
+      HELP
+    end
+
+    def self.flash_text
+      <<~HELP
+        Usage: #{COMMAND_USAGE.fetch(:flash)}
+
+        Copies the selected UF2 to an RP2350 BOOTSEL volume and waits for R2P2 to reconnect. It replaces persistent board firmware.
+        Defaults select pico2, firmware/picoruby-4.0.3-pico2.uf2, an automatic BOOTSEL mount and CDC 0 port, and 20 seconds.
+      HELP
+    end
+
+    def self.config_text(subcommand)
+      unless subcommand == "show"
+        return "Usage: #{COMMAND_USAGE.fetch(:config_show)}\n\nUse `rpremote config show --help` for the supported overrides.\n"
+      end
+
+      <<~HELP
+        Usage: #{COMMAND_USAGE.fetch(:config_show)}
+
+        Prints the configuration file, defaults, and command-line overrides after resolution. It does not connect to a board or change state.
+      HELP
+    end
+
+    def self.ports_text
+      "Usage: #{COMMAND_USAGE.fetch(:ports)}\n\nPrints each detected R2P2 CDC 0 serial path, one per line. It does not connect to a board.\n"
+    end
+
+    def self.run_text
+      <<~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.
+      HELP
+    end
+
+    def self.exec_text
+      <<~HELP
+        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.
+      HELP
+    end
+
+    def self.monitor_text
+      <<~HELP
+        Usage: #{COMMAND_USAGE.fetch(:monitor)}
+
+        Opens a serial monitor for the selected CDC 0 port. Defaults are 115200 baud and 20 seconds; exit with Ctrl-].
+      HELP
+    end
+
+    def self.repl_text
+      <<~HELP
+        Usage: #{COMMAND_USAGE.fetch(:repl)}
+
+        Opens PicoIRB on the selected CDC 0 port. Defaults are 115200 baud and 20 seconds; exit with Ctrl-].
+      HELP
+    end
+
+    def self.reset_text
+      <<~HELP
+        Usage: #{COMMAND_USAGE.fetch(:reset)}
+
+        Reboots R2P2 and waits for reconnection. Defaults are the automatic CDC 0 port, 115200 baud, and 20 seconds.
+      HELP
+    end
+
+    def self.fs_text(subcommand)
+      return fs_subcommand_text(subcommand) if %w[cp cat ls rm mkdir].include?(subcommand)
+
+      <<~HELP
+        Usage: #{COMMAND_USAGE.fetch(:fs_cp)}
+               #{COMMAND_USAGE.fetch(:fs_cat)}
+               #{COMMAND_USAGE.fetch(:fs_ls)}
+               #{COMMAND_USAGE.fetch(:fs_rm)}
+               #{COMMAND_USAGE.fetch(:fs_mkdir)}
+
+        Uses :/REMOTE/PATH for R2P2 paths. Run `rpremote fs SUBCOMMAND --help` for details.
+      HELP
+    end
+
+    def self.fs_subcommand_text(subcommand)
+      usage = COMMAND_USAGE.fetch(:"fs_#{subcommand}")
+      effect = case subcommand
+               when "rm" then "Deletes the remote path permanently."
+               when "mkdir" then "Creates a remote directory."
+               else "Reads or transfers remote files."
+               end
+      <<~HELP
+        Usage: #{usage}
+
+        #{effect} Defaults are the automatic CDC 0 port, 115200 baud, and 20 seconds.
+      HELP
+    end
   end
 end
+# rubocop:enable Metrics/ModuleLength, Metrics/CyclomaticComplexity

data/lib/rpremote/language_source.rb

@@ -4,6 +4,7 @@ require "fileutils"
 require "net/http"
 require "timeout"
 require "uri"
+require_relative "picoruby_source_patch"
 
 module Rpremote
   class LanguageSource
@@ -26,6 +27,7 @@ module Rpremote
       @fetcher = fetcher || method(:download)
       @extractor = extractor || method(:extract)
       @preparer = preparer || method(:prepare_repository)
+      @patcher = PicoRubySourcePatch.new(version: version).method(:apply)
     end
 
     def setup(force: false)
@@ -38,6 +40,7 @@ module Rpremote
       raise ExtractError, "PicoRuby source was not extracted: #{source_dir}" unless File.directory?(source_dir)
 
       preparer.call(source_dir)
+      patcher.call(source_dir)
       source_dir
     end
 
@@ -55,7 +58,7 @@ module Rpremote
 
     private
 
-    attr_reader :fetcher, :extractor, :preparer
+    attr_reader :fetcher, :extractor, :preparer, :patcher
 
     def fetch_archive
       temporary = "#{archive_path}.part"

data/lib/rpremote/picomodem.rb

@@ -24,7 +24,7 @@ module Rpremote
     READY = 0x01
 
     CHUNK_SIZE = 480
-    DEFAULT_TIMEOUT = 10.0
+    DEFAULT_TIMEOUT = 20.0
     MAX_FRAME_BODY = 65_535
     DFU_MAGIC = "DFU\0".b
     DFU_VERSION = 1
@@ -87,9 +87,7 @@ module Rpremote
           when DONE_ACK
             status, remote_crc = parse_completion(payload)
             raise DeviceError, format("download failed with status 0x%02x", status) unless status == OK
-            if total && data.bytesize != total
-              raise ProtocolError, "file size mismatch: expected #{total}, received #{data.bytesize}"
-            end
+            raise ProtocolError, "file size mismatch: expected #{total}, received #{data.bytesize}" if total && data.bytesize != total
 
             local_crc = Checksum.crc32(data)
             raise ChecksumError, checksum_mismatch("CRC32", local_crc, remote_crc, 8) unless remote_crc == local_crc
@@ -194,9 +192,7 @@ module Rpremote
     def expect_status(expected_command, expected_status, context)
       command, payload = receive_frame
       raise DeviceError, payload.force_encoding(Encoding::UTF_8) if command == ERROR
-      unless command == expected_command
-        raise ProtocolError, "unexpected response #{hex(command, 2)} while waiting for #{context}"
-      end
+      raise ProtocolError, "unexpected response #{hex(command, 2)} while waiting for #{context}" unless command == expected_command
       raise ProtocolError, "#{context} has no status" if payload.empty?
       return if payload.getbyte(0) == expected_status
 

data/lib/rpremote/picoruby_source_patch.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Rpremote
+  class PicoRubySourcePatch
+    JOB_PATH = "mrbgems/picoruby-shell/mrblib/job.rb"
+    PATCH_ALIASES = { "3.4.2" => "3.4.5" }.freeze
+
+    class Error < Rpremote::Error; end
+
+    attr_reader :version
+
+    def initialize(version:)
+      @version = version
+    end
+
+    def apply(source)
+      patch_version = PATCH_ALIASES.fetch(version, version)
+      patch = File.expand_path("../../patches/picoruby-#{patch_version}-ruby-exception-status.patch", __dir__)
+      return unless File.file?(patch) && File.file?(File.join(source, JOB_PATH))
+      return if git_apply?(source, patch, "--reverse", "--check")
+
+      raise Error, "cannot apply rpremote patch to PicoRuby #{version}" unless git_apply?(source, patch, "--check")
+      raise Error, "cannot apply rpremote patch to PicoRuby #{version}" unless git_apply?(source, patch)
+    end
+
+    private
+
+    def git_apply?(source, patch, *options)
+      system("git", "apply", *options, patch, chdir: source, out: File::NULL, err: File::NULL)
+    end
+  end
+end

data/lib/rpremote/resetter.rb

@@ -2,7 +2,7 @@
 
 module Rpremote
   class Resetter
-    DEFAULT_TIMEOUT = 10.0
+    DEFAULT_TIMEOUT = 20.0
     RETRY_INTERVAL = 0.1
     PROBE_TIMEOUT = 1.0
 

data/lib/rpremote/runner.rb

@@ -20,14 +20,14 @@ module Rpremote
       @path_factory = path_factory || method(:temporary_path)
     end
 
-    def run(data)
+    def run(data, output: nil)
       remote_path = @path_factory.call
       shell = @shell_class.new(io, timeout: timeout)
       shell.synchronize!
       @modem_class.new(io, timeout: timeout).upload(remote_path, data)
       shell.synchronize!
       shell_ready = true
-      shell.execute("./#{File.basename(remote_path)}")
+      output ? shell.execute("./#{File.basename(remote_path)}", output: output) : shell.execute("./#{File.basename(remote_path)}")
     ensure
       cleanup(shell, remote_path) if shell_ready && remote_path
     end

data/lib/rpremote/shell.rb

@@ -4,13 +4,14 @@ require "io/wait"
 
 module Rpremote
   class Shell
-    DEFAULT_TIMEOUT = 10.0
+    DEFAULT_TIMEOUT = 20.0
     PROMPT_START = "\e[?25l\e[1G$> \e[0K".b
     PROMPT_END = "\e[?25h".b
     ECHO_START = "\e[?25l\e[1G$> ".b
     ERASE_LINE = "\e[0K".b
     CURSOR_POSITION_QUERY = "\e[6n".b
     CURSOR_POSITION_RESPONSE = "\e[1;1R".b
+    RUBY_EXCEPTION_STATUS = "\x1eR2P2:RUBY_EXCEPTION\x1f".b
 
     class Error < Rpremote::Error; end
     class TimeoutError < Error; end
@@ -42,11 +43,18 @@ module Rpremote
       nil
     end
 
-    def execute(command)
+    def execute(command, output: nil)
       command = validate_command(command)
       send_command(command)
-      response = read_until_prompt(after: ECHO_START + command.b + ERASE_LINE)
-      extract_output(response, command)
+      echo = ECHO_START + command.b + ERASE_LINE
+      stream_state = {}
+      response = read_until_prompt(after: echo) { |buffer| stream_output(output, buffer, echo, stream_state) }
+      command_output = extract_output(response, command)
+      ruby_exception = command_output.include?(RUBY_EXCEPTION_STATUS)
+      command_output = remove_ruby_exception_status(command_output)
+      raise CommandError, "Ruby exception reported by R2P2" if ruby_exception
+
+      command_output
     rescue TimeoutError
       interrupt
       raise
@@ -78,6 +86,7 @@ module Rpremote
 
         buffer << read_available(deadline)
         answer_terminal_queries(buffer)
+        yield buffer if block_given?
       end
     end
 
@@ -95,6 +104,30 @@ module Rpremote
       response.byteslice((output_at + 1)...prompt_at) || +"".b
     end
 
+    def stream_output(output, response, echo, state)
+      return unless output
+
+      echo_at = response.rindex(echo)
+      return unless echo_at
+
+      output_at = response.index("\n", echo_at + echo.bytesize)
+      return unless output_at
+
+      output_at += 1
+      prompt_at = response.index(PROMPT_START, output_at)
+      safe_end = prompt_at || (response.rindex("\n", response.bytesize - 1).to_i + 1)
+      position = state.fetch(:position, output_at)
+      return if safe_end <= position
+
+      output.write(remove_ruby_exception_status(response.byteslice(position...safe_end)))
+      output.flush if output.respond_to?(:flush)
+      state[:position] = safe_end
+    end
+
+    def remove_ruby_exception_status(data)
+      data.gsub(RUBY_EXCEPTION_STATUS, "")
+    end
+
     def drain_input
       deadline = monotonic_time + 0.1
       buffer = +"".b
@@ -114,9 +147,7 @@ module Rpremote
     def read_available(deadline)
       remaining = deadline - monotonic_time
       raise TimeoutError, "timed out waiting for the R2P2 Shell after #{timeout} seconds" unless remaining.positive?
-      unless selectable_io.wait_readable(remaining)
-        raise TimeoutError, "timed out waiting for the R2P2 Shell after #{timeout} seconds"
-      end
+      raise TimeoutError, "timed out waiting for the R2P2 Shell after #{timeout} seconds" unless selectable_io.wait_readable(remaining)
 
       data = io.read_nonblock(4096)
       raise IOError, "serial connection closed" if data.nil? || data.empty?

data/lib/rpremote/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rpremote
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/rpremote.rb

@@ -19,6 +19,7 @@ require_relative "rpremote/terminal"
 require_relative "rpremote/shell"
 require_relative "rpremote/runner"
 require_relative "rpremote/resetter"
+require_relative "rpremote/picoruby_source_patch"
 require_relative "rpremote/language_source"
 require_relative "rpremote/mrbgems"
 require_relative "rpremote/mrbgems_command"