rpremote 0.2.0 → 0.4.0

data/lib/rpremote/mrbgems.rb

@@ -14,7 +14,7 @@ module Rpremote
     COMMIT_PATTERN = /\A[0-9a-f]{40,64}\z/i
     VMS = %i[mruby mrubyc].freeze
 
-    Dependency = Data.define(:type, :source, :branch, :commit, :path)
+    Dependency = Data.define(:type, :source, :branch, :commit, :path, :require_name)
     Overlay = Data.define(:path, :fingerprint)
 
     class Error < Rpremote::Error; end
@@ -68,6 +68,20 @@ module Rpremote
       raise LockError, "invalid mrbgems lock file #{lock_path}: #{e.message}"
     end
 
+    def require_names
+      lock_data = read_lock(required: false)
+      return [] unless lock_data
+
+      lock_data.fetch("gems").filter_map { |gem| gem["require_name"] }.uniq
+    end
+
+    def prepend_requires(source)
+      names = require_names
+      return source if names.empty?
+
+      names.map { |name| "require #{name.inspect}\n" }.join.b + source.b
+    end
+
     def generate_overlay(base_config:, target:, directory:, update: false)
       lock_data = lock(update: update)
       fingerprint = build_fingerprint(base_config, lock_data)
@@ -109,10 +123,12 @@ module Rpremote
           dependency.source, dependency.branch
         )
         { "type" => "github", "source" => dependency.source,
-          "branch" => dependency.branch, "commit" => validate_commit!(commit) }
+          "branch" => dependency.branch, "commit" => validate_commit!(commit),
+          "require_name" => dependency.require_name }.compact
       else
         { "type" => "path", "source" => dependency.source,
-          "sha256" => digest_directory(dependency.path) }
+          "sha256" => digest_directory(dependency.path),
+          "require_name" => dependency.require_name || local_require_name(dependency.path) }.compact
       end
     end
 
@@ -184,12 +200,22 @@ module Rpremote
 
     def valid_github_lock?(entry)
       GITHUB_PATTERN.match?(entry["source"].to_s) && !entry["branch"].to_s.empty? &&
-        COMMIT_PATTERN.match?(entry["commit"].to_s)
+        COMMIT_PATTERN.match?(entry["commit"].to_s) && valid_require_name?(entry["require_name"])
     end
 
     def valid_path_lock?(entry)
       entry["type"] == "path" && !entry["source"].to_s.empty? &&
-        /\A[0-9a-f]{64}\z/.match?(entry["sha256"].to_s)
+        /\A[0-9a-f]{64}\z/.match?(entry["sha256"].to_s) && valid_require_name?(entry["require_name"])
+    end
+
+    def valid_require_name?(name)
+      name.nil? || (name.is_a?(String) && !name.empty? && !name.match?(/[\x00-\x1f\x7f]/))
+    end
+
+    def local_require_name(directory)
+      source = File.read(File.join(directory, "mrbgem.rake"))
+      match = source.match(/^\s*spec\.require_name\s*=\s*["']([^"']+)["']\s*$/)
+      match && match[1]
     end
 
     def build_fingerprint(base_config, lock_data)
@@ -246,14 +272,17 @@ module Rpremote
         @vm_name = value
       end
 
-      def gem(github: nil, path: nil, branch: "main", commit: nil)
+      def gem(github: nil, path: nil, branch: "main", commit: nil, require: nil)
         sources = [github, path].compact
         raise DefinitionError, "gem requires exactly one of github or path" unless sources.length == 1
+        unless require.nil? || (require.is_a?(String) && !require.empty? && !require.match?(/[\x00-\x1f\x7f]/))
+          raise DefinitionError, "invalid mrbgem require name: #{require.inspect}"
+        end
 
         dependency = if github
-                       github_dependency(github, branch, commit)
+                       github_dependency(github, branch, commit, require)
                      else
-                       path_dependency(path, branch, commit)
+                       path_dependency(path, branch, commit, require)
                      end
         key = [dependency.type, dependency.source]
         raise DefinitionError, "duplicate mrbgem: #{dependency.source}" if dependencies.any? do |item|
