prremote 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 38c2f68eda963d1330c36a056cd57d7f40aa20916aab7b254b190aea3f9cde11
+  data.tar.gz: 6ef03b383f689c40a43a5449300e648cc693a1c7ebc974661398e2f290272396
+SHA512:
+  metadata.gz: 67e8c6d8ce84d1721f23671269460fa366ab3ceaf4316f535e185a8d4395b919d6cb746197934074a8942752ed389476a0e979d41705f22cb5053a0fbade6531
+  data.tar.gz: 88100fc592979327716cf747bebbd06c90087c8193c2bb7fc692fab36fb7a3f9d38d68b97c5b5533c3a682ca0ac4e55b39c311ff28c2ac0643aaea3fe1fd3a2f

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ITO Yosei
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,202 @@
+# prremote
+
+> ⚠️ This project is in early development. APIs and commands are subject to change.
+
+**prremote** is a command-line tool for deploying and running Ruby scripts on a Raspberry Pi Pico W over USB serial. It ships a minimal [mruby/c](https://github.com/mrubyc/mrubyc) runtime firmware and lets you compile and send `.rb` files from your Mac or Linux machine directly to the device.
+
+Inspired by [mpremote](https://docs.micropython.org/en/latest/reference/mpremote.html) for MicroPython.
+
+---
+
+## Requirements
+
+- Ruby 3.x or later
+- Raspberry Pi Pico W
+- `mrbc` in your PATH (for `run`, `deploy`, and `eval`) — install via `brew install mruby` on macOS
+
+---
+
+## Installation
+
+```bash
+gem install prremote
+```
+
+---
+
+## Quick Start
+
+```bash
+# 1. Flash the prremote runtime to your Pico W (one-time setup)
+prremote install
+
+# 2. Write your app
+echo 'puts "Hello from Pico W!"' > app.rb
+
+# 3. Run it
+prremote run app.rb
+```
+
+---
+
+## Commands
+
+### `install`
+
+Flash the prremote runtime firmware to a Pico W.
+
+```bash
+prremote install
+prremote install --version 0.1.1   # specify a runtime version
+```
+
+The firmware is downloaded from GitHub Releases on first use and cached in `~/.prremote/runtime/`. Subsequent installs use the cache.
+
+Put the Pico W into BOOTSEL mode (hold BOOTSEL, connect USB, release) when prompted.
+
+---
+
+### `run FILE`
+
+Compile a local `.rb` file to mruby bytecode and run it on the device immediately (one-shot).
+
+```bash
+prremote run app.rb
+prremote run blink.rb --port /dev/tty.usbmodem101
+```
+
+The device responds with `RUNNING`, streams any output, then `DONE`.
+
+---
+
+### `deploy FILE`
+
+Compile a local `.rb` file and save it to the device's flash. The script runs automatically on every boot.
+
+```bash
+prremote deploy app.rb
+```
+
+The device responds with `DEPLOYED` when the write is complete.
+
+---
+
+### `undeploy`
+
+Erase the deployed script from flash. After this, the device boots into idle mode.
+
+```bash
+prremote undeploy
+```
+
+---
+
+### `eval EXPR`
+
+Evaluate a Ruby one-liner on the device.
+
+```bash
+prremote eval "puts 1 + 1"
+prremote eval "CYW43.init; CYW43::GPIO.new(CYW43::GPIO::LED_PIN).write 1"
+```
+
+---
+
+### `reset`
+
+Send `Ctrl+C` to interrupt a running program.
+
+```bash
+prremote reset
+```
+
+---
+
+### `watch FILE`
+
+Watch a local file for changes and automatically re-run it on the device on every save.
+
+```bash
+prremote watch app.rb
+```
+
+Useful during development — save your file and the device immediately runs the updated code.
+
+---
+
+### `list`
+
+List USB serial devices that may be prremote-compatible.
+
+```bash
+prremote list
+```
+
+---
+
+### `version`
+
+Show the gem version, mrbc version, and the connected device's runtime version.
+
+```bash
+prremote version
+# prremote: 0.1.0
+# mrbc:     3.3.0 (/usr/local/bin/mrbc)
+# runtime:  0.1.2
+```
+
+---
+
+## Global Options
+
+| Option | Description |
+|---|---|
+| `--port`, `-p PORT` | Serial port (default: auto-detect) |
+| `--baud`, `-b N` | Baud rate (default: `115200`) |
+
+---
+
+## Typical Development Workflow
+
+```bash
+# First-time setup
+prremote install
+
+# Manual cycle
+prremote run app.rb       # compile + run (one-shot)
+prremote reset            # interrupt a running program
+
+# Automated cycle (recommended)
+prremote watch app.rb     # auto-run on every file save
+
+# Persistent deployment (auto-runs on boot)
+prremote deploy app.rb
+prremote undeploy         # remove from flash
+```
+
+---
+
+## How It Works
+
+prremote flashes a minimal C firmware (built on mruby/c) onto the Pico W. The firmware:
+
+1. Waits for a USB serial connection and sends `READY prremote-runtime/VERSION`
+2. Receives a command from the host:
+   - Raw `.mrb` bytecode → execute immediately and stream output (`run` / `eval` / `watch`)
+   - `DPLY` + `.mrb` bytecode → save to flash and confirm with `DEPLOYED` (`deploy`)
+3. Waits for the next command
+
+Scripts saved via `deploy` are stored in flash and run automatically on every boot. GPIO and WiFi (CYW43) C bindings are available in Ruby code running on the device.
+
+---
+
+## License
+
+[MIT License](LICENSE)
+
+---
+
+## Related Projects
+
+- [mruby/c](https://github.com/mrubyc/mrubyc) — Lightweight mruby implementation used in the runtime
+- [mpremote](https://docs.micropython.org/en/latest/reference/mpremote.html) — MicroPython equivalent (inspiration)

data/bin/prremote

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+require 'prremote'
+
+Prremote::CLI.start(ARGV)

data/lib/prremote/cli.rb

@@ -0,0 +1,140 @@
+require 'thor'
+require 'rubyserial'
+require_relative 'version'
+require_relative 'detector'
+require_relative 'mrbc'
+require_relative 'runtime_manager'
+require_relative 'commands/install'
+require_relative 'commands/deploy'
+require_relative 'commands/undeploy'
+require_relative 'commands/run'
+require_relative 'commands/eval_cmd'
+require_relative 'commands/watch'
+
+module Prremote
+  class CLI < Thor
+    class_option :port, aliases: '-p', desc: 'Serial port (default: auto-detect)'
+    class_option :baud, aliases: '-b', type: :numeric, default: 115_200, desc: 'Baud rate'
+
+    def self.exit_on_failure?
+      true
+    end
+
+    desc 'install', 'Flash prremote runtime firmware to Pico W'
+    option :version, type: :string, desc: "Firmware version to install (default: #{RUNTIME_VERSION})"
+    def install
+      version = options[:version] || RUNTIME_VERSION
+      Commands::Install.new(version: version).call
+    rescue RuntimeError => e
+      raise Thor::Error, e.message
+    end
+
+    desc 'run FILE', 'Compile and run a Ruby script on the device (one-shot)'
+    def run_script(file)
+      port = resolve_port
+      Commands::Run.new(port: port, baud: options[:baud]).call(file)
+    rescue RuntimeError => e
+      raise Thor::Error, e.message
+    end
+    map 'run' => :run_script
+
+    desc 'deploy FILE', 'Compile and save a Ruby script to flash (auto-runs on boot)'
+    def deploy(file)
+      port = resolve_port
+      Commands::Deploy.new(port: port, baud: options[:baud]).call(file)
+    rescue RuntimeError => e
+      raise Thor::Error, e.message
+    end
+
+    desc 'undeploy', 'Erase the deployed script from flash (disables auto-run on boot)'
+    def undeploy
+      port = resolve_port
+      Commands::Undeploy.new(port: port, baud: options[:baud]).call
+    rescue RuntimeError => e
+      raise Thor::Error, e.message
+    end
+
+    desc 'eval EXPR', 'Compile and run a one-liner Ruby expression on the device'
+    def eval(expr)
+      port = resolve_port
+      Commands::EvalCmd.new(port: port, baud: options[:baud]).call(expr)
+    rescue RuntimeError => e
+      raise Thor::Error, e.message
+    end
+
+    desc 'watch FILE', 'Watch a Ruby file for changes and re-run on the device automatically'
+    def watch(file)
+      port = resolve_port
+      Commands::Watch.new(port: port, baud: options[:baud]).call(file)
+    rescue RuntimeError => e
+      raise Thor::Error, e.message
+    end
+
+    desc 'list', 'Show available serial devices'
+    def list
+      devices = Detector.new.list_devices
+      if devices.empty?
+        puts 'No serial devices found.'
+      else
+        devices.each { |d| puts "#{d[:port]}  (#{d[:label]})" }
+      end
+    end
+
+    desc 'reset', 'Send Ctrl+C to interrupt the running program'
+    def reset
+      port = resolve_port
+      serial = Serial.new(port, options[:baud])
+      serial.write("\x03")
+      sleep 0.1
+      puts 'Reset signal sent.'
+    rescue RuntimeError => e
+      raise Thor::Error, e.message
+    ensure
+      serial&.close
+    end
+
+    desc 'version', 'Show prremote, mrbc, and device firmware version'
+    def version
+      puts "prremote: #{VERSION}"
+
+      begin
+        puts "mrbc:     #{Mrbc.version} (#{Mrbc.bin})"
+      rescue RuntimeError => e
+        puts "mrbc:     (#{e.message})"
+      end
+
+      puts "runtime:  #{fetch_runtime_version}"
+    end
+
+    private
+
+    def fetch_runtime_version
+      port = options[:port] || Detector.find_device
+      return '(no device connected)' unless port
+
+      serial = Serial.new(port, options[:baud])
+      serial.write("\x03")
+      buf      = +''
+      deadline = Time.now + 5
+      loop do
+        buf << (serial.read(256) || '').gsub("\r\n", "\n").gsub("\r", '')
+        return ::Regexp.last_match(1) if buf =~ %r{READY prremote-runtime/([\d.]+)}
+        break if Time.now > deadline
+
+        sleep 0.05
+      end
+      '(not responding)'
+    ensure
+      serial&.close
+    end
+
+    def resolve_port
+      return options[:port] if options[:port]
+
+      port = Detector.find_device
+      raise Thor::Error, 'No device found. Use --port to specify one.' unless port
+
+      port
+    end
+  end
+end

data/lib/prremote/commands/deploy.rb

@@ -0,0 +1,75 @@
+require 'open3'
+require 'tempfile'
+require_relative '../mrbc'
+
+module Prremote
+  module Commands
+    class Deploy
+      DEPLOY_MAGIC = 'DPLY'.freeze
+
+      def initialize(port:, baud:)
+        @port = port
+        @baud = baud
+      end
+
+      def call(rb_path)
+        raise "File not found: #{rb_path}" unless File.exist?(rb_path)
+
+        warn "Compiling #{rb_path}..."
+        mrb_data = compile(rb_path)
+
+        warn 'Deploying to flash...'
+        deploy_to_device(mrb_data)
+        warn 'Deployed. Script will run automatically on next boot.'
+      end
+
+      private
+
+      def compile(rb_path)
+        tmp = Tempfile.new(['prremote', '.mrb'])
+        out, status = Open3.capture2e(Mrbc.bin, '-o', tmp.path, rb_path)
+        raise "mrbc failed:\n#{out.chomp}" unless status.success?
+
+        File.binread(tmp.path)
+      ensure
+        tmp&.close!
+      end
+
+      def deploy_to_device(mrb_data)
+        serial = Serial.new(@port, @baud)
+        sleep 0.5
+        serial.read(4096)
+
+        serial.write(DEPLOY_MAGIC + mrb_data)
+        debug "sent DPLY + #{mrb_data.bytesize} bytes"
+
+        wait_for_deployed(serial)
+      ensure
+        serial&.close
+      end
+
+      def wait_for_deployed(serial)
+        buf = +''
+        deadline = Time.now + 30
+        loop do
+          chunk = normalize(serial.read(256) || '')
+          buf << chunk unless chunk.empty?
+
+          return if buf.include?("DEPLOYED\n")
+          raise "Device error: #{buf.strip}" if buf.match?(/^ERROR /)
+          raise 'Timeout waiting for deploy confirmation' if Time.now > deadline
+
+          sleep 0.05
+        end
+      end
+
+      def normalize(str)
+        str.gsub("\r\n", "\n").gsub("\r", '')
+      end
+
+      def debug(msg)
+        warn "[debug] #{msg}" if ENV['PRREMOTE_DEBUG']
+      end
+    end
+  end
+end

data/lib/prremote/commands/eval_cmd.rb

@@ -0,0 +1,22 @@
+require 'tempfile'
+require_relative 'run'
+
+module Prremote
+  module Commands
+    class EvalCmd
+      def initialize(port:, baud:)
+        @port = port
+        @baud = baud
+      end
+
+      def call(expr)
+        tmp = Tempfile.new(['prremote_eval', '.rb'])
+        tmp.write(expr)
+        tmp.flush
+        Run.new(port: @port, baud: @baud).call(tmp.path)
+      ensure
+        tmp&.close!
+      end
+    end
+  end
+end

data/lib/prremote/commands/install.rb

@@ -0,0 +1,62 @@
+require 'fileutils'
+
+module Prremote
+  module Commands
+    class Install
+      def initialize(version: RUNTIME_VERSION)
+        @version = version
+      end
+
+      def call
+        uf2_path = RuntimeManager.fetch(@version)
+
+        puts 'Put the Pico W into BOOTSEL mode:'
+        puts '  1. Hold the BOOTSEL button'
+        puts '  2. Connect USB (or press RUN while holding BOOTSEL)'
+        puts '  3. Release BOOTSEL — RPI-RP2 should appear as a USB drive'
+        puts
+        puts 'Waiting for RPI-RP2...'
+
+        volume = wait_for_volume
+        puts "Copying firmware to #{volume}..."
+        FileUtils.cp(uf2_path, File.join(volume, File.basename(uf2_path)))
+
+        puts 'Waiting for device to reboot...'
+        wait_for_unmount(volume)
+
+        puts "Done. Runtime #{@version} installed."
+      end
+
+      private
+
+      def volume_paths
+        [
+          '/Volumes/RPI-RP2',
+          "/run/media/#{ENV.fetch('USER', nil)}/RPI-RP2",
+          "/media/#{ENV.fetch('USER', nil)}/RPI-RP2"
+        ]
+      end
+
+      def wait_for_volume(timeout: 60)
+        deadline = Time.now + timeout
+        loop do
+          path = volume_paths.find { |p| File.directory?(p) }
+          return path if path
+          raise "Timed out waiting for RPI-RP2 volume (#{timeout}s)" if Time.now > deadline
+
+          sleep 1
+        end
+      end
+
+      def wait_for_unmount(volume, timeout: 30)
+        deadline = Time.now + timeout
+        loop do
+          return unless File.directory?(volume)
+          raise "Timed out waiting for device to reboot (#{timeout}s)" if Time.now > deadline
+
+          sleep 1
+        end
+      end
+    end
+  end
+end

data/lib/prremote/commands/run.rb

@@ -0,0 +1,102 @@
+require 'open3'
+require 'tempfile'
+require_relative '../mrbc'
+
+module Prremote
+  module Commands
+    class Run
+      def initialize(port:, baud:)
+        @port = port
+        @baud = baud
+      end
+
+      def call(rb_path)
+        raise "File not found: #{rb_path}" unless File.exist?(rb_path)
+
+        warn "Compiling #{rb_path}..."
+        mrb_data = compile(rb_path)
+
+        warn 'Running...'
+        run_on_device(mrb_data)
+      end
+
+      private
+
+      def compile(rb_path)
+        tmp = Tempfile.new(['prremote', '.mrb'])
+        out, status = Open3.capture2e(Mrbc.bin, '-o', tmp.path, rb_path)
+        raise "mrbc failed:\n#{out.chomp}" unless status.success?
+
+        File.binread(tmp.path)
+      ensure
+        tmp&.close!
+      end
+
+      def run_on_device(mrb_data)
+        serial = Serial.new(@port, @baud)
+        sleep 0.5
+        drained = serial.read(4096) || ''
+        debug "drained #{drained.bytesize} bytes: #{drained.inspect}"
+
+        serial.write(mrb_data)
+        debug "sent #{mrb_data.bytesize} bytes (first 4: #{mrb_data[0, 4].inspect})"
+
+        post_running = wait_for_running(serial)
+        stream_until_done(serial, post_running)
+      ensure
+        serial&.close
+      end
+
+      def wait_for_running(serial)
+        buf = +''
+        deadline = Time.now + 10
+        loop do
+          chunk = normalize(serial.read(256) || '')
+          unless chunk.empty?
+            debug "recv: #{chunk.inspect}"
+            buf << chunk
+          end
+          raise "Device error: #{buf.strip}" if buf.match?(/^ERROR /)
+
+          if (idx = buf.index("RUNNING\n"))
+            return buf[(idx + "RUNNING\n".length)..]
+          end
+
+          raise 'Timeout waiting for device to start execution' if Time.now > deadline
+
+          sleep 0.05
+        end
+      end
+
+      def stream_until_done(serial, initial = +'')
+        buf = initial
+        loop do
+          buf << normalize(serial.read(256) || '')
+
+          if (done_pos = buf.index("DONE\n"))
+            $stdout.print buf[0, done_pos] unless done_pos.zero?
+            $stdout.flush
+            return
+          end
+
+          if buf.length > 512
+            safe = buf.length - 5
+            $stdout.print buf[0, safe]
+            $stdout.flush
+            buf = buf[safe..]
+          end
+
+          sleep 0.01
+        end
+      end
+
+      def normalize(str)
+        str.gsub("\r\n", "\n").gsub("\r", '')
+      end
+
+      def debug(msg)
+        warn "[debug] #{msg}" if ENV['PRREMOTE_DEBUG']
+      end
+    end
+  end
+end

data/lib/prremote/commands/undeploy.rb

@@ -0,0 +1,41 @@
+module Prremote
+  module Commands
+    class Undeploy
+      ERASE_MAGIC = 'ERSE'.freeze
+
+      def initialize(port:, baud:)
+        @port = port
+        @baud = baud
+      end
+
+      def call
+        serial = Serial.new(@port, @baud)
+        sleep 0.5
+        serial.read(4096)
+
+        serial.write(ERASE_MAGIC)
+        wait_for_erased(serial)
+        warn 'Flash erased. Device will no longer auto-run a script on boot.'
+      ensure
+        serial&.close
+      end
+
+      private
+
+      def wait_for_erased(serial)
+        buf = +''
+        deadline = Time.now + 30
+        loop do
+          chunk = (serial.read(256) || '').gsub("\r\n", "\n").gsub("\r", '')
+          buf << chunk unless chunk.empty?
+
+          return if buf.include?("ERASED\n")
+          raise "Device error: #{buf.strip}" if buf.match?(/^ERROR /)
+          raise 'Timeout waiting for erase confirmation' if Time.now > deadline
+
+          sleep 0.05
+        end
+      end
+    end
+  end
+end

data/lib/prremote/commands/watch.rb

@@ -0,0 +1,42 @@
+require_relative 'run'
+
+module Prremote
+  module Commands
+    class Watch
+      POLL_INTERVAL = 0.5
+
+      def initialize(port:, baud:)
+        @port = port
+        @baud = baud
+      end
+
+      def call(rb_path)
+        raise "File not found: #{rb_path}" unless File.exist?(rb_path)
+
+        warn "Watching #{rb_path} (Ctrl+C to stop)..."
+        last_mtime = File.mtime(rb_path)
+        run(rb_path)
+
+        loop do
+          sleep POLL_INTERVAL
+          mtime = File.mtime(rb_path)
+          next if mtime == last_mtime
+
+          last_mtime = mtime
+          warn "\n--- #{rb_path} changed, re-running ---"
+          run(rb_path)
+        end
+      rescue Interrupt
+        warn "\nStopped watching."
+      end
+
+      private
+
+      def run(rb_path)
+        Run.new(port: @port, baud: @baud).call(rb_path)
+      rescue RuntimeError => e
+        warn "Error: #{e.message}"
+      end
+    end
+  end
+end

data/lib/prremote/detector.rb

@@ -0,0 +1,67 @@
+require 'rbconfig'
+
+module Prremote
+  class Detector
+    R2P2_VENDOR_IDS = %w[2e8a].freeze # Raspberry Pi USB VID
+
+    def self.find_device
+      new.find_device
+    end
+
+    def find_device
+      candidates = serial_ports
+      return candidates.first if candidates.size == 1
+
+      r2p2 = candidates.select { |p| r2p2_port?(p) }
+      r2p2.first || candidates.first
+    end
+
+    def list_devices
+      serial_ports.map do |port|
+        label = r2p2_port?(port) ? 'R2P2/PicoRuby' : 'unknown'
+        { port: port, label: label }
+      end
+    end
+
+    private
+
+    def serial_ports
+      case RbConfig::CONFIG['host_os']
+      when /darwin/
+        # Use cu.* (call-out) devices — tty.* blocks on carrier and causes EBUSY
+        Dir.glob('/dev/cu.usbmodem*') + Dir.glob('/dev/cu.usbserial*')
+      when /linux/
+        Dir.glob('/dev/ttyACM*') + Dir.glob('/dev/ttyUSB*')
+      when /mswin|mingw|cygwin/
+        # Enumerate COM ports via registry on Windows
+        require 'win32/registry'
+        ports = []
+        Win32::Registry::HKEY_LOCAL_MACHINE.open('HARDWARE\DEVICEMAP\SERIALCOMM') do |reg|
+          reg.each_value { |_name, _type, data| ports << data }
+        end
+        ports
+      else
+        []
+      end
+    end
+
+    def r2p2_port?(port)
+      # On macOS/Linux, check sysfs or ioreg for the Raspberry Pi VID
+      case RbConfig::CONFIG['host_os']
+      when /darwin/
+        ioreg_output = `ioreg -p IOUSB -l 2>/dev/null`
+        R2P2_VENDOR_IDS.any? { |vid| ioreg_output.include?(vid) } &&
+          port.match?(/usbmodem/)
+      when /linux/
+        port_name = File.basename(port)
+        vid_path = "/sys/class/tty/#{port_name}/device/../../../idVendor"
+        return false unless File.exist?(vid_path)
+
+        vid = File.read(vid_path).strip.downcase
+        R2P2_VENDOR_IDS.include?(vid)
+      else
+        false
+      end
+    end
+  end
+end

data/lib/prremote/mrbc.rb

@@ -0,0 +1,25 @@
+require 'open3'
+
+module Prremote
+  module Mrbc
+    SHIMS_RE = %r{\.rbenv/shims}
+
+    def self.bin
+      return ENV['MRBC'] if ENV['MRBC'] && File.executable?(ENV['MRBC'])
+
+      found = ENV['PATH'].split(File::PATH_SEPARATOR)
+                         .grep_v(SHIMS_RE)
+                         .map    { |d| File.join(d, 'mrbc') }
+                         .find   { |f| File.executable?(f) }
+
+      found || raise('mrbc not found. Install mruby: brew install mruby')
+    end
+
+    def self.version
+      out, = Open3.capture2e(bin, '--version')
+      out.strip
+    rescue RuntimeError
+      '(mrbc not found)'
+    end
+  end
+end

data/lib/prremote/runtime_manager.rb

@@ -0,0 +1,57 @@
+require 'net/http'
+require 'uri'
+require 'fileutils'
+
+module Prremote
+  module RuntimeManager
+    REPO  = 'lumbermill/prremote'.freeze
+    BOARD = 'picow'.freeze
+
+    def self.uf2_filename(version)
+      "prremote-#{BOARD}-runtime-#{version}.uf2"
+    end
+
+    def self.release_url(version)
+      "https://github.com/#{REPO}/releases/download/runtime-#{version}/#{uf2_filename(version)}"
+    end
+
+    def self.cache_dir
+      File.join(Dir.home, '.prremote', 'runtime')
+    end
+
+    def self.cached_path(version)
+      File.join(cache_dir, uf2_filename(version))
+    end
+
+    def self.fetch(version)
+      path = cached_path(version)
+      return path if File.exist?(path)
+
+      FileUtils.mkdir_p(cache_dir)
+      $stderr.print "Downloading #{uf2_filename(version)}..."
+      $stderr.flush
+      download(release_url(version), path)
+      warn ' done.'
+      path
+    end
+
+    def self.download(url, dest, redirects = 5)
+      raise 'Too many redirects' if redirects.zero?
+
+      uri = URI.parse(url)
+      response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+        http.request(Net::HTTP::Get.new(uri))
+      end
+
+      case response
+      when Net::HTTPRedirection
+        download(response['Location'], dest, redirects - 1)
+      when Net::HTTPSuccess
+        File.binwrite(dest, response.body)
+      else
+        FileUtils.rm_f(dest)
+        raise "Download failed: #{response.code} #{response.message}"
+      end
+    end
+  end
+end

data/lib/prremote/version.rb

@@ -0,0 +1,4 @@
+module Prremote
+  VERSION         = '0.1.0'.freeze
+  RUNTIME_VERSION = '0.1.2'.freeze
+end

data/lib/prremote.rb

@@ -0,0 +1,2 @@
+require_relative 'prremote/version'
+require_relative 'prremote/cli'

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification
+name: prremote
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- ITO Yosei
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubyserial
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.25'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.25'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.70'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.70'
+description: Compile and run mruby/c scripts on a Raspberry Pi Pico W over USB serial.
+email:
+- y-itou@lumber-mill.co.jp
+executables:
+- prremote
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/prremote
+- lib/prremote.rb
+- lib/prremote/cli.rb
+- lib/prremote/commands/deploy.rb
+- lib/prremote/commands/eval_cmd.rb
+- lib/prremote/commands/install.rb
+- lib/prremote/commands/run.rb
+- lib/prremote/commands/undeploy.rb
+- lib/prremote/commands/watch.rb
+- lib/prremote/detector.rb
+- lib/prremote/mrbc.rb
+- lib/prremote/runtime_manager.rb
+- lib/prremote/version.rb
+homepage: https://github.com/lumbermill/prremote
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: CLI tool for deploying and running mruby/c scripts on a Raspberry Pi Pico
+  W over USB serial
+test_files: []