diff --git a/CHANGELOG.md b/CHANGELOG.md index cc67b4e..1a8422b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,6 +9,20 @@ History before 0.1.0 is not reconstructed here; see the change log in ## [Unreleased] +### Added + +- Restored the **Reload** button next to the port dropdown in Settings to refresh the port list. + +### Fixed + +- Unplugging a serial device keeps its port selected. When it returns on the same port, + **Connect** resumes receiving without having to select the port again. +- On Windows, the app allows time for the port list to reflect an unplug before showing an + error dialog. When the OS confirms the port is gone, the disconnect is logged without a dialog. +- Disconnecting, a failed connection attempt, and manual reconnects preserve the capture. + **Clear** starts a new capture and prevents pending display updates from restoring old data. +- The ASCII view keeps short captures aligned at the top and avoids jumping while new lines arrive. + ## [0.1.0-beta.2] - 2026-11-04 (pre-release) Fixes for the first beta reports (issues #3 to #7) and a few problems found while fixing them, diff --git a/README.md b/README.md index 960258f..77a5084 100644 --- a/README.md +++ b/README.md @@ -30,9 +30,12 @@ did all of that, so I built this one. It is a Tauri/Rust rewrite of an earlier C (none / CR / LF / CRLF) and input history (↑ / ↓) - Any baud rate the driver accepts (including non-standard ones), DTR / RTS control, hardware or software flow control +- **Reload** refreshes the port list in Settings. The selected port stays selected when its + device is unplugged +- Received data stays available after a disconnect. While the app is open, reconnecting appends + to the same capture until you choose **Clear** in Receive - **Auto Connect**: connects to the selected port whenever it is available — at startup, when - the board is plugged in, and when it comes back after a reset or unplug. The capture - continues, so the output from before the reset is not lost. Disconnect turns it off + the board is plugged in, and when it comes back after a reset or unplug. Disconnect turns it off - Save the capture as a binary file or as text with timestamps, or copy it as hex or ASCII DTR and RTS are off by default, so connecting does not reset the board (an Arduino Uno resets @@ -123,6 +126,11 @@ published. 4. Click **Plotter** to open the plotter. Channels are created automatically from the incoming lines. +With **Auto Connect** off, unplugging a device leaves its port selected and marks it as +**(not present)**. When the device comes back on the same port, click **Connect** to resume +receiving. Use **Reload** to refresh the list immediately, for example when looking for a +device that appears under a different port number. + ## Using it with an AI agent (MCP) ![MCP Server row in the settings panel](docs/images/mcp-server.png) diff --git a/docs/01_overview.md b/docs/01_overview.md index b7ef5a9..d6a8b04 100644 --- a/docs/01_overview.md +++ b/docs/01_overview.md @@ -11,7 +11,7 @@ Rustの `serialport` クレートによるクロスプラットフォーム対 * **高速通信:** 12Mbps などの非標準・高速ボーレートに対応(OSおよびドライバ許容最大値まで)。 * **データ完全性:** 受信データは内部で1バイトも取りこぼさず保持・ログ保存する。UI描画遅延によるバッファ溢れを防ぐ。 -* **ホットプラグ:** USBケーブルの抜き差しを検知し、適切に切断・再接続待機状態へ遷移する。(実装: 切断は受信スレッドの read エラー検知、挿入はポート一覧の 2 秒ポーリング。クロスプラットフォームで同一機構。詳細は SYS-F-107 / docs/21) +* **ホットプラグ:** USB 抜去は受信スレッドの read エラーで検知する。選択中のポートは切断後も保持し、同じポートに戻れば **Connect** で再接続できる。ポート一覧は 2 秒間隔と **Reload** 操作時に更新する([システム要求仕様](21_system_requirements.md) の SYS-F-107)。 * **複数起動:** アプリの複数起動を許可し、それぞれで別のCOMポートを監視可能にする。 * **受信エラー処理:** フレーミングエラー、パリティエラー等の受信エラーは無視してデータ受信を継続する。 diff --git a/docs/03_data_structures.md b/docs/03_data_structures.md index 16f999a..e799642 100644 --- a/docs/03_data_structures.md +++ b/docs/03_data_structures.md @@ -77,11 +77,12 @@ struct PageMetadata { **UiNotifier Thread:** * `DataStore::total_bytes()` を監視し、最大60fpsに間引いてイベントを発火。 -* イベントには `total_bytes` のみを含む(データ本体は `get_display_rows` で取得)。 +* イベントには `capture_id` と `total_bytes` を含む(データ本体は `get_display_rows` で取得)。 ```rust // data-update イベントのペイロード struct DataUpdatePayload { + capture_id: u64, // Clear 前後の受信通知を識別する ID total_bytes: u64, // 受信済み総バイト数 } ``` @@ -99,7 +100,7 @@ struct DataUpdatePayload { | | |-- open_port -------------------------->| | | - |<-- data-update { total_bytes } --------| (60fps間引き) + |<-- data-update { capture_id, total_bytes } (60fps間引き) | | |-- get_display_rows(start_row, count) ->| (スクロール時) | | diff --git a/docs/04_api.md b/docs/04_api.md index 95ef793..37260fc 100644 --- a/docs/04_api.md +++ b/docs/04_api.md @@ -4,9 +4,10 @@ | コマンド名 | 引数 | 説明 | | --- | --- | --- | -| `open_port` | `port_name`, `config: SerialConfig` | 指定設定でポートを開く | -| `close_port` | なし | ポートを閉じる | -| `reopen_port` | `port_name`, `config: SerialConfig` | 自動再接続(SYS-F-807)。ポートを開き、**既存のデータストアに追記を再開**する(ストアが無ければ新規)。切断済みのハンドルが残っていても動くが、生きている接続があれば `Err` | +| `open_port` | `port_name`, `config: SerialConfig` | 指定設定でポートを開き、既存のデータストアに追記を再開する(ストアが無ければ新規)。成功時は接続 ID (`u64`) を返す | +| `close_port` | `connection_id: Option` | ポートを閉じる。ID を指定して現在の接続と一致しない場合は `false` を返す。処理を実行した場合は `true` を返す | +| `confirm_port_removed` | `port_name: String` | ポートを閉じた後で短時間、ポート一覧を再取得する。取得に成功し、指定ポートが一覧に含まれない場合に `true` を返す | +| `reopen_port` | `port_name`, `config: SerialConfig` | 自動再接続(SYS-F-807)。`open_port` と同じ処理で接続 ID (`u64`) を返す | | `set_reconnecting` | `waiting: bool` | 自動再接続の待機に入った / 出たことを記録する。ブリッジの `status.reconnecting` に反映 | | `write_data` | `data: Vec` | データを送信する | | `write_dtr` | `level: bool` | DTR信号を設定する | @@ -16,7 +17,7 @@ | `get_ascii_lines` | `start_line`, `line_count`, `show_ctrl`, `show_timestamp` | ASCII表示用行データを取得 | | `list_ports` | なし | 利用可能なシリアルポート一覧を取得 | | `export_log` | `path: String` | 受信データをファイルにエクスポート | -| `clear_data` | なし | 受信データをクリア | +| `clear_data` | なし | 受信データをクリアし、新しいキャプチャ ID (`u64`) を返す | | `get_clipboard_text` | `mode: String` | クリップボード用テキストを取得(hex/ascii) | | `bridge_status` | なし | ブリッジ(設定画面の MCP Server)の状態を取得(`{ enabled, port, connections, last_activity }`)。失敗しない | | `bridge_set` | `enabled: bool`, `port: Option` | ブリッジの起動 / 停止。`enabled=true` で同じポートが稼働中なら no-op、ポートが変われば再起動。戻り値は `bridge_status` と同じ形 | @@ -27,8 +28,8 @@ | イベント名 | ペイロード | 説明 | | --- | --- | --- | -| `serial-status` | `{ connected: bool, error: string \| null }` | 接続状態の変化。受信スレッドが致命的 I/O エラーを検知したときに `connected=false` で発火する。フロントエンドはこれを受けて `close_port` を呼び、バックエンド状態を再同期する(SYS-F-107) | -| `data-update` | `{ total_bytes: u64 }` | 新規データ受信通知。フロントエンドは `get_display_rows` で表示データを取得。 | +| `serial-status` | `{ connected: bool, error: string \| null, connection_id: u64 }` | 受信スレッドが致命的 I/O エラーを検知したときに `connected=false` で発火する。フロントエンドは通知の接続 ID を指定して `close_port` を呼ぶ(SYS-F-107) | +| `data-update` | `{ capture_id: u64, total_bytes: u64 }` | 新規データ受信通知。フロントエンドはキャプチャ ID で Clear 前の通知を識別し、現在の表示データを `get_display_rows` などで取得する | | `log-error` | `{ message: string }` | ディスクフルなどのエラー通知。Logger スレッドの `on_error` コールバック経由で発火し、**同種のエラーは 5 秒に 1 回まで**に抑制される(SYS-F-205) | | `bridge-activity` | `{ kind: string, bytes: usize, preview: string }` | ブリッジ経由の活動通知(現状 `kind: "send"` のみ)。`preview` は送信内容の先頭 64 文字。**AI の送信を人間が画面で確認できるようにするための必須経路**(SYS-F-1103) | diff --git a/docs/20_user_needs.md b/docs/20_user_needs.md index 1fb7ca4..b526c55 100644 --- a/docs/20_user_needs.md +++ b/docs/20_user_needs.md @@ -64,8 +64,8 @@ SH-1 は「今すぐ結果が欲しい」、SH-2 は「半年後の自分が読 ### US-02: ファーム再書き込みを挟んで再接続する 書き込みツールが COM ポートを使うため、いったん切断する。書き込み後に再接続する。 -このとき前セッションの表示が残っていると、新しいファームの出力と混ざって判断を誤る。 -「切断→再接続でセッションが切り替わる」ことが自明に見えてほしい。 +再接続後も切断直前のログを参照できる。新しいファームの出力だけを見たい場合は、 +再接続前に `Clear` で新しいセッションに切り替えたい。 ### US-03: 異常スパイクを調査する @@ -166,7 +166,7 @@ Y 軸が毎フレーム微調整される、X 軸の原点が動く)と、そ |----|--------|------|------|--------| | **UN-10** | 利用者は、受信データが**1 バイトも失われない**ことを必要とする。UI の描画遅延が受信に影響してはならない | 取りこぼしがあると、そのログで何かを結論づけることができなくなる(ツールとしての存在意義) | US-06 | 必須 | | **UN-11** | 利用者は、`Clear` を押したとき、**メインビューもプロッタも同時に空になる**ことを必要とする | 片方だけ残ると、どのセッションのデータを見ているのか分からなくなる。2026-09-03 の修正で挙動を統一済み([07 変更履歴](07_plotter_spec.md#挙動変更)) | US-02 | 必須 | -| **UN-12** | 利用者は、**切断→再接続でセッションが切り替わる**ことを必要とする。新セッションの表示に旧セッションのチャンネルや波形が混ざってはならない | US-02。ファーム更新の前後を混同すると、直っていないものを直ったと誤認する | US-02 | 必須 | +| **UN-12** | 利用者は、**再接続でログを保持し、`Clear` で新しいセッションに切り替えられる**ことを必要とする。新セッションの表示に旧セッションのチャンネルや波形が混ざってはならない | US-02。切断直前のログを確認でき、ファーム更新後の出力を独立して確認したいときには切り替えられる | US-02 | 必須 | | **UN-13** | 利用者は、受信データをファイルに**バイナリのままエクスポート**できることを必要とする | 本ツールで完結しない解析(FFT、統計)は外部ツールに渡す。加工されたテキストでは渡せない | US-06 | 必須 | | **UN-14** | 利用者は、ツールが**ユーザーのディスクを汚さない**ことを必要とする。一時ファイルは自動で片付くこと | 数十分のログは GB 級になる。放置された一時ファイルは後で必ず問題になる | US-06 | 重要 | diff --git a/docs/21_system_requirements.md b/docs/21_system_requirements.md index 7371376..9af93de 100644 --- a/docs/21_system_requirements.md +++ b/docs/21_system_requirements.md @@ -44,18 +44,19 @@ ISO/IEC/IEEE 29148 の要求記述スタイル(一意な ID、shall 形式、 | **SYS-F-104** | システムは、ポートを開いた直後に DTR / RTS を設定値どおりに駆動すること。また接続中の DTR / RTS 変更を即座に反映すること | Arduino 系デバイスは DTR/RTS がアサートされないと送信を開始しない | UN-09 | I, D | 実装済 | | **SYS-F-105** | システムは、不正な設定値(ボーレート 0、空欄、負数、小数、未知のパリティ名等)を**ポートを開く前に**拒否し、エラー理由を利用者に示すこと | 不正値で開くと、症状が「無反応」になり原因追跡が困難になる | UN-17 | T, D | 実装済 | | **SYS-F-106** | システムは、ポートのオープンに失敗した場合、**直前のセッションの受信データを破棄しないこと** | 「別ポートを開こうとして失敗したら今までのログが消えた」は回復不能な損失 | UN-10, UN-17 | I, D | 実装済 | -| **SYS-F-107** | システムは、受信中に致命的な I/O エラー(デバイス切断等)を検知した場合、受信を停止し、フロントエンドへ切断を通知すること。**加えて、2 秒間隔でポート一覧を能動的に再列挙し、着脱を一覧へ反映すること**。ただし接続中と自動再接続の待機中(SYS-F-807)は、再列挙によって選択中のポートが利用者に無断で変更されないこと | 来ないデータを待ち続けさせないため。挿し直したデバイスがアプリの再起動なしに現れないと、実機デバッグの往復ごとに再起動が必要になる | UN-19 | T, D | 実装済(*1) | +| **SYS-F-107** | システムは、受信中に致命的な I/O エラー(デバイス切断等)を検知した場合、受信を停止し、フロントエンドへ切断を通知すること。**2 秒間隔および Reload 操作時にポート一覧を再列挙し、着脱を一覧へ反映すること**。選択中のポートは、切断や再列挙で一覧から消えても保持すること | 来ないデータを待ち続けさせないため。挿し直したデバイスにポートを選び直さず接続するため | UN-19 | T, D | 実装済(*1) | | **SYS-F-108** | システムは、フレーミングエラー・パリティエラー等の**非致命的な受信エラーでは受信を継続すること** | ノイズ 1 バイトでセッションが落ちるとログ取得が成立しない | UN-10 | I | 実装済 | | **SYS-F-109** | システムは、同一 COM ポートを再オープンする際、先に旧セッションの受信を停止して OS ハンドルを解放してから開くこと | ハンドルが残っていると排他アクセスエラーで再接続に失敗する | UN-12, UN-17 | I, D | 実装済 | > (*1) **2026-09-03 実装(GAP-07 / GAP-08 解消)**。責務を 2 つに分ける。 > **切断の権威は read エラー経路**(`worker_thread.rs` → `serial-status`)にあり、ここは変更していない。 -> 能動検知は `src/App.tsx` の `PORT_POLL_INTERVAL_MS = 2000` によるポート一覧の再列挙で、 -> **一覧の更新のみ**を行う(接続中に選択が黙って移動しないことをテストで固定)。 +> `src/App.tsx` は 2 秒間隔と **Reload** 操作時にポートを再列挙する。選択中のポートが不在なら +> 選択を保持して `(not present)` と表示する。デバイスが同じポートに戻れば、一覧の更新前でも `Connect` で開ける。 > OS のデバイス着脱通知(Windows の `WM_DEVICECHANGE`)は使わない — プラットフォーム固有 API の > 直接呼び出しを避ける方針(SYS-NF-501)と、2 秒の遅延が UN-19 の要求に対して十分小さいため。 > また `serial-status(connected=false)` の受信時にフロントエンドが `close_port` を呼び、 -> バックエンドのポートハンドルを解放して UI 状態と再同期する(旧 GAP-08 / DEBT-1)。 +> 接続 ID を照合して該当するポートハンドルを解放する。切断時のエラーは記録し、ポートが消えたことを +> 再列挙で確認できた場合はダイアログを省略する。OS の一覧反映が遅れる場合は、解放後に短時間だけ再確認する。 ## A.2 受信・保存 (2xx) @@ -180,12 +181,12 @@ ISO/IEC/IEEE 29148 の要求記述スタイル(一意な ID、shall 形式、 |----|------|------|------|------|------| | **SYS-F-801** | `Clear` 実行時、システムは受信データストアを**新しいインスタンスへ差し替える**こと。旧インスタンスの一時ファイルは削除されること | 「消す」の意味を「新しいセッションを始める」と定義することで、部分削除に伴う索引の整合性問題を回避する | UN-11 | I, D | 実装済 | | **SYS-F-802** | `Clear` 実行時、**プロッタの集約データも同時にリセットされること**。プロッタに旧セッションのチャンネル・波形が残らないこと | メインビューが空なのにプロッタだけ旧データが残る不整合を解消(2026-09-03 挙動変更) | UN-11 | T(`test_thread_survives_store_swap`), D | 実装済 | -| **SYS-F-803** | **利用者の操作による**ポートのオープン(Connect)は、SYS-F-801 / SYS-F-802 と同一の意味論であること(新しいセッションを始める)。自動再接続は対象外(SYS-F-807) | 利用者から見て「セッションが切り替わる」点は Clear と手動の接続で同じ。**既知の非一貫性**: 同じ抜き差しでも、自動再接続が OFF の利用者が手で Connect し直すとそれまでのログは消え、ON なら残る。「Connect はデータを壊さない」に全員を揃えるのは本要求の大きな変更になるので、2026-11-04 時点では採らない | UN-12 | T, D | 実装済(2026-11-04 範囲を手動に限定) | +| **SYS-F-803** | 同一アプリ起動中、手動の Disconnect、接続喪失、オープン失敗で受信ログを保持すること。手動の Connect で同じストアに追記を再開すること。新しいセッションを始めるには `Clear` を実行する(SYS-F-801 / SYS-F-802) | 手動で再接続しても切断前の受信ログを閲覧できる。ファーム更新後に別のセッションとして扱う場合は、利用者が `Clear` を実行する | UN-10, UN-12 | T, D | 実装済 | | **SYS-F-804** | プロッタ解析スレッドは、データストアの差し替えを**1 ポーリング周期(10 ms)以内に検知**し、読み出しオフセットとパーサ状態をリセットすること | 起動時のストア参照を掴み続けると、再接続・Clear 後にプロットが永久停止する(2026-09-03 修正) | UN-12, UN-17 | T(`test_thread_survives_store_swap`) | 実装済 | | **SYS-F-805** | プロッタ解析スレッドは、**データストアが存在しない状態でも動作を継続**し、後から生成されたストアへ接続すること | プロッタウィンドウを先に開いてからポートを接続する操作順を許すため(2026-09-03 修正) | UN-17 | T(`test_aggregator_enabled_empty_data_store`), D | 実装済 | | **SYS-F-806** | ポートが閉じている状態での `Clear` は、データストアを空(不在)にすること。以後の表示要求は空の結果を返し、エラーとしないこと | 切断後にログを消してから再接続する操作を許す | UN-11 | I | 実装済 | -| **SYS-F-807** | **自動接続(Auto Connect)**: 利用者が有効にしている場合(既定 OFF、設定は再起動後も保持)、システムはポートが開いていない間、**選択中のポート**が開けるようになり次第、利用者の操作なしに開くこと(起動時・デバイスを挿したとき・有効にしたとき。起動時は前回選んだポートを、無くても選択したまま待つ)。受信中の致命的エラーで切断したときは、**同じデバイスパス**(`COM16`、`/dev/ttyACM0`)が一覧に戻ったとき開き直すこと。利用者が Disconnect または待機の Cancel をしたら自動接続を OFF にすること(C# 版と同じ。OFF にしないと即座に開き直す)。一覧にあるのに開けない(他のプログラムが使用中など)ときは再試行を 200 ms から 1 s に落とし、開けない旨を表示すること。自動で開いた場合は常に(a) **同じデータストアに追記を続け**(オフセットは連続、ブリッジは `reset` を出さない、切断前の受信データは保持)、(b) 切断で途切れた行と再開後の最初の行は**別の行として索引**し(受信バイトは変えない)、(c) 待機中は操作を妨げる通知(モーダル)を出さず、待機中であることを画面に示し、利用者が取り消せること、(d) 待機中はポート選択を自動で変更しないこと、(e) 待機中であることをブリッジの `status.reconnecting` で外部へ示すこと。待機中に変更した通信設定は再接続時に使う。切断中に Clear した場合(ストア不在)は新しいストアで始める | ボードのリセットや書き込みのたびに USB が抜け差しされる。そのたびに手で Connect し直すと、直前のクラッシュ出力(最も見たいログ)が消える。モーダルの alert は JS スレッドを止めるので再接続も止まる。エージェントは `status` を見て「待てば続きが来る」と判断できる | UN-19, UN-10, UN-24 | T, D(実機の抜き差しは未確認 → [27 OV-1〜4](27_open_verification.md)) | 実装済(2026-11-04)。**制約**: 照合はデバイスパスのみ(Linux で `ttyACM0` が `ttyACM1` に変わる再番号付けは追わない)。WebView のタイマは最小化時に間引かれうる | -| **SYS-F-808** | プロッタの時間軸は、**新しいセッション(手動の Connect、Clear)ごとに 0 から始めること**。原点はセッションの開始(受信ストアの作成)とし、プロッタを開いた時点にしないこと。プロッタを開く前に届いていたデータは、ストアが約 100 ms ごとに記録する受信時刻の位置に描くこと(1 回の読み出し上限をまたいでも同じ)。自動再接続(同じセッション)では戻さないこと。ポートを閉じた状態の Clear では、その時点でプロッタも空にすること。フロントエンドは、データが流れ続けていてもセッションの切り替わり(世代の変化)を検知して表示を作り直し、Inspect 中なら LIVE に戻ること | 以前は時間軸がプロッタを開いた時点から数え続け、再接続後に Duration が実データより長く表示され、300 秒の窓では左側が空いていた(PF-5)。また Disconnect → Clear → Connect では旧セッションのチャンネルが残って新データと混ざっていた(SYS-F-802 違反、PF-7)。原点だけを戻すと、フロントエンドが古い時間軸の窓を要求し続けてプロッタが固まるので、世代番号とセットで入れる(Fable の指摘)。さらに、データを受信した後でプロッタを開くと、溜まっていた行がすべて開いた瞬間(時刻 0)に割り当てられ、**1 点に潰れて**いた(2026-11-04 の画面確認で発見。同じ原因で `test_batch_timestamps_are_spread` が高負荷時にまれに失敗していた) | UN-11, UN-12, UN-01 | T(`test_store_swap_resets_time_origin`, `test_detach_clears_the_plot`, `test_version_increments_on_clear`, `test_backlog_keeps_its_reception_times`, `test_backlog_spanning_reads_keeps_its_times`, `test_records_off_the_clock_fall_back_to_now`, `test_lines_waiting_at_attach_stay_distinct`、フロント 3 件) | 実装済(2026-11-04) | +| **SYS-F-807** | **自動接続(Auto Connect)**: 利用者が有効にしている場合(既定 OFF、設定は再起動後も保持)、システムはポートが開いていない間、**選択中のポート**が開けるようになり次第、利用者の操作なしに開くこと(起動時・デバイスを挿したとき・有効にしたとき。起動時は前回選んだポートを、無くても選択したまま待つ)。受信中の致命的エラーで切断したときは、**同じデバイスパス**(`COM16`、`/dev/ttyACM0`)が一覧に戻ったとき開き直すこと。利用者が Disconnect または待機の Cancel をしたら自動接続を OFF にすること(C# 版と同じ。OFF にしないと即座に開き直す)。一覧にあるのに開けない(他のプログラムが使用中など)ときは再試行を 200 ms から 1 s に落とし、開けない旨を表示すること。自動で開いた場合は常に(a) **同じデータストアに追記を続け**(オフセットは連続、ブリッジは `reset` を出さない、切断前の受信データは保持)、(b) 切断で途切れた行と再開後の最初の行は**別の行として索引**し(受信バイトは変えない)、(c) 待機中は操作を妨げる通知(モーダル)を出さず、待機中であることを画面に示し、利用者が取り消せること、(d) 待機中はポート選択を自動で変更しないこと、(e) 待機中であることをブリッジの `status.reconnecting` で外部へ示すこと。待機中に変更した通信設定は再接続時に使う。切断中に Clear した場合(ストア不在)は新しいストアで始める | ボードのリセットや書き込みのたびに USB が抜け差しされる。自動接続を有効にしておくと、手で Connect し直すことなく直前のクラッシュ出力から続けて確認できる。モーダルの alert は JS スレッドを止めるので再接続も止まる。エージェントは `status` を見て「待てば続きが来る」と判断できる | UN-19, UN-10, UN-24 | T, D(実機の抜き差しは未確認 → [27 OV-1〜4](27_open_verification.md)) | 実装済(2026-11-04)。**制約**: 照合はデバイスパスのみ(Linux で `ttyACM0` が `ttyACM1` に変わる再番号付けは追わない)。WebView のタイマは最小化時に間引かれうる | +| **SYS-F-808** | プロッタの時間軸は、**新しいセッション(初回接続、Clear)ごとに 0 から始めること**。原点はセッションの開始(受信ストアの作成)とし、プロッタを開いた時点にしないこと。プロッタを開く前に届いていたデータは、ストアが約 100 ms ごとに記録する受信時刻の位置に描くこと(1 回の読み出し上限をまたいでも同じ)。手動・自動の再接続では戻さないこと。ポートを閉じた状態の Clear では、その時点でプロッタも空にすること。フロントエンドは、データが流れ続けていてもセッションの切り替わり(世代の変化)を検知して表示を作り直し、Inspect 中なら LIVE に戻ること | 以前は時間軸がプロッタを開いた時点から数え続け、再接続後に Duration が実データより長く表示され、300 秒の窓では左側が空いていた(PF-5)。また Disconnect → Clear → Connect では旧セッションのチャンネルが残って新データと混ざっていた(SYS-F-802 違反、PF-7)。原点だけを戻すと、フロントエンドが古い時間軸の窓を要求し続けてプロッタが固まるので、世代番号とセットで入れる(Fable の指摘)。さらに、データを受信した後でプロッタを開くと、溜まっていた行がすべて開いた瞬間(時刻 0)に割り当てられ、**1 点に潰れて**いた(2026-11-04 の画面確認で発見。同じ原因で `test_batch_timestamps_are_spread` が高負荷時にまれに失敗していた) | UN-11, UN-12, UN-01 | T(`test_store_swap_resets_time_origin`, `test_detach_clears_the_plot`, `test_version_increments_on_clear`, `test_backlog_keeps_its_reception_times`, `test_backlog_spanning_reads_keeps_its_times`, `test_records_off_the_clock_fall_back_to_now`, `test_lines_waiting_at_attach_stay_distinct`、フロント 3 件) | 実装済(2026-11-04) | ## A.9 ウィンドウ・ライフサイクル (9xx) @@ -215,7 +216,7 @@ ISO/IEC/IEEE 29148 の要求記述スタイル(一意な ID、shall 形式、 | **SYS-F-1103** | ブリッジは、アプリが保持するポートへの**送信**を提供すること。送信が成功するたびに、システムは GUI へ `bridge-activity` イベント(種別・バイト数・内容のプレビュー)を通知し、**利用者が AI の送信内容を画面で確認できること**。ポートが開いていない場合は送信せずエラーを返すこと | UN-24 の中核。人間に見えない送信経路を作らないことが、この機能を安全に使える条件そのものである | UN-24, UN-09 | T, D | 実装済 | | **SYS-F-1104** | ブリッジは、GUI の `list_ports` と**同一の列挙結果**を返す `ports` メソッドを提供すること | AI と人間が別々のポート一覧を見ると、どのポートの話をしているのか合わなくなる | UN-24, UN-20 | T | 実装済 | | **SYS-F-1105** | システムは、上記ブリッジを Model Context Protocol (MCP) のツールへ変換する**アダプタをリポジトリ同梱で提供**すること。アダプタはアプリ本体とは**別プロセス**であること。アプリ未起動・ブリッジ無効の場合は、例外ではなく対処方法を含むエラーメッセージを返すこと | MCP SDK をアプリ本体に取り込むと、Rust 側に Node/JS 依存とプロトコル追従の負担が乗る(ADR-12)。「繋がらない」だけのエラーは AI エージェントにとって復旧不能になる | UN-24 | T, D | 実装済 | -| **SYS-F-1106** | ブリッジは、`subscribe` 中にデータストアの世代が変わった場合(ポート再オープン / Clear)、`reset` フレームを送出してオフセットを 0 に戻すこと | 世代をまたいでオフセットを続けると、購読側が旧セッションと新セッションのバイト列を連結して読む(UN-12 の外部版) | UN-24, UN-12 | T | 実装済 | +| **SYS-F-1106** | ブリッジは、`subscribe` 中にデータストアの世代が変わった場合(Clear)、`reset` フレームを送出してオフセットを 0 に戻すこと | 世代をまたいでオフセットを続けると、購読側が旧セッションと新セッションのバイト列を連結して読む(UN-12 の外部版) | UN-24, UN-12 | T | 実装済 | | **SYS-F-1107** | システムは、MCP stdio アダプタを**アプリ本体の実行ファイルに内蔵**すること(`--mcp` フラグで GUI を起動せず MCP サーバとして動作する)。内蔵アダプタは Node 版(`mcp/server.mjs`)と**同一のツール群・同等の出力形式**を提供すること。`--mcp` モードの stdout は JSON-RPC 専用とし、ログは stderr にのみ出すこと | インストーラで入れただけの環境には Node.js もリポジトリも無い(UN-25)。exe 1 つで完結しなければ、インストール後のユーザーは AI 連携を使えない。stdout への混入は MCP クライアントのパースを壊す | UN-25, UN-24 | T, D | 実装済 | | **SYS-F-1108** | システムは、AI 連携のセットアップ手順を示す**ガイドウィンドウ**を GUI から起動できること。ガイドは (a) **実行中バイナリの実際のパス**を埋め込んだコピー可能な MCP 登録コマンド、(b) ブリッジの現在の有効/無効とポート、(c) ツール一覧と利用例、(d) セキュリティ特性(localhost 限定・既定 OFF・送信の可視化)を表示すること | AI 連携だけは外部クライアントへの登録という不可視の手順を要し、登録コマンドはインストール先パスに依存する。アプリだけが自分の実パスを知っている(UN-25) | UN-25 | T, I | 実装済 | | **SYS-F-1109** | ブリッジは、**認証不要**の `help` メソッドで自身のプロトコル仕様(全メソッド・制限値・使い方)を機械可読で返すこと。`help` はキャプチャデータを一切含まないこと | MCP を使わず生 TCP で繋ぐエージェントが、外部文書なしで使い方を自己取得できる。認証前に呼べても、仕様の開示はデータの開示ではない | UN-25, UN-24 | T | 実装済 | diff --git a/docs/22_architecture_description.md b/docs/22_architecture_description.md index 7d9ab3a..2679ed2 100644 --- a/docs/22_architecture_description.md +++ b/docs/22_architecture_description.md @@ -226,8 +226,7 @@ stateDiagram-v2 Closed --> Open : open_port 成功 Closed --> Closed : open_port 失敗 / エラー表示 Open --> Closed : close_port - Open --> Open : open_port 成功 / 旧ポートを閉じてから開く - Open --> Closed : open_port 失敗 / 旧ポートは既に閉じている + Open --> Open : open_port を拒否 / 接続中 Open --> Disconnected : Worker が致命的 read エラーを検知 Disconnected --> Open : open_port 成功 Disconnected --> Closed : close_port @@ -237,18 +236,19 @@ stateDiagram-v2 |------|------| | `Closed` | ポートハンドルなし。送信不可 | | `Open` | ハンドルあり。Worker が読み出し中 | -| `Disconnected` | フロントエンドは切断表示だが、バックエンドはハンドルを保持している中間状態。**設計上の負債**(§5.9 参照) | +| `Disconnected` | Worker が受信を停止し、切断通知に対応する `close_port` でハンドルを解放するまでの中間状態 | -> `open_port` は旧ポートの停止 → 新ポートのオープンの順で行う。オープンに失敗した場合、 -> ポートは `Closed` になるが**旧セッションのデータストアは残る**(SYS-F-106)。 +> 切断通知は接続 ID を持つ。通知に応じて呼ぶ `close_port` は、その ID に一致するポートだけを閉じる。 +> `open_port` は停止済みの旧ポートを解放してから新しいポートを開く。オープンに失敗しても +> 受信済みのデータストアは残る(SYS-F-106)。 ### 5.2 SM-2: DataStore(世代) ```mermaid stateDiagram-v2 [*] --> None - None --> Active : open_port 成功 / 世代 k=1 を生成 - Active --> Active : open_port 成功 / 旧世代を停止し破棄、k を +1 + None --> Active : open_port または reopen_port 成功 / 新世代を生成 + Active --> Active : open_port または reopen_port 成功 / 同じ世代に追記 Active --> Active : clear_data かつポートが開いている / k を +1 Active --> None : clear_data かつポートが閉じている Active --> Active : close_port / 受信のみ停止、世代は不変 @@ -394,10 +394,10 @@ SM-2 との対応は SM-3(PlotterThread)と同じ形だが、**集約器と | イベント | SM-1 ポート | SM-2 ストア | SM-3 Pスレッド | SM-4 Pウィンドウ | SM-5 ビュー | SM-6 ビューア | |----------|-------------|-------------|----------------|------------------|-------------|---------------| -| **Connect** (`open_port` 成功) | →`Open` | →`Active(k+1)` | 次ポーリングで `Attached(k+1)`、集約器 clear | | LIVE を維持 | | -| **Connect 失敗** | →`Closed` | 変化なし(旧世代維持) | 旧世代のまま `Attached(k)` | | | | +| **Connect** (`open_port` 成功) | →`Open` | ストアがなければ生成。あれば `Active(k)` に追記 | 新規ストアを検知して `Attached`、または `Attached(k)` 維持 | | | | +| **Connect 失敗** | 接続中は `Open`、それ以外は `Closed` | 変化なし | 変化なし | | | | | **Disconnect** (`close_port`) | →`Closed` | `Active(k)` 維持、受信停止 | `Attached(k)` 維持(新データが来ないだけ) | | LIVE のまま右端が空白へ | | -| **Reopen**(同一/別ポート再接続) | `Open`→`Open` | →`Active(k+1)` | `Attached(k+1)`、集約器 clear | | | | +| **Reopen** (`reopen_port` 成功) | →`Open` | Connect と同じ | Connect と同じ | | | | | **Clear**(ポート開) | | →`Active(k+1)` | `Attached(k+1)`、集約器 clear | | 表示が空へ | 先頭へ | | **Clear**(ポート閉) | | →`None` | →`Detached` | | 表示が空へ | 先頭へ | | **DataArrival** | | 内部データ増加 | 読み出し → パース → 集約、`data_version` 増加 | | LIVE: 右端更新 / Inspect: 変化なし | AutoScroll ON なら下端追従 | @@ -418,7 +418,7 @@ SM-2 との対応は SM-3(PlotterThread)と同じ形だが、**集約器と | ID | 不変条件 | 根拠 / 保証手段 | |----|----------|-----------------| | **INV-1** | PlotterThread は、DataStore の差し替えを**1 ポーリング周期(10 ms)以内**に検知し、現行世代へ追従する | 起動時の `Arc` を掴まず、毎ポーリングで共有ハンドルから再解決する。`Arc::ptr_eq` で世代を識別(ADR-03) | -| **INV-2** | Clear / 再接続の後、プロッタには**新世代のデータのみ**が含まれる | 世代変化検知時に `aggregator.clear()` + `parser.reset()` + オフセット 0 リセット | +| **INV-2** | Clear 後のプロッタには**新世代のデータのみ**が含まれる。再接続時は既存の世代と集約を保持する | 世代変化検知時に `aggregator.clear()` + `parser.reset()` + オフセット 0 リセット。再接続は既存ストアの受信位置から再開 | | **INV-3** | 受信済みのバイトは、常に `archived_index` と `finished_list` の**少なくとも一方に存在する** | Logger の順序を「書き込み → 索引公開 → pop」に固定(ADR-05)。逆順だと両方に存在しない瞬間ができる | | **INV-4** | `total_bytes` は同一世代内で単調非減少である | Worker は push のみ、Logger は index 公開後に pop する | | **INV-5** | プロッタウィンドウが `Closed` のとき、PlotterThread は `Stopped` かつ集約器は無効である | `WindowEvent::Destroyed` ハンドラで両方を実行(ADR-10) | @@ -539,7 +539,10 @@ sequenceDiagram `version` が変化していれば `has_data` が false でも取得する。 そうしないと Clear 後に古いグラフが残る(2026-09-03 修正)。 -### 6.3 Clear / 再接続でのストア差し替えとスレッド追従 +### 6.3 Clear でのストア差し替えとスレッド追従 + +手動・自動の再接続は既存ストアに追記する。ストアが存在しなければ新規作成する。 +以下は接続中に Clear が成功し、新しいストアへ切り替わる場合の流れである。 ```mermaid sequenceDiagram @@ -553,13 +556,13 @@ sequenceDiagram participant AG as PlotterAggregator FE->>CMD: clear_data - CMD->>SH: lock して take + CMD->>SH: lock して現行ストアを参照 + CMD->>S2: DataStore::new で新しい temp ディレクトリを作成 CMD->>S1: stop_reception でスレッド join Note over S1: この時点では PlotterThread が Arc を保持している可能性があり
Drop は遅延し得る - CMD->>S2: DataStore::new で新しい temp ディレクトリを作成 CMD->>S2: start_reception 既存ポートを再利用 CMD->>SH: 世代 k+1 を格納 - CMD-->>FE: Ok + CMD-->>FE: 新しいキャプチャ ID loop 次のポーリング 10ms 以内 PT->>SH: lock して clone @@ -641,11 +644,11 @@ sequenceDiagram | **採用理由** | レベルアップ方式なら、メモリは上限内に収まりつつ、解像度の低下が時間に対して均一になる。統計量を全部持つことで、モード切替がデータ再構築なしの表示時変換(`to_point(mode)`)で済む | | **帰結** | 再集約は加重平均で行う必要がある(単純平均では精度が落ちる)。`min ≤ avg ≤ max` と count 保存が不変条件になる(INV-8)。古いデータほど時間解像度が粗い | -### ADR-03: Clear / 再接続はストアの差し替えとし、プロッタは動的に解決する +### ADR-03: Clear はストアを切り替え、プロッタは動的に解決する | 項目 | 内容 | |------|------| -| **決定** | `clear_data` / `open_port` は `DataStore` を**新しいインスタンスに差し替える**。`SerialState.data_store` は `Arc>>>` として共有し、PlotterThread は毎ポーリングでこのハンドルから現在のストアを解決する。`Arc::ptr_eq` で世代変化を検知する | +| **決定** | `clear_data` は、接続中は `DataStore` を新しいインスタンスに差し替え、切断中は共有スロットを空にする。`open_port` / `reopen_port` は既存のストアを再利用し、スロットが空なら作成する。`SerialState.data_store` は `Arc>>>` として共有し、PlotterThread は毎ポーリングで現在のストアを解決する。`Arc::ptr_eq` で世代変化を検知する | | **背景** | 「データを消す」を要素削除として実装すると、`archived_index` / `timestamp_index` / `line_index` / ディスク上のオフセットをすべて整合的に巻き戻す必要があり、状態が増える。一方、PlotterThread が起動時の `Arc` を掴んだままだと、差し替え後に永久に古いストアをポーリングし続ける(実際に「Clear 後にプロットが永久フリーズ」した) | | **検討した代替案** | (a) DataStore に `clear()` メソッドを持たせ、内部を空にする。(b) 差し替え時にプロッタスレッドを停止・再起動する。(c) 差し替えをイベントでプロッタへ通知する | | **採用理由** | インスタンス差し替えなら「空の状態」はコンストラクタが 1 か所で保証する。ポーリングでの動的解決は、(b) のような停止/再起動の順序問題(誰が誰を先に止めるか)や、(c) のイベント取りこぼしの問題を持たない。副次的に、**ポートを開く前にプロッタウィンドウを開いても動く**(`Detached` 状態が自然に存在する) | diff --git a/docs/23_traceability.md b/docs/23_traceability.md index f6fbe06..f81a6e5 100644 --- a/docs/23_traceability.md +++ b/docs/23_traceability.md @@ -111,8 +111,8 @@ | SYS-F-103 | 12 Mbps 級ボーレート | `serial/port.rs::SerialPort::new` | `E2E`([07 7-8](07_plotter_spec.md#7-8-パフォーマンスチューニング)) | | SYS-F-104 | DTR/RTS 駆動と動的変更 | `serial/port.rs::write_dtr` / `write_rts`、`serial/mod.rs::write_dtr` / `write_rts`、`src/App.tsx`(config 変更時の反映) | `E2E`(DTR/RTS トグル)、`INSP` | | SYS-F-105 | 不正設定の事前拒否 | `serial/port.rs::SerialPort::new`(baud 0 チェック、data_bits/parity/stop_bits の照合)、`src/components/SettingsPanel.tsx`(入力検証) | `INSP`、**GAP-13** | -| SYS-F-106 | オープン失敗で旧データを守る | `serial/mod.rs::open_port`(`SerialPort::new` 成功後に旧ストアを破棄) | `INSP`、**GAP-14** | -| SYS-F-107 | 致命的エラーで切断通知 + 2 秒間隔の能動再列挙 | `serial/worker_thread.rs`(`serial-status` emit)、`src/App.tsx`(listen、`PORT_POLL_INTERVAL_MS = 2000` の `list_ports` ポーリング、`close_port` による再同期) | `FE`: `src/test/App.test.tsx`(`polls list_ports on an interval so hotplugged devices appear`, `stops polling once unmounted`, `releases the backend port handle when a disconnect is detected`, `still releases the handle when the disconnect carries no error text`, `does not close the port on a connected=true status`)/ `E2E` — **GAP-07 / GAP-08 解消(2026-09-03)** | +| SYS-F-106 | オープン失敗で旧データを守る | `serial/mod.rs::open_capture`(接続結果にかかわらず既存ストアを保持) | `INSP`、**GAP-14** | +| SYS-F-107 | 致命的エラーで切断通知。定期・手動の再列挙と選択の保持 | `serial/data_store.rs`(`serial-status`)、`serial/port.rs`(`confirm_port_removed`)、`src/App.tsx`(接続 ID 付き `close_port`、`list_ports`、選択の保持)、`src/components/SettingsPanel.tsx`(`Reload` と不在表示) | `FE`: `src/test/App.test.tsx`(切断・遅延する抜去検知・定期更新・手動再接続・Reload)/ `UT`: `serial::port::tests`(遅延するポート消失・消失を確認できない場合)/ `E2E`: USB 抜去と再挿入 | | SYS-F-108 | 非致命エラーで受信継続 | `serial/port.rs::read`(TimedOut を 0 バイト扱い) | `INSP` | | SYS-F-109 | 再オープン時のハンドル解放順序 | `serial/mod.rs::open_port`(`stop_reception` を先に実行) | `E2E`(切断→再接続)、`INSP` | @@ -219,11 +219,11 @@ |-----|----------|----------|------| | SYS-F-801 | Clear はストア差し替え | `serial/mod.rs::clear_data` | `E2E`(Clear 後にプロットがリセットされ継続更新)/ **GAP-14** | | SYS-F-802 | Clear でプロッタも同期リセット (INV-2) | `plotter/thread.rs::run`(世代変化検知で `aggregator.clear()`) | `UT`: **`test_thread_survives_store_swap`** / `E2E` | -| SYS-F-803 | 手動の接続は新セッション | `serial/mod.rs::open_port`(`open_port_impl(keep_store=false)`)、`src/App.tsx::handleToggleConnection`(`setTotalBytes(0)` は手動のみ) | `E2E`(切断→再接続でリセットして継続)/ **GAP-14** | +| SYS-F-803 | 手動の再接続で受信ログを保持・追記し、Clear で新セッションに切り替える | `serial/mod.rs::open_capture` / `clear_data`、`src/App.tsx::handleToggleConnection` / `handleClear` | `E2E`(切断 → 再接続 → Clear)/ **GAP-14** | | SYS-F-804 | 10 ms 以内の世代追従 (INV-1) | `plotter/thread.rs::run`(`Arc::ptr_eq` による識別、10 ms ポーリング) | `UT`: `test_thread_survives_store_swap`, `test_thread_sleeps_between_polls`, `test_thread_reads_data_from_store` | | SYS-F-805 | ストア不在でも動作継続 | `plotter/thread.rs::run`(`None` 分岐で 50 ms 待機) | `UT`: `test_aggregator_enabled_empty_data_store`, `test_parser_is_new_each_thread` / `E2E`(プロッタを先に開いてから接続) | | SYS-F-806 | ポート閉状態の Clear | `serial/mod.rs::clear_data`(`None` にする分岐) | `INSP` / **GAP-14** | -| SYS-F-807 | 自動再接続(同じストアに継続) | `serial/mod.rs::reopen_port` / `set_reconnecting`(`open_port_impl(keep_store=true)`)、`serial/data_store.rs::start_reception`(`total_bytes()` から再開)、`serial/worker_thread.rs`(`start_offset`、`LineIndexer`、致命経路の行索引)、`bridge.rs::method_status`(`reconnecting`)、`mcp_stdio.rs` / `mcp/server.mjs`(`connected_label`)、`src/App.tsx`(自動接続の開始・待機の状態・200 ms の照合と使用中の 1 s 再試行・選択の保持・Disconnect / Cancel で OFF)、`src/components/SettingsPanel.tsx`(Auto Connect・Cancel・状態表示)、`src/utils/portUtils.ts` | `UT`: `test_resumed_worker_continues_offsets_and_splits_cut_line`, `test_fatal_read_error_indexes_the_last_chunk`, `test_resume_boundary_*`(3 件), `test_resume_after_pending_cr`, `test_status_reports_reconnecting`, `test_tools_call_status_reports_reconnecting` / `FE`: `src/test/App.test.tsx`(`auto connect` の 11 件)/ Node smoke `status shows a pending reconnect` / `D`: 実機の抜き差し | +| SYS-F-807 | 自動再接続(同じストアに継続) | `serial/mod.rs::reopen_port` / `set_reconnecting`(`open_capture` で既存ストアに再接続)、`serial/data_store.rs::start_reception`(`total_bytes()` から再開)、`serial/worker_thread.rs`(`start_offset`、`LineIndexer`、致命経路の行索引)、`bridge.rs::method_status`(`reconnecting`)、`mcp_stdio.rs` / `mcp/server.mjs`(`connected_label`)、`src/App.tsx`(自動接続の開始・待機の状態・200 ms の照合と使用中の 1 s 再試行・選択の保持・Disconnect / Cancel で OFF)、`src/components/SettingsPanel.tsx`(Auto Connect・Cancel・状態表示)、`src/utils/portUtils.ts` | `UT`: `test_resumed_worker_continues_offsets_and_splits_cut_line`, `test_fatal_read_error_indexes_the_last_chunk`, `test_resume_boundary_*`(3 件), `test_resume_after_pending_cr`, `test_status_reports_reconnecting`, `test_tools_call_status_reports_reconnecting` / `FE`: `src/test/App.test.tsx`(`auto connect` の 11 件)/ Node smoke `status shows a pending reconnect` / `D`: 実機の抜き差し | | SYS-F-808 | セッションごとに時間軸を 0 から。閉じた状態の Clear でプロッタも空に | `plotter/thread.rs`(アタッチ時に `start_time` を戻す、`had_store`、外れたら `clear`)、`plotter/aggregator.rs`(`generation`)、`src/components/plotter/PlotterWindow.tsx`(世代の変化で作り直し・LIVE へ、`[0, W]` 表示) | `UT`: `test_store_swap_resets_time_origin`, `test_detach_clears_the_plot`, `test_version_increments_on_clear` / `FE`: `re-anchors with a bootstrap request when the session generation changes`, `returns to LIVE when a new session arrives while inspecting`, `does not show negative times before a full window of data exists` | ### 2.9 ウィンドウ・ライフサイクル (SYS-F-9xx) @@ -344,7 +344,7 @@ | **GAP-04** | ~~min/max バンドが Y オートレンジに含まれない~~ **解消済(2026-09-03)**: `LineChart.tsx::calculateYRange` が表示中チャンネルのバンド min/max を畳み込む(関数を export して単体テスト可能に)。`src/test/calculateYRange.test.ts` 10 件で検証(非表示チャンネル除外・X ウィンドウ外除外・null 混入を含む) | SYS-F-525 | 解消 | | **GAP-05** | ~~3 状態モデルが未実装~~ **解消済(2026-09-03)**: LIVE/Inspect/Paused 実装、FSM テスト(`PlotterViewFsm.test.tsx` 49 ペア)+ E2E で検証 | SYS-F-601〜609, SYS-NF-301 | 解消 | | **GAP-06** | プロッタのドッキング / フロート切替が未実装。**オーナー決定(2026-09-03): スコープ外化を撤回し、実装予定として維持する(時期未定)**。[25 §1.3 条件 A](25_release_strategy.md#条件-a-機能未実装gap-の扱いが全件判断済であること) の暫定「スコープ外化の候補」は無効 | SYS-F-905 | 低(実装予定・時期未定) | -| **GAP-07** | ~~ホットプラグの能動検知が未実装~~ **解消済(2026-09-03)**: `src/App.tsx` に `PORT_POLL_INTERVAL_MS = 2000` のポート一覧ポーリングを実装。切断の権威は read エラー経路のまま、ポーリングは列挙更新のみを担い、接続中に選択が黙って移動しないことをテストで固定。`FE`: `src/test/App.test.tsx`(`polls list_ports on an interval so hotplugged devices appear`, `stops polling once unmounted`) | SYS-F-107, DEBT-2 | 解消 | +| **GAP-07** | ~~ホットプラグの能動検知が未実装~~ **解消済(2026-09-03)**: `src/App.tsx` の 2 秒ポーリングで一覧を更新し、切断は read エラーで検知する。現在は `Reload` でも再列挙でき、選択中のポートは一覧から消えても保持する。`FE`: `src/test/App.test.tsx`(定期更新、切断後の選択保持、Reload) | SYS-F-107, DEBT-2 | 解消 | | **GAP-08** | ~~切断検知後もバックエンドがポートハンドルを保持し、UI 状態と不一致~~ **解消済(2026-09-03)**: `serial-status(connected=false)` を受けて `src/App.tsx` が `close_port` を呼び、状態を再同期(DEBT-1 / TBD-R4 決定済)。`FE`: `src/test/App.test.tsx`(`releases the backend port handle when a disconnect is detected`, `still releases the handle when the disconnect carries no error text`, `does not close the port on a connected=true status`) | SYS-F-107 | 解消 | | **GAP-09** | ~~`log-error` イベントの発火経路が未実装~~ **解消済(2026-09-03)**: `logger_thread.rs` に `on_error` コールバック(`Box`、5 秒レート制限)を追加し、`data_store.rs` が `log-error` を emit、`src/App.tsx` が利用者へ提示。`UT`: `test_process_buffer_io_error_keeps_chunks`, `test_spawn_logger_thread_notifies_error_rate_limited`, `test_spawn_logger_thread_notifies_open_failure` / `FE`: `src/test/App.test.tsx`(`surfaces log-error events to the user`) | SYS-F-205 | 解消 | diff --git a/docs/24_vv_plan.md b/docs/24_vv_plan.md index 6e42f0f..b91af09 100644 --- a/docs/24_vv_plan.md +++ b/docs/24_vv_plan.md @@ -344,10 +344,10 @@ flowchart TB | S-1 | `PlotterOpen` → `Connect` | スレッドが `Detached` から `Attached(1)` になり、集約器は clear されない | | S-2 | `Connect` → `PlotterOpen` | `Attached(1)`。既存データが取り込まれる | | S-3 | `Connect` → `Clear` | `Attached(2)`、集約器 clear、10 ms 以内に追従(INV-1, INV-2) | -| S-4 | `Connect` → `Reopen` | `Attached(2)`、集約器 clear | +| S-4 | `Connect` → 切断検知 → `Reopen` | 同じストアの `Attached(1)` を維持し、集約を保持して追記する | | S-5 | `Clear` → `Clear` | `Attached(3)`。連続 clear で停止しない | | S-6 | `Disconnect` → `Clear` | `Detached`。ストアが `None` になっても停止しない | -| S-7 | `Disconnect` → `Connect` | `Attached(k+1)` | +| S-7 | `Disconnect` → `Connect` | `Attached(k)` を維持し、切断前の受信データに追記する | | S-8 | `Clear` → `Connect` | `Attached(k+1)` | | S-9 | `Connect` → `PlotterClose` | `Stopped`、収集無効(INV-5) | | S-10 | `PlotterClose` → `PlotterOpen` | 再度 `Attached`。ウィンドウ再オープンで復帰 | @@ -363,6 +363,9 @@ flowchart TB データ注入に使う `DataStore::push_test_data` が `#[cfg(test)]` でクレート外からは見えないため。 - **vitest**: SM-5 / SM-6 を、コンポーネントの状態遷移として検査する。 - **E2E**: SM-4 と、実 OS が絡む S-9〜S-12。 +- **再接続時のストア保持**: `serial::tests::reconnect_keeps_capture_and_failed_opens_do_not_discard_it` + で、手動・自動の接続が共通で使う `open_capture` のデータ保持を検証する。 + `state_transition_tests.rs` の `SwapStore` は Clear などによるストアの差し替えを検証する。 ### 4.5 合否基準 @@ -503,6 +506,7 @@ hashlib(OpenSSL) は別実装の SHA-256 であり、一致はクロス実装の ### 6.2 実施済みのシナリオ(2026-09-03) [07_plotter_spec.md 検証節](07_plotter_spec.md#検証)より。**これらは今後の回帰の基準線**である。 +E-4 の当時の結果を以下に残す。現在は再接続時にプロットと受信ログを保持し、新しいデータを追記する(S-7)。 | # | シナリオ | 確認内容 | |---|----------|----------| @@ -809,7 +813,7 @@ thread.rs を対象に含めた。 | シナリオ | 確認する問い | |----------|--------------| | US-01 接続してセンサ値を眺める | 波形の形で「想定どおりか」を判断できたか。表示の揺れが気になったか | -| US-02 再書き込みを挟んで再接続 | セッションが切り替わったことが自明だったか | +| US-02 再書き込みを挟んで再接続 | 再接続前のログを参照できたか。`Clear` で新しい出力だけを確認できたか | | US-03 異常スパイクの調査 | スパイクを見逃さなかったか。止めて拡大するまでの操作が滞りなかったか | | US-04 Hex 確認 | バイト位置を見失わずに Hex/ASCII を往復できたか | | US-05 コマンド送信 | 履歴の呼び戻しが編集の邪魔をしなかったか | @@ -817,7 +821,7 @@ thread.rs を対象に含めた。 | US-07 AI と一緒にデバッグ | Setup Guide だけで MCP 登録できたか。エージェントの要約・待機が実際の調査で役立ったか。AI の送信を画面で追えたか(2026-11-04 追加。表から漏れていた) | **未実施の一覧と記録は [27_open_verification.md §2](27_open_verification.md)**(VA-1〜9。プロッタの VA-1〜3 が最優先)。 -Auto Connect(SYS-F-807)は利用者が ON / OFF を選べるので US-02 とは衝突しない(2026-11-04 オーナー判断。US-02 は OFF で確認する)。 +US-02 は Auto Connect を OFF にして手動で確認する([27 VA-4](27_open_verification.md))。現在は ON / OFF ともに再接続でログを保持し、`Clear` で新しいセッションに切り替える(SYS-F-803)。2026-11-04 時点の判断は [27 §4](27_open_verification.md) を参照。 **合否基準**: 上記の問いに「いいえ」が出た場合、その体験を新しいニーズ(UN)として [20_user_needs.md](20_user_needs.md) に追加してから要求へ変換する。実装の場当たり修正で済ませない。 diff --git a/docs/27_open_verification.md b/docs/27_open_verification.md index 1068ed9..91d830c 100644 --- a/docs/27_open_verification.md +++ b/docs/27_open_verification.md @@ -76,7 +76,7 @@ | **VA-1** | **プロッタ: 眺めて判断する**(US-01 / UN-01, 02, 05) | 実センサの波形を数秒眺めて「想定どおりか」(周期・振幅・オフセット)を判断できたか。表示の揺れ・ストリーム停止・今のモードは気になったか。既定のウィンドウ幅(10 s)と既定の間引き(LTTB)は、そのまま使えたか | 揺れないこと(プロパティ試験 P-5。画面での確認 E-15 は §1 OV-6 で未実施)、停止の可視化(E-14)、モード遷移とフッター表示(E-16 / E-18)、ウィンドウ幅の切替(E-13、10 s / 30 s のみ)。いずれも合成波形 | 実機のセンサ(加速度・温度・ADC 等、周期と振幅を自分で知っている信号)を 10 分以上眺める。違和感はその場で書き留める | 2026-11-04 | **必須**(T2-6) | | **VA-2** | **プロッタ: スパイクを追う**(US-03 / UN-03, 04) | 実際に「たまに値が飛ぶ」現象で、飛んだ瞬間を見逃さなかったか。気づいてから Pause → 拡大 → 前後を見る、までの操作が滞りなかったか。LIVE への戻り方に迷わなかったか | バケットが min / max を保持すること(P-3, P-4)、LTTB は静的範囲専用(SYS-F-515)、Y 軸の即時拡大(単体。E2E の E-19 は §1 OV-6 で未実施) | 間欠的に外れ値を出す実機(ノイズの乗る ADC、取りこぼしのある通信など)、無ければファームで低頻度の外れ値を混ぜて、気づけたかを自分で試す | 2026-11-04 | **必須**(T2-6) | | **VA-3** | **プロッタ: State Timeline**(UN-06) | 実際の状態信号(状態数が多い・頻繁に切り替わる・ラベルが長い)でも、数値波形と同じ時間軸で読めたか。数値と状態の対応(「モータ ON の直後に電流が跳ねる」等)を目で追えたか | 描画が重ならないこと(SYS-NF-304。125% / 150% の E2E は §1 OV-6 で未実施)、ラベル付き入力のパース(単体) | 実機のステートマシンの状態(3 状態以上、秒間数回以上の切り替え)を数値と一緒に流す | 2026-11-04 | **必須**(T2-6) | -| **VA-4** | **再書き込みを挟んだ再接続**(US-02 / UN-12) | Auto Connect を **OFF** にして、ファーム更新サイクルで切断 → 再接続したとき、セッションが切り替わったことが自明だったか(前のファームの出力と混ざって判断を誤らなかったか) | OFF での新セッション化(SYS-F-803、E2E)。ON での継続は利用者の選択(§4 の決定) | 実際のファーム更新サイクル(ビルド → 書き込み → 動作確認)を Auto Connect OFF で数回回す | 2026-11-04 | **必須**(T2-6) | +| **VA-4** | **再書き込みを挟んだ再接続**(US-02 / UN-12) | Auto Connect を **OFF** にして、再接続前のログを残したまま確認できたか。ファーム更新後の出力を別に見たいときに `Clear` で切り替えられたか | 手動再接続でログを保持し、`Clear` で新セッションに切り替える(SYS-F-801〜803) | ファーム更新後に手動で再接続し、旧ログの保持と `Clear` 後に新しい出力だけが表示されることを確認する | 2026-11-04 | **必須**(T2-6) | | **VA-5** | **Auto Connect でリセット前のログが役立つか**(UN-19, UN-10) | ボードがクラッシュ → リセットしたとき、残ったリセット直前の出力で原因に近づけたか。「Waiting for …」の表示に気づけたか。既定 OFF は妥当か | §1 OV-1〜4 が通れば挙動は確認済みになる | 実際にクラッシュするファーム(ウォッチドッグ・ハードフォルト)で、リセット前後のログを見て原因を追う | 2026-11-04 | 任意 | | **VA-6** | **Hex でバイナリプロトコルを確認**(US-04 / UN-07, 08) | 実際の独自フレームを Hex で読んで、フレーム境界・チェックサムを確かめられたか。Hex / ASCII の往復で位置を見失わなかったか | 表示の正しさと位置の保持(単体・E2E) | 実機のバイナリプロトコル(独自フレーム、Modbus RTU 等) | 2026-11-04 | **必須**(T2-6) | | **VA-7** | **コマンド送信**(US-05 / UN-09) | 実機に対話的にコマンドを打ち続けたとき、履歴の呼び戻しが編集の邪魔をしなかったか。改行コードの選択に迷わなかったか | 送信・履歴・改行コードの動作(単体・E2E) | AT コマンドや独自 CLI を持つ実機で 10 分程度の対話 | 2026-11-04 | **必須**(T2-6) | @@ -112,7 +112,7 @@ | — | 検証 | **E-17**: Inspect 中は新しいデータが来ても表示範囲が動かない(ホイールで Inspect に入り、5 秒あけて 2 枚撮影) | 2026-11-04 | PASS。グラフと State Timeline の領域でピクセル差 0 / 179,349。「▶LIVE」ボタンとフッターの「Inspect」表示も確認。§3 の方法 | | — | 検証 | **E-19**: 外れ値で Y 軸が即座に拡大し、窓から出て 3 秒ほどで縮小する | 2026-11-04 | **PASS**。当初は Average モードでのみ PASS(LTTB では潰れた値約 41 までしか広がらなかった。PF-1)。Peak への置換後、既定モードでも 30 → 500 に即拡大し、窓から出た後に 30 へ戻ることを再確認 | | PF-1 | 検証 | Peak への置換後の再確認: 画面評価と同じ信号(100 Hz、外れ値 400、7.3 秒ごとの 6.0 のスパイク)を流して撮影 | 2026-11-04 | **PASS**。10 秒窓で外れ値 400・スパイク 6.0 とも元の値で描かれた(置換前は約 41・約 1.7)。300 秒窓でも外れ値は 400、6.0 のスパイクはすべて残った(置換前は約 9、6.0 は消失)。ノイズの細かい形も見えるようになった | -| — | 決定 | Auto Connect(SYS-F-807)と US-02「再接続でセッションが切り替わってほしい」の関係 | 2026-11-04 | **衝突しない**(オーナー判断)。Auto Connect は利用者が ON / OFF を切り替えられるので、切り替わってほしい人は OFF にすれば US-02 が満たされ、リセット前のログを残したい人は ON にする。VA-4 は OFF での確認に絞った | +| — | 決定 | Auto Connect(SYS-F-807)と US-02「再接続でセッションが切り替わってほしい」の関係 | 2026-11-04 | **衝突しない**(オーナー判断)。Auto Connect は利用者が ON / OFF を切り替えられるので、切り替わってほしい人は OFF にすれば US-02 が満たされ、リセット前のログを残したい人は ON にする。VA-4 は OFF での確認に絞った。これは当時の判断。現在は ON / OFF ともに再接続でログを保持し、新しいセッションへ切り替えるには `Clear` を使う(SYS-F-803) | | — | 検証 | MCP Server ON のままの 12 Mbaud 欠落ゼロと索引の追随(docs/26 §9 / DEBT-9 (4))。24 §6.5 T2-5 に「未実施」と残っていた | 2026-11-04 | PASS。[24 §6.5](24_vv_plan.md) T2-5c(本書の起票前に完了していた。記述の更新漏れ) | | — | 検証 | 表示名の変更(AI Bridge → MCP Server)後の UIA E2E と MCP stdio スモーク | 2026-11-04 | PASS。`run_bridge_e2e.ps1`(UIA が新ラベルでトグルを操作)、`mcp_stdio_smoke.py`(リリースバイナリ) | diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs index 1620d2e..1c78627 100644 --- a/src-tauri/src/lib.rs +++ b/src-tauri/src/lib.rs @@ -94,6 +94,7 @@ pub fn run() { serial::list_ports, serial::open_port, serial::close_port, + serial::confirm_port_removed, serial::reopen_port, serial::set_reconnecting, serial::write_data, diff --git a/src-tauri/src/serial/data_store.rs b/src-tauri/src/serial/data_store.rs index c4510a8..3061a2c 100644 --- a/src-tauri/src/serial/data_store.rs +++ b/src-tauri/src/serial/data_store.rs @@ -43,6 +43,7 @@ pub struct LogErrorPayload { struct SerialStatusPayload { connected: bool, error: Option, + connection_id: u64, } /// DataStore: データ管理の中核 @@ -50,6 +51,7 @@ struct SerialStatusPayload { /// ObjectPool、FinishedQueue、ArchivedIndexを統合し、 /// Worker/Logger/UiNotifier スレッドのライフサイクルを管理する。 pub struct DataStore { + capture_id: u64, /// When this store (= the capture session) was created: the time origin for /// readers that attach later, such as the plotter. `Instant` for elapsed time, /// wall-clock ms to place `timestamp_index` entries on the same axis. @@ -74,13 +76,22 @@ pub struct DataStore { } impl DataStore { + pub(super) fn next_capture_id() -> u64 { + use std::sync::atomic::AtomicU64; + + static NEXT_ID: AtomicU64 = AtomicU64::new(1); + NEXT_ID.fetch_add(1, Ordering::Relaxed) + } + + pub(super) fn capture_id(&self) -> u64 { + self.capture_id + } + /// 新しいDataStoreを作成 /// /// PIDを使った一時ディレクトリを作成し、ObjectPoolを初期化する。 /// 起動時に古い一時ディレクトリをクリーンアップする。 pub fn new() -> Result { - use std::sync::atomic::AtomicU64; - let pid = std::process::id(); let base_dir = std::env::temp_dir().join("SerialMonitorEssential"); @@ -90,13 +101,12 @@ impl DataStore { // 一時ディレクトリ作成 // // インスタンスごとに一意のサブディレクトリを使う。同一プロセス内で - // DataStore が作り直されるとき(clear / ポート再オープン)、古い + // DataStore が作り直されるとき(clear)、古い // インスタンスの Drop はプロッタスレッド等が Arc を離した後に遅延 // 実行され得る。ディレクトリを共有していると、その Drop が新しい // インスタンスのライブなデータファイルまで削除してしまう。 - static INSTANCE_COUNTER: AtomicU64 = AtomicU64::new(0); - let instance = INSTANCE_COUNTER.fetch_add(1, Ordering::Relaxed); - let temp_dir = base_dir.join(pid.to_string()).join(instance.to_string()); + let capture_id = Self::next_capture_id(); + let temp_dir = base_dir.join(pid.to_string()).join(capture_id.to_string()); fs::create_dir_all(&temp_dir) .map_err(|e| format!("Failed to create temp directory: {:?}", e))?; @@ -107,6 +117,7 @@ impl DataStore { } Ok(Self { + capture_id, free_pool, finished_list: Arc::new(RwLock::new(VecDeque::new())), archived_index: Arc::new(RwLock::new(Vec::new())), @@ -158,6 +169,7 @@ impl DataStore { // Worker Thread起動 debug!("[DataStore] Spawning Worker Thread"); let status_handle = app_handle.clone(); + let connection_id = port.id(); let worker_handle = worker_thread::spawn_worker_thread( port, parked, @@ -171,6 +183,7 @@ impl DataStore { let payload = SerialStatusPayload { connected: false, error: Some(error), + connection_id, }; if let Err(e) = status_handle.emit("serial-status", payload) { error!("[DataStore] Failed to emit serial-status event: {}", e); @@ -861,6 +874,7 @@ mod tests { fs::create_dir_all(&temp_dir).unwrap(); DataStore { + capture_id: DataStore::next_capture_id(), free_pool: Arc::new(SegQueue::new()), finished_list: Arc::new(RwLock::new(VecDeque::new())), archived_index: Arc::new(RwLock::new(Vec::new())), diff --git a/src-tauri/src/serial/mod.rs b/src-tauri/src/serial/mod.rs index e99b9ce..8f1249b 100644 --- a/src-tauri/src/serial/mod.rs +++ b/src-tauri/src/serial/mod.rs @@ -17,8 +17,8 @@ use tauri::{AppHandle, State}; /// シリアル通信の状態を管理する構造体 /// /// `data_store` は外側も `Arc` で包み、プロッタスレッドが「現在の」DataStore を -/// 毎ポーリングで解決できるようハンドルを共有する(ポート再オープンや -/// クリアで内側の `Arc` は差し替わるため)。 +/// 毎ポーリングで解決できるようハンドルを共有する(クリアで内側の +/// `Arc` は差し替わるため)。 /// /// `port` も同じ理由で外側を `Arc` にしてある。AI ブリッジ(`bridge.rs`)の /// サーバスレッドはコマンドのスコープより長生きするので Tauri の `State` を @@ -49,15 +49,15 @@ fn extract_port_path(port_name: &str) -> &str { } } -/// 手動の Connect。新しいセッションを始める(受信データは新しいストアへ。SYS-F-803) +/// Manual Connect resumes the capture. Only Clear discards received data. #[tauri::command] pub fn open_port( state: State<'_, SerialState>, app: AppHandle, port_name: String, config: port::SerialConfig, -) -> Result<(), String> { - open_port_impl(&state, app, &port_name, config, false) +) -> Result { + open_port_impl(&state, app, &port_name, config) } /// 自動再接続。デバイスが消えて戻ってきたとき、**同じストアに追記を再開**する @@ -73,8 +73,8 @@ pub fn reopen_port( app: AppHandle, port_name: String, config: port::SerialConfig, -) -> Result<(), String> { - open_port_impl(&state, app, &port_name, config, true) +) -> Result { + open_port_impl(&state, app, &port_name, config) } /// 自動再接続の待機に入った / 出たことを記録する(ブリッジの `status.reconnecting`) @@ -88,12 +88,29 @@ fn open_port_impl( app: AppHandle, port_name: &str, config: port::SerialConfig, - keep_store: bool, -) -> Result<(), String> { +) -> Result { + let port_path = extract_port_path(port_name); + open_capture( + state, + || { + let port = port::SerialPort::new(port_path, config)?; + Ok(Arc::new(tx::OpenPort::new(port_path, Box::new(port)))) + }, + |store, port| store.start_reception(port, app, store.clone()), + ) +} + +/// Shared by manual and automatic opens. Keep the capture independently of the +/// connection, including when opening the device or starting reception fails. +fn open_capture( + state: &SerialState, + open: impl FnOnce() -> Result, String>, + start: impl FnOnce(&Arc, Arc) -> Result<(), String>, +) -> Result { let mut port_guard = state.port.lock().map_err(|e| e.to_string())?; let mut store_guard = state.data_store.lock().map_err(|e| e.to_string())?; - if keep_store && port_guard.as_ref().is_some_and(|p| p.is_connected()) { + if port_guard.as_ref().is_some_and(|p| p.is_connected()) { return Err("a port is already connected".to_string()); } @@ -110,44 +127,48 @@ fn open_port_impl( existing.close(); } - // Parse the device path out of the friendly name - let port_path = extract_port_path(port_name); - - // Try to open the new port BEFORE destroying the previous session's data. - // If the open fails (port busy, device absent, bad config), the previous - // capture stays intact and browsable/exportable. - let port = port::SerialPort::new(port_path, config)?; - let port_arc = Arc::new(tx::OpenPort::new(port_path, Box::new(port))); - *port_guard = Some(port_arc.clone()); - state.reconnecting.store(false, Ordering::Relaxed); - - // 自動再接続: 同じストアで受信を再開する(start_reception が前回の総バイト数から続ける) - if keep_store { - if let Some(existing_store) = store_guard.as_ref() { - log::info!("[reopen_port] Resuming reception on the existing DataStore"); - return existing_store.start_reception(port_arc, app, existing_store.clone()); - } - } - - // Now it is safe to drop the old DataStore (deletes its temp files) - if let Some(existing_store) = store_guard.take() { - log::info!("[open_port] Stopping and dropping existing DataStore"); - existing_store.stop_reception(); - // existing_store is dropped here, temp files deleted + let port = open()?; + let data_store = match store_guard.as_ref() { + Some(store) => store.clone(), + None => Arc::new(DataStore::new()?), + }; + if let Err(error) = start(&data_store, port.clone()) { + data_store.stop_reception(); + port.close(); + return Err(error); } + let connection_id = port.id(); + *store_guard = Some(data_store); + *port_guard = Some(port); + state.reconnecting.store(false, Ordering::Relaxed); + Ok(connection_id) +} - // Create NEW DataStore and start reception with UI event notification - log::info!("[open_port] Creating new DataStore"); - let data_store = Arc::new(DataStore::new()?); - data_store.start_reception(port_arc.clone(), app, data_store.clone())?; - *store_guard = Some(data_store.clone()); - - Ok(()) +#[tauri::command] +pub fn close_port( + state: State<'_, SerialState>, + connection_id: Option, +) -> Result { + close_capture(&state, connection_id) } #[tauri::command] -pub fn close_port(state: State<'_, SerialState>) -> Result<(), String> { +pub async fn confirm_port_removed(port_name: String) -> Result { + tauri::async_runtime::spawn_blocking(move || { + port::confirm_port_removed(&port_name, serialport::available_ports, std::thread::sleep) + }) + .await + .map_err(|error| error.to_string()) +} + +fn close_capture(state: &SerialState, connection_id: Option) -> Result { let mut port_guard = state.port.lock().map_err(|e| e.to_string())?; + // A delayed disconnect event must never stop a subsequently opened port. + if let Some(id) = connection_id { + if port_guard.as_ref().is_none_or(|port| port.id() != id) { + return Ok(false); + } + } let store_guard = state.data_store.lock().map_err(|e| e.to_string())?; // Stop data reception (but keep DataStore alive to preserve temp files) @@ -160,7 +181,7 @@ pub fn close_port(state: State<'_, SerialState>) -> Result<(), String> { port.close(); } - Ok(()) + Ok(true) } /// 現在のポートを解決する(外側のロックはここで手放す) @@ -677,35 +698,44 @@ pub fn export_text_with_timestamps( } #[tauri::command] -pub fn clear_data(state: State<'_, SerialState>, app: AppHandle) -> Result<(), String> { - let mut store_guard = state.data_store.lock().map_err(|e| e.to_string())?; +pub fn clear_data(state: State<'_, SerialState>, app: AppHandle) -> Result { + clear_capture(&state, |store, port| { + store.start_reception(port, app, store.clone()) + }) +} + +fn clear_capture( + state: &SerialState, + start: impl FnOnce(&Arc, Arc) -> Result<(), String>, +) -> Result { let port_guard = state.port.lock().map_err(|e| e.to_string())?; + let mut store_guard = state.data_store.lock().map_err(|e| e.to_string())?; + + // Allocate before stopping reception so that a failed allocation leaves the + // previous capture and its reception intact. + let mut new_store = port_guard + .as_ref() + .filter(|port| port.is_connected()) + .map(|_| DataStore::new().map(Arc::new)) + .transpose()?; - if let Some(old_store) = store_guard.take() { + if let Some(old_store) = store_guard.as_ref() { log::info!("[clear_data] Stopping old DataStore"); old_store.stop_reception(); } - // If port is open, restart DataStore. 切断で I/O が破棄済み(Disconnected)の - // ポートでは受信を再開できないので、閉じている場合と同じ扱いにする。 - if let Some(port_arc) = port_guard.as_ref().filter(|p| p.is_parked()) { - log::info!("[clear_data] Creating new DataStore"); - let new_store = Arc::new(DataStore::new()?); - // Reuse the existing port - new_store.start_reception(port_arc.clone(), app, new_store.clone())?; - *store_guard = Some(new_store); - } else { - // If port not open, we just leave store as None (cleared) or create an empty one? - // Actually SerialState currently holds DataStore only when open_port is called? - // Wait, open_port creates it. close_port keeps it alive? - // close_port stops reception but keeps DataStore handle. - // If we clear while closed, we probably just want to drop the old one and maybe create a fresh empty one? - // Or just None? - // If we set it to None, then `get_display_rows` returns empty. That's fine. - log::info!("[clear_data] Port closed, DataStore cleared (set to None)"); + // A worker can lose the port before returning it to the parked state. + match (port_guard.as_ref().filter(|p| p.is_parked()), &new_store) { + (Some(port), Some(store)) => start(store, port.clone())?, + _ => new_store = None, } - Ok(()) + // Clear while disconnected also invalidates already-queued notifications. + let capture_id = new_store + .as_ref() + .map_or_else(DataStore::next_capture_id, |store| store.capture_id()); + *store_guard = new_store; + Ok(capture_id) } #[tauri::command] @@ -762,6 +792,131 @@ pub fn get_clipboard_text( mod tests { use super::*; + fn capture_state() -> SerialState { + SerialState { + port: Arc::new(Mutex::new(None)), + data_store: Arc::new(Mutex::new(None)), + reconnecting: Arc::new(AtomicBool::new(false)), + } + } + + fn fake_port() -> Arc { + Arc::new(tx::OpenPort::new( + "COM4", + Box::new(tx::fake::FakePort::new(115200, tx::fake::WriteMode::Accept)), + )) + } + + #[test] + fn reconnect_keeps_capture_and_failed_opens_do_not_discard_it() { + let state = capture_state(); + let first = fake_port(); + let id = open_capture( + &state, + || Ok(first.clone()), + |store, _| { + store.push_test_data(b"before\r\n"); + Ok(()) + }, + ) + .unwrap(); + let capture = state.data_store.lock().unwrap().as_ref().unwrap().clone(); + assert!(close_capture(&state, Some(id)).unwrap()); + assert!(!first.is_connected()); + assert!(!first.is_parked()); + assert!(open_capture( + &state, + || Err("device absent".into()), + |_, _| { panic!("failed opens must not start reception") } + ) + .is_err()); + assert_eq!(capture.get_data(0, 8).unwrap(), b"before\r\n"); + let second = fake_port(); + let resumed_id = open_capture( + &state, + || Ok(second.clone()), + |store, _| { + assert!(Arc::ptr_eq(store, &capture)); + assert_eq!(store.total_bytes(), 8); + store.push_test_data(b"after\r\n"); + Ok(()) + }, + ) + .unwrap(); + assert_ne!(id, resumed_id); + assert_eq!(capture.get_data(0, 15).unwrap(), b"before\r\nafter\r\n"); + // A stale event or an already queued cleanup cannot touch the new open. + assert!(!close_capture(&state, Some(id)).unwrap()); + assert!(second.is_connected()); + assert!(Arc::ptr_eq( + state.data_store.lock().unwrap().as_ref().unwrap(), + &capture + )); + assert!(close_capture(&state, Some(resumed_id)).unwrap()); + } + + #[test] + fn clear_keeps_connection_identity_but_never_restores_the_old_capture() { + let state = capture_state(); + let port = fake_port(); + let id = open_capture( + &state, + || Ok(port.clone()), + |store, _| { + store.push_test_data(b"old\n"); + Ok(()) + }, + ) + .unwrap(); + let old = state.data_store.lock().unwrap().as_ref().unwrap().clone(); + let capture_id = clear_capture(&state, |store, same_port| { + assert_eq!(same_port.id(), id); + assert_eq!(store.total_bytes(), 0); + Ok(()) + }) + .unwrap(); + let cleared = state.data_store.lock().unwrap().as_ref().unwrap().clone(); + assert!(!Arc::ptr_eq(&old, &cleared)); + assert!(capture_id > old.capture_id()); + assert_eq!(capture_id, cleared.capture_id()); + close_capture(&state, Some(id)).unwrap(); + open_capture( + &state, + || Ok(fake_port()), + |store, _| { + assert!(Arc::ptr_eq(store, &cleared)); + store.push_test_data(b"new\n"); + Ok(()) + }, + ) + .unwrap(); + assert_eq!(cleared.get_data(0, 4).unwrap(), b"new\n"); + close_capture(&state, None).unwrap(); + let disconnected_capture_id = + clear_capture(&state, |_, _| panic!("closed port must stay closed")).unwrap(); + assert!(disconnected_capture_id > capture_id); + assert!(state.data_store.lock().unwrap().is_none()); + } + + #[test] + fn reception_start_failure_releases_port_and_retains_capture() { + let state = capture_state(); + let capture = Arc::new(DataStore::new().unwrap()); + capture.push_test_data(b"keep"); + *state.data_store.lock().unwrap() = Some(capture.clone()); + let port = fake_port(); + assert!(open_capture( + &state, + || Ok(port.clone()), + |_, _| Err("cannot start".into()) + ) + .is_err()); + assert!(state.port.lock().unwrap().is_none()); + assert!(!port.is_parked()); + assert!(!port.is_connected()); + assert_eq!(capture.get_data(0, 4).unwrap(), b"keep"); + } + #[test] fn clamp_start_line_serves_the_tail_for_requests_past_the_end() { // In range: unchanged diff --git a/src-tauri/src/serial/port.rs b/src-tauri/src/serial/port.rs index 1356da9..73d3e60 100644 --- a/src-tauri/src/serial/port.rs +++ b/src-tauri/src/serial/port.rs @@ -6,6 +6,43 @@ use std::time::Duration; use super::tx::{LineTiming, PortIo}; +/// Allow the OS port list to catch up after the failing handle has been closed. +/// Only a successful enumeration that omits the port confirms removal. +pub(super) fn confirm_port_removed( + port_name: &str, + mut enumerate: impl FnMut() -> serialport::Result>, + mut wait: impl FnMut(Duration), +) -> bool { + const RETRIES: usize = 10; + const INTERVAL: Duration = Duration::from_millis(100); + + for attempt in 0..=RETRIES { + match enumerate() { + Ok(ports) => { + let present = ports.iter().any(|port| { + if cfg!(windows) { + port.port_name.eq_ignore_ascii_case(port_name) + } else { + port.port_name == port_name + } + }); + if !present { + return true; + } + } + Err(error) if attempt == RETRIES => warn!( + "[SerialPort] Cannot confirm removal of {}: {}", + port_name, error + ), + Err(_) => {} + } + if attempt < RETRIES { + wait(INTERVAL); + } + } + false +} + #[derive(Debug, Clone, Serialize, Deserialize)] pub struct SerialConfig { pub baud_rate: u32, @@ -196,3 +233,56 @@ impl PortIo for SerialPort { SerialPort::write_rts(self, level) } } + +#[cfg(test)] +mod tests { + use super::confirm_port_removed; + use serialport::{Error, ErrorKind, SerialPortInfo, SerialPortType}; + use std::time::Duration; + + fn present_port() -> Vec { + vec![SerialPortInfo { + port_name: "COM4".into(), + port_type: SerialPortType::Unknown, + }] + } + + #[test] + fn removal_is_confirmed_when_stale_enumeration_catches_up() { + let mut results = [ + Ok(present_port()), + Err(Error::new(ErrorKind::Unknown, "enumeration failed")), + Ok(Vec::new()), + ] + .into_iter(); + let mut waits = 0; + assert!(confirm_port_removed( + "COM4", + || results.next().unwrap(), + |_| { + waits += 1; + } + )); + assert_eq!(waits, 2); + } + + #[test] + fn persistent_presence_or_enumeration_errors_do_not_confirm_removal() { + let mut waited = Duration::ZERO; + let mut attempts = 0; + assert!(!confirm_port_removed( + "COM4", + || { + attempts += 1; + if attempts % 2 == 0 { + Ok(present_port()) + } else { + Err(Error::new(ErrorKind::Unknown, "enumeration failed")) + } + }, + |interval| waited += interval, + )); + assert_eq!(waited, Duration::from_secs(1)); + assert_eq!(attempts, 11); + } +} diff --git a/src-tauri/src/serial/tx.rs b/src-tauri/src/serial/tx.rs index 2fa3eca..14a4f1c 100644 --- a/src-tauri/src/serial/tx.rs +++ b/src-tauri/src/serial/tx.rs @@ -28,7 +28,7 @@ use crossbeam::channel::{self, Receiver, Sender, TryRecvError}; use log::{info, warn}; use std::io::ErrorKind; -use std::sync::atomic::{AtomicBool, Ordering}; +use std::sync::atomic::{AtomicBool, AtomicU64, Ordering}; use std::sync::Mutex; use std::time::{Duration, Instant}; @@ -160,6 +160,7 @@ pub struct Parked { /// どちらかにしか存在しない。`Mutex` を誰かが lock して I/O する /// 経路は型として存在しない(INV-14)。 pub struct OpenPort { + id: u64, name: String, cmd_tx: Sender, parked: Mutex>, @@ -169,8 +170,10 @@ pub struct OpenPort { impl OpenPort { pub fn new(name: &str, io: Box) -> Self { + static NEXT_ID: AtomicU64 = AtomicU64::new(1); let (cmd_tx, rx) = channel::unbounded(); Self { + id: NEXT_ID.fetch_add(1, Ordering::Relaxed), name: name.to_string(), cmd_tx, parked: Mutex::new(Some(Parked { @@ -182,6 +185,11 @@ impl OpenPort { } } + /// Identifies this open, including after Clear restarts its receive worker. + pub fn id(&self) -> u64 { + self.id + } + /// デバイスパス(例: "COM7", "/dev/ttyUSB0") pub fn name(&self) -> &str { &self.name @@ -924,7 +932,14 @@ mod tests { assert!(port.is_parked() && port.is_connected()); let p = port.clone(); let waiter = thread::spawn(move || p.send(b"hello".to_vec())); - thread::sleep(Duration::from_millis(50)); + let deadline = Instant::now() + Duration::from_secs(2); + while port.cmd_tx.is_empty() { + assert!( + Instant::now() < deadline, + "sender did not queue its request" + ); + thread::sleep(Duration::from_millis(1)); + } let started = Instant::now(); port.close(); assert_eq!(waiter.join().unwrap(), Err("port closed".to_string())); diff --git a/src-tauri/src/serial/ui_notifier.rs b/src-tauri/src/serial/ui_notifier.rs index ebca75f..6cd035c 100644 --- a/src-tauri/src/serial/ui_notifier.rs +++ b/src-tauri/src/serial/ui_notifier.rs @@ -19,6 +19,7 @@ const TIMESTAMP_RECORD_INTERVAL: u32 = 6; // 100ms (16ms × 6 ≈ 96ms) #[derive(Clone, serde::Serialize)] pub struct DataUpdatePayload { + pub capture_id: u64, pub total_bytes: u64, } @@ -57,7 +58,10 @@ pub fn spawn_ui_notifier_thread( // データが増えた場合のみ通知 if total_bytes > last_total_bytes { - let payload = DataUpdatePayload { total_bytes }; + let payload = DataUpdatePayload { + capture_id: data_store.capture_id(), + total_bytes, + }; if let Err(e) = app_handle.emit("data-update", payload) { warn!("[UiNotifier] Failed to emit event: {:?}", e); diff --git a/src/App.tsx b/src/App.tsx index 8b08b94..8778f54 100644 --- a/src/App.tsx +++ b/src/App.tsx @@ -13,6 +13,7 @@ import { usePersistentState, loadSetting, saveSetting, isBoolean, isString } fro import './App.css'; interface DataUpdatePayload { + capture_id: number; total_bytes: number; } @@ -56,7 +57,16 @@ function App() { loadSetting('autoConnect', false, isBoolean) ? loadSetting(LAST_PORT_KEY, '', isString) : '' ); const [isConnected, setIsConnected] = useState(false); - const [totalBytes, setTotalBytes] = useState(0); + const [{ capture_id: captureId, total_bytes: totalBytes }, setCapture] = + useState({ capture_id: 0, total_bytes: 0 }); + const updateCapture = useCallback((next: DataUpdatePayload) => { + setCapture((current) => + next.capture_id > current.capture_id || + (next.capture_id === current.capture_id && next.total_bytes > current.total_bytes) + ? next + : current + ); + }, []); const [theme, setTheme] = useTheme(); // Confirms Copy / Save, as the C# version's auto-closing message box did const [toast, showToast] = useToast(); @@ -80,18 +90,10 @@ function App() { saveSetting(LAST_PORT_KEY, port); }, []); - // Read in the poll callback without making it a dependency (the interval - // must not be torn down and restarted on every connect/disconnect). - const isConnectedRef = useRef(isConnected); - useEffect(() => { - isConnectedRef.current = isConnected; - }, [isConnected]); - // --- Auto Connect (SYS-F-807) --------------------------------------------- // While waiting, look for the device path and open it with `reopen_port`, which - // continues the SAME capture (offsets continue, nothing is cleared); only the - // Connect button starts a new one. When the connected device disappears, wait for - // the same path again. A user-initiated Disconnect never produces + // continues the current capture at the same offsets. When the connected + // device disappears, wait for the same path again. A user-initiated Disconnect never produces // `serial-status connected:false`, so every such event is an unexpected disconnect. const autoConnectRef = useRef(autoConnect); useEffect(() => { @@ -107,12 +109,29 @@ function App() { const [waitError, setWaitError] = useState(null); // The list entry of the current connection (the device to wait for if it goes away) const connectedPortRef = useRef(''); + const connectionIdRef = useRef(null); + const pendingOpenRef = useRef | null>(null); + const openAttemptRef = useRef(0); // Reconnect uses the settings as they are when the device comes back const configRef = useRef(config); useEffect(() => { configRef.current = config; }, [config]); + const openConnection = useCallback( + async (command: 'open_port' | 'reopen_port', entry: string) => { + openAttemptRef.current += 1; + const opening = invoke(command, { portName: entry, config: configRef.current }); + pendingOpenRef.current = opening; + try { + connectionIdRef.current = await opening; + } finally { + if (pendingOpenRef.current === opening) pendingOpenRef.current = null; + } + }, + [] + ); + const beginWaiting = useCallback((path: string) => { waitingRef.current = path; setWaitingFor(path); @@ -130,38 +149,27 @@ function App() { }, []); // Shared by the manual refresh (SettingsPanel) and the hotplug poll below. + const portRefresh = useRef({ requested: 0, applied: 0 }); const updatePorts = useCallback(async () => { + const request = ++portRefresh.current.requested; try { const p = await invoke('list_ports'); + // A slow poll may finish after a manual Reload has already refreshed the list. + if (request < portRefresh.current.applied) return; + portRefresh.current.applied = request; // Skip the state update when the list is unchanged: the poll runs every // PORT_POLL_INTERVAL_MS and a new array identity would re-render the // whole tree (and the settings dropdown) on every tick for nothing. setPorts((current) => current.length === p.length && current.every((name, i) => name === p[i]) ? current : p ); - // Use the functional form: this callback may run after the user changed - // the selection, so decide based on the CURRENT value, not a stale one. setSelectedPort((current) => { - // While connected the port - {/* The device being waited for has left the list; keep it selectable so the - dropdown keeps showing what the app is waiting for */} - {reconnectWaitingFor !== null && selectedPort && !ports.includes(selectedPort) && ( + {/* Keep showing the selected port even when its device is unplugged. */} + {selectedPort && !ports.includes(selectedPort) && ( )} {ports.map((port) => ( @@ -294,9 +296,7 @@ export default function SettingsPanel({ {port} ))} - {ports.length === 0 && reconnectWaitingFor === null && ( - - )} + {ports.length === 0 && !selectedPort && }
diff --git a/src/components/viewers/AsciiViewer.tsx b/src/components/viewers/AsciiViewer.tsx index cffb8d4..43c3726 100644 --- a/src/components/viewers/AsciiViewer.tsx +++ b/src/components/viewers/AsciiViewer.tsx @@ -50,18 +50,20 @@ export default function AsciiViewer({ const [lines, setLines] = useState([]); const [totalLines, setTotalLines] = useState(0); const [currentStartLine, setCurrentStartLine] = useState(0); - // Whether the fetched block contains the last line (issue #3). The block is then - // laid out bottom-anchored, so the newest line is at the very bottom even when + // Whether the fetched block contains the last line (issue #3). A truncated tail + // is bottom-anchored, so the newest line is at the very bottom even when // Line Wrap makes rows taller than ROW_HEIGHT (the scroll model assumes fixed // rows) or the scroll height is scaled down for huge captures. Decided by the // data, not the scroll position, so entering/leaving the mode cannot oscillate. const [reachesEnd, setReachesEnd] = useState(false); const isTail = reachesEnd && lines.length > 0; + const hasCompleteBlock = isTail && currentStartLine === 0; // Fetching guard const fetchingRef = useRef(false); const lastFetchLineRef = useRef(-Infinity); const lastTotalBytesRef = useRef(0); + const fetchGenerationRef = useRef(0); // Track total lines from backend for proper scroll calculation const totalLinesRef = useRef(0); @@ -69,9 +71,11 @@ export default function AsciiViewer({ // Track initialization to prevent double-setting const [initialLineSet, setInitialLineSet] = useState(false); - // Determine effective total lines for scroll calculation - const effectiveTotalLines = + // A complete block has no virtual rows. The backend line index can include + // a trailing empty line that is not rendered. + const indexedLineCount = totalLinesRef.current > 0 ? totalLinesRef.current : Math.max(1, Math.ceil(totalBytes / 80)); + const effectiveTotalLines = hasCompleteBlock ? lines.length : indexedLineCount; // Byte-based scroll const { @@ -170,6 +174,7 @@ export default function AsciiViewer({ lastFetchLineRef.current = target; try { + const generation = fetchGenerationRef.current; const fetchCount = visibleRows + BUFFER_ROWS * 2; const payload = await invoke('get_ascii_lines', { startLine: target, @@ -177,6 +182,7 @@ export default function AsciiViewer({ showCtrl: false, showTimestamp: showTimestamp, }); + if (generation !== fetchGenerationRef.current) continue; setLines(payload.lines); setTotalLines(payload.total_lines); totalLinesRef.current = payload.total_lines; @@ -196,9 +202,16 @@ export default function AsciiViewer({ // Effect: fetch data when scroll position changes or totalBytes changes useEffect(() => { if (totalBytes === 0) { + // Clear invalidates both queued requests and replies already in flight. + fetchGenerationRef.current += 1; + pendingFetchRef.current = null; + lastFetchLineRef.current = -Infinity; + lastTotalBytesRef.current = 0; setLines([]); setTotalLines(0); totalLinesRef.current = 0; + setCurrentStartLine(0); + setReachesEnd(false); return; } @@ -247,7 +260,7 @@ export default function AsciiViewer({ useEffect(() => { const el = containerRef.current; if (!autoScroll || !isTail || !el) return; - const bottom = el.scrollHeight - el.clientHeight; + const bottom = Math.max(0, el.scrollHeight - el.clientHeight); if (Math.abs(el.scrollTop - bottom) > 1) el.scrollTop = bottom; }, [autoScroll, isTail, lines, totalBytes, asciiScrollHeight, containerRef]); @@ -363,7 +376,7 @@ export default function AsciiViewer({ minHeight: asciiScrollHeight, display: 'flex', flexDirection: 'column', - justifyContent: 'flex-end', + justifyContent: hasCompleteBlock ? 'flex-start' : 'flex-end', } : { height: asciiScrollHeight, position: 'relative' } } diff --git a/src/components/viewers/HexViewer.tsx b/src/components/viewers/HexViewer.tsx index 0150e02..d20e8ca 100644 --- a/src/components/viewers/HexViewer.tsx +++ b/src/components/viewers/HexViewer.tsx @@ -47,6 +47,7 @@ export default function HexViewer({ const lastFetchRowRef = useRef(-Infinity); const totalRowsRef = useRef(0); const lastTotalBytesRef = useRef(0); + const fetchGenerationRef = useRef(0); // Calculate effective total rows for scroll height // Use backend confirmed rows if available, otherwise estimate @@ -140,12 +141,14 @@ export default function HexViewer({ lastFetchRowRef.current = targetStartRow; try { + const generation = fetchGenerationRef.current; const fetchCount = visibleRows + BUFFER_ROWS * 2; const payload = await invoke('get_display_rows', { startRow: targetStartRow, rowCount: fetchCount, showTimestamp, }); + if (generation !== fetchGenerationRef.current) continue; // Only update state if this is still relevant? // Ideally yes. Even if old, it's better than blank. @@ -171,9 +174,15 @@ export default function HexViewer({ // Effect: fetch data when scroll position changes useEffect(() => { if (totalBytes === 0) { + fetchGenerationRef.current += 1; + pendingStartRowRef.current = null; + pendingForceRef.current = false; + lastFetchRowRef.current = -Infinity; + lastTotalBytesRef.current = 0; setRows([]); setTotalRows(0); totalRowsRef.current = 0; + setCurrentStartRow(0); return; } diff --git a/src/components/viewers/useByteScroll.test.ts b/src/components/viewers/useByteScroll.test.ts index cf7e72a..67e0b2f 100644 --- a/src/components/viewers/useByteScroll.test.ts +++ b/src/components/viewers/useByteScroll.test.ts @@ -105,6 +105,29 @@ describe('useByteScroll', () => { expect(result.current.scrollTop).toBe(500); }); + it('resets a manual scroll anchor on Clear before receiving new data', () => { + const { result, rerender } = renderHook((props) => useByteScroll(props), { + initialProps: { ...defaultProps, totalBytes: 16000 }, + }); + const container = document.createElement('div'); + Object.defineProperty(container, 'clientHeight', { value: 500 }); + container.scrollTop = 10000; + (result.current.containerRef as React.MutableRefObject).current = + container; + act(() => { + result.current.handleScroll({ + currentTarget: container, + } as unknown as React.UIEvent); + }); + rerender({ ...defaultProps, totalBytes: 0 }); + expect(container.scrollTop).toBe(0); + expect(result.current.scrollTop).toBe(0); + expect(defaultProps.onScrollChange).toHaveBeenLastCalledWith(0); + rerender({ ...defaultProps, totalBytes: 16000 }); + expect(container.scrollTop).toBe(0); + expect(result.current.scrollTop).toBe(0); + }); + it('caps scrollHeight at MAX_SCROLL_HEIGHT', () => { const hugeBytes = 100_000_000 * 16; // 100M rows const { result } = renderHook(() => useByteScroll({ ...defaultProps, totalBytes: hugeBytes })); diff --git a/src/components/viewers/useByteScroll.ts b/src/components/viewers/useByteScroll.ts index 22b9a88..3ad832c 100644 --- a/src/components/viewers/useByteScroll.ts +++ b/src/components/viewers/useByteScroll.ts @@ -130,6 +130,19 @@ export function useByteScroll({ // Anchor Scroll Logic: Maintain viewing position when data grows useLayoutEffect(() => { + if (totalBytes === 0) { + // Clear starts a new capture at the top, including in manual scroll mode. + // Do not let a trailing scroll callback restore the old capture's anchor. + if (trailingRef.current) clearTimeout(trailingRef.current); + trailingRef.current = null; + anchorPositionRef.current = 0; + lastProgrammaticScrollTopRef.current = 0; + if (containerRef.current) containerRef.current.scrollTop = 0; + // Synchronize the rendered rows with the DOM scroll reset before paint. + // eslint-disable-next-line react-hooks/set-state-in-effect + setScrollTop(0); + onScrollChange(0); + } // If not auto-scrolling... if (!autoScroll && containerRef.current) { // Check if geometry changed significantly (Bytes grew OR Height changed due to new TotalLines) @@ -162,7 +175,7 @@ export function useByteScroll({ prevScrollHeightRef.current = scrollHeight; // NOTE: We do NOT update anchorPositionRef here. We trust our previous anchor. // Only USER interaction should update the anchor. - }, [totalBytes, scrollHeight, autoScroll, totalRows, getScrollTopFromAnchor]); + }, [totalBytes, scrollHeight, autoScroll, totalRows, getScrollTopFromAnchor, onScrollChange]); // Handle initial offset on mount (manual mode only) useLayoutEffect(() => { diff --git a/src/test/App.test.tsx b/src/test/App.test.tsx index 286c16e..b05edef 100644 --- a/src/test/App.test.tsx +++ b/src/test/App.test.tsx @@ -64,6 +64,10 @@ describe('App', () => { }); mockInvoke.mockImplementation((cmd: string) => { if (cmd === 'list_ports') return Promise.resolve(['COM1']); + if (cmd === 'open_port' || cmd === 'reopen_port') return Promise.resolve(1); + if (cmd === 'close_port') return Promise.resolve(true); + if (cmd === 'confirm_port_removed') return Promise.resolve(false); + if (cmd === 'clear_data') return Promise.resolve(2); return Promise.resolve(undefined); }); }); @@ -78,22 +82,37 @@ describe('App', () => { it('releases the backend port handle when a disconnect is detected', async () => { render(); await flush(); + fireEvent.click(screen.getByRole('button', { name: 'Connect' })); + await flush(); mockInvoke.mockClear(); - emit('serial-status', { connected: false, error: 'Device removed' }); + emit('serial-status', { + connected: false, + connection_id: 1, + error: 'Read failed', + }); + await flush(); - expect(mockInvoke).toHaveBeenCalledWith('close_port'); - expect(window.alert).toHaveBeenCalledWith('Serial disconnected: Device removed'); + expect(mockInvoke).toHaveBeenCalledWith('close_port', { connectionId: 1 }); + expect(mockInvoke).toHaveBeenCalledWith('confirm_port_removed', { portName: 'COM1' }); + expect(window.alert).toHaveBeenCalledWith('Serial disconnected: Read failed'); }); it('still releases the handle when the disconnect carries no error text', async () => { render(); await flush(); + fireEvent.click(screen.getByRole('button', { name: 'Connect' })); + await flush(); mockInvoke.mockClear(); - emit('serial-status', { connected: null, error: null }); + emit('serial-status', { + connected: false, + connection_id: 1, + error: null, + }); + await flush(); - expect(mockInvoke).toHaveBeenCalledWith('close_port'); + expect(mockInvoke).toHaveBeenCalledWith('close_port', { connectionId: 1 }); expect(window.alert).not.toHaveBeenCalled(); }); @@ -107,6 +126,214 @@ describe('App', () => { expect(mockInvoke).not.toHaveBeenCalledWith('close_port'); }); + it('updates the UI before confirming a delayed unplug and retains diagnostics', async () => { + const diagnostic = vi.spyOn(console, 'error').mockImplementation(() => {}); + let finishConfirmation!: (removed: boolean) => void; + mockInvoke.mockImplementation(async (cmd) => { + if (cmd === 'list_ports') return ['XIAO (COM4)']; + if (cmd === 'open_port') return 1; + if (cmd === 'close_port') return true; + if (cmd === 'confirm_port_removed') { + return new Promise((resolve) => (finishConfirmation = resolve)); + } + return undefined; + }); + render(); + await flush(); + fireEvent.click(screen.getByRole('button', { name: 'Connect' })); + await flush(); + emit('serial-status', { + connected: false, + connection_id: 1, + error: 'Failed to read from port: Os { code: 22 }', + }); + await flush(); + expect(screen.getByRole('button', { name: 'Connect' })).toBeInTheDocument(); + expect(mockInvoke).toHaveBeenCalledWith('close_port', { connectionId: 1 }); + expect(mockInvoke).toHaveBeenCalledWith('confirm_port_removed', { portName: 'COM4' }); + expect(window.alert).not.toHaveBeenCalled(); + await act(async () => { + finishConfirmation(true); + }); + expect(window.alert).not.toHaveBeenCalled(); + expect(diagnostic).toHaveBeenCalledWith( + 'Serial disconnected:', + expect.stringContaining('code: 22') + ); + }); + + it('does not show an old read error once another open attempt has started', async () => { + let finishConfirmation!: (removed: boolean) => void; + let finishOpen!: (id: number) => void; + let openCount = 0; + mockInvoke.mockImplementation(async (cmd) => { + if (cmd === 'list_ports') return ['COM1']; + if (cmd === 'open_port') { + openCount += 1; + if (openCount === 1) return 1; + return new Promise((resolve) => (finishOpen = resolve)); + } + if (cmd === 'close_port') return true; + if (cmd === 'confirm_port_removed') { + return new Promise((resolve) => (finishConfirmation = resolve)); + } + return undefined; + }); + render(); + await flush(); + fireEvent.click(screen.getByRole('button', { name: 'Connect' })); + await flush(); + emit('serial-status', { connected: false, connection_id: 1, error: 'Read failed' }); + await flush(); + fireEvent.click(screen.getByRole('button', { name: 'Connect' })); + await act(async () => { + finishConfirmation(false); + }); + expect(window.alert).not.toHaveBeenCalled(); + await act(async () => { + finishOpen(2); + }); + expect(screen.getByRole('button', { name: 'Disconnect' })).toBeInTheDocument(); + }); + + it('ignores an old disconnect event after the same port is reopened', async () => { + render(); + await flush(); + fireEvent.click(screen.getByRole('button', { name: 'Connect' })); + await flush(); + fireEvent.click(screen.getByRole('button', { name: 'Disconnect' })); + await flush(); + mockInvoke.mockResolvedValueOnce(2); + fireEvent.click(screen.getByRole('button', { name: 'Connect' })); + await flush(); + mockInvoke.mockClear(); + emit('serial-status', { + connected: false, + connection_id: 1, + error: 'old', + }); + await flush(); + expect(screen.getByRole('button', { name: 'Disconnect' })).toBeInTheDocument(); + expect(mockInvoke.mock.calls.filter(([cmd]) => cmd === 'close_port')).toHaveLength(0); + expect(window.alert).not.toHaveBeenCalled(); + }); + + it('ignores a delayed cleanup reply once a new connection has opened', async () => { + render(); + await flush(); + fireEvent.click(screen.getByRole('button', { name: 'Connect' })); + await flush(); + let finishClose!: (closed: boolean) => void; + mockInvoke.mockImplementationOnce( + () => + new Promise((resolve) => { + finishClose = resolve; + }) + ); + emit('serial-status', { + connected: false, + connection_id: 1, + error: 'old', + }); + await flush(); + fireEvent.click(screen.getByRole('button', { name: 'Disconnect' })); + await flush(); + mockInvoke.mockResolvedValueOnce(2); + fireEvent.click(screen.getByRole('button', { name: 'Connect' })); + await flush(); + await act(async () => { + finishClose(true); + }); + expect(screen.getByRole('button', { name: 'Disconnect' })).toBeInTheDocument(); + expect(window.alert).not.toHaveBeenCalled(); + }); + + it('handles an unplug that arrives before the open reply', async () => { + let finishOpen!: (id: number) => void; + mockInvoke.mockImplementation(async (cmd) => { + if (cmd === 'list_ports') return ['COM1']; + if (cmd === 'open_port') return new Promise((resolve) => (finishOpen = resolve)); + if (cmd === 'close_port' || cmd === 'confirm_port_removed') return true; + return undefined; + }); + render(); + await flush(); + fireEvent.click(screen.getByRole('button', { name: 'Connect' })); + emit('serial-status', { + connected: false, + connection_id: 1, + error: 'removed', + }); + await act(async () => { + finishOpen(1); + }); + await flush(); + expect(mockInvoke).toHaveBeenCalledWith('close_port', { connectionId: 1 }); + expect(screen.getByRole('button', { name: 'Connect' })).toBeInTheDocument(); + expect(window.alert).not.toHaveBeenCalled(); + }); + + it('keeps the displayed byte count across disconnect, failed open and reconnect until Clear', async () => { + render(); + await flush(); + fireEvent.click(screen.getByRole('button', { name: 'Connect' })); + await flush(); + emit('data-update', { capture_id: 1, total_bytes: 10 }); + await flush(); + fireEvent.click(screen.getByRole('button', { name: 'Disconnect' })); + await flush(); + expect(screen.getByText(/Total: 10 bytes/)).toBeInTheDocument(); + mockInvoke.mockRejectedValueOnce('busy'); + fireEvent.click(screen.getByRole('button', { name: 'Connect' })); + await flush(); + expect(screen.getByText(/Total: 10 bytes/)).toBeInTheDocument(); + fireEvent.click(screen.getByRole('button', { name: 'Connect' })); + await flush(); + expect(screen.getByText(/Total: 10 bytes/)).toBeInTheDocument(); + fireEvent.click(screen.getByRole('button', { name: 'Clear' })); + await flush(); + expect(screen.getByText(/Total: 0 bytes/)).toBeInTheDocument(); + emit('data-update', { capture_id: 1, total_bytes: 20 }); + expect(screen.getByText(/Total: 0 bytes/)).toBeInTheDocument(); + }); + + it('shows new data that arrives before the Clear reply even at the previous byte count', async () => { + let finishClear!: (captureId: number) => void; + let finishOldFetch!: (payload: unknown) => void; + let cleared = false; + const row = (text: string) => ({ + lines: [{ offset: 0, text, timestamp: null }], + total_lines: 1, + start_line: 0, + reaches_end: true, + }); + mockInvoke.mockImplementation(async (cmd) => { + if (cmd === 'list_ports') return ['COM1']; + if (cmd === 'clear_data') return new Promise((resolve) => (finishClear = resolve)); + if (cmd === 'get_ascii_lines') { + if (cleared) return row('new capture'); + return new Promise((resolve) => (finishOldFetch = resolve)); + } + return undefined; + }); + + render(); + await flush(); + emit('data-update', { capture_id: 1, total_bytes: 10 }); + await flush(); + fireEvent.click(screen.getByRole('button', { name: 'Clear' })); + cleared = true; + emit('data-update', { capture_id: 2, total_bytes: 10 }); + expect(await screen.findByText('new capture')).toBeInTheDocument(); + await act(async () => { + finishClear(2); + finishOldFetch(row('old capture')); + }); + expect(screen.getByText(/Total: 10 bytes/)).toBeInTheDocument(); + expect(screen.getByText('new capture')).toBeInTheDocument(); + expect(screen.queryByText('old capture')).not.toBeInTheDocument(); + }); + // ---------------- GAP-09 ---------------- it('surfaces log-error events to the user', async () => { @@ -146,6 +373,83 @@ describe('App', () => { expect(options).toContain('COM7'); }); + it('keeps the selected port through unplug and reconnects before the next refresh', async () => { + vi.useFakeTimers(); + vi.spyOn(console, 'error').mockImplementation(() => {}); + const device = 'XIAO (COM4)'; + let available = ['COM1', device]; + mockInvoke.mockImplementation(async (cmd) => { + if (cmd === 'list_ports') return available; + if (cmd === 'open_port') { + if (!available.includes(device)) throw new Error('COM4 not found'); + return 1; + } + if (cmd === 'close_port' || cmd === 'confirm_port_removed') return true; + return undefined; + }); + + render(); + await flush(); + const port = screen.getByRole('combobox', { name: 'Port' }); + fireEvent.change(port, { target: { value: device } }); + fireEvent.click(screen.getByRole('button', { name: 'Connect' })); + await flush(); + expect(screen.getByRole('button', { name: 'Reload' })).toBeDisabled(); + + available = ['COM1']; + emit('serial-status', { connected: false, connection_id: 1, error: 'USB unplugged' }); + await flush(); + await act(() => vi.advanceTimersByTimeAsync(2000)); + expect(port).toHaveValue(device); + expect(port.selectedOptions[0]).toHaveTextContent(`${device} (not present)`); + + fireEvent.click(screen.getByRole('button', { name: 'Connect' })); + await flush(); + expect(window.alert).toHaveBeenCalledWith(expect.stringContaining('COM4 not found')); + expect(port).toHaveValue(device); + + available = ['COM1', device]; + mockInvoke.mockClear(); + fireEvent.click(screen.getByRole('button', { name: 'Connect' })); + await flush(); + expect(mockInvoke).toHaveBeenCalledWith( + 'open_port', + expect.objectContaining({ portName: device }) + ); + expect(screen.getByRole('button', { name: 'Disconnect' })).toBeInTheDocument(); + }); + + it('reloads immediately and keeps the selected COM number when its label changes', async () => { + vi.useFakeTimers(); + let finishOldPoll!: (ports: string[]) => void; + mockInvoke.mockImplementationOnce(async () => ['COM1', 'XIAO (COM4)']); + render(); + await flush(); + const port = screen.getByRole('combobox', { name: 'Port' }); + fireEvent.change(port, { target: { value: 'XIAO (COM4)' } }); + + mockInvoke.mockImplementation(async (cmd) => { + if (cmd === 'list_ports') + return new Promise((resolve) => (finishOldPoll = resolve)); + return undefined; + }); + await act(() => vi.advanceTimersByTimeAsync(2000)); + mockInvoke.mockImplementation(async (cmd) => { + if (cmd === 'list_ports') return ['COM1', 'USB Serial Device (COM4)', 'COM7']; + return undefined; + }); + mockInvoke.mockClear(); + fireEvent.click(screen.getByRole('button', { name: 'Reload' })); + await flush(); + expect(mockInvoke).toHaveBeenCalledWith('list_ports'); + expect(port).toHaveValue('USB Serial Device (COM4)'); + expect(screen.getByRole('option', { name: 'COM7' })).toBeInTheDocument(); + + await act(async () => finishOldPoll(['COM1'])); + expect(port).toHaveValue('USB Serial Device (COM4)'); + expect(screen.getByRole('option', { name: 'COM7' })).toBeInTheDocument(); + }); + // ---------------- Settings survive a restart (issue #7) ---------------- describe('remembered settings', () => { @@ -226,7 +530,7 @@ describe('App', () => { async function renderWithData() { render(); await flush(); - emit('data-update', { total_bytes: 10 }); + emit('data-update', { capture_id: 1, total_bytes: 10 }); } it('saves text with timestamps when Timestamp is ON', async () => { @@ -373,8 +677,10 @@ describe('App', () => { mockInvoke.mockImplementation((cmd: string) => { if (cmd === 'list_ports') return Promise.resolve(available); if (cmd === 'reopen_port') { - return reopenFails ? Promise.reject('Access is denied.') : Promise.resolve(undefined); + return reopenFails ? Promise.reject('Access is denied.') : Promise.resolve(2); } + if (cmd === 'open_port') return Promise.resolve(1); + if (cmd === 'close_port') return Promise.resolve(true); return Promise.resolve(undefined); }); }); @@ -406,14 +712,18 @@ describe('App', () => { await flush(); available = []; - emit('serial-status', { connected: false, error: 'Device removed' }); + emit('serial-status', { + connected: false, + connection_id: 1, + error: 'Device removed', + }); await flush(); } it('waits for the lost device without a blocking alert', async () => { await connectAndLoseDevice(); - expect(mockInvoke).toHaveBeenCalledWith('close_port'); + expect(mockInvoke).toHaveBeenCalledWith('close_port', { connectionId: 1 }); expect(window.alert).not.toHaveBeenCalled(); expect(mockInvoke).toHaveBeenCalledWith('set_reconnecting', { waiting: true }); expect(screen.getByRole('status')).toHaveTextContent('Waiting for COM1…'); diff --git a/src/test/AsciiViewer.test.tsx b/src/test/AsciiViewer.test.tsx index 9f781d4..9639e73 100644 --- a/src/test/AsciiViewer.test.tsx +++ b/src/test/AsciiViewer.test.tsx @@ -1,8 +1,9 @@ import { describe, it, expect, vi, beforeEach } from 'vitest'; -import { render, waitFor } from '@testing-library/react'; +import { act, render, waitFor } from '@testing-library/react'; import { invoke } from '@tauri-apps/api/core'; import AsciiViewer from '../components/viewers/AsciiViewer'; import { TAIL_START_LINE } from '../components/viewers/scrollUtils'; +import { ROW_HEIGHT } from '../components/viewers/viewerConstants'; const invokeMock = vi.mocked(invoke); @@ -71,4 +72,84 @@ describe('AsciiViewer - Auto Scroll reaches the last line (issue #3)', () => { expect(spacer.style.justifyContent).toBe(''); expect(spacer.style.position).toBe('relative'); }); + + it.each([false, true])( + 'keeps a complete short capture at the top as partial lines end (wrap=%s)', + async (lineWrap) => { + let count = 1; + let trailingNewline = false; + invokeMock.mockImplementation(async (cmd) => { + if (cmd !== 'get_ascii_lines') return undefined; + return { + lines: lines(0, count), + total_lines: count + Number(trailingNewline), + start_line: 0, + reaches_end: true, + }; + }); + const { container, rerender, findByText } = render( + + ); + await findByText('line 0'); + const spacer = container.querySelector('.ascii-scroll-container > div') as HTMLElement; + // Include the empty index entry after CR/LF, the next partial line, and + // growth through a typical viewport boundary. None may shift line 0. + for (const [nextCount, newline] of [ + [1, true], + [2, false], + [2, true], + [25, true], + [26, false], + ] as const) { + count = nextCount; + trailingNewline = newline; + rerender( + + ); + await waitFor(() => expect(container.querySelectorAll('.ascii-row')).toHaveLength(count)); + expect(spacer.style.justifyContent).toBe('flex-start'); + expect(spacer.style.minHeight).toBe(`${count * ROW_HEIGHT}px`); + expect(spacer.firstElementChild).not.toHaveStyle({ position: 'absolute' }); + } + } + ); + + it('discards an in-flight reply after Clear and fetches new data even at the previous byte count', async () => { + let finishOld!: (payload: unknown) => void; + invokeMock.mockImplementationOnce( + () => + new Promise((resolve) => { + finishOld = resolve; + }) + ); + const { container, rerender, findByText } = render( + + ); + await waitFor(() => expect(finishOld).toBeDefined()); + rerender(); + await act(async () => { + finishOld({ + lines: [{ offset: 0, text: 'old', timestamp: null }], + total_lines: 1, + start_line: 0, + reaches_end: true, + }); + }); + expect(container.querySelectorAll('.ascii-row')).toHaveLength(0); + invokeMock.mockResolvedValue({ + lines: [{ offset: 0, text: 'new', timestamp: null }], + total_lines: 1, + start_line: 0, + reaches_end: true, + }); + rerender(); + expect(await findByText('new')).toBeInTheDocument(); + expect(container).not.toHaveTextContent('old'); + const spacer = container.querySelector('.ascii-scroll-container > div') as HTMLElement; + expect(spacer.style.justifyContent).toBe('flex-start'); + }); }); diff --git a/src/test/HexViewer.test.tsx b/src/test/HexViewer.test.tsx new file mode 100644 index 0000000..fe75551 --- /dev/null +++ b/src/test/HexViewer.test.tsx @@ -0,0 +1,45 @@ +import { act, render, waitFor } from '@testing-library/react'; +import { describe, expect, it, vi } from 'vitest'; +import { invoke } from '@tauri-apps/api/core'; +import HexViewer from '../components/viewers/HexViewer'; + +class MockResizeObserver { + observe() {} + unobserve() {} + disconnect() {} +} +globalThis.ResizeObserver = MockResizeObserver as unknown as typeof ResizeObserver; + +describe('HexViewer capture reset', () => { + it('rejects a pre-Clear reply and fetches new bytes at the same offset and count', async () => { + const invokeMock = vi.mocked(invoke); + invokeMock.mockReset(); + let finishOld!: (payload: unknown) => void; + invokeMock.mockImplementationOnce( + () => + new Promise((resolve) => { + finishOld = resolve; + }) + ); + const { container, rerender, findByText } = render( + + ); + await waitFor(() => expect(finishOld).toBeDefined()); + rerender(); + await act(async () => { + finishOld({ + rows: [{ offset: 0, hex: '6F 6C 64', ascii: 'old', timestamp: null }], + total_rows: 1, + }); + }); + expect(container).not.toHaveTextContent('old'); + invokeMock.mockResolvedValue({ + rows: [{ offset: 0, hex: '6E 65 77', ascii: 'new', timestamp: null }], + total_rows: 1, + }); + rerender(); + expect(await findByText('6E 65 77')).toBeInTheDocument(); + expect(container).toHaveTextContent('new'); + expect(container).not.toHaveTextContent('old'); + }); +});