@@ -267,21 +296,21 @@ module Rpremote
 
       attr_reader :directory
 
-      def github_dependency(source, branch, commit)
+      def github_dependency(source, branch, commit, require_name)
         raise DefinitionError, "invalid GitHub mrbgem: #{source.inspect}" unless GITHUB_PATTERN.match?(source.to_s)
         raise DefinitionError, "GitHub mrbgem branch must not be empty" if branch.to_s.empty?
         raise DefinitionError, "invalid Git commit: #{commit.inspect}" if commit && !COMMIT_PATTERN.match?(commit.to_s)
 
         Dependency.new(type: :github, source: source, branch: branch,
-                       commit: commit&.downcase, path: nil)
+                       commit: commit&.downcase, path: nil, require_name: require_name)
       end
 
-      def path_dependency(source, branch, commit)
+      def path_dependency(source, branch, commit, require_name)
         raise DefinitionError, "local mrbgem path must not be empty" if source.to_s.empty?
         raise DefinitionError, "local mrbgem does not accept branch or commit" if branch != "main" || commit
 
         Dependency.new(type: :path, source: source, branch: nil, commit: nil,
-                       path: File.expand_path(source, directory))
+                       path: File.expand_path(source, directory), require_name: require_name)
       end
     end
   end

data/lib/rpremote/nuke_firmware.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "net/http"
+require "timeout"
+require "uri"
+
+module Rpremote
+  class NukeFirmware
+    URL = "https://github.com/raspberrypi/pico-sdk-prebuilts/releases/latest/download/nuke_universal.uf2"
+    FILENAME = "nuke_universal.uf2"
+    MAX_REDIRECTS = 5
+
+    class DownloadError < Rpremote::Error; end
+
+    def initialize(directory: Target::DEFAULT_CACHE_DIR, fetcher: nil)
+      @directory = File.expand_path(directory)
+      @fetcher = fetcher || method(:download)
+    end
+
+    def setup(force: false)
+      FileUtils.mkdir_p(directory)
+      return path if File.size?(path) && !force
+
+      temporary = "#{path}.part"
+      File.binwrite(temporary, fetcher.call(URL))
+      raise DownloadError, "downloaded nuke_universal.uf2 is empty" unless File.size?(temporary)
+
+      File.rename(temporary, path)
+      path
+    rescue SystemCallError => e
+      raise DownloadError, "cannot store nuke_universal.uf2: #{e.message}"
+    ensure
+      FileUtils.rm_f(temporary) if temporary
+    end
+
+    private
+
+    attr_reader :directory, :fetcher
+
+    def path
+      File.join(directory, FILENAME)
+    end
+
+    def download(url, redirects = MAX_REDIRECTS)
+      raise DownloadError, "too many redirects while downloading nuke_universal.uf2" if redirects.negative?
+
+      uri = URI(url)
+      raise DownloadError, "nuke_universal.uf2 download requires HTTPS" unless uri.is_a?(URI::HTTPS)
+
+      request = Net::HTTP::Get.new(uri)
+      request["User-Agent"] = "rpremote/#{Rpremote::VERSION}"
+      response = Net::HTTP.start(
+        uri.host, uri.port, use_ssl: true, open_timeout: 10, read_timeout: 60
+      ) { |http| http.request(request) }
+
+      case response
+      when Net::HTTPSuccess then response.body
+      when Net::HTTPRedirection
+        location = response["location"]
+        raise DownloadError, "nuke_universal.uf2 download redirect has no location" unless location
+
+        download(URI.join(url, location).to_s, redirects - 1)
+      else
+        raise DownloadError, "nuke_universal.uf2 download failed: HTTP #{response.code} #{response.message}"
+      end
+    rescue SocketError, SystemCallError, Timeout::Error => e
+      raise DownloadError, "nuke_universal.uf2 download failed: #{e.message}"
+    end
+  end
+end

data/lib/rpremote/picoruby_source_patch.rb

