rpremote 0.5.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4eb2ee018d6af469de77f435dd2a7d7021ae6e017d078655d5a7ca06e0735ac7
-  data.tar.gz: 547f6b9d2c98deab27f1a67b9b37bd375a2c0bbfbb55e7f1a1faca156de67ada
+  metadata.gz: 69cb11c8175c8864e4ae4a11108fb37e1ac08bab49b0b61ade2331f550b7d4b6
+  data.tar.gz: 7e32c77e20cda016f4b95ad5e60a5ccabf8a5d8aa1570ce8bcf3fd642b700b9d
 SHA512:
-  metadata.gz: c732178d037299500ee01e6a9ba0dfbe3836372e543be0db1a2e156586043f153a8fdf45f47d435390996b9a840e399a3140c65e3159d16ca9302018308003a4
-  data.tar.gz: fcca0bbaf3d04fd352fcd9ec00dbf08217c77dd23f2228cdfb17940d094d0c815d4bef14320d24641abb30a8dd6cdd8ce32858146bb3866f6e45f03d3f1f0089
+  metadata.gz: f690408489ed84040dd492d4872747ec0a523d17bafc76603c885722c5aaca43a3a5f0d74584ca81f0ec5e7b4758bf0477a17f2877af045c81756894962fd5a8
+  data.tar.gz: bd1046210f3d48e00604328f72531455f236bd3e348b2bded6495b2681bf383367413ed2083b1469090d24ce10ab37ce85605454efa867e01c88a351807595aa

data/CHANGELOG.md

@@ -4,6 +4,19 @@ Notable changes to the `rpremote` RubyGem will be documented in this file. Repos
 
 ## Unreleased
 
+## 0.7.0 - 2026-10-04
+
+- Add Bundler-style `group` blocks and `gem ..., group:` to `Mrbgems`; `mrbgems lock|update --with/--without` now selects the locked firmware contents, with exclusions taking precedence, and build/runtime commands consume `Mrbgems.lock` without selecting groups again.
+- Make `Mrbgems.lock` version 2 a self-contained build input, add path checksum verification, and replace build/runtime `--mrbgems` and `--groups` options with `--lockfile`.
+- Keep active RP2040/RP2350 PWM slices clocked during scheduler sleep on PicoRuby 4.0.4, and restore clock gating after the final slice stops.
+
+## 0.6.0 - 2026-09-20
+
+- Change the default PicoRuby version to `latest`, backed by the current `master` branch, while retaining `--language-version` for selecting a release tag.
+- Replace the patched R2P2 `bootsel` executable with a temporary PicoModem script that calls `Machine.enter_bootsel` from the embedded `picoruby-bootsel` mrbgem.
+- Support both the legacy `build/host/bin/mrbc` layout and the PicoRuby 4.0.4 `build/mrbc/default/bin/mrbc` layout when building custom firmware.
+- Expand the human-readable executable specifications and validate bilingual documentation structure, links, command coverage, and safety warnings.
+
 ## 0.5.0 - 2026-09-12
 
 - Make `deploy PATH` flash the existing UF2 by default, and add `deploy PATH --build` for the previous build-and-deploy workflow.

data/README.ja.md

@@ -1,4 +1,4 @@
-# rpremote CLIリファレンス
+# rpremote
 
 [English](README.md)
 
@@ -26,7 +26,7 @@ gem install rpremote
 ```sh
 rpremote setup
 rpremote build
-rpremote flash --mount /Volumes/RP2350
+rpremote flash
 rpremote run main.rb
 ```
 
@@ -39,7 +39,7 @@ rpremote deploy path/to/project
 rpremote deploy path/to/project --build
 ```
 
-既定では`firmware/picoruby-4.0.3/`にソースを準備し、`firmware/picoruby-4.0.3-pico2.uf2`を生成します。対象ボードを明示する必要がある場合は、`rpremote ports`でR2P2のCDC 0ポートを確認してください。
+既定では`firmware/picoruby-latest/`にソースを準備し、`firmware/picoruby-latest-pico2.uf2`を生成します。対象ボードを明示する必要がある場合は、`rpremote ports`でR2P2のCDC 0ポートを確認してください。
 
 ## mrbgemを追加する
 
@@ -59,68 +59,52 @@ rpremote mrbgems lock
 rpremote build
 ```
 
