Shell 17: platform-single-instance (#809) #890

Closed
charles wants to merge 0 commits from shell-17-platform-single-instance into shell
Owner

What

fluxer_platform::single_instance (Desktop shell spec §7.2, §12; plan Task 17), and UpdateLock::release() for the #754 relaunch.

  • acquire(scope) -> io::Result<Instance>: Instance::Primary(InstanceListener) or Instance::Secondary(InstanceSender). Runs without an async runtime (first thing in main, Task 33); the primary's listener serves on its own thread with a private current-thread tokio runtime.
  • InstanceListener::next().await -> Option<(InstanceMessage, Reply)>, Reply::{ok, busy} (dropped unanswered = error), close() / drop releases at once (stop thread, remove socket, unlock), endpoint().
  • InstanceSender::send(&InstanceMessage, limit) -> SendOutcome::{Ok, Busy, NoAnswer, Refused} (blocking, own small runtime; retries a channel that is not there yet until the limit).
  • wait_and_acquire(scope, limit), wait_for_pid_exit(pid, limit); acquire_in / wait_and_acquire_in / socket_path take the runtime directory explicitly (tests).
  • Unix: flock (std File::try_lock) on <runtime>/flaxative/<scope hash>.lock, socket <hash>.sock beside it; runtime = $XDG_RUNTIME_DIR, else the data directory. Directory created 0700; one wider, a link or another user's is refused (PermissionDenied); socket 0600; peer uid checked per connection via tokio's peer_cred (SO_PEERCRED), own uid read the same way from a socket pair (no libc dependency); stale socket removed only while holding the lock.
  • Windows: mutex Local\Flaxative-<hash>; pipe \\.\pipe\flaxative-<SID>-<hash> with first_pipe_instance(true), reject_remote_clients(true), security attributes from SDDL D:P(A;;GA;;;<SID>); SID from the process token (ConvertSidToStringSidW). Every unsafe has a SAFETY: comment.
  • Frames: 4-byte big-endian length + JSON of InstanceMessage::encode, max 4 KiB (a longer length is answered error before reading any of it), whole message within 2 s (else closed unanswered), answer frame ok / busy / error. Messages are decoded by Task 10's codec; nothing is executed, used as a path or logged in full. At most 16 queued; more are answered busy.
  • update/lock.rs: UpdateLock::release(self), and docs that the lock file is close-on-exec (std opens with O_CLOEXEC; not inheritable on Windows).

Tests

crates/fluxer-platform/tests/single_instance.rs (temp runtime dirs; same tests drive the pipe on the Windows runner except the three cfg(unix) ones): first_is_primary_second_is_secondary, message_arrives_and_is_answered, busy_answer, oversize_and_malformed_refused, slow_sender_times_out, no_primary_is_no_answer, stale_socket_replaced (unix), wide_runtime_dir_refused (unix; modes and a symlink), uid_check (the peer_allowed / dir_acceptable predicates), released_on_close_and_on_drop, wait_and_acquire_gives_up_at_the_limit, wait_and_acquire_takes_over_once_released, relaunch_waits_for_pid_then_acquires (a child of the test binary holds the instance), wait_for_pid_exit_of_a_missing_process, update_lock_not_inherited (unix: a child started while both locks are held keeps neither). Unit tests: scope hash, dropped reply. The tests passed several times in a row locally; FLUXER_SCREENSHOT_TESTS=1 cargo xtask ci is green. No real-desktop test is needed (no display involved); none run.

The Windows code was compiled and clippy-checked (-D warnings) for x86_64-pc-windows-msvc in a scratch crate with the same windows 0.62.2 / tokio 1.54.1 (the full crate cannot be checked for that target here: C build scripts). The Windows tests have not been run.

Deviations from the plan

  • InstanceListener::next() is async and returns Option<…> (None once the listener stopped) instead of a bare tuple.
  • SendOutcome has a fourth variant, Refused (the primary answered error: malformed, too long, or the reply was dropped), as the spec's ok / busy / error answers need one.
  • The update lock was already close-on-exec (std); the task adds release() and the regression test. Releasing both locks before the relaunch is wired by Task 33.
  • Windows: the first pipe instance is retried for up to 1 s on ERROR_ACCESS_DENIED (a primary that just released the mutex may still be closing its pipe handles); a pipe still there after that is refused.
  • Cargo.toml: tokio net; on Windows the windows dependency gains Win32_Security_Authorization (on the crate's line, not the workspace's).
  • Test hardening: re-acquiring right after a release uses wait_and_acquire_in (another test spawning a process forks this one, and until that child execs it shares the open lock file for a few milliseconds).

For Charles to check on Windows (Task 44)

  • Start Flaxative twice once Task 33 wires it: the second launch raises the first and exits; \\.\pipe\flaxative-<SID>-<hash> exists only while the first runs.
  • The single_instance tests pass on the Windows runner.

Stacked on: origin/shell-10-core-instance-messages-tasks (already merged into shell at the base commit)

Closes #809

🤖 Generated with Claude Code

https://claude.ai/code/session_0161qMQMsCyJhjYw4gqa6e4K

## What `fluxer_platform::single_instance` (Desktop shell spec §7.2, §12; plan Task 17), and `UpdateLock::release()` for the #754 relaunch. - `acquire(scope) -> io::Result<Instance>`: `Instance::Primary(InstanceListener)` or `Instance::Secondary(InstanceSender)`. Runs without an async runtime (first thing in `main`, Task 33); the primary's listener serves on its own thread with a private current-thread tokio runtime. - `InstanceListener::next().await -> Option<(InstanceMessage, Reply)>`, `Reply::{ok, busy}` (dropped unanswered = `error`), `close()` / drop releases at once (stop thread, remove socket, unlock), `endpoint()`. - `InstanceSender::send(&InstanceMessage, limit) -> SendOutcome::{Ok, Busy, NoAnswer, Refused}` (blocking, own small runtime; retries a channel that is not there yet until the limit). - `wait_and_acquire(scope, limit)`, `wait_for_pid_exit(pid, limit)`; `acquire_in` / `wait_and_acquire_in` / `socket_path` take the runtime directory explicitly (tests). - **Unix:** `flock` (std `File::try_lock`) on `<runtime>/flaxative/<scope hash>.lock`, socket `<hash>.sock` beside it; runtime = `$XDG_RUNTIME_DIR`, else the data directory. Directory created 0700; one wider, a link or another user's is refused (`PermissionDenied`); socket 0600; peer uid checked per connection via tokio's `peer_cred` (SO_PEERCRED), own uid read the same way from a socket pair (no `libc` dependency); stale socket removed only while holding the lock. - **Windows:** mutex `Local\Flaxative-<hash>`; pipe `\\.\pipe\flaxative-<SID>-<hash>` with `first_pipe_instance(true)`, `reject_remote_clients(true)`, security attributes from SDDL `D:P(A;;GA;;;<SID>)`; SID from the process token (`ConvertSidToStringSidW`). Every `unsafe` has a `SAFETY:` comment. - **Frames:** 4-byte big-endian length + JSON of `InstanceMessage::encode`, max 4 KiB (a longer length is answered `error` before reading any of it), whole message within 2 s (else closed unanswered), answer frame `ok` / `busy` / `error`. Messages are decoded by Task 10's codec; nothing is executed, used as a path or logged in full. At most 16 queued; more are answered `busy`. - `update/lock.rs`: `UpdateLock::release(self)`, and docs that the lock file is close-on-exec (std opens with `O_CLOEXEC`; not inheritable on Windows). ## Tests `crates/fluxer-platform/tests/single_instance.rs` (temp runtime dirs; same tests drive the pipe on the Windows runner except the three `cfg(unix)` ones): `first_is_primary_second_is_secondary`, `message_arrives_and_is_answered`, `busy_answer`, `oversize_and_malformed_refused`, `slow_sender_times_out`, `no_primary_is_no_answer`, `stale_socket_replaced` (unix), `wide_runtime_dir_refused` (unix; modes and a symlink), `uid_check` (the `peer_allowed` / `dir_acceptable` predicates), `released_on_close_and_on_drop`, `wait_and_acquire_gives_up_at_the_limit`, `wait_and_acquire_takes_over_once_released`, `relaunch_waits_for_pid_then_acquires` (a child of the test binary holds the instance), `wait_for_pid_exit_of_a_missing_process`, `update_lock_not_inherited` (unix: a child started while both locks are held keeps neither). Unit tests: scope hash, dropped reply. The tests passed several times in a row locally; `FLUXER_SCREENSHOT_TESTS=1 cargo xtask ci` is green. No real-desktop test is needed (no display involved); none run. The Windows code was compiled and clippy-checked (`-D warnings`) for `x86_64-pc-windows-msvc` in a scratch crate with the same `windows` 0.62.2 / `tokio` 1.54.1 (the full crate cannot be checked for that target here: C build scripts). The Windows tests have not been run. ## Deviations from the plan - `InstanceListener::next()` is `async` and returns `Option<…>` (`None` once the listener stopped) instead of a bare tuple. - `SendOutcome` has a fourth variant, `Refused` (the primary answered `error`: malformed, too long, or the reply was dropped), as the spec's `ok` / `busy` / `error` answers need one. - The update lock was already close-on-exec (std); the task adds `release()` and the regression test. Releasing both locks before the relaunch is wired by Task 33. - Windows: the first pipe instance is retried for up to 1 s on `ERROR_ACCESS_DENIED` (a primary that just released the mutex may still be closing its pipe handles); a pipe still there after that is refused. - `Cargo.toml`: tokio `net`; on Windows the `windows` dependency gains `Win32_Security_Authorization` (on the crate's line, not the workspace's). - Test hardening: re-acquiring right after a release uses `wait_and_acquire_in` (another test spawning a process forks this one, and until that child `exec`s it shares the open lock file for a few milliseconds). ## For Charles to check on Windows (Task 44) - Start Flaxative twice once Task 33 wires it: the second launch raises the first and exits; `\\.\pipe\flaxative-<SID>-<hash>` exists only while the first runs. - The `single_instance` tests pass on the Windows runner. Stacked on: origin/shell-10-core-instance-messages-tasks (already merged into shell at the base commit) Closes #809 🤖 Generated with [Claude Code](https://claude.com/claude-code) https://claude.ai/code/session_0161qMQMsCyJhjYw4gqa6e4K
One client per data directory (Desktop shell spec §7.2, §12): a flock and
a 0700/0600 Unix socket with the peer uid checked, or a Local\ mutex and a
first-instance, user-only, local-only named pipe on Windows. Frames of at
most 4 KiB, read within 2 s, answered ok / busy / error. wait_and_acquire
and wait_for_pid_exit for the updater's handover (#754); UpdateLock gains
release() for the relaunch.

Refs #809

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0161qMQMsCyJhjYw4gqa6e4K
Author
Owner

Independent review: Shell 17, platform single instance (fd598bf4)

Scope: git diff 2412c1d0..origin/shell-17-platform-single-instance.

Local gate: FLUXER_SCREENSHOT_TESTS=1 cargo xtask ci on fd598bf4: all steps passed (Linux). tests/single_instance.rs: 16/16 passed. The two unit tests passed too.

Findings

  1. BLOCKING (Windows CI will be red). crates/fluxer-platform/tests/single_instance.rs:12 has use std::path::{Path, PathBuf};, but Path is only used inside the #[cfg(unix)] test stale_socket_replaced (line 326). On the Windows runner, cargo xtask ci runs clippy --workspace --all-targets -D warnings, so this becomes error: unused import: Path. I reproduced it with rustc 1.98.1 --target x86_64-pc-windows-msvc -D warnings on a minimal file with the same shape. Fix: use std::path::Path inside that test, or put the import behind #[cfg(unix)]. The other imports and items in the test file are used on Windows.
  2. minor (security hardening, Windows). The client (windows.rs::connect) does not check who owns the pipe server. The pipe name is predictable, since a SID is not secret. Another local user could create \\.\pipe\flaxative-<SID>-<hash> before the primary does. In that case the primary's first_pipe_instance fails after 1 s and it runs with no channel, while later launches hand their message (a URL or an activation token) to the squatter. The client already defaults to SECURITY_IDENTIFICATION, so the squatter cannot impersonate. The plan does not ask for this check. A follow-up could compare the token user of GetNamedPipeServerProcessId with the client's own SID.
  3. minor (interface deviations, for Task 33). next() is async and returns Option<(InstanceMessage, Reply)>, and SendOutcome gains Refused. Both are reasonable and documented. Task 33 must match Refused and the None that next() returns after the listener stops.
  4. minor. deliver answers busy when the queue is full (16 messages) or closed, but busy is documented as "shutting down". A sender then waits up to 10 s and stays a secondary. This is acceptable, but Task 33 should drain next() promptly.
  5. minor (Windows). wait_for_pid_exit treats any OpenProcess failure, including ACCESS_DENIED for a process running elevated or as another user, as "exited". On Unix, the kill -0 fallback without /proc treats EPERM the same way.
  6. minor. acquire_in and InstanceSender::send_frame build and drop a current-thread runtime in the caller's thread, so calling them from inside a tokio runtime panics. send documents this. acquire / wait_and_acquire only say that they need no runtime, not that they must not run inside one.

Checks

  • Plan tests: all 11 named tests exist (first_is_primary_second_is_secondary, message_arrives_and_is_answered, busy_answer, oversize_and_malformed_refused, slow_sender_times_out, stale_socket_replaced, wide_runtime_dir_refused, uid_check, released_on_close_and_on_drop, relaunch_waits_for_pid_then_acquires, update_lock_not_inherited). They assert the spec's values: 4 KiB (MAX_MESSAGE_BYTES = 4096, an oversize frame and a u32::MAX prefix both refused), the 2 s read limit, a 0700 directory, a 0600 socket, and refusal of a wide directory or a symlink.
  • Interfaces: acquire(&Path) -> io::Result<Instance>, Instance::{Primary, Secondary}, Reply::{ok, busy}, close(), send(&InstanceMessage, Duration) -> SendOutcome::{Ok, Busy, NoAnswer, +Refused}, wait_and_acquire(scope, limit), wait_for_pid_exit(pid, limit) -> bool, and UpdateLock::release() are all present.
  • Review Focus 4: on Unix, only the same uid is accepted (peer_cred on accept, and again on connect). On Windows, the DACL is D:P(A;;GA;;;<SID>), with reject_remote_clients and first_pipe_instance. Frames are at most 4096 bytes, and the codec refuses unknown kinds and fields. Nothing is executed. Logs carry only InstanceCodecError text and no message content or paths.
  • Unsafe code in windows.rs: I checked it against the windows 0.62.2 and tokio 1.54.1 signatures. The SID buffer is u64-aligned and stays alive until after it is used. The SID string and the security descriptor are each freed once with LocalFree. The descriptor outlives every pipe instance. The shadowed OwnedHandle token stays alive until the function returns. GetLastError is read right after CreateMutexW. The mutex and pipe handles are not inheritable. Every unsafe block has a SAFETY: comment.
  • Drain until EOF after the answer: it is bounded by READ_LIMIT, and the answer is read before the handle closes. OK.
  • Crate invariants: the change touches only fluxer-platform. The tokio net feature and Win32_Security_Authorization are each a single-line registration change. No secrets.
  • Parity with the fork: (a) the scope is the userData directory (fluxer_desktop/src/main/Bootstrap.ts:213-223: configureUserDataPath(), then requestSingleInstanceLock()); (b) second launches that arrive before the sink is set are buffered (ModuleBootHandoff.ts:94-112), which the mpsc queue does here; (c) the original ignores a launch while it is quitting, and the spec's busy answer replaces that. All three match.
  • Release before relaunch: the relaunch happens in apps/fluxer/src/update_rt.rs, and plan Task 33 says it "releases the instance and update locks before any relaunch". Leaving the call to Task 33 is correct.
  • Not run: the Windows tests. Charles must check them on the Windows runner after the fix.

Verdict: changes requested. One blocking finding (#1, the Windows clippy failure). Linux gate green.

## Independent review: Shell 17, platform single instance (fd598bf4) Scope: `git diff 2412c1d0..origin/shell-17-platform-single-instance`. **Local gate:** `FLUXER_SCREENSHOT_TESTS=1 cargo xtask ci` on fd598bf4: **all steps passed** (Linux). `tests/single_instance.rs`: 16/16 passed. The two unit tests passed too. ### Findings 1. **BLOCKING (Windows CI will be red).** `crates/fluxer-platform/tests/single_instance.rs:12` has `use std::path::{Path, PathBuf};`, but `Path` is only used inside the `#[cfg(unix)]` test `stale_socket_replaced` (line 326). On the Windows runner, `cargo xtask ci` runs `clippy --workspace --all-targets -D warnings`, so this becomes `error: unused import: Path`. I reproduced it with rustc 1.98.1 `--target x86_64-pc-windows-msvc -D warnings` on a minimal file with the same shape. Fix: use `std::path::Path` inside that test, or put the import behind `#[cfg(unix)]`. The other imports and items in the test file are used on Windows. 2. **minor (security hardening, Windows).** The client (`windows.rs::connect`) does not check who owns the pipe server. The pipe name is predictable, since a SID is not secret. Another local user could create `\\.\pipe\flaxative-<SID>-<hash>` before the primary does. In that case the primary's `first_pipe_instance` fails after 1 s and it runs with no channel, while later launches hand their message (a URL or an activation token) to the squatter. The client already defaults to `SECURITY_IDENTIFICATION`, so the squatter cannot impersonate. The plan does not ask for this check. A follow-up could compare the token user of `GetNamedPipeServerProcessId` with the client's own SID. 3. **minor (interface deviations, for Task 33).** `next()` is async and returns `Option<(InstanceMessage, Reply)>`, and `SendOutcome` gains `Refused`. Both are reasonable and documented. Task 33 must match `Refused` and the `None` that `next()` returns after the listener stops. 4. **minor.** `deliver` answers `busy` when the queue is full (16 messages) or closed, but `busy` is documented as "shutting down". A sender then waits up to 10 s and stays a secondary. This is acceptable, but Task 33 should drain `next()` promptly. 5. **minor (Windows).** `wait_for_pid_exit` treats any `OpenProcess` failure, including ACCESS_DENIED for a process running elevated or as another user, as "exited". On Unix, the `kill -0` fallback without `/proc` treats EPERM the same way. 6. **minor.** `acquire_in` and `InstanceSender::send_frame` build and drop a current-thread runtime in the caller's thread, so calling them from inside a tokio runtime panics. `send` documents this. `acquire` / `wait_and_acquire` only say that they need no runtime, not that they must not run inside one. ### Checks - Plan tests: all 11 named tests exist (`first_is_primary_second_is_secondary`, `message_arrives_and_is_answered`, `busy_answer`, `oversize_and_malformed_refused`, `slow_sender_times_out`, `stale_socket_replaced`, `wide_runtime_dir_refused`, `uid_check`, `released_on_close_and_on_drop`, `relaunch_waits_for_pid_then_acquires`, `update_lock_not_inherited`). They assert the spec's values: 4 KiB (`MAX_MESSAGE_BYTES` = 4096, an oversize frame and a `u32::MAX` prefix both refused), the 2 s read limit, a 0700 directory, a 0600 socket, and refusal of a wide directory or a symlink. - Interfaces: `acquire(&Path) -> io::Result<Instance>`, `Instance::{Primary, Secondary}`, `Reply::{ok, busy}`, `close()`, `send(&InstanceMessage, Duration) -> SendOutcome::{Ok, Busy, NoAnswer, +Refused}`, `wait_and_acquire(scope, limit)`, `wait_for_pid_exit(pid, limit) -> bool`, and `UpdateLock::release()` are all present. - Review Focus 4: on Unix, only the same uid is accepted (`peer_cred` on accept, and again on connect). On Windows, the DACL is `D:P(A;;GA;;;<SID>)`, with `reject_remote_clients` and `first_pipe_instance`. Frames are at most 4096 bytes, and the codec refuses unknown kinds and fields. Nothing is executed. Logs carry only `InstanceCodecError` text and no message content or paths. - Unsafe code in windows.rs: I checked it against the windows 0.62.2 and tokio 1.54.1 signatures. The SID buffer is u64-aligned and stays alive until after it is used. The SID string and the security descriptor are each freed once with `LocalFree`. The descriptor outlives every pipe instance. The shadowed `OwnedHandle` token stays alive until the function returns. `GetLastError` is read right after `CreateMutexW`. The mutex and pipe handles are not inheritable. Every unsafe block has a `SAFETY:` comment. - Drain until EOF after the answer: it is bounded by `READ_LIMIT`, and the answer is read before the handle closes. OK. - Crate invariants: the change touches only fluxer-platform. The tokio `net` feature and `Win32_Security_Authorization` are each a single-line registration change. No secrets. - Parity with the fork: (a) the scope is the userData directory (`fluxer_desktop/src/main/Bootstrap.ts:213-223`: `configureUserDataPath()`, then `requestSingleInstanceLock()`); (b) second launches that arrive before the sink is set are buffered (`ModuleBootHandoff.ts:94-112`), which the mpsc queue does here; (c) the original ignores a launch while it is quitting, and the spec's `busy` answer replaces that. All three match. - Release before relaunch: the relaunch happens in `apps/fluxer/src/update_rt.rs`, and plan Task 33 says it "releases the instance and update locks before any relaunch". Leaving the call to Task 33 is correct. - Not run: the Windows tests. Charles must check them on the Windows runner after the fix. **Verdict: changes requested.** One blocking finding (#1, the Windows clippy failure). Linux gate green.
- tests: `Path` imported only by the Unix test that uses it (Windows clippy
  -D warnings: unused import).
- A full message queue is answered `error` (Refused) instead of `busy`, which
  stays for a stopped listener (shutting down).
- `acquire_in` and `send_frame` called inside an async runtime run their own
  runtime on a thread of their own instead of panicking.
- `wait_for_pid_exit`: ACCESS_DENIED from OpenProcess (an elevated or another
  user's process) counts as running on Windows; without /proc, Unix asks `ps`
  instead of `kill -0` (EPERM).

Refs #809

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0161qMQMsCyJhjYw4gqa6e4K
Author
Owner

Review round 1 addressed in c84f8bed (cargo xtask ci green locally with FLUXER_SCREENSHOT_TESTS=1).

Blocking

  • tests/single_instance.rs unused Path on Windows: the import is now use std::path::PathBuf; only; the Unix-only stale_socket_replaced names std::path::Path in its closure.

Minor

  • Pipe server owner not verified (windows.rs): deferred to follow-up #896 (check the server process token SID via GetNamedPipeServerProcessId; needs a new windows feature and a Windows-runner test).
  • Interface deviations (next() -> Option<(InstanceMessage, Reply)>, SendOutcome::Refused): kept on purpose (None once the listener stopped; Refused for a malformed or refused message, which must not make the sender wait for the lock). Task 33 must treat None as "no more messages" and Refused like a failed hand-off (exit without waiting). Both are documented in the crate README.
  • busy on a full or closed queue: split. A closed queue (listener stopped, shutting down) still answers busy; a full queue (client running but not taking messages) now answers error (SendOutcome::Refused), so the sender does not wait 10 s for a lock it will not get. Test first: full_queue_refuses_closed_queue_is_busy (unit test of deliver). Docs of SendOutcome::{Busy, Refused} and the README updated.
  • wait_for_pid_exit and denied access: Windows now treats ERROR_ACCESS_DENIED from OpenProcess as running and polls until the process is gone or the limit passes (then waits on the handle with the remaining time). Unix without /proc now asks ps -p <pid> -o stat= (lists every user process; zombies count as ended) instead of kill -0, which cannot tell EPERM from ESRCH. Tests: unix::tests::{ps_states, other_users_process_is_alive} (pid 1 through both paths). The Windows branch is compiled and linted by the Windows runner only.
  • acquire_in / send_frame inside a tokio runtime: they now run their own runtime on a scoped thread of their own when Handle::try_current() succeeds, instead of panicking (the caller thread still blocks, as documented). Test first: usable_inside_a_runtime (failed with "Cannot start a runtime from within a runtime" before the fix).
Review round 1 addressed in c84f8bed (`cargo xtask ci` green locally with `FLUXER_SCREENSHOT_TESTS=1`). **Blocking** - `tests/single_instance.rs` unused `Path` on Windows: the import is now `use std::path::PathBuf;` only; the Unix-only `stale_socket_replaced` names `std::path::Path` in its closure. **Minor** - Pipe server owner not verified (windows.rs): deferred to follow-up #896 (check the server process token SID via `GetNamedPipeServerProcessId`; needs a new `windows` feature and a Windows-runner test). - Interface deviations (`next() -> Option<(InstanceMessage, Reply)>`, `SendOutcome::Refused`): kept on purpose (`None` once the listener stopped; `Refused` for a malformed or refused message, which must not make the sender wait for the lock). Task 33 must treat `None` as "no more messages" and `Refused` like a failed hand-off (exit without waiting). Both are documented in the crate README. - `busy` on a full or closed queue: split. A closed queue (listener stopped, shutting down) still answers `busy`; a full queue (client running but not taking messages) now answers `error` (`SendOutcome::Refused`), so the sender does not wait 10 s for a lock it will not get. Test first: `full_queue_refuses_closed_queue_is_busy` (unit test of `deliver`). Docs of `SendOutcome::{Busy, Refused}` and the README updated. - `wait_for_pid_exit` and denied access: Windows now treats `ERROR_ACCESS_DENIED` from `OpenProcess` as running and polls until the process is gone or the limit passes (then waits on the handle with the remaining time). Unix without `/proc` now asks `ps -p <pid> -o stat=` (lists every user process; zombies count as ended) instead of `kill -0`, which cannot tell EPERM from ESRCH. Tests: `unix::tests::{ps_states, other_users_process_is_alive}` (pid 1 through both paths). The Windows branch is compiled and linted by the Windows runner only. - `acquire_in` / `send_frame` inside a tokio runtime: they now run their own runtime on a scoped thread of their own when `Handle::try_current()` succeeds, instead of panicking (the caller thread still blocks, as documented). Test first: `usable_inside_a_runtime` (failed with "Cannot start a runtime from within a runtime" before the fix).
Author
Owner

Independent review, round 2: Shell 17, platform single instance (c84f8bed)

Scope: git diff 2412c1d0..origin/shell-17-platform-single-instance (fd598bf4 + c84f8bed).

Local gate: FLUXER_SCREENSHOT_TESTS=1 cargo xtask ci on c84f8bed, run twice in the review worktree:

  • Run 1: red. Step test failed in fluxer-platform --lib: update::lock::tests::one_holder_at_a_time_and_released_on_drop panicked at crates/fluxer-platform/src/update/lock.rs:78:14: free after drop. The other 50 lib tests passed.
  • Run 2 (no change): all steps passed. tests/single_instance.rs 17/17; the lib tests full_queue_refuses_closed_queue_is_busy, ps_states, other_users_process_is_alive and dropped_reply_answers_error passed. Three separate runs of cargo test -p fluxer-platform --lib also passed.

Windows: I type-checked the Windows code here. I made a stub crate holding single_instance/{mod,unix,windows}.rs and tests/single_instance.rs unchanged, with fluxer-core from this branch and windows 0.62.2 (Win32_Foundation, Win32_Security, Win32_System_Threading, Win32_Security_Authorization), on toolchain 1.98.1. cargo clippy --target x86_64-pc-windows-msvc --all-targets -- -D warnings is clean for the lib and the integration test. A deliberate type error in windows.rs was reported, so the cfg(windows) code really was checked. Not linked and not run.

Findings

  1. BLOCKING (CI flaky red). update/lock.rs:76-78. The new assertion takes the update lock again right after drop(first) and expects it free at once. Tests in the same lib test binary start child processes on other threads: the new single_instance::unix::tests::other_users_process_is_alive runs ps up to three times, and desktop_entry::linux::tests::missing_tool_is_an_error_not_a_hang spawns too. A child forked in that window shares the flock's open file description until it execs, so the lock is briefly still held. That is the same race that primary_soon in tests/single_instance.rs already documents and works around. It failed in my first gate run. Fix: retry the post-drop and post-release acquisitions for a short bounded time, as primary_soon / update_lock_not_inherited do. Do not assert immediate availability inside a binary whose tests spawn processes.
  2. minor (for Task 33, carried over). next() is async and returns Option<…>, and SendOutcome gains Refused. Both are documented in the README and in PR comment 8929, and the spec allows error (§7.2). Task 33 must build against the code: None means no more messages, and Refused means exit without waiting for the lock.
  3. minor (Windows, deferred). The client does not verify the pipe server's owner. It is tracked in follow-up #896 (label follow-up), which is acceptable: the DACL, FILE_FLAG_FIRST_PIPE_INSTANCE, PIPE_REJECT_REMOTE_CLIENTS and the SID in the name are all present, and a primary that fails to create the first instance drops its mutex, so later launches do not reach a squatter in the usual case.
  4. minor (Task 33 note). ANSWER_LIMIT is 5 s, but spec §7.2 has the secondary give up after 2 s with no answer. A primary that answers between 2 s and 5 s is therefore treated as NoAnswer, and the sender waits for the lock. Task 33 should answer promptly or use a send limit that agrees.

Checks

  • (1) Plan tests: all 11 named tests exist: first_is_primary_second_is_secondary, message_arrives_and_is_answered, busy_answer, oversize_and_malformed_refused, slow_sender_times_out, stale_socket_replaced (unix), wide_runtime_dir_refused (unix), uid_check, released_on_close_and_on_drop, relaunch_waits_for_pid_then_acquires, update_lock_not_inherited (unix; on Windows std handles are not inheritable). They use the spec's values: 4096 bytes (MAX_FRAME_BYTES = MAX_MESSAGE_BYTES; an oversize frame and a u32::MAX prefix both answered error), READ_LIMIT 2 s, directory 0700, socket 0600, and refusal of a wide directory (0755/0750/0707/0777) or a symlink. The round-1 fixes also have tests.
  • (2) Interfaces: acquire(&Path) -> io::Result<Instance>, Instance::{Primary(InstanceListener), Secondary(InstanceSender)}, Reply::{ok, busy} (dropped = error), InstanceListener::close, InstanceSender::send(&InstanceMessage, Duration) -> SendOutcome::{Ok, Busy, NoAnswer, +Refused}, wait_and_acquire(scope, limit), wait_for_pid_exit(pid, limit) -> bool, and UpdateLock::release. They match the plan apart from the documented deviations in finding 2.
  • (3) Invariants: the work stays in fluxer-platform and fluxer-core is untouched. The only new dependencies are tokio net and the windows Win32_Security_Authorization feature, both named by the plan and spec §5.5. Logs carry no message content (InstanceCodecError carries none), no paths and no keys; Debug of the listener, sender and reply is opaque. A decode error cannot panic: frames are length-checked before allocation, and every error is answered or closes the connection. Every unsafe block has a SAFETY: comment. No secrets.
  • (4) Parity (fork fluxer_desktop/src/main):
    • Bootstrap.ts:219-223 / index.ts:374-376: the lock is taken early and the loser forwards and quits, which matches Instance::Secondary plus send.
    • Electron's lock is per userData directory, which matches scope = the data directory.
    • DeepLinks.ts:223-242: the second-instance kinds update → task → link → show map onto UpdateRelaunch, Task, OpenUrl and Activate, all carried and tested in message_arrives_and_is_answered.
    • ModuleBootHandoff.ts:94-112: second instances are buffered until the sink is armed, which matches the bounded queue of 16 held until next().
  • (5) Review Focus 4:
    • Current user only: SO_PEERCRED is checked on both ends against the uid from a socket pair, and on Windows the user-only DACL D:P(A;;GA;;;<SID>) and remote clients are rejected.
    • Messages: only well-formed ones of at most 4 KiB, read within 2 s.
    • Nothing is executed or used as a path; unknown kinds, unknown tasks and extra fields are refused by the codec (tested with {"kind":"run",…} and {"kind":"task","task":"format-disk"}).
    • A stale socket is replaced only while the lock is held, and the primary removes its socket before releasing the lock.
  • (6) Gate: as above. Run 1 was red from finding 1 and run 2 was green.

Verdict: changes requested. One blocking finding: the flaky update-lock unit test (finding 1). Everything else is ready. With the lock test made tolerant of the fork window, I would approve.

## Independent review, round 2: Shell 17, platform single instance (c84f8bed) Scope: `git diff 2412c1d0..origin/shell-17-platform-single-instance` (fd598bf4 + c84f8bed). **Local gate:** `FLUXER_SCREENSHOT_TESTS=1 cargo xtask ci` on c84f8bed, run twice in the review worktree: - Run 1: **red**. Step `test` failed in `fluxer-platform --lib`: `update::lock::tests::one_holder_at_a_time_and_released_on_drop` panicked at `crates/fluxer-platform/src/update/lock.rs:78:14`: `free after drop`. The other 50 lib tests passed. - Run 2 (no change): **all steps passed**. `tests/single_instance.rs` 17/17; the lib tests `full_queue_refuses_closed_queue_is_busy`, `ps_states`, `other_users_process_is_alive` and `dropped_reply_answers_error` passed. Three separate runs of `cargo test -p fluxer-platform --lib` also passed. **Windows:** I type-checked the Windows code here. I made a stub crate holding `single_instance/{mod,unix,windows}.rs` and `tests/single_instance.rs` unchanged, with `fluxer-core` from this branch and `windows` 0.62.2 (`Win32_Foundation`, `Win32_Security`, `Win32_System_Threading`, `Win32_Security_Authorization`), on toolchain 1.98.1. `cargo clippy --target x86_64-pc-windows-msvc --all-targets -- -D warnings` is **clean** for the lib and the integration test. A deliberate type error in `windows.rs` was reported, so the cfg(windows) code really was checked. Not linked and not run. ### Findings 1. **BLOCKING (CI flaky red).** `update/lock.rs:76-78`. The new assertion takes the update lock again right after `drop(first)` and expects it free at once. Tests in the same lib test binary start child processes on other threads: the new `single_instance::unix::tests::other_users_process_is_alive` runs `ps` up to three times, and `desktop_entry::linux::tests::missing_tool_is_an_error_not_a_hang` spawns too. A child forked in that window shares the `flock`'s open file description until it `exec`s, so the lock is briefly still held. That is the same race that `primary_soon` in `tests/single_instance.rs` already documents and works around. It failed in my first gate run. Fix: retry the post-drop and post-`release` acquisitions for a short bounded time, as `primary_soon` / `update_lock_not_inherited` do. Do not assert immediate availability inside a binary whose tests spawn processes. 2. **minor (for Task 33, carried over).** `next()` is `async` and returns `Option<…>`, and `SendOutcome` gains `Refused`. Both are documented in the README and in PR comment 8929, and the spec allows `error` (§7.2). Task 33 must build against the code: `None` means no more messages, and `Refused` means exit without waiting for the lock. 3. **minor (Windows, deferred).** The client does not verify the pipe server's owner. It is tracked in follow-up #896 (label `follow-up`), which is acceptable: the DACL, `FILE_FLAG_FIRST_PIPE_INSTANCE`, `PIPE_REJECT_REMOTE_CLIENTS` and the SID in the name are all present, and a primary that fails to create the first instance drops its mutex, so later launches do not reach a squatter in the usual case. 4. **minor (Task 33 note).** `ANSWER_LIMIT` is 5 s, but spec §7.2 has the secondary give up after 2 s with no answer. A primary that answers between 2 s and 5 s is therefore treated as NoAnswer, and the sender waits for the lock. Task 33 should answer promptly or use a send limit that agrees. ### Checks - **(1) Plan tests:** all 11 named tests exist: `first_is_primary_second_is_secondary`, `message_arrives_and_is_answered`, `busy_answer`, `oversize_and_malformed_refused`, `slow_sender_times_out`, `stale_socket_replaced` (unix), `wide_runtime_dir_refused` (unix), `uid_check`, `released_on_close_and_on_drop`, `relaunch_waits_for_pid_then_acquires`, `update_lock_not_inherited` (unix; on Windows `std` handles are not inheritable). They use the spec's values: 4096 bytes (`MAX_FRAME_BYTES` = `MAX_MESSAGE_BYTES`; an oversize frame and a `u32::MAX` prefix both answered `error`), `READ_LIMIT` 2 s, directory 0700, socket 0600, and refusal of a wide directory (0755/0750/0707/0777) or a symlink. The round-1 fixes also have tests. - **(2) Interfaces:** `acquire(&Path) -> io::Result<Instance>`, `Instance::{Primary(InstanceListener), Secondary(InstanceSender)}`, `Reply::{ok, busy}` (dropped = `error`), `InstanceListener::close`, `InstanceSender::send(&InstanceMessage, Duration) -> SendOutcome::{Ok, Busy, NoAnswer, +Refused}`, `wait_and_acquire(scope, limit)`, `wait_for_pid_exit(pid, limit) -> bool`, and `UpdateLock::release`. They match the plan apart from the documented deviations in finding 2. - **(3) Invariants:** the work stays in `fluxer-platform` and `fluxer-core` is untouched. The only new dependencies are tokio `net` and the `windows` `Win32_Security_Authorization` feature, both named by the plan and spec §5.5. Logs carry no message content (`InstanceCodecError` carries none), no paths and no keys; `Debug` of the listener, sender and reply is opaque. A decode error cannot panic: frames are length-checked before allocation, and every error is answered or closes the connection. Every `unsafe` block has a `SAFETY:` comment. No secrets. - **(4) Parity** (fork `fluxer_desktop/src/main`): - `Bootstrap.ts:219-223` / `index.ts:374-376`: the lock is taken early and the loser forwards and quits, which matches `Instance::Secondary` plus send. - Electron's lock is per userData directory, which matches scope = the data directory. - `DeepLinks.ts:223-242`: the second-instance kinds update → task → link → show map onto `UpdateRelaunch`, `Task`, `OpenUrl` and `Activate`, all carried and tested in `message_arrives_and_is_answered`. - `ModuleBootHandoff.ts:94-112`: second instances are buffered until the sink is armed, which matches the bounded queue of 16 held until `next()`. - **(5) Review Focus 4:** - Current user only: `SO_PEERCRED` is checked on both ends against the uid from a socket pair, and on Windows the user-only DACL `D:P(A;;GA;;;<SID>)` and remote clients are rejected. - Messages: only well-formed ones of at most 4 KiB, read within 2 s. - Nothing is executed or used as a path; unknown kinds, unknown tasks and extra fields are refused by the codec (tested with `{"kind":"run",…}` and `{"kind":"task","task":"format-disk"}`). - A stale socket is replaced only while the lock is held, and the primary removes its socket before releasing the lock. - **(6) Gate:** as above. Run 1 was red from finding 1 and run 2 was green. **Verdict: changes requested.** One blocking finding: the flaky update-lock unit test (finding 1). Everything else is ready. With the lock test made tolerant of the fork window, I would approve.
The lock test expected the flock free right after drop, but other tests in the
same binary fork child processes that share the open file until they exec. It
now retries for a bounded time after drop and after release.

Docs: ANSWER_LIMIT vs the second launch's 2 s limit, and Refused means exit
without waiting for the lock.

Refs #809

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0161qMQMsCyJhjYw4gqa6e4K
Author
Owner

Round 2 fixes (3ee93d87):

  • Blocking, update/lock.rs flaky test: one_holder_at_a_time_and_released_on_drop now retries the post-drop and post-release acquisitions for up to 5 s (acquire_soon), since a child forked by another test shares the open lock file until it execs. Local FLUXER_SCREENSHOT_TESTS=1 cargo xtask ci green.
  • Minor, interface deviations (next() async/Option, SendOutcome::Refused): already documented on next(); Refused docs now state the second launch exits without waiting for the lock. Task 33 should treat None as no more messages.
  • Minor, Windows pipe server owner SID: unchanged, deferred to follow-up #896.
  • Minor, ANSWER_LIMIT 5 s vs 2 s secondary: value kept; its doc now says the app answers each message at once (before acting on it) or gives the sender a send limit at least this long. For Task 33.

🤖 Generated with Claude Code

Round 2 fixes (3ee93d87): - **Blocking, `update/lock.rs` flaky test**: `one_holder_at_a_time_and_released_on_drop` now retries the post-drop and post-release acquisitions for up to 5 s (`acquire_soon`), since a child forked by another test shares the open lock file until it execs. Local `FLUXER_SCREENSHOT_TESTS=1 cargo xtask ci` green. - **Minor, interface deviations (`next()` async/Option, `SendOutcome::Refused`)**: already documented on `next()`; `Refused` docs now state the second launch exits without waiting for the lock. Task 33 should treat `None` as no more messages. - **Minor, Windows pipe server owner SID**: unchanged, deferred to follow-up #896. - **Minor, `ANSWER_LIMIT` 5 s vs 2 s secondary**: value kept; its doc now says the app answers each message at once (before acting on it) or gives the sender a send limit at least this long. For Task 33. 🤖 Generated with [Claude Code](https://claude.com/claude-code)
Author
Owner

Independent review: Shell 17 (platform single instance), commit 3ee93d87

Scope: git diff 2412c1d0..origin/shell-17-platform-single-instance (single_instance/{mod,unix,windows}.rs, update/lock.rs, tests/single_instance.rs, Cargo.toml, lib.rs, README).

Checks

  1. Plan tests. All 11 tests the plan names are present and assert what it says: first_is_primary_second_is_secondary, message_arrives_and_is_answered, busy_answer, oversize_and_malformed_refused (4 KiB + 1, a u32::MAX length prefix, malformed JSON, unknown kinds and tasks, extra fields), slow_sender_times_out (2 s READ_LIMIT, others still served), stale_socket_replaced (checks socket 0600 and dir 0700), wide_runtime_dir_refused (0755/0750/0707/0777 and a symlink), uid_check, released_on_close_and_on_drop, relaunch_waits_for_pid_then_acquires (a real child process), update_lock_not_inherited. The extras cover use inside a runtime, no primary, and the wait_and_acquire limit and takeover.
  2. Interfaces. acquire, Instance::{Primary, Secondary}, Reply::{ok, busy}, close, send(&InstanceMessage, limit), wait_and_acquire, wait_for_pid_exit exist. Two differences from the plan's block are listed under minor findings.
  3. Invariants. The change stays in fluxer-platform. The only dependency changes are tokio net and the windows feature Win32_Security_Authorization, both named by the task. No secrets or paths in logs. Message contents are never logged: errors are InstanceCodecError's fixed strings. Nothing from a message is executed or used as a path. A malformed frame cannot panic the client: reads are bounded and every error is mapped.
  4. Parity (fluxer-soundboard). fluxer_desktop/src/main/Bootstrap.ts:219-223: the lock is taken after configureUserDataPath(), so it is scoped to the data directory, as acquire(scope) is here. When the lock is lost, the launch is forwarded and that process quits, which matches Secondary. ModuleBootHandoff.ts:90-112: second launches are buffered until the sink is set, which matches the queue of 16 waiting for next(). During quit the original ignores a second launch; here it is answered busy and the sender takes over, the deviation spec §7.2 asks for (#754).
  5. Review Focus 4. Same user only: SO_PEERCRED is checked on both ends, the directory must be 0700 and the user's own, not a link, and the socket is 0600. On Windows the pipe is created as the first instance, rejects remote clients, has the DACL D:P(A;;GA;;;SID) and carries the SID in its name. Only well-formed messages of at most 4 KiB reach the client, and nothing in them is executed.
  6. Gate. FLUXER_SCREENSHOT_TESTS=1 cargo xtask ci run locally in the review worktree: all steps passed (EXIT=0). This includes tests/single_instance.rs and update::lock::tests::one_holder_at_a_time_and_released_on_drop. As an extra check for the Windows code, cargo clippy -p fluxer-platform --target x86_64-pc-windows-gnu --all-targets -- -D warnings is clean. This is the mingw target, not the MSVC runner, but the cfg(windows) code is the same.

Findings

  • minor (interface, for Task 33). Two signatures differ from the plan's block, both documented in the README and the doc comments. InstanceListener::next() is async and returns Option<(InstanceMessage, Reply)>, with None once the listener has stopped. SendOutcome has a fourth variant, Refused (malformed, queue full or reply dropped: exit without waiting). Task 33's match must handle Refused. Neither difference breaks code that is merged today.
  • minor (Task 33 contract). If the app does not answer a message within ANSWER_LIMIT (5 s), the connection closes without an answer, but the message stays queued and is delivered to the client later. The sender has already seen NoAnswer after 2 s and gone into wait_and_acquire. Task 33 must take next() and answer straight away, before acting, as the ANSWER_LIMIT doc now says. Otherwise a slow-starting primary can act on a launch whose sender believes it failed.
  • minor (Windows hardening, tracked). Local\Flaxative-<hash> is created without an owner check, so a different user in the same logon session could hold the mutex and turn our launches into secondaries (DoS only: the pipe name carries our SID and its DACL is ours). This is already deferred to #896.

Verdict: approved. No blocking findings, and the local gate is green.

## Independent review: Shell 17 (platform single instance), commit 3ee93d87 Scope: `git diff 2412c1d0..origin/shell-17-platform-single-instance` (single_instance/{mod,unix,windows}.rs, update/lock.rs, tests/single_instance.rs, Cargo.toml, lib.rs, README). **Checks** 1. **Plan tests.** All 11 tests the plan names are present and assert what it says: `first_is_primary_second_is_secondary`, `message_arrives_and_is_answered`, `busy_answer`, `oversize_and_malformed_refused` (4 KiB + 1, a `u32::MAX` length prefix, malformed JSON, unknown kinds and tasks, extra fields), `slow_sender_times_out` (2 s `READ_LIMIT`, others still served), `stale_socket_replaced` (checks socket 0600 and dir 0700), `wide_runtime_dir_refused` (0755/0750/0707/0777 and a symlink), `uid_check`, `released_on_close_and_on_drop`, `relaunch_waits_for_pid_then_acquires` (a real child process), `update_lock_not_inherited`. The extras cover use inside a runtime, no primary, and the `wait_and_acquire` limit and takeover. 2. **Interfaces.** `acquire`, `Instance::{Primary, Secondary}`, `Reply::{ok, busy}`, `close`, `send(&InstanceMessage, limit)`, `wait_and_acquire`, `wait_for_pid_exit` exist. Two differences from the plan's block are listed under minor findings. 3. **Invariants.** The change stays in `fluxer-platform`. The only dependency changes are tokio `net` and the windows feature `Win32_Security_Authorization`, both named by the task. No secrets or paths in logs. Message contents are never logged: errors are `InstanceCodecError`'s fixed strings. Nothing from a message is executed or used as a path. A malformed frame cannot panic the client: reads are bounded and every error is mapped. 4. **Parity (fluxer-soundboard).** `fluxer_desktop/src/main/Bootstrap.ts:219-223`: the lock is taken after `configureUserDataPath()`, so it is scoped to the data directory, as `acquire(scope)` is here. When the lock is lost, the launch is forwarded and that process quits, which matches `Secondary`. `ModuleBootHandoff.ts:90-112`: second launches are buffered until the sink is set, which matches the queue of 16 waiting for `next()`. During quit the original ignores a second launch; here it is answered `busy` and the sender takes over, the deviation spec §7.2 asks for (#754). 5. **Review Focus 4.** Same user only: SO_PEERCRED is checked on both ends, the directory must be 0700 and the user's own, not a link, and the socket is 0600. On Windows the pipe is created as the first instance, rejects remote clients, has the DACL `D:P(A;;GA;;;SID)` and carries the SID in its name. Only well-formed messages of at most 4 KiB reach the client, and nothing in them is executed. 6. **Gate.** `FLUXER_SCREENSHOT_TESTS=1 cargo xtask ci` run locally in the review worktree: **all steps passed** (EXIT=0). This includes `tests/single_instance.rs` and `update::lock::tests::one_holder_at_a_time_and_released_on_drop`. As an extra check for the Windows code, `cargo clippy -p fluxer-platform --target x86_64-pc-windows-gnu --all-targets -- -D warnings` is clean. This is the mingw target, not the MSVC runner, but the cfg(windows) code is the same. **Findings** - **minor (interface, for Task 33).** Two signatures differ from the plan's block, both documented in the README and the doc comments. `InstanceListener::next()` is async and returns `Option<(InstanceMessage, Reply)>`, with `None` once the listener has stopped. `SendOutcome` has a fourth variant, `Refused` (malformed, queue full or reply dropped: exit without waiting). Task 33's `match` must handle `Refused`. Neither difference breaks code that is merged today. - **minor (Task 33 contract).** If the app does not answer a message within `ANSWER_LIMIT` (5 s), the connection closes without an answer, but the message stays queued and is delivered to the client later. The sender has already seen `NoAnswer` after 2 s and gone into `wait_and_acquire`. Task 33 must take `next()` and answer straight away, before acting, as the `ANSWER_LIMIT` doc now says. Otherwise a slow-starting primary can act on a launch whose sender believes it failed. - **minor (Windows hardening, tracked).** `Local\Flaxative-<hash>` is created without an owner check, so a different user in the same logon session could hold the mutex and turn our launches into secondaries (DoS only: the pipe name carries our SID and its DACL is ours). This is already deferred to #896. **Verdict: approved.** No blocking findings, and the local gate is green.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Author
Owner

Merged into shell by hand (the merge API returns 405); the commits are in the branch.

Merged into `shell` by hand (the merge API returns 405); the commits are in the branch.
charles closed this pull request 2026-11-18 19:02:37 +00:00

Pull request closed

Sign in to join this conversation.
No description provided.