@@ -3,6 +3,7 @@
 module Rpremote
   class PicoRubySourcePatch
     JOB_PATH = "mrbgems/picoruby-shell/mrblib/job.rb"
+    BOOTSEL_PATH = "mrbgems/picoruby-machine/include/machine.h"
     PATCH_ALIASES = { "3.4.2" => "3.4.5" }.freeze
 
     class Error < Rpremote::Error; end
@@ -14,19 +15,35 @@ module Rpremote
     end
 
     def apply(source)
+      return unless Dir.exist?(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")
+      patches(patch_version).each do |patch, prerequisite|
+        next unless File.file?(patch) && File.file?(File.join(source, prerequisite))
+        next if prerequisite == BOOTSEL_PATH && File.read(File.join(source, prerequisite)).include?("Machine_bootsel")
+
+        next 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)
+        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
+      nil
     end
 
     private
 
+    def patches(patch_version)
+      definitions = {
+        "ruby-exception-status" => JOB_PATH,
+        "bootsel" => BOOTSEL_PATH
+      }
+      definitions.map do |name, prerequisite|
+        [File.expand_path("../../patches/picoruby-#{patch_version}-#{name}.patch", __dir__), prerequisite]
+      end
+    end
+
     def git_apply?(source, patch, *options)
-      system("git", "apply", *options, patch, chdir: source, out: File::NULL, err: File::NULL)
+      system("git", "apply", "--unidiff-zero", *options, patch, chdir: source, out: File::NULL, err: File::NULL)
     end
   end
 end

data/lib/rpremote/recursive_copy.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Rpremote
+  class RecursiveCopy
+    def initialize(output:, serial: Serial, device: Device)
+      @output = output
+      @serial = serial
+      @device = device
+    end
+
+    def call(source, destination, options)
+      validate!(source, destination)
+      remote_root = RemotePath.validate(destination)
+      directories, files = collect(source, remote_root)
+      create_directories(directories, options)
+      upload_files(files, options)
+      output.puts("uploaded #{files.length} files: #{source} -> #{destination}")
+    rescue Errno::ENOENT => e
+      raise ArgumentError, e.message
+    end
+
+    private
+
+    attr_reader :output, :serial, :device
+
+    def validate!(source, destination)
+      raise ArgumentError, "recursive cp only supports a local source and remote destination" if RemotePath.remote?(source)
+      raise ArgumentError, "recursive cp source must be a directory: #{source}" unless File.directory?(source)
+
+      RemotePath.validate(destination)
+    end
+
+    def collect(source, remote_root)
+      directories = [remote_root]
+      files = []
+      local_entries(source).each do |path|
+        remote_path = File.join(remote_root, path.delete_prefix("#{source}/"))
+        File.directory?(path) ? directories << remote_path : files << [path, remote_path]
+      end
+      [directories.sort_by { |path| [path.count("/"), path] }.uniq, files.sort]
+    end
+
+    def local_entries(source)
+      entries = Dir.glob(File.join(source, "**", "*"), File::FNM_DOTMATCH).reject do |path|
+        %w[. ..].include?(File.basename(path))
+      end
+      symbolic_link = entries.find { |path| File.symlink?(path) }
+      raise ArgumentError, "recursive cp does not support symbolic links: #{symbolic_link}" if symbolic_link
+
+      entries
+    end
+
+    def create_directories(directories, options)
+      with_port(options) do |port|
+        shell = Shell.new(port, timeout: options[:timeout])
+        shell.synchronize!
+        directories.each do |path|
+          quoted_path = Shell.quote_argument(path)
+          next unless shell.execute("ls #{quoted_path}").start_with?("ls:")
+
+          result = shell.execute("mkdir #{quoted_path}")
+          raise Shell::CommandError, result.strip unless result.empty?
+
+          output.puts("created remote directory: :#{path}")
+        end
+      end
+    end
+
+    def upload_files(files, options)
+      with_port(options) do |port|
+        modem = PicoModem.new(port, timeout: options[:timeout])
+        files.each do |local_path, remote_path|
+          size = modem.upload(remote_path, File.binread(local_path))
+          output.puts("uploaded #{size} bytes: #{local_path} -> :#{remote_path}")
+        end
+      end
+    end
+
+    def with_port(options, &)
+      port_path = device.main_port(options[:port])
+      serial.open(port_path, baud: options[:baud], &)
+    end
+  end
+end

