rpremote 0.1.0 → 0.3.0

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/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,49 @@
+# frozen_string_literal: true
+
+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
+
+    attr_reader :version
+
+    def initialize(version:)
+      @version = version
+    end
+
+    def apply(source)
+      return unless Dir.exist?(source)
+
+      patch_version = PATCH_ALIASES.fetch(version, version)
+      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)
+      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", "--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/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

@@ -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)
-      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
-      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

@@ -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
@@ -28,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!
@@ -42,11 +44,20 @@ module Rpremote
       nil
     end
 
-    def execute(command)
+    def execute(command, output: nil, idle_timeout: false)
       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, 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)
+      raise CommandError, "Ruby exception reported by R2P2" if ruby_exception
+
+      command_output
     rescue TimeoutError
       interrupt
       raise
@@ -68,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
@@ -77,7 +88,9 @@ 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
     end
 
@@ -95,6 +108,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 +151,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?
@@ -155,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.1.0"
+  VERSION = "0.3.0"
 end

data/lib/rpremote.rb

@@ -19,7 +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"
@@ -28,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-3.4.5-ruby-exception-status.patch

@@ -0,0 +1,59 @@
+diff --git a/mrbgems/picoruby-shell/mrblib/job.rb b/mrbgems/picoruby-shell/mrblib/job.rb
+index 9351ee0..91e7e74 100644
+--- a/mrbgems/picoruby-shell/mrblib/job.rb
++++ b/mrbgems/picoruby-shell/mrblib/job.rb
+@@ -1,5 +1,7 @@
+ class Shell
+   class Job
++    RUBY_EXCEPTION_STATUS = "\x1eR2P2:RUBY_EXCEPTION\x1f"
++
+     def initialize(*params)
+       if params.empty?
+         raise ArgumentError, "Job requires at least one parameter"
+@@ -24,12 +26,11 @@ class Shell
+       @sandbox.resume
+       @sandbox.wait(timeout: nil)
+       if error = @sandbox.error
+-        puts "#{error.message} (#{error.class})"
++        return report_ruby_exception(error)
+       end
+       return true
+     rescue Exception => e
+-      puts "#{e.message} (#{e.class})"
+-      return false
++      return report_ruby_exception(e)
+     end
+ 
+     def state
+@@ -46,22 +47,28 @@ class Shell
+       trap
+       @sandbox.load_file(@exefile)
+       if error = @sandbox.error
+-        puts "\n#{error.message} (#{error.class})"
++        return report_ruby_exception(error, true)
+       end
+       return true
+     rescue Exception => e
+-      puts "#{e.message} (#{e.class})"
+       # backtrace uses a lot of memory
+       #if e.respond_to?(:backtrace)
+       #  e.backtrace.each do |line|
+       #    puts "  #{line}"
+       #  end
+       #end
+-      return false
++      return report_ruby_exception(e)
+     end
+ 
+     private
+ 
++    def report_ruby_exception(error, leading_newline = false)
++      print "\n" if leading_newline
++      puts "#{error.message} (#{error.class})"
++      print RUBY_EXCEPTION_STATUS
++      false
++    end
++
+     def trap
+       Signal.trap(:TSTP) do
+         @sandbox.suspend