-`Mrbgems.lock`はGitHubのコミットとローカルgemの内容ハッシュを固定します。`build`は既存のlockを再利用し、`rpremote mrbgems update`だけが新しいコミットを解決します。
+`Mrbgems.lock`は`build`で使うmrbgemを確定します。ビルドは`Mrbgems`を評価せず、GitHub branchも解決せずにlockを読みます。新しいコミットを解決するのは`rpremote mrbgems update`です。
+
+構成ごとのgemは`group :development do ... end`または`gem ..., group: :development`で整理できます。`rpremote mrbgems lock --with production --without test`はグループ外の共通gemとproduction gemをlockへ記録します。除外指定が優先され、`build`、`deploy`、`run`、`exec`はそのlockだけを使います。
 
 ファームウェアへ組み込む一方で、すべての`run`、`exec`、`deploy`に先行ロードしないgemには`auto_require: false`を指定できます。アプリケーション側から必要なgemを明示的に`require`してください。
 
 ## 対象を選択する
 
 ```sh
-rpremote setup --language picoruby --language-version 3.4.2
-rpremote build --language picoruby --language-version 3.4.2 --board pico2
-rpremote flash --language picoruby --language-version 3.4.2 --board pico2 --mount /Volumes/RP2350
+rpremote setup
+rpremote build
+rpremote flash
 ```
 
 コマンドラインオプションは`config/setting.json`より優先されます。現在実装されているのはPicoRubyです。将来のMicroPythonと追加Picoボード対応に備え、`language`と`board`はインターフェースに残しています。
 
-## コマンド
-
-| コマンド | 説明 |
-| --- | --- |
-| `rpremote setup` | 設定を作成し、言語ソースを準備します。 |
-| `rpremote build` | mrbgemを含むカスタムUF2をビルドします。 |
-| `rpremote build clean` | 中間ビルドファイルを削除します。 |
-| `rpremote bootsel` | 実行中のR2P2へBOOTSEL移行を要求し、USBボリュームの出現を待ちます。 |
-| `rpremote deploy PATH` | 既存ファームウェアを書き込み、存在する場合は`PATH/lib/NAME`を`:/lib/NAME`へコピーしてから`PATH/main.rb`を一時実行します。ハードウェア出力は次のコマンドまで維持されます。 |
-| `rpremote deploy PATH --build` | ファームウェアをビルドして書き込んだ後、同じコピーと一時実行を行います。 |
-| `rpremote dfu app FILE` | PicoModem DFUでRubyまたは版を照合したバイトコードのアプリを更新します。 |
-| `rpremote dfu compile FILE` | DFU用にPicoRuby版と一致する`.mrb`を生成します。 |
-| `rpremote dfu status` | DFUのアクティブおよび起動候補スロットを表示します。 |
-| `rpremote dfu remove` | DFU起動アプリを両スロットから削除します。実行中のアプリを停止するには別途リセットします。 |
-| `rpremote mrbgems …` | mrbgemを検査、表示、固定、更新します。 |
-| `rpremote flash` | 選択したUF2をBOOTSEL経由で書き込みます。 |
-| `rpremote bootsel --reset-flash-memory` | BOOTSELへ移行し、Pico 2の外部フラッシュメモリ全体を消去します。 |
-| `rpremote config show` | 設定ファイルとコマンドラインオプションを反映した実効設定を表示します。 |
-| `rpremote ports` | R2P2シリアルポートを表示します。 |
-| `rpremote run FILE` | Rubyファイルを転送して実行します。ディレクトリ指定時は`main.rb`を実行し、出力をリアルタイム表示します。タイムアウトは無出力の継続時間として扱い、Ruby例外時は非0で終了します。`--reset-on-timeout`を指定すると実行タイムアウト後にR2P2をリセットします。 |
-| `rpremote exec CODE` | 短いRubyコードを実行します。Ruby例外時は非0で終了します。 |
-| `rpremote monitor` / `repl` | 対話型シリアルセッションを開きます。 |
-| `rpremote reset` | R2P2を再起動して再接続まで待ちます。 |
-| `rpremote fs cp/push/cat/ls/rm/mkdir` | R2P2ファイルシステムを操作します。 |
-
-コマンド一覧は`rpremote --help`で確認できます。コマンド固有の構文、既定値、影響は`rpremote <command> --help`で確認できます。
+## 作業を選ぶ
+
+- `setup`でプロジェクトを準備し、`config show`で実効設定を確認します。最初のファームウェア導入には`build`と`flash`を使います。
+- プロジェクト開発では`deploy PATH`を使います。選択したファームウェアを書き込み、存在する場合は`PATH/lib/NAME`をコピーして`PATH/main.rb`を実行します。先にファームウェアを再ビルドする場合は`--build`を付けます。
+- Rubyを一時実行する場合は`run`または`exec`、対話型シリアル接続には`monitor`または`repl`を使います。`monitor`と`repl`は`Ctrl-]`で終了します。
+- R2P2上へファイルを保持する場合は`fs`、再起動後も実行するA/B起動アプリには`dfu`を使います。
+
+完全なコマンド一覧は`rpremote --help`で確認します。現在の構文、既定値、処理順、影響についてはコマンドヘルプが実行可能なリファレンスです。
 
 ```sh
-rpremote flash --help
+rpremote deploy --help
 rpremote dfu app --help
+rpremote fs cp --help
 ```
 