data/lib/rpremote/runner.rb

@@ -3,6 +3,8 @@
 module Rpremote
   class Runner
     REMOTE_DIRECTORY = "/home"
+    RUN_REMOTE_PATH = "#{REMOTE_DIRECTORY}/.rpremote-run.rb".freeze
+    DEPLOY_REMOTE_PATH = "#{REMOTE_DIRECTORY}/.rpremote-deploy.rb".freeze
 
     attr_reader :io, :timeout
 
@@ -20,16 +22,33 @@ module Rpremote
       @path_factory = path_factory || method(:temporary_path)
     end
 
-    def run(data, output: nil)
-      remote_path = @path_factory.call
+    def run(data, output: nil, cleanup: true, remote_path: nil, diagnostics: nil)
+      remote_path ||= @path_factory.call
       shell = @shell_class.new(io, timeout: timeout)
+      trace(diagnostics, "SYNC_BEFORE_UPLOAD_START")
       shell.synchronize!
+      trace(diagnostics, "SYNC_BEFORE_UPLOAD_DONE")
+      trace(diagnostics, "UPLOAD_START", "bytes=#{data.bytesize},path=#{remote_path}")
       @modem_class.new(io, timeout: timeout).upload(remote_path, data)
+      trace(diagnostics, "UPLOAD_DONE")
+      trace(diagnostics, "SYNC_BEFORE_RUN_START")
       shell.synchronize!
+      trace(diagnostics, "SYNC_BEFORE_RUN_DONE")
       shell_ready = true
-      output ? shell.execute("./#{File.basename(remote_path)}", output: output) : shell.execute("./#{File.basename(remote_path)}")
+      command = "./#{File.basename(remote_path)}"
+      trace(diagnostics, "EXECUTE_START", "command=#{command}")
+      result = output ? shell.execute(command, output: output, idle_timeout: true) : shell.execute(command, idle_timeout: true)
+      trace(diagnostics, "EXECUTE_DONE", "bytes=#{result.to_s.bytesize}")
+      result
+    rescue StandardError => e
+      trace(diagnostics, "ERROR", "class=#{e.class},message=#{e.message.to_s.gsub("\n", " ")}")
+      raise
     ensure
-      cleanup(shell, remote_path) if shell_ready && remote_path
+      if cleanup && shell_ready && remote_path
+        trace(diagnostics, "CLEANUP_START", "path=#{remote_path}")
+        cleanup(shell, remote_path)
+        trace(diagnostics, "CLEANUP_DONE")
+      end
     end
 
     private
@@ -40,9 +59,17 @@ module Rpremote
       nil
     end
 
+    def trace(diagnostics, event, details = nil)
+      return unless diagnostics
+
+      line = "rpremote: run event=#{event}"
+      line += ",#{details}" if details
+      diagnostics.puts(line)
+      diagnostics.flush if diagnostics.respond_to?(:flush)
+    end
+
     def temporary_path
-      stamp = (Process.clock_gettime(Process::CLOCK_MONOTONIC) * 1_000_000).to_i
-      "#{REMOTE_DIRECTORY}/.rpremote-run-#{Process.pid}-#{stamp}.rb"
+      RUN_REMOTE_PATH
     end
   end
 end

data/lib/rpremote/setup_command.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
 require "optparse"
+require_relative "nuke_firmware"
 
 module Rpremote
   class SetupCommand
-    def self.run(args, defaults:, config:, config_filename:, output: $stdout)
+    def self.run(args, defaults:, config:, config_filename:, output: $stdout, nuke_firmware: NukeFirmware)
       options = {
         force: false,
         cache_dir: defaults.fetch(:cache, Target::DEFAULT_CACHE_DIR),
@@ -29,6 +30,8 @@ module Rpremote
         cache_dir: target.cache_dir
       ).setup(force: options[:force])
       output.puts("installed #{target.language} #{target.language_version}: #{path}")
+      nuke_path = nuke_firmware.new.setup(force: options[:force])
+      output.puts("installed Raspberry Pi nuke firmware: #{nuke_path}")
     end
   end
 end

data/lib/rpremote/shell.rb

@@ -29,11 +29,12 @@ module Rpremote
 
     attr_reader :io, :timeout
 
-    def initialize(io, timeout: DEFAULT_TIMEOUT)
+    def initialize(io, timeout: DEFAULT_TIMEOUT, clock: nil)
       raise ArgumentError, "timeout must be positive" unless timeout.positive?
 
       @io = io
       @timeout = timeout
+      @clock = clock || -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) }
     end
 
     def synchronize!
@@ -43,12 +44,14 @@ module Rpremote
       nil
     end
 
-    def execute(command, output: nil)
+    def execute(command, output: nil, idle_timeout: false)
       command = validate_command(command)
       send_command(command)
       echo = ECHO_START + command.b + ERASE_LINE
       stream_state = {}
-      response = read_until_prompt(after: echo) { |buffer| stream_output(output, buffer, echo, stream_state) }
+      response = read_until_prompt(after: echo, idle_timeout: idle_timeout) do |buffer|
+        stream_output(output, buffer, echo, stream_state)
+      end
       command_output = extract_output(response, command)
       ruby_exception = command_output.include?(RUBY_EXCEPTION_STATUS)
       command_output = remove_ruby_exception_status(command_output)
@@ -76,7 +79,7 @@ module Rpremote
       command
     end
 
-    def read_until_prompt(wait: timeout, after: nil)
+    def read_until_prompt(wait: timeout, after: nil, idle_timeout: false)
       deadline = monotonic_time + wait
       buffer = +"".b
       loop do
@@ -85,6 +88,7 @@ module Rpremote
         return buffer if prompt_at && buffer.index(PROMPT_END, prompt_at + PROMPT_START.bytesize)
 
         buffer << read_available(deadline)
+        deadline = monotonic_time + wait if idle_timeout
         answer_terminal_queries(buffer)
         yield buffer if block_given?
       end
@@ -186,7 +190,7 @@ module Rpremote
     end
 
     def monotonic_time
-      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      @clock.call
     end
   end
 end

data/lib/rpremote/terminal.rb

@@ -49,7 +49,7 @@ module Rpremote
         data = serial_io.read_nonblock(BUFFER_SIZE)
         return false if data.nil? || data.empty?
 
-        output.write(data)
+        output.write(normalize_line_endings(data))
         output.flush if output.respond_to?(:flush)
         true
       else
@@ -75,6 +75,18 @@ module Rpremote
       true
     end
 
+    # input.raw disables the terminal's usual LF-to-CRLF output conversion.
+    # Preserve device CRLF while making a bare LF start at the left margin.
+    def normalize_line_endings(data)
+      normalized = +"".b
+      data.each_byte do |byte|
+        normalized << "\r" if byte == 0x0A && !@previous_output_was_cr
+        normalized << byte
+        @previous_output_was_cr = byte == 0x0D
+      end
+      normalized
+    end
+
     def selectable_serial
       @selectable_serial ||= serial_io.respond_to?(:to_io) ? serial_io.to_io : serial_io
     end

data/lib/rpremote/version.rb

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

data/lib/rpremote.rb

@@ -19,8 +19,10 @@ require_relative "rpremote/terminal"
 require_relative "rpremote/shell"
 require_relative "rpremote/runner"
 require_relative "rpremote/resetter"
+require_relative "rpremote/recursive_copy"
 require_relative "rpremote/picoruby_source_patch"
 require_relative "rpremote/language_source"
+require_relative "rpremote/nuke_firmware"
 require_relative "rpremote/mrbgems"
 require_relative "rpremote/mrbgems_command"
 require_relative "rpremote/flasher"
@@ -29,3 +31,5 @@ require_relative "rpremote/dfu_command"
 require_relative "rpremote/setup_command"
 require_relative "rpremote/build_command"
 require_relative "rpremote/flash_command"