-`monitor`と`repl`は`Ctrl-]`で終了します。
-
-`run`と`exec`の例外終了コードには、Ruby例外ステータスに対応したR2P2ファームウェアが必要です。[GitHubリポジトリ](https://github.com/ogom/rpremote)のPicoRubyソースから`rpremote build`で生成したUF2が対応しています。
-
-## 操作モデル
+### 安全上の境界
 
-- `run`と`exec`はRubyコードを一時的に転送・実行して出力を表示し、一時リモートファイルを削除します。対応するR2P2ファームウェアがRuby例外を報告した場合は、非0で終了します。
-- `deploy PATH`はBOOTSELへ移行して既存の選択済みファームウェアを書き込んだ後、R2P2 Shellの起動完了を待ちます。存在する場合は`PATH/lib/NAME`を`:/lib/NAME`へコピーし、実行直前に読み込んだ`PATH/main.rb`を一時実行します。`deploy PATH --build`は同じ処理の前にファームウェアをビルドします。Shellジョブを保持するため、ハードウェア出力は次のコマンドまで維持されます。正常終了と出力バイト数を表示し、R2P2のRuby例外はコマンド失敗として扱います。ライブラリディレクトリがない場合、コピー処理はスキップします。PicoRuby 4系のファームウェアが必要です。
-- `flash`はUF2をRP2350 BOOTSELボリュームへコピーし、永続的なR2P2ファームウェアを置き換えます。
-- `dfu app`はRubyソースまたは対応するバイトコードのアプリを非アクティブDFUスロットへ登録します。R2P2を再起動して試行し、正常に起動したアプリは`DFU.confirm`を呼び出します。
-- `dfu remove`はDFUのA/B両アプリスロットを完全に空にします。RAM上ですでに動作しているアプリは`rpremote reset`を実行するまで継続するため、起動アプリのログを混ぜずに`rpremote run`を使う場合は両方のコマンドを実行します。その他の`/home`ファイルとR2P2ファームウェアは削除しません。
-- リモートパスには`:/REMOTE/PATH`を使います。`fs cp`はローカルパスとリモートパスの間で転送します。`fs push LOCAL_DIR :/REMOTE_DIR`は`fs cp --recursive`の別名で、不足しているリモートディレクトリを作成し、ローカルディレクトリの内容を一括転送します。リモートにだけ存在するファイルは削除しません。`fs rm`は指定したリモートパスを完全に削除します。
+- `flash`は永続的なR2P2ファームウェアを置き換えます。`bootsel --reset-flash-memory`はPico 2の外部フラッシュ全体を消去するため、実行後にR2P2を再度書き込む必要があります。
+- `dfu remove`はDFUのA/B両アプリスロットを完全に空にします。RAM上ですでに動作しているアプリを停止するには、別途リセットします。
+- `fs rm`は指定したリモートパスを完全に削除します。再帰転送ではボード上だけに存在するファイルを削除しません。
+- `run`と`exec`は一時リモートファイルを削除します。Ruby例外時の非0終了には対応するR2P2ファームウェアが必要で、このリポジトリからビルドしたUF2は対応しています。
 
 ## ドキュメントとサンプル
 
-[GitHubリポジトリ](https://github.com/ogom/rpremote)に、英語・日本語のガイド、設定リファレンス、Mrbgems.lockの解説、カスタムファームウェア手順、電子工作サンプルがあります。
+- [作業に応じてコマンドを選ぶ](https://github.com/ogom/rpremote/blob/main/docs/command.ja.md)
+- [プロジェクトを設定する](https://github.com/ogom/rpremote/blob/main/docs/config.ja.md)
+- [カスタムファームウェアをビルドする](https://github.com/ogom/rpremote/blob/main/docs/firmware.ja.md)
+- [MrbgemsとMrbgems.lockを管理する](https://github.com/ogom/rpremote/blob/main/docs/mrbgems.ja.md)
+- [PicoModem DFUで起動アプリを更新する](https://github.com/ogom/rpremote/blob/main/docs/dfu.ja.md)
+- [電子工作サンプルを見る](https://github.com/ogom/rpremote/tree/main/examples)
 
 ## 関連プロジェクト
 

data/README.md

@@ -1,4 +1,4 @@
-# rpremote CLI reference
+# rpremote
 
 [日本語](README.ja.md)
 
@@ -26,7 +26,7 @@ Run these commands in a project directory:
 ```sh
 rpremote setup
 rpremote build
-rpremote flash --mount /Volumes/RP2350
+rpremote flash
 rpremote run main.rb
 ```
 
@@ -39,7 +39,7 @@ rpremote deploy path/to/project
 rpremote deploy path/to/project --build
 ```
 
-The defaults prepare `firmware/picoruby-4.0.3/` and create `firmware/picoruby-4.0.3-pico2.uf2`. Use `rpremote ports` to locate the R2P2 CDC 0 port when a board must be selected explicitly.
+The defaults prepare `firmware/picoruby-latest/` and create `firmware/picoruby-latest-pico2.uf2`. Use `rpremote ports` to locate the R2P2 CDC 0 port when a board must be selected explicitly.
 
 ## Add mrbgems
 
@@ -59,69 +59,52 @@ rpremote mrbgems lock
 rpremote build
 ```
 
-`Mrbgems.lock` pins GitHub commits and hashes local gem contents. Existing locks are reused by `build`; `rpremote mrbgems update` deliberately resolves new commits.
+`Mrbgems.lock` pins the exact mrbgems used by `build`. Builds read the lock without evaluating `Mrbgems` or resolving GitHub branches; `rpremote mrbgems update` deliberately resolves new commits.
+
+Use `group :development do ... end` blocks or `gem ..., group: :development` to organize variant-specific gems. `rpremote mrbgems lock --with production --without test` writes common and production gems to the lock; exclusions take precedence, and `build`, `deploy`, `run`, and `exec` then use exactly that lock.
 
 Set `auto_require: false` for a gem that should remain embedded in firmware without being loaded before every `run`, `exec`, or `deploy`. Require that gem explicitly from the application when needed.
 
 ## Select a target
 
 ```sh
-rpremote setup --language picoruby --language-version 3.4.2
-rpremote build --language picoruby --language-version 3.4.2 --board pico2
-rpremote flash --language picoruby --language-version 3.4.2 --board pico2 --mount /Volumes/RP2350
+rpremote setup
+rpremote build
+rpremote flash
 ```
 
 Command-line options override `config/setting.json`. PicoRuby is implemented today; `language` and `board` are retained for planned MicroPython and additional Pico board support.
 
-## Commands
-
-| Command | Description |
-| --- | --- |
-| `rpremote setup` | Create configuration and prepare language sources. |
-| `rpremote build` | Build a custom UF2 with project mrbgems. |
-| `rpremote build clean` | Remove intermediate build files. |
-| `rpremote bootsel` | Ask the running R2P2 firmware to enter BOOTSEL and wait for its USB volume. |
-| `rpremote deploy PATH` | Flash existing firmware, copy `PATH/lib/NAME` to `:/lib/NAME` when present, then temporarily run `PATH/main.rb` while preserving its hardware output until the next command. |
-| `rpremote deploy PATH --build` | Build and flash firmware, then perform the same copy and temporary run workflow. |
-| `rpremote dfu app FILE` | Stage a Ruby or version-checked bytecode app through PicoModem DFU. |
-| `rpremote dfu compile FILE` | Compile `.rb` to matching PicoRuby bytecode for DFU. |
-| `rpremote dfu status` | Show the active and candidate DFU slots. |
-| `rpremote dfu remove` | Remove both DFU boot applications; reset separately to stop one already running. |
-| `rpremote mrbgems …` | Check, list, lock, or update mrbgems. |
-| `rpremote flash` | Flash the selected UF2 through BOOTSEL. |
-| `rpremote bootsel --reset-flash-memory` | Enter BOOTSEL and erase all Pico 2 external flash memory. |
-| `rpremote config show` | Show the effective configuration after file and command-line options are resolved. |
-| `rpremote ports` | List detected R2P2 serial ports. |
-| `rpremote run FILE` | Upload and run a Ruby file, or `main.rb` when FILE is a directory, with real-time output; exit nonzero on a Ruby exception. The timeout measures idle time without output. Use `--reset-on-timeout` to reset R2P2 after a run timeout. |
-| `rpremote exec CODE` | Run short Ruby code and exit nonzero on a Ruby exception. |
-| `rpremote monitor` / `repl` | Open an interactive serial session. |
-| `rpremote reset` | Reboot R2P2 and wait for reconnection. |
-| `rpremote fs cp/push/cat/ls/rm/mkdir` | Operate on the R2P2 filesystem. |
-
-Run `rpremote --help` for the complete command list. Run `rpremote <command> --help` for command-specific syntax, defaults, and effects.
+## Choose a workflow
+
+- Prepare a project with `setup`, inspect resolved settings with `config show`, then use `build` and `flash` for the first firmware installation.
+- Use `deploy PATH` during project development. It flashes the selected firmware, copies `PATH/lib/NAME` when present, and runs `PATH/main.rb`; add `--build` when the firmware must be rebuilt first.
+- Use `run` or `exec` for temporary Ruby execution, and `monitor` or `repl` for an interactive serial session. `monitor` and `repl` exit with `Ctrl-]`.
+- Use `fs` commands for persistent R2P2 files, and use `dfu` commands when an A/B boot application must survive a restart.
+
+Run `rpremote --help` for the complete command list. Command help is the executable reference for current syntax, defaults, processing order, and effects.
 
 ```sh
-rpremote flash --help
+rpremote deploy --help
 rpremote dfu app --help
+rpremote fs cp --help
 ```
 
-`monitor` and `repl` exit with `Ctrl-]`.
-
-Ruby-exception exit statuses for `run` and `exec` require R2P2 firmware with Ruby exception status support.
-UF2 files built with `rpremote build` from the [GitHub repository](https://github.com/ogom/rpremote) include that support.
-
-## Operation model
+### Safety boundaries
 
-- `run` and `exec` upload Ruby code temporarily, relay output, then remove the temporary remote file. A Ruby exception reported by compatible R2P2 firmware makes the command exit nonzero.
-- `deploy PATH` enters BOOTSEL, flashes the existing selected firmware, waits until the R2P2 Shell is ready, copies `PATH/lib/NAME` to `:/lib/NAME` when present, then temporarily runs the current contents of `PATH/main.rb`. `deploy PATH --build` builds that firmware before the same workflow. The Shell job is retained so hardware output remains active until the next command. It reports successful completion and the output byte count; an R2P2 Ruby exception remains a command failure. If the library directory is absent, the copy step is skipped. It requires PicoRuby 4.x firmware.
-- `flash` copies a UF2 to the RP2350 BOOTSEL volume and replaces persistent R2P2 firmware.
-- `dfu app` stages a Ruby source or matching bytecode app in the inactive DFU slot. Restart R2P2 to try it; a successful app must call `DFU.confirm`.
-- `dfu remove` permanently clears both DFU A/B application slots. The application already loaded in RAM continues until you run `rpremote reset`; use both commands before `rpremote run` when boot-app output would be unwanted. It does not remove other `/home` files or R2P2 firmware.
-- Remote paths use `:/REMOTE/PATH`. `fs cp` transfers between one local and one remote path. `fs push LOCAL_DIR :/REMOTE_DIR` is an alias of `fs cp --recursive`; it creates missing remote directories and uploads the local directory contents. It does not delete remote files. `fs rm` permanently deletes the selected remote path.
+- `flash` replaces persistent R2P2 firmware. `bootsel --reset-flash-memory` erases all Pico 2 external flash and requires R2P2 to be flashed again.
+- `dfu remove` permanently clears both DFU A/B application slots. Reset separately to stop an application already running in RAM.
+- `fs rm` permanently deletes the selected remote path. Recursive uploads do not delete files that exist only on the board.
+- `run` and `exec` remove their temporary remote file. Their nonzero Ruby-exception status requires compatible R2P2 firmware; UF2 files built from this repository include that support.
 
 ## Documentation and examples
 
-The [GitHub repository](https://github.com/ogom/rpremote) contains the full English and Japanese guides, configuration reference, Mrbgems.lock reference, custom firmware guide, and electronic-craft examples.
+- [Choose commands by workflow](https://github.com/ogom/rpremote/blob/main/docs/command.md)
+- [Configure a project](https://github.com/ogom/rpremote/blob/main/docs/config.md)
+- [Build custom firmware](https://github.com/ogom/rpremote/blob/main/docs/firmware.md)
+- [Manage Mrbgems and Mrbgems.lock](https://github.com/ogom/rpremote/blob/main/docs/mrbgems.md)
+- [Update a boot application with PicoModem DFU](https://github.com/ogom/rpremote/blob/main/docs/dfu.md)
+- [Browse electronic-craft examples](https://github.com/ogom/rpremote/tree/main/examples)
 
 ## Related projects
 

data/RELEASING.md

@@ -49,7 +49,7 @@ bundle exec rake release
 After the tag exists on GitHub, create a GitHub Release and attach the exact gem that passed validation. `--verify-tag` prevents GitHub CLI from silently creating a tag at another commit:
 
 ```sh
-gh release create v0.5.0 rpremote-0.5.0.gem --verify-tag --generate-notes
+gh release create v0.7.0 rpremote-0.7.0.gem --verify-tag --generate-notes
 ```
 
-Replace `0.5.0` in both places for later versions. Finally, install from RubyGems.org in a fresh environment and run `rpremote --version`.
+Replace `0.7.0` in both places for later versions. Finally, install from RubyGems.org in a fresh environment and run `rpremote --version`.

data/THIRD_PARTY_NOTICES.md

@@ -1,6 +1,6 @@
 # Third-Party Notices
 
-`rpremote` does not bundle R2P2 firmware. The `setup` command downloads a selected PicoRuby/R2P2 4.0.3 or 3.4.2 release from the PicoRuby project and verifies its published SHA-256 digest.
+`rpremote` does not bundle R2P2 firmware. The `setup` command downloads and prepares the selected PicoRuby/R2P2 source archive from the PicoRuby project.
 
 `setup` also downloads Raspberry Pi's `nuke_universal.uf2` from the official Pico SDK prebuilts release. It is used only by `rpremote bootsel --reset-flash-memory` to erase external flash memory.
 

data/lib/rpremote/bootsel_command.rb

@@ -7,6 +7,8 @@ module Rpremote
     SHELL_READY_TIMEOUT = 2.0
     RETRY_INTERVAL = 0.25
     RESET_FLASH_FIRMWARE = File.join("firmware", "nuke_universal.uf2").freeze
+    REMOTE_SCRIPT_PATH = "/home/.rpremote-bootsel.rb"
+    REMOTE_SCRIPT = "require \"bootsel\"\nMachine.enter_bootsel\n".b.freeze
 
     class Error < Rpremote::Error; end
 
@@ -47,7 +49,8 @@ module Rpremote
 
       request_bootsel(
         port: port, baud: baud, deadline: deadline, output: output,
-        serial: serial, device: device, shell: shell, sleeper: sleeper, clock: clock
+        serial: serial, device: device, shell: shell, modem: services.fetch(:modem) { PicoModem },
+        sleeper: sleeper, clock: clock
       )
 
       remaining = deadline - clock.call
@@ -66,6 +69,7 @@ module Rpremote
       serial = context.fetch(:serial)
       device = context.fetch(:device)
       shell = context.fetch(:shell)
+      modem = context.fetch(:modem) { PicoModem }
       sleeper = context.fetch(:sleeper)
       clock = context.fetch(:clock)
       announced = false
@@ -84,11 +88,9 @@ module Rpremote
 
           remote_shell = shell.new(connection, timeout: [remaining, SHELL_READY_TIMEOUT].min)
           remote_shell.synchronize!
-          unless remote_shell.execute("type bootsel").include?("bootsel is")
-            raise Error, "connected R2P2 firmware does not support BOOTSEL reset; flash a current rpremote UF2 once while holding BOOTSEL"
-          end
-
-          remote_shell.send_command("bootsel")
+          modem.new(connection, timeout: remaining).upload(REMOTE_SCRIPT_PATH, REMOTE_SCRIPT)
+          remote_shell.synchronize!
+          remote_shell.send_command("./#{File.basename(REMOTE_SCRIPT_PATH)}")
           requested = true
         end
         break if requested

data/lib/rpremote/build_command.rb

@@ -19,7 +19,7 @@ module Rpremote
         board: Target::DEFAULT_BOARD,
         cache_dir: defaults.fetch(:cache, Target::DEFAULT_CACHE_DIR),
         firmware: defaults[:firmware],
-        mrbgems: nil
+        mrbgems_lock: defaults[:mrbgems_lock]
       }.merge(defaults.except(:cache))
       OptionParser.new do |parser|
         parser.on("--language LANGUAGE") { |value| options[:language] = value }
@@ -27,8 +27,8 @@ module Rpremote
         parser.on("--board BOARD") { |value| options[:board] = value }
         parser.on("--firmware FILE") { |value| options[:firmware] = value }
         parser.on("--cache DIR") { |value| options[:cache_dir] = value }
-        parser.on("--mrbgems FILE") { |value| options[:mrbgems] = value }
-        parser.on("--no-mrbgems") { options[:mrbgems] = false }
+        parser.on("--lockfile FILE") { |value| options[:mrbgems_lock] = value }
+        parser.on("--no-mrbgems") { options[:mrbgems_lock] = false }
       end.parse!(args)
       raise ArgumentError, "build does not accept arguments" unless args.empty?
 

data/lib/rpremote/builder.rb

@@ -71,12 +71,12 @@ module Rpremote
     end
 
     def add_mrbgems_environment!(environment, options, source_dir, output)
-      definition = mrbgems_definition(options[:mrbgems])
-      return unless definition
+      lock_file = mrbgems_lock(options[:mrbgems_lock])
+      return unless lock_file
 
-      manager = mrbgems_class.new(path: definition, cwd: root)
+      manager = mrbgems_class.new(lock_path: lock_file, cwd: root)
       config_language = mrbgems_config_language(
-        manager.vm, options.fetch(:language), options.fetch(:language_version)
+        manager.locked_vm, options.fetch(:language), options.fetch(:language_version)
       )
       config_name = "r2p2-#{config_language}-#{options.fetch(:board)}"
       base_config = File.join(source_dir, "build_config", "#{config_name}.rb")
@@ -90,25 +90,31 @@ module Rpremote
       environment["RPREMOTE_CONFIG_NAME"] = config_name
       environment["RPREMOTE_MRUBY_CONFIG"] = overlay.path
       environment["RPREMOTE_MRBGEMS_FINGERPRINT"] = overlay.fingerprint
-      output.puts("using Mrbgems: #{manager.path}")
       output.puts("using Mrbgems.lock: #{manager.lock_path}")
     end
 
     def mrbgems_config_language(vm_name, language, version)
       return language unless vm_name
 
-      modern = Gem::Version.new(version) >= Gem::Version.new("4.0.0")
+      modern = version == "latest" || Gem::Version.new(version) >= Gem::Version.new("4.0.0")
       return modern ? "femtoruby" : "picoruby" if vm_name == :mrubyc
 
       modern ? "picoruby" : "microruby"
     end
 
-    def mrbgems_definition(option)
+    def mrbgems_lock(option)
       return if option == false
 
-      candidate = File.expand_path(option || Mrbgems::DEFAULT_PATH, root)
+      candidate = File.expand_path(option || Mrbgems::DEFAULT_LOCK_PATH, root)
       return candidate if File.file?(candidate)
-      raise Error, "mrbgems definition does not exist: #{candidate}" if option
+      raise Error, "mrbgems lock file does not exist: #{candidate}" if option
+
+      definition = File.join(root, Mrbgems::DEFAULT_PATH)
+      if File.file?(definition)
+        raise Error,
+              "Mrbgems.lock does not exist: #{candidate}; " \
+              "run `rpremote mrbgems lock` before building"
+      end
 
       nil
     end

data/lib/rpremote/cli/filesystem_commands.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Rpremote
+  class CLI
+    module FilesystemCommands
+      private
+
+      def fs(args)
+        subcommand = args.shift
+        recursive = subcommand == "cp" && (args.delete("--recursive") || args.delete("-r"))
+        options = parse_connection_options(args)
+        case subcommand
+        when "cp"
+          copy(args, options, recursive: recursive)
+        when "push"
+          copy(args, options, recursive: true, command: "push")
+        when "cat"
+          cat(args, options)
+        when "ls", "rm", "mkdir"
+          filesystem_shell_command(subcommand, args, options)
+        else
+          raise ArgumentError, "unknown fs command: #{subcommand || "(none)"}"
+        end
+      rescue Shell::TimeoutError => e
+        raise Shell::TimeoutError, "filesystem connection failed: #{e.message}"
+      end
+
+      def copy(args, options, recursive: false, command: "cp")
+        usage = command == "push" ? "rpremote fs push LOCAL_DIR :/REMOTE_DIR" : "rpremote fs cp SOURCE DESTINATION"
+        raise ArgumentError, "usage: #{usage} [options]" unless args.length == 2
+
+        source, destination = args
+        source_remote = RemotePath.remote?(source)
+        destination_remote = RemotePath.remote?(destination)
+        raise ArgumentError, "exactly one cp path must be remote (prefix remote paths with :)" if source_remote == destination_remote
+        return RecursiveCopy.new(output: stdout, serial: serial, device: device).call(source, destination, options) if recursive
+
+        ensure_filesystem_connection!(options)
+        if source_remote
+          data = with_modem(options) { |modem| modem.download(RemotePath.unwrap(source)) }
+          File.binwrite(local_destination(destination, source), data)
+          stdout.puts("downloaded #{data.bytesize} bytes: #{source} -> #{destination}")
+        else
+          data = File.binread(source)
+          with_modem(options) { |modem| modem.upload(RemotePath.unwrap(destination), data) }
+          stdout.puts("uploaded #{data.bytesize} bytes: #{source} -> #{destination}")
+        end
+      rescue Errno::ENOENT => e
+        raise ArgumentError, e.message
+      end
+
+      def cat(args, options)
+        raise ArgumentError, "usage: rpremote fs cat :/REMOTE/PATH [options]" unless args.length == 1
+        raise ArgumentError, "cat path must be remote (prefix it with :)" unless RemotePath.remote?(args.first)
+
+        stdout.write(with_modem(options) { |modem| modem.download(RemotePath.unwrap(args.first)) })
+      end
+
+      def filesystem_shell_command(command, args, options)
+        usage = "usage: rpremote fs #{command} :/REMOTE/PATH [options]"
+        raise ArgumentError, usage unless args.length == 1
+
+        path = RemotePath.validate(args.first)
+        stdout.puts("deleting remote path permanently: #{path}") if command == "rm"
+        output = with_shell(options) do |shell|
+          shell.execute("#{command} #{Shell.quote_argument(path)}")
+        end
+        ensure_filesystem_success!(command, output)
+        stdout.write(output)
+      end
+
+      def ensure_filesystem_success!(command, output)
+        failed = command == "ls" ? output.start_with?("ls:") : !output.empty?
+        raise Shell::CommandError, output.strip if failed
+      end
+
+      def ensure_filesystem_connection!(options)
+        output = with_shell(options) { |shell| shell.execute("ls '/'") }
+        ensure_filesystem_success!("ls", output)
+      end
+
+      def with_modem(options)
+        port_path = device.main_port(options[:port])
+        serial.open(port_path, baud: options[:baud]) do |port|
+          yield PicoModem.new(port, timeout: options[:timeout])
+        end
+      end
+
+      def with_shell(options)
+        port_path = device.main_port(options[:port])
+        serial.open(port_path, baud: options[:baud]) do |port|
+          shell = Shell.new(port, timeout: options[:timeout])
+          shell.synchronize!
+          yield shell
+        end
+      end
+
+      def local_destination(destination, source)
+        return destination unless File.directory?(destination)
+
+        File.join(destination, File.basename(RemotePath.unwrap(source)))
+      end
+    end
+  end
+end