+require_relative "rpremote/bootsel_command"
+require_relative "rpremote/deploy_command"

data/patches/picoruby-3.4.5-bootsel.patch

@@ -0,0 +1,71 @@
+diff --git a/mrbgems/picoruby-machine/include/machine.h b/mrbgems/picoruby-machine/include/machine.h
+--- a/mrbgems/picoruby-machine/include/machine.h
++++ b/mrbgems/picoruby-machine/include/machine.h
+@@ -48,1 +48,2 @@
+ void Machine_reboot(void);
++void Machine_bootsel(void);
+diff --git a/mrbgems/picoruby-machine/mrblib/machine.rb b/mrbgems/picoruby-machine/mrblib/machine.rb
+--- a/mrbgems/picoruby-machine/mrblib/machine.rb
++++ b/mrbgems/picoruby-machine/mrblib/machine.rb
+@@ -22,0 +23,4 @@
++  def self.bootsel
++    self._bootsel
++  end
++
+diff --git a/mrbgems/picoruby-machine/ports/rp2040/machine.c b/mrbgems/picoruby-machine/ports/rp2040/machine.c
+--- a/mrbgems/picoruby-machine/ports/rp2040/machine.c
++++ b/mrbgems/picoruby-machine/ports/rp2040/machine.c
+@@ -12,0 +13,1 @@
++#include "pico/bootrom.h"
+@@ -32,0 +34,6 @@
++void
++Machine_bootsel(void)
++{
++  rom_reset_usb_boot(0, 0);
++}
++
+diff --git a/mrbgems/picoruby-machine/src/mruby/machine.c b/mrbgems/picoruby-machine/src/mruby/machine.c
+--- a/mrbgems/picoruby-machine/src/mruby/machine.c
++++ b/mrbgems/picoruby-machine/src/mruby/machine.c
+@@ -417,0 +418,11 @@
++static mrb_value
++mrb_s__bootsel(mrb_state *mrb, mrb_value self)
++{
++#if !defined(PICORB_PLATFORM_POSIX)
++  Machine_bootsel();
++#else
++  mrb_raise(mrb, E_NOTIMP_ERROR, "Machine._bootsel is not available on this platform");
++#endif
++  return mrb_nil_value();
++}
++
+@@ -443,0 +455,1 @@
++  mrb_define_class_method_id(mrb, module_Machine, MRB_SYM(_bootsel), mrb_s__bootsel, MRB_ARGS_NONE());
+diff --git a/mrbgems/picoruby-machine/src/mrubyc/machine.c b/mrbgems/picoruby-machine/src/mrubyc/machine.c
+--- a/mrbgems/picoruby-machine/src/mrubyc/machine.c
++++ b/mrbgems/picoruby-machine/src/mrubyc/machine.c
+@@ -252,0 +253,11 @@
++static void
++c_Machine__bootsel(mrbc_vm *vm, mrbc_value *v, int argc)
++{
++#if !defined(PICORB_PLATFORM_POSIX)
++  Machine_bootsel();
++#else
++  mrbc_raise(vm, MRBC_CLASS(RuntimeError), "Machine.bootsel is not available on this platform.");
++#endif
++  SET_NIL_RETURN();
++}
++
+@@ -439,0 +451,1 @@
++  mrbc_define_method(vm, module_Machine, "_bootsel", c_Machine__bootsel);
+diff --git a/mrbgems/picoruby-shell/shell_executables/_path.txt b/mrbgems/picoruby-shell/shell_executables/_path.txt
+--- a/mrbgems/picoruby-shell/shell_executables/_path.txt
++++ b/mrbgems/picoruby-shell/shell_executables/_path.txt
+@@ -16,0 +17,1 @@
++/bin/bootsel
+diff --git a/mrbgems/picoruby-shell/shell_executables/bootsel.rb b/mrbgems/picoruby-shell/shell_executables/bootsel.rb
+new file mode 100644
+--- /dev/null
++++ b/mrbgems/picoruby-shell/shell_executables/bootsel.rb
+@@ -0,0 +1 @@
++Machine.bootsel

data/patches/picoruby-4.0.3-bootsel.patch

@@ -0,0 +1,71 @@
+diff --git a/mrbgems/picoruby-machine/include/machine.h b/mrbgems/picoruby-machine/include/machine.h
+--- a/mrbgems/picoruby-machine/include/machine.h
++++ b/mrbgems/picoruby-machine/include/machine.h
+@@ -68,1 +68,2 @@
+ void Machine_reboot(void);
++void Machine_bootsel(void);
+diff --git a/mrbgems/picoruby-machine/mrblib/machine.rb b/mrbgems/picoruby-machine/mrblib/machine.rb
+--- a/mrbgems/picoruby-machine/mrblib/machine.rb
++++ b/mrbgems/picoruby-machine/mrblib/machine.rb
+@@ -22,0 +23,4 @@
++  def self.bootsel
++    self._bootsel
++  end
++
+diff --git a/mrbgems/picoruby-machine/ports/rp2040/machine.c b/mrbgems/picoruby-machine/ports/rp2040/machine.c
+--- a/mrbgems/picoruby-machine/ports/rp2040/machine.c
++++ b/mrbgems/picoruby-machine/ports/rp2040/machine.c
+@@ -10,0 +11,1 @@
++#include "pico/bootrom.h"
+@@ -42,0 +44,6 @@
++void
++Machine_bootsel(void)
++{
++  rom_reset_usb_boot(0, 0);
++}
++
+diff --git a/mrbgems/picoruby-machine/src/mruby/machine.c b/mrbgems/picoruby-machine/src/mruby/machine.c
+--- a/mrbgems/picoruby-machine/src/mruby/machine.c
++++ b/mrbgems/picoruby-machine/src/mruby/machine.c
+@@ -496,0 +497,11 @@
++static mrb_value
++mrb_s__bootsel(mrb_state *mrb, mrb_value self)
++{
++#if !defined(PICORB_PLATFORM_POSIX)
++  Machine_bootsel();
++#else
++  mrb_raise(mrb, E_NOTIMP_ERROR, "Machine._bootsel is not available on this platform");
++#endif
++  return mrb_nil_value();
++}
++
+@@ -529,0 +541,1 @@
++  mrb_define_class_method_id(mrb, module_Machine, MRB_SYM(_bootsel), mrb_s__bootsel, MRB_ARGS_NONE());
+diff --git a/mrbgems/picoruby-machine/src/mrubyc/machine.c b/mrbgems/picoruby-machine/src/mrubyc/machine.c
+--- a/mrbgems/picoruby-machine/src/mrubyc/machine.c
++++ b/mrbgems/picoruby-machine/src/mrubyc/machine.c
+@@ -316,0 +317,11 @@
++static void
++c_Machine__bootsel(mrbc_vm *vm, mrbc_value *v, int argc)
++{
++#if !defined(PICORB_PLATFORM_POSIX)
++  Machine_bootsel();
++#else
++  mrbc_raise(vm, MRBC_CLASS(RuntimeError), "Machine.bootsel is not available on this platform.");
++#endif
++  SET_NIL_RETURN();
++}
++
+@@ -546,0 +558,1 @@
++  mrbc_define_method(vm, module_Machine, "_bootsel", c_Machine__bootsel);
+diff --git a/mrbgems/picoruby-shell/shell_executables/_path.txt b/mrbgems/picoruby-shell/shell_executables/_path.txt
+--- a/mrbgems/picoruby-shell/shell_executables/_path.txt
++++ b/mrbgems/picoruby-shell/shell_executables/_path.txt
+@@ -17,0 +18,1 @@
++/bin/bootsel
+diff --git a/mrbgems/picoruby-shell/shell_executables/bootsel.rb b/mrbgems/picoruby-shell/shell_executables/bootsel.rb
+new file mode 100644
+--- /dev/null
++++ b/mrbgems/picoruby-shell/shell_executables/bootsel.rb
+@@ -0,0 +1 @@
++Machine.bootsel