On feat/gemini-branch-ux-polish: gemini ux-polish WIP: viewer-list/kick/notifications/tray (review baseline)

index on feat/gemini-branch-ux-polish: e8f86b0 feat(gui): focus the viewer code field when the View screen opens
untracked files on feat/gemini-branch-ux-polish: e8f86b0 feat(gui): focus the viewer code field when the View screen opens
2026-05-25 15:20:10 -04:00 · 2026-05-25 15:20:10 -04:00 · 2026-05-25 15:20:10 -04:00
44 changed files with 1030 additions and 5167 deletions
@@ -34,32 +34,9 @@ ureq = { version = "3", default-features = false, features = ["rustls"] }
 toml = "1"
 chrono = { version = "0.4", default-features = false, features = ["clock", "serde"] }
 eframe = { version = "0.34.2", default-features = false, features = ["glow", "default_fonts", "wayland", "x11"], optional = true }
-# Desktop notifications on viewer join/leave. Default features give the
+tray-icon = { version = "0.24.0", optional = true }
-# pure-Rust zbus backend (no system libdbus, no image crate).
+notify-rust = { version = "4.17.0", optional = true }
-notify-rust = { version = "4", optional = true }
+gtk = { version = "0.18.2", optional = true }
 # System-tray icon (StatusNotifierItem over D-Bus). Pure-Rust, riding the same
 # zbus stack notify-rust already pulls — no GTK, no libappindicator/C libdbus.
 ksni = { version = "0.3", optional = true }
 # Hand-rolled windowing stack for the GUI (replaces eframe::run_native) so we
 # can drop the OS window on "hide to tray" — the only way to truly hide a
 # toplevel on Wayland — and recreate it on Show. All of these are already pulled
 # in transitively by eframe; making them direct adds no new crates to vet.
 # eframe is kept for its egui re-export + icon_data PNG decoder. egui_glow needs
 # its (non-default) `winit` feature for the `EguiGlow` integration type; eframe
 # pulls egui_glow but without that feature, so we enable it here.
 egui_glow = { version = "0.34.2", default-features = false, features = ["winit", "wayland", "x11"], optional = true }
 # winit's default set minus `wayland-csd-adwaita`: KWin (and most desktop
 # compositors) draw server-side decorations, and eframe never enabled CSD
 # either, so dropping it keeps the dependency tree identical to before (no
 # sctk-adwaita / tiny-skia / ttf-parser pulled in just for a fallback titlebar).
 winit = { version = "0.30", default-features = false, features = ["rwh_06", "x11", "wayland", "wayland-dlopen"], optional = true }
 glutin = { version = "0.32", optional = true }
 glutin-winit = { version = "0.5", optional = true }
 # QR-encode the host ticket so a phone (or a second laptop with a webcam) can
 # pick it up without typing 140 chars. default-features = false to skip the
 # `image` crate dep tree — we render the modules to an `egui::ColorImage`
 # directly.
 qrcode = { version = "0.14", default-features = false, optional = true }
 [profile.release]
 lto = "thin"
@@ -69,4 +46,4 @@ strip = "symbols"
 [features]
 # Opt-in graphical front-end (pixelpass --gui). Default-off so the headless
 # build never pulls the GUI toolkit tree.
-gui = ["dep:eframe", "dep:notify-rust", "dep:ksni", "dep:egui_glow", "dep:winit", "dep:glutin", "dep:glutin-winit", "dep:qrcode"]
+gui = ["dep:eframe", "dep:tray-icon", "dep:notify-rust", "dep:gtk"]
@@ -1,202 +0,0 @@
                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/
   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
   1. Definitions.
      "License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.
      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.
      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.
      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.
      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.
      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.
      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).
      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.
      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."
      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.
   2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.
   3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.
   4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:
      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and
      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and
      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and
      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.
      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.
   5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.
   6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.
   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.
   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.
   9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.
   END OF TERMS AND CONDITIONS
   APPENDIX: How to apply the Apache License to your work.
      To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "[]"
      replaced with your own identifying information. (Don't include
      the brackets!)  The text should be enclosed in the appropriate
      comment syntax for the file format. We also recommend that a
      file or class name and description of purpose be included on the
      same "printed page" as the copyright notice for easier
      identification within third-party archives.
   Copyright 2026 mollusk
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
       http://www.apache.org/licenses/LICENSE-2.0
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
@@ -1,21 +0,0 @@
 MIT License
 Copyright (c) 2026 mollusk
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
@@ -83,15 +83,8 @@ pixelpass --gui
 ```
 Host: pick quality / max-viewers / options, click **Start hosting**, and the
-share code appears with a copy button. Connected viewers are listed with a
+share code appears with a copy button alongside a live viewer count. View:
-**Kick** button each, and a desktop notification fires as they join or leave.
+paste a code, pick mpv or VLC, click **Connect** and the player launches.
 View: paste a code, pick mpv or VLC, click **Connect** and the player launches.
 A system-tray icon shows current status. **Settings → "Keep running in the
 tray when I close the window"** (off by default) makes the close button hide
 the window — truly, by dropping it — while any active stream keeps running in
 the child; reopen it from the tray. (Plain close still quits when the option is
 off, or when no system tray is present.)
 The window is a thin driver — it runs the same headless `pixelpass` as a
 child process and reads its event stream, so the GUI is purely additive and
@@ -223,65 +216,6 @@ measured_at = "2026-05-21T20:41:16Z"
 - Skip is sticky — once you skip the test, pixelpass won't ask again
  unless you reconfigure.
 ## Relay
 By default pixelpass uses iroh's bundled relay servers to coordinate the
 P2P connection (peers still hole-punch a direct UDP path when they can; the
 relay is the fallback and the rendezvous point). You can point it at a
 different relay — a self-hosted one, or n0's staging/production servers —
 with either:
 ```bash
 pixelpass --relay https://relay.example/            # host or viewer
 PIXELPASS_RELAY=https://relay.example/ pixelpass …  # env-var form
 ```
 The flag applies to both host and viewer and takes precedence over the
 environment variable. The env-var form is handy for the `--gui` front-end,
 since the GUI's child host/viewer processes inherit it; the `--gui --relay`
 flag form is forwarded to them too. Both ends must use the same relay to
 find each other.
 ## Themes
 The `--gui` front-end ships three colour themes — **Default Dark**,
 **Catppuccin Mocha**, and **Catppuccin Latte** — and you can add your own.
 Pick one under **Settings → Appearance**; the choice is remembered.
 A theme is a small TOML file of named colours:
 ```toml
 name = "My Theme"
 dark = true            # base egui defaults to start from (dark or light)
 window_bg = "#1b1b1f"  # window background
 panel_bg = "#242429"   # panels / frames
 input_bg = "#141417"   # text fields, the ticket box
 text = "#e6e6ea"       # primary text
 weak_text = "#a0a0a8"  # hints, secondary text
 accent = "#5aa0f2"     # selection, links, the active control
 button_bg = "#33333a"  # buttons at rest
 button_hovered = "#44444d"
 streaming = "#6fdc8c"  # "● Streaming"
 waiting = "#f2c14e"    # "● Waiting for viewers…"
 success = "#6fdc8c"    # "✓ Copied", valid-code confirmation
 warning = "#f0a85a"    # non-fatal warnings
 error = "#f2756f"      # errors
 ```
 Colours are `#rrggbb` hex strings. Any field you leave out falls back to
 Default Dark, so partial files are fine.
 Two ways to make one:
 - **In the app:** Settings → Appearance → *Edit / create a theme* gives you a
  colour picker per field with a live preview, and **Save** writes a `.toml`.
 - **By hand:** drop a `.toml` into `~/.config/pixelpass/themes/` (the XDG
  config dir). It appears in the picker next time you open Settings.
 Sharing a theme is just sending someone the file. A user theme whose `name`
 matches a built-in overrides that built-in.
 ## Audio
 By default pixelpass captures the default sink's monitor — the viewer
@@ -1,93 +0,0 @@
 Copyright 2022 The Noto Project Authors (https://github.com/notofonts/latin-greek-cyrillic)
 This Font Software is licensed under the SIL Open Font License, Version 1.1.
 This license is copied below, and is also available with a FAQ at:
 https://scripts.sil.org/OFL
 -----------------------------------------------------------
 SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
 -----------------------------------------------------------
 PREAMBLE
 The goals of the Open Font License (OFL) are to stimulate worldwide
 development of collaborative font projects, to support the font creation
 efforts of academic and linguistic communities, and to provide a free and
 open framework in which fonts may be shared and improved in partnership
 with others.
 The OFL allows the licensed fonts to be used, studied, modified and
 redistributed freely as long as they are not sold by themselves. The
 fonts, including any derivative works, can be bundled, embedded, 
 redistributed and/or sold with any software provided that any reserved
 names are not used by derivative works. The fonts and derivatives,
 however, cannot be released under any other type of license. The
 requirement for fonts to remain under this license does not apply
 to any document created using the fonts or their derivatives.
 DEFINITIONS
 "Font Software" refers to the set of files released by the Copyright
 Holder(s) under this license and clearly marked as such. This may
 include source files, build scripts and documentation.
 "Reserved Font Name" refers to any names specified as such after the
 copyright statement(s).
 "Original Version" refers to the collection of Font Software components as
 distributed by the Copyright Holder(s).
 "Modified Version" refers to any derivative made by adding to, deleting,
 or substituting -- in part or in whole -- any of the components of the
 Original Version, by changing formats or by porting the Font Software to a
 new environment.
 "Author" refers to any designer, engineer, programmer, technical
 writer or other person who contributed to the Font Software.
 PERMISSION & CONDITIONS
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of the Font Software, to use, study, copy, merge, embed, modify,
 redistribute, and sell modified and unmodified copies of the Font
 Software, subject to the following conditions:
 1) Neither the Font Software nor any of its individual components,
 in Original or Modified Versions, may be sold by itself.
 2) Original or Modified Versions of the Font Software may be bundled,
 redistributed and/or sold with any software, provided that each copy
 contains the above copyright notice and this license. These can be
 included either as stand-alone text files, human-readable headers or
 in the appropriate machine-readable metadata fields within text or
 binary files as long as those fields can be easily viewed by the user.
 3) No Modified Version of the Font Software may use the Reserved Font
 Name(s) unless explicit written permission is granted by the corresponding
 Copyright Holder. This restriction only applies to the primary font name as
 presented to the users.
 4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
 Software shall not be used to promote, endorse or advertise any
 Modified Version, except to acknowledge the contribution(s) of the
 Copyright Holder(s) and the Author(s) or with their explicit written
 permission.
 5) The Font Software, modified or unmodified, in part or in whole,
 must be distributed entirely under this license, and must not be
 distributed under any other license. The requirement for fonts to
 remain under this license does not apply to any document created
 using the Font Software.
 TERMINATION
 This license becomes null and void if any of the above conditions are
 not met.
 DISCLAIMER
 THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
 OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
 COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
 DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
 OTHER DEALINGS IN THE FONT SOFTWARE.
@@ -1,12 +0,0 @@
 [Desktop Entry]
 Type=Application
 Name=pixelpass
 GenericName=Screen Sharing
 Comment=P2P screen sharing over iroh — no port forwarding, no signup
 Exec=pixelpass --gui
 Icon=pixelpass
 StartupWMClass=pixelpass
 Terminal=false
 Categories=Network;RemoteAccess;
 Keywords=screen;share;sharing;remote;p2p;iroh;cast;
 StartupNotify=true
@@ -1,16 +0,0 @@
 <svg xmlns="http://www.w3.org/2000/svg" width="256" height="256" viewBox="0 0 256 256">
  <title>pixelpass</title>
  <defs>
    <linearGradient id="bg" x1="0" y1="0" x2="256" y2="256" gradientUnits="userSpaceOnUse">
      <stop offset="0" stop-color="#4338ca"/>
      <stop offset="1" stop-color="#7c3aed"/>
    </linearGradient>
  </defs>
  <rect x="8" y="8" width="240" height="240" rx="56" fill="url(#bg)"/>
  <!-- pixel stream: squares fading cyan -> white, "passed" toward the arrow -->
  <rect x="50.25" y="181.29" width="16" height="16" rx="3.2" fill="#2dd5ef"/>
  <rect x="67" y="124.44" width="20" height="20" rx="4" fill="#62dff2"/>
  <rect x="96.25" y="82.09" width="24" height="24" rx="4.8" fill="#98e8f6"/>
  <rect x="134.04" y="55.77" width="28" height="28" rx="5.6" fill="#c9f1f9"/>
  <path d="M 225.5 57.5 L 183.1 85.8 L 176.9 42.2 Z" fill="#f8fafc"/>
 </svg>
@@ -1,3 +0,0 @@
 .tools/
 AppDir/
 *.AppImage
@@ -1,20 +0,0 @@
 #!/bin/sh
 # AppRun for the PixelPass AppImage.
 #
 # PixelPass is an orchestrator: it shells out to gst-launch-1.0, pactl, and a
 # player (mpv/vlc) found on the host PATH. We prepend our own usr/bin so any
 # bundled helpers win, but the host's tools remain reachable — that's why this
 # app suits AppImage (no sandbox) better than a Flatpak.
 HERE="$(dirname "$(readlink -f "$0")")"
 export PATH="$HERE/usr/bin:$PATH"
 BIN="$HERE/usr/bin/pixelpass"
 # With no arguments and no controlling terminal — i.e. launched from a file
 # manager or the .desktop entry — open the GUI. From a terminal, or with any
 # argument (a ticket, --host, --gui, --repair, …), pass through so the CLI and
 # the interactive menu both work.
 if [ "$#" -eq 0 ] && [ ! -t 0 ]; then
  exec "$BIN" --gui
 fi
 exec "$BIN" "$@"
@@ -1,72 +0,0 @@
 # PixelPass AppImage
 A "thin" AppImage: the gui-enabled `pixelpass` binary, a launcher (`AppRun`),
 and the desktop entry + icon. Run `./build-appimage.sh` to produce
 `pixelpass-<version>-x86_64.AppImage`.
 ## Why thin
 `pixelpass` is an orchestrator — it links almost nothing (only `libpipewire`,
 which is excludelisted because it must match the host daemon) and instead
 **shells out** to `gst-launch-1.0`, `pactl`, and a player (`mpv`/`vlc`) found on
 the host `PATH`. The GUI's graphics libraries (`libGL`, `libwayland-*`,
 `libxkbcommon`, X11) are dlopen'd at runtime and are likewise on the AppImage
 excludelist — every desktop already has a matching set. So there is nothing
 useful to bundle, and bundling the graphics stack would only risk driver
 mismatches. The AppImage therefore carries just the binary.
 This also explains why PixelPass suits AppImage better than Flatpak: the
 no-sandbox model lets the bundled binary freely spawn the host's `gst-launch`,
 `pactl`, and player, which a Flatpak sandbox would block.
 ## Host requirements
 The AppImage runs on any reasonably current glibc-based distro that has:
 - **GStreamer + plugins** — `gst-launch-1.0`/`gst-inspect-1.0` plus base,
  good/bad/ugly, libav, and the PipeWire plugin (the binary tells you the exact
  package names for your distro if something is missing).
 - **PipeWire** (with the PulseAudio shim, for `pactl`).
 - **A player** — `mpv` (preferred) or `vlc` — for the viewer side.
 - For X11 single-window capture: `xwininfo`.
 These are the same dependencies the Arch package lists; the AppImage just spares
 you the Rust toolchain.
 ## Building for broad compatibility (lower glibc baseline)
 An AppImage requires a host glibc **at least as new** as the build host's. Built
 straight on a rolling distro (e.g. CachyOS, glibc 2.43) the AppImage only runs
 on equally-new systems. Build inside an older base for wider reach. The script
 honours `CARGO_TARGET_DIR`, so an isolated toolchain won't clobber your host's
 `target/`:
 ```sh
 # One-time: an Ubuntu 24.04 distrobox (docker or podman backend).
 distrobox create --yes --image ubuntu:24.04 --name pixelpass-build
 distrobox enter pixelpass-build -- sudo apt-get update
 distrobox enter pixelpass-build -- sudo apt-get install -y \
  build-essential cmake clang libclang-dev pkg-config \
  libpipewire-0.3-dev libspa-0.2-dev curl ca-certificates file
 # Install rustup inside the box (edition 2024 needs rustc >= 1.85), then:
 distrobox enter pixelpass-build -- env \
  CARGO_TARGET_DIR=~/.cache/pixelpass-ubuntu/target \
  ./packaging/appimage/build-appimage.sh
 ```
 **Why Ubuntu 24.04 and not something older:** PixelPass's `pipewire` crate
 binds the system's PipeWire headers via bindgen, and anything older than ~PW 1.0
 (e.g. Ubuntu 22.04's 0.3.48) fails to compile (missing struct fields / wrong
 types). And since PixelPass *is* a PipeWire/portal/Wayland app, it can only run
 on distros new enough to have modern PipeWire anyway — so an ancient glibc base
 buys nothing. 24.04 (glibc 2.39, PW 1.0.5) is the sweet spot.
 The 24.04-built binary's baseline is **glibc 2.39** — and the only 2.39 symbols
 are two *weak* `pidfd_*` references from Rust std's process spawning (everything
 else is ≤ 2.35). That covers Ubuntu 24.04+, Debian 13+, Fedora 40+, and current
 rolling distros.
 ## Caveats
 - **Hardware encode (VAAPI `vah264enc`)** uses the host GPU driver; it can't be
  bundled. The software path (`--no-hwencode`, x264) always works.
@@ -1,59 +0,0 @@
 #!/usr/bin/env bash
 # Build a "thin" PixelPass AppImage: the gui-enabled release binary plus only
 # its non-excludelisted shared libraries. The graphics stack (libGL, wayland,
 # xkbcommon, X11) is intentionally left to the host — those libs are on the
 # AppImage excludelist because they must match the host driver — and the
 # runtime tools PixelPass shells out to (gst-launch-1.0, pactl, mpv/vlc) are
 # expected on the host PATH, the same contract the Arch package documents.
 #
 # Usage: packaging/appimage/build-appimage.sh
 # Output: packaging/appimage/pixelpass-x86_64.AppImage
 set -euo pipefail
 here="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 repo="$(cd "$here/../.." && pwd)"
 tools="$here/.tools"
 appdir="$here/AppDir"
 mkdir -p "$tools"
 # linuxdeploy is itself an AppImage; run it without FUSE so this works on hosts
 # (and CI) that lack libfuse2.
 export APPIMAGE_EXTRACT_AND_RUN=1
 # Embed the version from Cargo.toml into the AppImage filename metadata.
 VERSION="$(grep -m1 '^version' "$repo/Cargo.toml" | sed -E 's/.*"(.*)".*/\1/')"
 export VERSION
 echo ">> building release binary (--features gui)"
 ( cd "$repo" && cargo build --release --features gui )
 # Honour CARGO_TARGET_DIR so an isolated build (e.g. inside an old-glibc
 # distrobox) doesn't have to clobber the host's target/.
 bin="${CARGO_TARGET_DIR:-$repo/target}/release/pixelpass"
 echo ">> fetching linuxdeploy"
 ld="$tools/linuxdeploy-x86_64.AppImage"
 if [ ! -x "$ld" ]; then
  curl -fL --retry 3 -o "$ld" \
    "https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-x86_64.AppImage"
  chmod +x "$ld"
 fi
 echo ">> assembling AppDir"
 rm -rf "$appdir"
 mkdir -p "$appdir/usr/bin"
 install -m755 "$bin" "$appdir/usr/bin/pixelpass"
 echo ">> running linuxdeploy (bundles libs, builds the AppImage)"
 # -e: analyse this binary for libraries to bundle (only libpipewire et al. that
 #     aren't excludelisted will be copied; glibc + graphics libs are skipped).
 # -d/-i: desktop entry + icon for desktop integration.
 # --custom-apprun: our launcher that opens --gui from a file manager.
 ( cd "$here" && OUTPUT="pixelpass-${VERSION}-x86_64.AppImage" "$ld" \
    --appdir "$appdir" \
    -e "$bin" \
    -d "$repo/assets/pixelpass.desktop" \
    -i "$repo/assets/pixelpass-256.png" \
    --icon-filename pixelpass \
    --custom-apprun "$here/AppRun" \
    --output appimage )
 echo ">> done: $here/pixelpass-${VERSION}-x86_64.AppImage"
@@ -1,6 +0,0 @@
 # makepkg build artifacts
 src/
 pkg/
 /pixelpass/
 *.pkg.tar.*
 *.log
@@ -1,65 +0,0 @@
 # Maintainer: mollusk <jitty+lc1iz0dc@protonmail.com>
 #
 # Local versioned package, built from the local git repo on `main`.
 # For a tagged release, switch the source fragment to `#tag=v0.1.0`.
 pkgname=pixelpass
 pkgver=0.1.0
 pkgrel=1
 pkgdesc='P2P screen sharing over iroh — no port forwarding, no signup'
 arch=('x86_64')
 url='file:///home/mollusk/git/butter/pixelpass'
 license=('MIT' 'Apache-2.0' 'OFL-1.1')
 depends=(
  'gstreamer'          # gst-launch-1.0 / gst-inspect-1.0
  'gst-plugins-base'   # videoscale (quality-preset downscale)
  'gst-plugins-good'   # ximagesrc (X11 capture) + pulsesrc
  'gst-plugins-bad'    # h264parse, mpegtsmux, aacparse
  'gst-libav'          # avenc_aac (audio encode)
  'gst-plugin-va'      # vah264enc (default hardware H.264 encoder)
  'libpulse'           # pactl (audio routing / device control)
  'hicolor-icon-theme' # owns the scalable icon dir
  'libglvnd'           # libGL for the egui (glow) GUI
  'libxkbcommon'       # GUI keyboard handling (winit)
  'wayland'            # GUI Wayland backend libs
 )
 optdepends=(
  'mpv: recommended stream viewer (the GUI launches mpv)'
  'vlc: alternative stream viewer'
  'gst-plugins-ugly: software x264 encoding for `pixelpass --no-hwencode`'
  'gst-plugin-pipewire: screen capture on Wayland sessions'
  'xorg-xwininfo: share a single window on X11 (`pixelpass --window`)'
 )
 makedepends=('cargo' 'git')
 options=('!lto')
 _branch='main'
 source=("$pkgname::git+file:///home/mollusk/git/butter/pixelpass#branch=$_branch")
 sha256sums=('SKIP')
 prepare() {
  cd "$srcdir/$pkgname"
  export RUSTUP_TOOLCHAIN=stable
  cargo fetch --locked --target "$(rustc -vV | sed -n 's/host: //p')"
 }
 build() {
  cd "$srcdir/$pkgname"
  export RUSTUP_TOOLCHAIN=stable
  export CARGO_TARGET_DIR=target
  # --features gui so the .desktop launcher (pixelpass --gui) works.
  cargo build --frozen --release --features gui
 }
 package() {
  cd "$srcdir/$pkgname"
  install -Dm0755 "target/release/$pkgname" "$pkgdir/usr/bin/$pkgname"
  install -Dm0644 assets/pixelpass.desktop \
    "$pkgdir/usr/share/applications/$pkgname.desktop"
  install -Dm0644 assets/pixelpass.svg \
    "$pkgdir/usr/share/icons/hicolor/scalable/apps/$pkgname.svg"
  install -Dm0644 README.md "$pkgdir/usr/share/doc/$pkgname/README.md"
  install -Dm0644 LICENSE-MIT "$pkgdir/usr/share/licenses/$pkgname/LICENSE-MIT"
  install -Dm0644 LICENSE-APACHE "$pkgdir/usr/share/licenses/$pkgname/LICENSE-APACHE"
  install -Dm0644 assets/NotoSans-OFL.txt \
    "$pkgdir/usr/share/licenses/$pkgname/NotoSans-OFL.txt"
 }
@@ -68,13 +68,6 @@ pub struct Cli {
    pub port: u16,
    // ── global ────────────────────────────────────────────────────────
    /// Relay server URL to use instead of the bundled defaults, e.g.
    /// `https://relay.example/`. Applies to both host and viewer. Falls back
    /// to the `PIXELPASS_RELAY` environment variable. Use this to get off the
    /// pre-release default relays or to point at a self-hosted relay.
    #[arg(long, value_name = "URL")]
    pub relay: Option<String>,
    /// Launch the graphical front-end (a window with Host/View controls)
    /// instead of the terminal menu. Requires a build with `--features gui`.
    #[arg(long)]
@@ -147,16 +140,12 @@ pub struct HostOpts {
    pub no_hwencode: bool,
    pub max_viewers: Option<u32>,
    pub interactive: bool,
    /// Relay override (resolved from `--relay` / `PIXELPASS_RELAY`); None = defaults.
    pub relay: Option<String>,
 }
 #[derive(Debug, Clone)]
 pub struct ViewerOpts {
    pub port: u16,
    pub interactive: bool,
    /// Relay override (resolved from `--relay` / `PIXELPASS_RELAY`); None = defaults.
    pub relay: Option<String>,
 }
 impl Cli {
@@ -174,15 +163,10 @@ impl Cli {
            no_hwencode: self.no_hwencode,
            max_viewers: self.max_viewers,
            interactive,
            relay: crate::common::endpoint::relay_override(self.relay.as_deref()),
        }
    }
    pub fn into_viewer_opts(self, interactive: bool) -> ViewerOpts {
-        ViewerOpts {
+        ViewerOpts { port: self.port, interactive }
            port: self.port,
            interactive,
            relay: crate::common::endpoint::relay_override(self.relay.as_deref()),
        }
    }
 }
@@ -1,14 +1,5 @@
-/// ALPN identifying the pixelpass video wire protocol on the iroh tunnel.
+/// ALPN identifying the pixelpass wire protocol on the iroh tunnel.
 ///
 /// Bump the version suffix whenever the wire format changes. Today the wire is
 /// "raw MPEG-TS bytes copied bidirectionally," so bumps will be rare.
 pub const ALPN: &[u8] = b"pixelpass/0";
 /// ALPN for the friends control plane — the always-on presence endpoint that
 /// carries friend requests and shared codes between peers' GUIs. Separate from
 /// [`ALPN`] so the same machine can run a control endpoint and a video endpoint
 /// without their accept loops colliding, and so a control dial never lands on a
 /// bare video host (which doesn't speak this protocol). GUI-only, like the rest
 /// of the friends stack.
 #[cfg(feature = "gui")]
 pub const CONTROL_ALPN: &[u8] = b"pixelpass/ctrl/0";
@@ -65,41 +65,9 @@ pub fn measure_upstream_blocking() -> Result<Measurement> {
 /// via SAFETY_FACTOR) into a recommended viewer count. Floors to at least 1.
 pub fn recommended_max_viewers(safe_mbps: f64, bitrate_kbps: u32) -> u32 {
    let per_viewer_mbps = (bitrate_kbps as f64) / 1000.0;
-    // Guard non-finite / non-positive inputs (only reachable from a corrupted
+    if per_viewer_mbps <= 0.0 {
    // config): a NaN safe_mbps would cast to 0 and an infinite one to u32::MAX,
    // both of which break the "at least 1" contract.
    if !safe_mbps.is_finite() || safe_mbps <= 0.0 || per_viewer_mbps <= 0.0 {
        return 1;
    }
    let n = (safe_mbps / per_viewer_mbps).floor();
    if n < 1.0 { 1 } else { n as u32 }
 }
 #[cfg(test)]
 mod tests {
    use super::recommended_max_viewers;
    #[test]
    fn divides_bandwidth_by_per_viewer_bitrate() {
        // 8 Mbps safe / 2 Mbps each = 4 viewers.
        assert_eq!(recommended_max_viewers(8.0, 2000), 4);
        // Floors the fractional part: 7.9 / 2 = 3.95 -> 3.
        assert_eq!(recommended_max_viewers(7.9, 2000), 3);
    }
    #[test]
    fn floors_to_at_least_one() {
        // Not even enough for one viewer still allows one (best effort).
        assert_eq!(recommended_max_viewers(0.5, 2000), 1);
        // Zero / unknown bitrate can't size a budget; floor to one.
        assert_eq!(recommended_max_viewers(8.0, 0), 1);
    }
    #[test]
    fn degenerate_inputs_floor_to_one() {
        // A corrupted config must not yield 0 (NaN) or u32::MAX (Inf).
        assert_eq!(recommended_max_viewers(f64::NAN, 2000), 1);
        assert_eq!(recommended_max_viewers(f64::INFINITY, 2000), 1);
        assert_eq!(recommended_max_viewers(-5.0, 2000), 1);
    }
 }
@@ -1,7 +1,8 @@
 //! Persistent user-level config at `~/.config/pixelpass/config.toml`.
 //!
-//! It tracks the bandwidth pre-flight result and the GUI's preferences.
+//! Right now this only tracks the bandwidth pre-flight result. Future
-//! Further settings can hang off the same file under their own `[section]`.
+//! preferences (default player, default bitrate, etc.) can hang off the
 //! same file under their own `[section]`.
 use anyhow::{Context, Result};
 use chrono::{DateTime, Utc};
@@ -15,59 +16,6 @@ use std::path::PathBuf;
 pub struct Config {
    #[serde(default)]
    pub bandwidth: BandwidthEntry,
    #[serde(default)]
    pub gui: GuiSettings,
 }
 /// Preferences for the `pixelpass --gui` front-end.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct GuiSettings {
    /// When true, the window's close button hides the app to the system tray
    /// (keeping any live stream running) instead of quitting. Defaults to
    /// false — closing quits, which is what people expect.
    #[serde(default)]
    pub close_to_tray: bool,
    /// When true, the host screen renders a QR-code panel for the ticket.
    /// Defaults to true; the toggle exists for users who prefer the plain
    /// text-only host screen.
    #[serde(default = "default_true")]
    pub show_qr: bool,
    /// Name of the active GUI colour theme (a built-in, or a user file in
    /// `~/.config/pixelpass/themes/`). Defaults to the built-in Default Dark.
    #[serde(default = "default_theme")]
    pub theme: String,
    /// The display name shown to friends (in requests and shared codes).
    /// Seeded from the login name; editable in Settings.
    #[serde(default = "default_display_name")]
    pub display_name: String,
 }
 impl Default for GuiSettings {
    fn default() -> Self {
        Self {
            close_to_tray: false,
            show_qr: true,
            theme: default_theme(),
            display_name: default_display_name(),
        }
    }
 }
 fn default_true() -> bool {
    true
 }
 fn default_theme() -> String {
    "Default Dark".to_string()
 }
 /// Seed the friends display name from the login name, falling back to a
 /// generic label when `$USER` isn't set.
 fn default_display_name() -> String {
    std::env::var("USER")
        .ok()
        .filter(|s| !s.trim().is_empty())
        .unwrap_or_else(|| "PixelPass user".to_string())
 }
 /// Result of the first-run upstream measurement.
@@ -89,15 +37,19 @@ pub struct BandwidthEntry {
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "lowercase")]
 #[derive(Default)]
 pub enum BandwidthStatus {
    #[default]
    Unmeasured,
    Measured,
    Skipped,
    Failed,
 }
 impl Default for BandwidthStatus {
    fn default() -> Self {
        Self::Unmeasured
    }
 }
 fn default_status() -> BandwidthStatus {
    BandwidthStatus::Unmeasured
 }
@@ -129,9 +81,11 @@ pub fn save(cfg: &Config) -> Result<()> {
    let parent = path
        .parent()
        .context("config path has no parent directory")?;
-    fs::create_dir_all(parent).with_context(|| format!("failed to create {}", parent.display()))?;
+    fs::create_dir_all(parent)
        .with_context(|| format!("failed to create {}", parent.display()))?;
-    let serialized = toml::to_string_pretty(cfg).context("failed to serialize config to TOML")?;
+    let serialized =
        toml::to_string_pretty(cfg).context("failed to serialize config to TOML")?;
    let tmp = parent.join(format!(".config.toml.tmp.{}", std::process::id()));
    {
@@ -1,257 +0,0 @@
 //! Friends control-plane protocol and service.
 //!
 //! This is the always-on presence channel that rides the [`CONTROL_ALPN`]
 //! endpoint (bound with the persistent identity — see
 //! [`super::endpoint::bind_control`]). It's how two peers' GUIs exchange friend
 //! requests and pushed share-codes, independent of any video session.
 //!
 //! Wire shape: **one message per connection.** The sender opens a bi-stream,
 //! writes the JSON-encoded [`ControlMsg`], and finishes its send side (EOF
 //! delimits the message — no length framing needed). The receiver reads to EOF,
 //! parses, hands the message up, then writes a one-byte [`ACK`] back so the
 //! sender knows it was delivered *and* parsed. That delivery signal is what
 //! lets the host-side code-push queue (a later phase) tell "sent" from "friend
 //! was offline." A friend's *reply* (accept/decline) is a separate later
 //! connection in the other direction, because acceptance can happen minutes
 //! after the request — not a response on the same stream.
 use std::time::Duration;
 use anyhow::{Context, Result, bail};
 use iroh::endpoint::{Incoming, VarInt};
 use iroh::{Endpoint, EndpointAddr, EndpointId};
 use serde::{Deserialize, Serialize};
 use tokio::sync::mpsc;
 use super::alpn::CONTROL_ALPN;
 /// Upper bound on a single control message. Generous for a display name plus a
 /// share-code ticket (~150 chars); rejects a peer trying to make us buffer a
 /// huge blob.
 const MAX_MSG: usize = 64 * 1024;
 /// One-byte application acknowledgement the receiver returns once it has parsed
 /// a message. ASCII ACK (0x06).
 const ACK: &[u8] = b"\x06";
 /// Bound on each phase of the send handshake, so a half-dead peer or relay
 /// can't park a sender (or an inbound handler) forever.
 const IO_TIMEOUT: Duration = Duration::from_secs(10);
 /// A message on the friends control plane.
 ///
 /// `#[serde(tag = "type")]` keeps the JSON self-describing and lets us add
 /// variants without breaking older peers (an unknown tag fails to parse and is
 /// logged, rather than being silently misread as another variant).
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(tag = "type", rename_all = "snake_case")]
 pub enum ControlMsg {
    /// "I'm online; here's my current display name." A presence/name refresh.
    Hello { name: String },
    /// Ask the recipient to become friends.
    FriendRequest { name: String },
    /// Accept a request the recipient previously sent us.
    FriendAccept { name: String },
    /// Decline a pending request, or cancel an outgoing one.
    FriendDecline,
    /// A host pushing a freshly generated share-code to an accepted friend.
    ShareCode { name: String, ticket: String },
 }
 /// A received control message, paired with the *authenticated* sender id (the
 /// connection's verified remote public key — not a value the peer can spoof in
 /// the payload, which is why no variant carries a sender id).
 #[derive(Debug, Clone)]
 pub struct Inbound {
    pub from: EndpointId,
    pub msg: ControlMsg,
 }
 fn encode(msg: &ControlMsg) -> Result<Vec<u8>> {
    serde_json::to_vec(msg).context("failed to encode control message")
 }
 fn decode(bytes: &[u8]) -> Result<ControlMsg> {
    serde_json::from_slice(bytes).context("failed to decode control message")
 }
 /// Deliver one message to `peer` over `endpoint`, returning once the recipient
 /// has acknowledged it. An error means it was *not* delivered (peer offline,
 /// unreachable, or rejected the stream) — the caller can queue and retry.
 ///
 /// `peer` is usually a bare [`EndpointId`] — friends store only the stable id,
 /// and n0 DNS discovery resolves it to a live address. The full [`EndpointAddr`]
 /// form exists for callers that already hold one (and for hermetic tests).
 pub async fn send(
    endpoint: &Endpoint,
    peer: impl Into<EndpointAddr>,
    msg: &ControlMsg,
 ) -> Result<()> {
    let payload = encode(msg)?;
    let conn = tokio::time::timeout(IO_TIMEOUT, endpoint.connect(peer, CONTROL_ALPN))
        .await
        .context("timed out connecting to peer")?
        .context("failed to connect to peer")?;
    let io = async {
        let (mut send, mut recv) = conn
            .open_bi()
            .await
            .context("failed to open control stream")?;
        send.write_all(&payload)
            .await
            .context("failed to write control message")?;
        send.finish().context("failed to finish control stream")?;
        // Read the peer's ACK. read_to_end returns once the peer finishes its
        // send side, so this also serves as "the peer is done with us."
        let ack = recv
            .read_to_end(ACK.len() + 1)
            .await
            .context("peer closed the control stream without acknowledging")?;
        if ack != ACK {
            bail!(
                "peer sent an unexpected acknowledgement ({} bytes)",
                ack.len()
            );
        }
        Ok(())
    };
    let result = tokio::time::timeout(IO_TIMEOUT, io)
        .await
        .context("timed out sending control message")?;
    // Clean close so the peer's `closed().await` returns promptly either way.
    conn.close(VarInt::from_u32(0), b"done");
    result
 }
 /// Run the control-plane accept loop, forwarding every received message to
 /// `tx`. Returns when the endpoint stops accepting (i.e. it was closed).
 pub async fn serve(endpoint: Endpoint, tx: mpsc::Sender<Inbound>) {
    while let Some(incoming) = endpoint.accept().await {
        let tx = tx.clone();
        tokio::spawn(async move {
            if let Err(e) = handle(incoming, &tx).await {
                tracing::warn!("control: inbound connection failed: {e:#}");
            }
        });
    }
    tracing::info!("control: endpoint stopped accepting");
 }
 async fn handle(incoming: Incoming, tx: &mpsc::Sender<Inbound>) -> Result<()> {
    let conn = incoming
        .await
        .context("inbound control connection failed")?;
    let from = conn.remote_id();
    let msg = async {
        let (mut send, mut recv) = conn
            .accept_bi()
            .await
            .context("failed to accept control stream")?;
        let bytes = recv
            .read_to_end(MAX_MSG)
            .await
            .context("failed to read control message")?;
        let msg = decode(&bytes)?;
        // ACK only after a successful parse, so the sender's delivery signal
        // means "received and understood."
        send.write_all(ACK).await.context("failed to write ack")?;
        send.finish().context("failed to finish ack stream")?;
        Ok::<_, anyhow::Error>(msg)
    };
    let msg = tokio::time::timeout(IO_TIMEOUT, msg)
        .await
        .context("timed out reading control message")??;
    // Wait (briefly) for the sender's close so our ACK flushes before the
    // connection is dropped at the end of this scope.
    let _ = tokio::time::timeout(IO_TIMEOUT, conn.closed()).await;
    tx.send(Inbound { from, msg })
        .await
        .map_err(|_| anyhow::anyhow!("control: receiver dropped"))?;
    Ok(())
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    #[test]
    fn control_msg_round_trips() {
        let cases = [
            ControlMsg::Hello {
                name: "alice".into(),
            },
            ControlMsg::FriendRequest { name: "bob".into() },
            ControlMsg::FriendAccept {
                name: "carol".into(),
            },
            ControlMsg::FriendDecline,
            ControlMsg::ShareCode {
                name: "dave".into(),
                ticket: "endpointaa…".into(),
            },
        ];
        for msg in cases {
            let bytes = encode(&msg).unwrap();
            assert_eq!(decode(&bytes).unwrap(), msg);
        }
    }
    #[test]
    fn unknown_tag_is_rejected() {
        assert!(decode(br#"{"type":"nonsense"}"#).is_err());
    }
    /// Bind a control-plane endpoint with a *fresh* random key, so two of them
    /// in one test get distinct ids (two real machines each have their own
    /// persistent key; `bind_control` would give both the same one here, and
    /// iroh refuses "connecting to ourself").
    async fn bind_test_control() -> Endpoint {
        iroh::Endpoint::builder(iroh::endpoint::presets::N0)
            .secret_key(iroh::SecretKey::generate())
            .alpns(vec![CONTROL_ALPN.to_vec()])
            .bind()
            .await
            .unwrap()
    }
    /// End-to-end over two real iroh endpoints on this machine. Ignored by
    /// default — it binds endpoints and waits on the relay, so it's slow and
    /// network-dependent. Run with `cargo test -- --ignored control`.
    #[tokio::test]
    #[ignore = "binds real iroh endpoints; run on demand"]
    async fn loopback_delivers_and_acks() {
        let server = bind_test_control().await;
        let client = bind_test_control().await;
        // Connect by full addr so the test doesn't depend on DNS discovery.
        server.online().await;
        client.online().await;
        let server_addr = server.addr();
        let (tx, mut rx) = mpsc::channel(4);
        let server_ep = server.clone();
        let serve_task = tokio::spawn(async move { serve(server_ep, tx).await });
        let msg = ControlMsg::FriendRequest {
            name: "tester".into(),
        };
        // Full addr (not just the id) so the test doesn't depend on DNS discovery.
        send(&client, server_addr.clone(), &msg).await.unwrap();
        let got = tokio::time::timeout(Duration::from_secs(15), rx.recv())
            .await
            .expect("no inbound within 15s")
            .expect("channel closed");
        assert_eq!(got.msg, msg);
        assert_eq!(got.from, client.addr().id);
        server.close().await;
        client.close().await;
        serve_task.abort();
    }
 }
@@ -85,24 +85,20 @@ fn install_hint_for_bin(bin: &str) -> String {
    let distro = detect_distro();
    let pkg = match bin {
        "gst-launch-1.0" | "gst-inspect-1.0" => match distro.as_deref() {
-            Some("arch" | "cachyos" | "manjaro" | "endeavouros" | "artix" | "garuda") => {
+            Some("arch" | "cachyos" | "manjaro" | "endeavouros") => "gstreamer gst-plugins-base",
                "gstreamer gst-plugins-base"
            }
            Some("debian" | "ubuntu" | "pop" | "linuxmint") => "gstreamer1.0-tools",
            Some("fedora" | "nobara") => "gstreamer1 gstreamer1-plugins-base-tools",
            _ => "gstreamer + tools",
        },
        "pactl" => match distro.as_deref() {
-            Some("arch" | "cachyos" | "manjaro" | "endeavouros" | "artix" | "garuda") => "libpulse",
+            Some("arch" | "cachyos" | "manjaro" | "endeavouros") => "libpulse",
            Some("debian" | "ubuntu" | "pop" | "linuxmint") => "pulseaudio-utils",
            Some("fedora" | "nobara") => "pulseaudio-utils",
            Some("opensuse" | "opensuse-tumbleweed" | "opensuse-leap") => "pulseaudio-utils",
            _ => "pulseaudio-utils (provides `pactl`)",
        },
        "xwininfo" => match distro.as_deref() {
-            Some("arch" | "cachyos" | "manjaro" | "endeavouros" | "artix" | "garuda") => {
+            Some("arch" | "cachyos" | "manjaro" | "endeavouros") => "xorg-xwininfo",
                "xorg-xwininfo"
            }
            Some("debian" | "ubuntu" | "pop" | "linuxmint") => "x11-utils",
            Some("fedora" | "nobara") => "xorg-x11-utils",
            Some("opensuse" | "opensuse-tumbleweed" | "opensuse-leap") => "xwininfo",
@@ -117,74 +113,56 @@ fn install_hint_for_gst_element(name: &str) -> String {
    let distro = detect_distro();
    let pkg = match name {
        "pipewiresrc" => match distro.as_deref() {
-            Some("arch" | "cachyos" | "manjaro" | "endeavouros" | "artix" | "garuda") => {
+            Some("arch" | "cachyos" | "manjaro" | "endeavouros") => "gst-plugin-pipewire",
                "gst-plugin-pipewire"
            }
            Some("debian" | "ubuntu" | "pop" | "linuxmint") => "gstreamer1.0-pipewire",
            Some("fedora" | "nobara") => "pipewire-gstreamer",
            Some("opensuse" | "opensuse-tumbleweed" | "opensuse-leap") => "pipewire-gstreamer",
            _ => "the GStreamer PipeWire plugin",
        },
        "vah264enc" => match distro.as_deref() {
-            Some("arch" | "cachyos" | "manjaro" | "endeavouros" | "artix" | "garuda") => {
+            Some("arch" | "cachyos" | "manjaro" | "endeavouros") => "gst-plugin-va",
                "gst-plugin-va"
            }
            Some("debian" | "ubuntu" | "pop" | "linuxmint") => "gstreamer1.0-plugins-bad",
            Some("fedora" | "nobara") => "gstreamer1-plugins-bad-free",
            Some("opensuse" | "opensuse-tumbleweed" | "opensuse-leap") => "gstreamer-plugins-bad",
-            _ => {
+            _ => "the GStreamer VA-API plugin (requires an H.264-capable GPU; almost all modern GPUs)",
                "the GStreamer VA-API plugin (requires an H.264-capable GPU; almost all modern GPUs)"
            }
        },
        "x264enc" => match distro.as_deref() {
-            Some("arch" | "cachyos" | "manjaro" | "endeavouros" | "artix" | "garuda") => {
+            Some("arch" | "cachyos" | "manjaro" | "endeavouros") => "gst-plugins-ugly",
                "gst-plugins-ugly"
            }
            Some("debian" | "ubuntu" | "pop" | "linuxmint") => "gstreamer1.0-plugins-ugly",
            Some("fedora" | "nobara") => "gstreamer1-plugins-ugly",
            Some("opensuse" | "opensuse-tumbleweed" | "opensuse-leap") => "gstreamer-plugins-ugly",
            _ => "the GStreamer x264 plugin (plugins-ugly)",
        },
        "ximagesrc" => match distro.as_deref() {
-            Some("arch" | "cachyos" | "manjaro" | "endeavouros" | "artix" | "garuda") => {
+            Some("arch" | "cachyos" | "manjaro" | "endeavouros") => "gst-plugins-good",
                "gst-plugins-good"
            }
            Some("debian" | "ubuntu" | "pop" | "linuxmint") => "gstreamer1.0-plugins-good",
            Some("fedora" | "nobara") => "gstreamer1-plugins-good",
            Some("opensuse" | "opensuse-tumbleweed" | "opensuse-leap") => "gstreamer-plugins-good",
            _ => "the GStreamer X11 plugin (plugins-good)",
        },
        "videoscale" => match distro.as_deref() {
-            Some("arch" | "cachyos" | "manjaro" | "endeavouros" | "artix" | "garuda") => {
+            Some("arch" | "cachyos" | "manjaro" | "endeavouros") => "gst-plugins-base",
                "gst-plugins-base"
            }
            Some("debian" | "ubuntu" | "pop" | "linuxmint") => "gstreamer1.0-plugins-base",
            Some("fedora" | "nobara") => "gstreamer1-plugins-base",
            Some("opensuse" | "opensuse-tumbleweed" | "opensuse-leap") => "gstreamer-plugins-base",
            _ => "the GStreamer plugins-base set",
        },
        "h264parse" | "mpegtsmux" | "aacparse" => match distro.as_deref() {
-            Some("arch" | "cachyos" | "manjaro" | "endeavouros" | "artix" | "garuda") => {
+            Some("arch" | "cachyos" | "manjaro" | "endeavouros") => "gst-plugins-bad",
                "gst-plugins-bad"
            }
            Some("debian" | "ubuntu" | "pop" | "linuxmint") => "gstreamer1.0-plugins-bad",
            Some("fedora" | "nobara") => "gstreamer1-plugins-bad-free",
            Some("opensuse" | "opensuse-tumbleweed" | "opensuse-leap") => "gstreamer-plugins-bad",
            _ => "the GStreamer plugins-bad set",
        },
        "pulsesrc" => match distro.as_deref() {
-            Some("arch" | "cachyos" | "manjaro" | "endeavouros" | "artix" | "garuda") => {
+            Some("arch" | "cachyos" | "manjaro" | "endeavouros") => "gst-plugins-good",
                "gst-plugins-good"
            }
            Some("debian" | "ubuntu" | "pop" | "linuxmint") => "gstreamer1.0-pulseaudio",
            Some("fedora" | "nobara") => "gstreamer1-plugins-good",
            Some("opensuse" | "opensuse-tumbleweed" | "opensuse-leap") => "gstreamer-plugins-good",
            _ => "the GStreamer PulseAudio plugin",
        },
        "avenc_aac" => match distro.as_deref() {
-            Some("arch" | "cachyos" | "manjaro" | "endeavouros" | "artix" | "garuda") => {
+            Some("arch" | "cachyos" | "manjaro" | "endeavouros") => "gst-libav",
                "gst-libav"
            }
            Some("debian" | "ubuntu" | "pop" | "linuxmint") => "gstreamer1.0-libav",
            Some("fedora" | "nobara") => "gstreamer1-libav",
            Some("opensuse" | "opensuse-tumbleweed" | "opensuse-leap") => "gstreamer-libav",
@@ -197,14 +175,10 @@ fn install_hint_for_gst_element(name: &str) -> String {
 fn install_command(distro: &Option<String>, pkg: &str) -> String {
    let cmd = match distro.as_deref() {
-        Some("arch" | "cachyos" | "manjaro" | "endeavouros" | "artix" | "garuda") => {
+        Some("arch" | "cachyos" | "manjaro" | "endeavouros") => format!("sudo pacman -S {pkg}"),
            format!("sudo pacman -S {pkg}")
        }
        Some("debian" | "ubuntu" | "pop" | "linuxmint") => format!("sudo apt install {pkg}"),
        Some("fedora" | "nobara") => format!("sudo dnf install {pkg}"),
-        Some("opensuse" | "opensuse-tumbleweed" | "opensuse-leap") => {
+        Some("opensuse" | "opensuse-tumbleweed" | "opensuse-leap") => format!("sudo zypper install {pkg}"),
            format!("sudo zypper install {pkg}")
        }
        _ => format!("install the `{pkg}` package via your distro's package manager"),
    };
    format!("Install hint: {cmd}")
@@ -1,84 +0,0 @@
 //! Shared iroh endpoint construction.
 //!
 //! Two planes, two identities:
 //!
 //! * The **video** plane (host/viewer sessions) binds with an *ephemeral*
 //!   keypair — a fresh `EndpointId` per run. Each session is a throwaway tunnel,
 //!   and keeping its id ephemeral means a screen-share leaks no stable
 //!   fingerprint.
 //! * The **control** plane (the always-on friends presence service) binds with
 //!   the machine's *persistent* identity (see [`identity`]), so peers can find
 //!   and recognise each other across launches.
 //!
 //! They must use different identities because both can be live at once on the
 //! same machine (the GUI's control endpoint while a host session runs), and
 //! iroh routes by `EndpointId` — two live endpoints sharing one id would make
 //! relay delivery ambiguous.
 use std::str::FromStr;
 use anyhow::{Context, Result};
 use iroh::endpoint::presets;
 use iroh::{Endpoint, RelayMap, RelayMode, RelayUrl};
 use super::alpn::ALPN;
 /// Environment variable consulted when `--relay` isn't passed. Lets the GUI's
 /// child processes and scripted runs inherit a relay choice without a flag.
 pub const RELAY_ENV: &str = "PIXELPASS_RELAY";
 /// Resolve the relay override: explicit `--relay` wins, else `PIXELPASS_RELAY`,
 /// else `None` (use the bundled defaults).
 pub fn relay_override(flag: Option<&str>) -> Option<String> {
    flag.map(str::to_owned).or_else(|| {
        std::env::var(RELAY_ENV)
            .ok()
            .filter(|s| !s.trim().is_empty())
    })
 }
 /// Bind a **video-plane** endpoint (host/viewer) with an ephemeral identity.
 ///
 /// With no `relay` override we use [`presets::N0`] — n0 DNS discovery, the
 /// library's default relays, and the chosen crypto provider. With an override
 /// we keep all of that but swap in a single custom relay via
 /// [`RelayMode::Custom`]; this is how a user gets off the rc's bundled
 /// (canary-grade) relays or points at a self-hosted one. Discovery is
 /// unchanged, so peers still resolve each other by endpoint id.
 pub async fn bind(relay: Option<&str>) -> Result<Endpoint> {
    // No `secret_key` set → iroh mints a fresh ephemeral keypair for this run.
    bind_with(relay, None, ALPN).await
 }
 /// Bind the **control-plane** endpoint with the machine's persistent identity
 /// (see [`super::identity`]) and the friends [`super::alpn::CONTROL_ALPN`]. Its
 /// `EndpointId` is the stable id friends know you by.
 #[cfg(feature = "gui")]
 pub async fn bind_control(relay: Option<&str>) -> Result<Endpoint> {
    let secret_key = super::identity::load_or_create()?;
    bind_with(relay, Some(secret_key), super::alpn::CONTROL_ALPN).await
 }
 /// Shared builder: optional persistent key (None → ephemeral) + the plane's ALPN.
 async fn bind_with(
    relay: Option<&str>,
    key: Option<iroh::SecretKey>,
    alpn: &[u8],
 ) -> Result<Endpoint> {
    let mut builder = Endpoint::builder(presets::N0).alpns(vec![alpn.to_vec()]);
    if let Some(key) = key {
        builder = builder.secret_key(key);
    }
    if let Some(url) = relay {
        let url = RelayUrl::from_str(url).with_context(|| {
            format!("invalid relay URL {url:?} (expected e.g. https://relay.example/)")
        })?;
        builder = builder.relay_mode(RelayMode::Custom(RelayMap::from(url)));
    }
    builder
        .bind()
        .await
        .context("failed to bind the iroh endpoint")
 }
@@ -1,296 +0,0 @@
 //! Persistent friends store at `~/.config/pixelpass/friends.toml`.
 //!
 //! Kept in its own file rather than a `[friends]` section of `config.toml` so
 //! the headless CLI — which never manages friends and would round-trip the
 //! config without this knowledge — can't drop the list on a `--reconfigure`.
 //! Same reasoning as the separate `identity.key`.
 //!
 //! A friend is identified by their stable control-plane [`EndpointId`] (the id
 //! from [`super::endpoint::bind_control`]). `EndpointId` serialises as its
 //! string form in TOML, so the file is human-readable and hand-editable.
 use anyhow::{Context, Result};
 use iroh::EndpointId;
 use serde::{Deserialize, Serialize};
 use std::fs;
 use std::io::Write;
 use std::path::PathBuf;
 /// Where a friendship sits in the mutual-consent handshake.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum FriendState {
    /// We've sent them a request and are waiting for them to accept.
    PendingOutgoing,
    /// They've requested us; waiting for the local user to accept or decline.
    PendingIncoming,
    /// Both sides have agreed — a real friend.
    Accepted,
 }
 /// One entry in the friends list.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct Friend {
    pub id: EndpointId,
    /// Display name — seeded from the name the peer reported, locally editable.
    pub name: String,
    pub state: FriendState,
    /// Whether the host auto-shares its session code with this friend. Toggled
    /// on the host's share picker; persisted here so the choice survives a
    /// restart. Defaults to `true` so a newly added friend is included (and an
    /// older `friends.toml` without the field loads as share-with-all).
    #[serde(default = "default_share")]
    pub share: bool,
 }
 fn default_share() -> bool {
    true
 }
 /// The persisted friends list. Serialises as a TOML array of tables
 /// (`[[friends]]`).
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
 pub struct FriendStore {
    #[serde(default)]
    pub friends: Vec<Friend>,
 }
 /// Returns `~/.config/pixelpass/friends.toml`. Shares the config directory with
 /// [`super::config`]; the parent is created on save.
 pub fn friends_path() -> Result<PathBuf> {
    Ok(super::config::config_path()?
        .parent()
        .context("config path has no parent directory")?
        .join("friends.toml"))
 }
 /// Load the store, or a default (empty) one if the file doesn't exist yet.
 /// Parse errors bubble up so a hand-edit being debugged isn't silently
 /// overwritten.
 pub fn load() -> Result<FriendStore> {
    let path = friends_path()?;
    match fs::read_to_string(&path) {
        Ok(s) => toml::from_str(&s).with_context(|| format!("failed to parse {}", path.display())),
        Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(FriendStore::default()),
        Err(e) => Err(e).with_context(|| format!("failed to read {}", path.display())),
    }
 }
 impl FriendStore {
    /// Atomic write via tempfile-in-same-dir + rename (mirrors
    /// [`super::config::save`]).
    pub fn save(&self) -> Result<()> {
        let path = friends_path()?;
        let parent = path
            .parent()
            .context("friends path has no parent directory")?;
        fs::create_dir_all(parent)
            .with_context(|| format!("failed to create {}", parent.display()))?;
        let serialized = toml::to_string_pretty(self).context("failed to serialize friends")?;
        let tmp = parent.join(format!(".friends.toml.tmp.{}", std::process::id()));
        {
            let mut f = fs::File::create(&tmp)
                .with_context(|| format!("failed to create {}", tmp.display()))?;
            f.write_all(serialized.as_bytes())
                .with_context(|| format!("failed to write {}", tmp.display()))?;
            f.sync_all().ok();
        }
        fs::rename(&tmp, &path)
            .with_context(|| format!("failed to rename {} -> {}", tmp.display(), path.display()))?;
        Ok(())
    }
    pub fn find(&self, id: &EndpointId) -> Option<&Friend> {
        self.friends.iter().find(|f| &f.id == id)
    }
    pub fn find_mut(&mut self, id: &EndpointId) -> Option<&mut Friend> {
        self.friends.iter_mut().find(|f| &f.id == id)
    }
    /// True iff this id is a fully-accepted friend — the gate the code-push
    /// (Phase 4) and "is this a known friend?" checks use.
    pub fn is_accepted(&self, id: &EndpointId) -> bool {
        matches!(
            self.find(id),
            Some(Friend {
                state: FriendState::Accepted,
                ..
            })
        )
    }
    /// Insert a new friend, or update an existing one's `name`/`state` in place.
    /// Returns a mutable reference to the stored entry.
    pub fn upsert(&mut self, id: EndpointId, name: String, state: FriendState) -> &mut Friend {
        if let Some(idx) = self.friends.iter().position(|f| f.id == id) {
            let f = &mut self.friends[idx];
            f.name = name;
            f.state = state;
            f
        } else {
            self.friends.push(Friend {
                id,
                name,
                state,
                share: true,
            });
            self.friends.last_mut().expect("just pushed")
        }
    }
    /// Remove a friend by id. Returns whether an entry was removed.
    pub fn remove(&mut self, id: &EndpointId) -> bool {
        let before = self.friends.len();
        self.friends.retain(|f| &f.id != id);
        self.friends.len() != before
    }
    /// Apply an inbound friend request. Returns `true` if it *completes a mutual
    /// match* — we'd already sent them one, so they're now [`Accepted`] and the
    /// caller should reply with a `FriendAccept`. Otherwise it's recorded as
    /// [`PendingIncoming`] for the user to act on and `false` is returned.
    ///
    /// [`Accepted`]: FriendState::Accepted
    /// [`PendingIncoming`]: FriendState::PendingIncoming
    pub fn on_friend_request(&mut self, id: EndpointId, name: String) -> bool {
        if matches!(
            self.find(&id).map(|f| f.state),
            Some(FriendState::PendingOutgoing)
        ) {
            self.upsert(id, name, FriendState::Accepted);
            true
        } else {
            self.upsert(id, name, FriendState::PendingIncoming);
            false
        }
    }
    /// Apply an inbound acceptance of a request we sent. Returns `true` if it
    /// advanced a friendship to [`Accepted`] (i.e. we actually knew this peer);
    /// an accept from a stranger is ignored.
    ///
    /// [`Accepted`]: FriendState::Accepted
    pub fn on_friend_accept(&mut self, id: EndpointId, name: String) -> bool {
        if self.find(&id).is_some() {
            self.upsert(id, name, FriendState::Accepted);
            true
        } else {
            false
        }
    }
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    fn sample_id() -> EndpointId {
        iroh::SecretKey::generate().public()
    }
    #[test]
    fn round_trips_through_toml() {
        let mut store = FriendStore::default();
        store.upsert(sample_id(), "Alice".into(), FriendState::Accepted);
        store.upsert(sample_id(), "Bob".into(), FriendState::PendingIncoming);
        let toml = toml::to_string_pretty(&store).unwrap();
        let back: FriendStore = toml::from_str(&toml).unwrap();
        assert_eq!(back.friends, store.friends);
    }
    #[test]
    fn new_friends_default_to_shared_and_survive_round_trip() {
        let mut store = FriendStore::default();
        let id = sample_id();
        store.upsert(id, "Alice".into(), FriendState::Accepted);
        assert!(store.find(&id).unwrap().share, "new friends start shared");
        // An older friends.toml predating the field loads as share-with-all.
        let toml = format!("[[friends]]\nid = \"{id}\"\nname = \"Legacy\"\nstate = \"accepted\"\n");
        let back: FriendStore = toml::from_str(&toml).unwrap();
        assert!(back.friends[0].share);
    }
    #[test]
    fn upsert_preserves_share_across_refresh() {
        let mut store = FriendStore::default();
        let id = sample_id();
        store.upsert(id, "Alice".into(), FriendState::Accepted);
        store.find_mut(&id).unwrap().share = false;
        // A later name/presence refresh re-upserts the same peer; the share
        // choice must not be reset by it.
        store.upsert(id, "Alice (new name)".into(), FriendState::Accepted);
        assert!(!store.find(&id).unwrap().share);
    }
    #[test]
    fn upsert_updates_in_place() {
        let mut store = FriendStore::default();
        let id = sample_id();
        store.upsert(id, "Old".into(), FriendState::PendingOutgoing);
        store.upsert(id, "New".into(), FriendState::Accepted);
        assert_eq!(store.friends.len(), 1);
        let f = store.find(&id).unwrap();
        assert_eq!(f.name, "New");
        assert_eq!(f.state, FriendState::Accepted);
    }
    #[test]
    fn is_accepted_only_for_accepted_state() {
        let mut store = FriendStore::default();
        let pending = sample_id();
        let friend = sample_id();
        store.upsert(pending, "P".into(), FriendState::PendingOutgoing);
        store.upsert(friend, "F".into(), FriendState::Accepted);
        assert!(!store.is_accepted(&pending));
        assert!(store.is_accepted(&friend));
        assert!(!store.is_accepted(&sample_id()));
    }
    #[test]
    fn remove_reports_whether_present() {
        let mut store = FriendStore::default();
        let id = sample_id();
        store.upsert(id, "X".into(), FriendState::Accepted);
        assert!(store.remove(&id));
        assert!(!store.remove(&id));
        assert!(store.friends.is_empty());
    }
    #[test]
    fn incoming_request_from_stranger_is_pending() {
        let mut store = FriendStore::default();
        let id = sample_id();
        let mutual = store.on_friend_request(id, "Stranger".into());
        assert!(!mutual);
        assert_eq!(store.find(&id).unwrap().state, FriendState::PendingIncoming);
    }
    #[test]
    fn incoming_request_matching_our_outgoing_is_mutual() {
        let mut store = FriendStore::default();
        let id = sample_id();
        // We asked them first…
        store.upsert(id, "Pal".into(), FriendState::PendingOutgoing);
        // …then their request arrives — that's a mutual match.
        let mutual = store.on_friend_request(id, "Pal".into());
        assert!(mutual);
        assert_eq!(store.find(&id).unwrap().state, FriendState::Accepted);
    }
    #[test]
    fn accept_advances_known_peer_only() {
        let mut store = FriendStore::default();
        let known = sample_id();
        store.upsert(known, "Known".into(), FriendState::PendingOutgoing);
        assert!(store.on_friend_accept(known, "Known".into()));
        assert_eq!(store.find(&known).unwrap().state, FriendState::Accepted);
        // An accept from someone we never asked is ignored.
        let stranger = sample_id();
        assert!(!store.on_friend_accept(stranger, "Nope".into()));
        assert!(store.find(&stranger).is_none());
    }
 }
@@ -1,141 +0,0 @@
 //! Persistent node identity at `~/.config/pixelpass/identity.key`.
 //!
 //! Without this, [`super::endpoint::bind`] would let iroh mint a fresh random
 //! keypair on every launch, so a peer's `EndpointId` would change each run.
 //! The friends system identifies people by that id (it's the public key already
 //! embedded in every share code), so it must stay stable across launches — and
 //! across roles: the same machine gets the same id whether it's hosting,
 //! viewing, or just sitting in the GUI.
 //!
 //! The key is the ed25519 secret (32 bytes) stored as hex on its own line, in a
 //! `0600` file separate from `config.toml` — it's a secret, not a preference,
 //! and keeping it out of the TOML means a hand-edit or a config reset can't
 //! clobber your identity.
 use anyhow::{Context, Result, bail};
 use iroh::SecretKey;
 use std::fs;
 use std::io::Write;
 use std::path::PathBuf;
 /// Returns `~/.config/pixelpass/identity.key` (or the XDG equivalent). Shares
 /// the config directory with [`super::config`]; the parent is created on save.
 pub fn identity_path() -> Result<PathBuf> {
    Ok(super::config::config_path()?
        .parent()
        .context("config path has no parent directory")?
        .join("identity.key"))
 }
 /// Load the persisted secret key, or generate-and-save one on first run.
 ///
 /// A malformed file is a hard error rather than a silent regenerate: silently
 /// minting a new identity would orphan every friend who has the old id, so we'd
 /// rather fail loud and let the user notice (and decide) than lose it quietly.
 pub fn load_or_create() -> Result<SecretKey> {
    let path = identity_path()?;
    match fs::read_to_string(&path) {
        Ok(s) => parse_key(s.trim())
            .with_context(|| format!("failed to parse the identity key at {}", path.display())),
        Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
            let key = SecretKey::generate();
            save(&key)?;
            tracing::info!(id = %key.public(), "generated a new persistent identity");
            Ok(key)
        }
        Err(e) => Err(e).with_context(|| format!("failed to read {}", path.display())),
    }
 }
 fn parse_key(hex: &str) -> Result<SecretKey> {
    let bytes = decode_hex(hex)?;
    let arr: [u8; 32] = bytes
        .try_into()
        .map_err(|_| anyhow::anyhow!("identity key must be 32 bytes (64 hex chars)"))?;
    Ok(SecretKey::from_bytes(&arr))
 }
 /// Atomic, `0600` write: tempfile-in-same-dir, chmod, then rename. Same
 /// approach as [`super::config::save`], but with restrictive perms applied
 /// before the rename so the secret is never briefly world-readable.
 pub fn save(key: &SecretKey) -> Result<()> {
    let path = identity_path()?;
    let parent = path
        .parent()
        .context("identity path has no parent directory")?;
    fs::create_dir_all(parent).with_context(|| format!("failed to create {}", parent.display()))?;
    let tmp = parent.join(format!(".identity.key.tmp.{}", std::process::id()));
    {
        let mut f = fs::File::create(&tmp)
            .with_context(|| format!("failed to create {}", tmp.display()))?;
        #[cfg(unix)]
        {
            use std::os::unix::fs::PermissionsExt;
            f.set_permissions(fs::Permissions::from_mode(0o600))
                .with_context(|| format!("failed to chmod {}", tmp.display()))?;
        }
        f.write_all(encode_hex(&key.to_bytes()).as_bytes())
            .with_context(|| format!("failed to write {}", tmp.display()))?;
        f.write_all(b"\n").ok();
        f.sync_all().ok();
    }
    fs::rename(&tmp, &path)
        .with_context(|| format!("failed to rename {} -> {}", tmp.display(), path.display()))?;
    Ok(())
 }
 fn encode_hex(bytes: &[u8]) -> String {
    let mut s = String::with_capacity(bytes.len() * 2);
    for b in bytes {
        s.push_str(&format!("{b:02x}"));
    }
    s
 }
 fn decode_hex(s: &str) -> Result<Vec<u8>> {
    if !s.len().is_multiple_of(2) {
        bail!("hex string has an odd length");
    }
    (0..s.len())
        .step_by(2)
        .map(|i| {
            u8::from_str_radix(&s[i..i + 2], 16)
                .with_context(|| format!("invalid hex byte at offset {i}"))
        })
        .collect()
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    #[test]
    fn hex_round_trips() {
        let bytes: Vec<u8> = (0u8..=255).collect();
        let encoded = encode_hex(&bytes);
        assert_eq!(encoded.len(), bytes.len() * 2);
        assert_eq!(decode_hex(&encoded).unwrap(), bytes);
    }
    #[test]
    fn key_round_trips_through_hex() {
        let key = SecretKey::generate();
        let hex = encode_hex(&key.to_bytes());
        let parsed = parse_key(&hex).unwrap();
        assert_eq!(parsed.to_bytes(), key.to_bytes());
        assert_eq!(parsed.public(), key.public());
    }
    #[test]
    fn rejects_wrong_length() {
        assert!(parse_key("dead").is_err());
        assert!(parse_key("").is_err());
    }
    #[test]
    fn rejects_odd_and_nonhex() {
        assert!(decode_hex("abc").is_err());
        assert!(decode_hex("zz").is_err());
    }
 }
@@ -1,18 +1,8 @@
 pub mod alpn;
 pub mod bandwidth;
 pub mod config;
 // The friends stack (persistent identity + control plane) is GUI-only — a
 // headless CLI host runs no presence service — so it's gated with the feature
 // that pulls the rest of the GUI, keeping the headless build lean.
 #[cfg(feature = "gui")]
 pub mod control;
 pub mod deps;
 pub mod display;
 pub mod endpoint;
 #[cfg(feature = "gui")]
 pub mod friends;
 #[cfg(feature = "gui")]
 pub mod identity;
 pub mod output;
 pub mod process;
 pub mod signal;
@@ -22,11 +22,7 @@ pub fn set_json(enabled: bool) {
    JSON_ENABLED.store(enabled, Ordering::Relaxed);
 }
-/// Whether the JSON event stream is on — i.e. we're being driven by a
+fn json_enabled() -> bool {
 /// machine front-end (the `--gui` shell-out) rather than a human terminal.
 /// Gates features that only make sense under that front-end, like the
 /// stdin command channel the host reads `kick` requests from.
 pub fn json_enabled() -> bool {
    JSON_ENABLED.load(Ordering::Relaxed)
 }
@@ -46,11 +42,9 @@ pub enum Event<'a> {
        max_viewers: u32,
        max_viewers_source: &'a str,
    },
-    /// A viewer joined. `id` is the viewer's endpoint id; `active` is the new
+    /// A new viewer joined.
    /// total after the join.
    ViewerJoined { id: &'a str, active: u32, max: u32 },
-    /// A viewer left — disconnected on their own or kicked by the host. `id`
+    /// A viewer disconnected.
    /// is the viewer's endpoint id; `active` is the new total after.
    ViewerLeft { id: &'a str, active: u32, max: u32 },
    /// Capture pipeline lifecycle (spawned on first viewer, torn down on last).
    Capture { state: CaptureState },
@@ -7,17 +7,10 @@ pub fn install_ctrl_c() -> CancellationToken {
    let token = CancellationToken::new();
    let trigger = token.clone();
    tokio::spawn(async move {
-        if let Err(e) = tokio::signal::ctrl_c().await {
+        if tokio::signal::ctrl_c().await.is_ok() {
-            // Installing the handler failed — ctrl-c won't trigger a graceful
+            tracing::info!("ctrl-c received, shutting down");
-            // shutdown. Say so instead of failing silently; the user can still
+            trigger.cancel();
            // kill the process, and the second-ctrl-c arm below would only fail
            // the same way, so bail out of the task.
            tracing::warn!("could not install ctrl-c handler: {e}; ctrl-c won't shut down cleanly");
            return;
        }
        tracing::info!("ctrl-c received, shutting down");
        trigger.cancel();
        if tokio::signal::ctrl_c().await.is_ok() {
            tracing::warn!("second ctrl-c — exiting now");
            std::process::exit(130);
@@ -6,18 +6,17 @@
 //! egui app drains each frame. stderr is captured into a small ring so a
 //! failed launch (e.g. a missing gst plugin) can be surfaced in the window.
-use std::io::{BufRead, BufReader, Write};
+use std::io::{BufRead, BufReader};
-use std::process::{Child, ChildStdin, Command, Stdio};
+use std::process::{Child, Command, Stdio};
 use std::sync::mpsc::Receiver;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 use eframe::egui;
 use nix::sys::signal::{Signal, kill};
 use nix::unistd::Pid;
 use serde::Deserialize;
 use super::Waker;
 /// One parsed event from the child's stdout. Owned mirror of
 /// [`crate::common::output::Event`] (which borrows for emit); kept separate so
 /// the wire format and the parser can evolve independently.
@@ -67,36 +66,26 @@ pub enum CaptureState {
 const STDERR_TAIL_MAX: usize = 60;
 pub struct ChildProc {
-    /// `Some` while the child is owned here; `Drop` takes it to hand off to a
+    child: Child,
    /// detached reaper thread (see the `Drop` impl).
    child: Option<Child>,
    pub rx: Receiver<ChildEvent>,
    stderr_tail: Arc<Mutex<Vec<String>>>,
-    /// Write end of the child's stdin, for the line-based command channel
+    stdin: std::process::ChildStdin,
    /// (see [`ChildProc::send_command`]). `None` once it's been closed.
    stdin: Option<ChildStdin>,
 }
 impl ChildProc {
-    /// Spawn `pixelpass <args>` as a child, wiring up the event reader. The
+    /// Spawn `pixelpass <args>` as a child, wiring up the event reader. `ctx`
-    /// `waker` is pinged whenever an event arrives so the UI thread wakes to
+    /// is repainted whenever an event arrives so the UI updates live.
-    /// drain it — this wakes the winit event loop directly (via an
+    pub fn spawn(args: &[String], ctx: egui::Context) -> std::io::Result<Self> {
    /// `EventLoopProxy`), so it works even when the window is hidden to the tray
    /// and no frames are running (egui's own repaint callback would not fire
    /// repeatedly in that idle state — see [`super::Waker`]).
    pub fn spawn(args: &[String], waker: Waker) -> std::io::Result<Self> {
        let exe = std::env::current_exe()?;
        let mut child = Command::new(exe)
            .args(args)
            // Piped so we can send line commands (e.g. `kick <id>`); the host
            // only reads it when driven this way (`--output json`).
            .stdin(Stdio::piped())
            .stdout(Stdio::piped())
            .stderr(Stdio::piped())
            .spawn()?;
        let stdin = child.stdin.take();
        let (tx, rx) = std::sync::mpsc::channel();
        let stdin = child.stdin.take().expect("stdin piped");
        let stdout = child.stdout.take().expect("stdout piped");
        std::thread::spawn(move || {
            let reader = BufReader::new(stdout);
@@ -109,14 +98,9 @@ impl ChildProc {
                    if tx.send(ev).is_err() {
                        break; // app gone
                    }
-                    waker.wake();
+                    ctx.request_repaint();
                }
            }
            // stdout closed → the child has exited (player closed, connection
            // ended, or a failed launch). Wake once more so the UI reaps it and
            // clears the "running" view, even if no final event was emitted and
            // the window is hidden to the tray.
            waker.wake();
        });
        let stderr_tail = Arc::new(Mutex::new(Vec::<String>::new()));
@@ -135,64 +119,55 @@ impl ChildProc {
        });
        Ok(Self {
-            child: Some(child),
+            child,
            rx,
            stderr_tail,
            stdin,
        })
    }
    /// Send one newline-terminated command to the child over its stdin (the
    /// host parses these as `kick <endpoint-id>`). Best-effort: a closed pipe
    /// (child already gone) just drops the command.
    pub fn send_command(&mut self, cmd: &str) {
        let Some(stdin) = self.stdin.as_mut() else {
            return;
        };
        if let Err(e) = writeln!(stdin, "{cmd}") {
            tracing::warn!("failed to send command to host child: {e}");
            self.stdin = None; // pipe is dead; stop trying
        }
    }
    /// Whether the child is still running.
    pub fn is_alive(&mut self) -> bool {
-        matches!(self.child.as_mut().map(Child::try_wait), Some(Ok(None)))
+        matches!(self.child.try_wait(), Ok(None))
    }
    /// The last captured stderr lines, joined — for error display.
    pub fn stderr_tail(&self) -> String {
        self.stderr_tail.lock().unwrap().join("\n")
    }
    /// Send a newline-terminated command to the child.
    pub fn send_command(&mut self, cmd: &str) {
        use std::io::Write;
        if let Err(e) = writeln!(self.stdin, "{cmd}") {
            tracing::warn!("failed to send command to child: {e}");
        }
    }
    /// Gracefully stop the child: SIGINT (so the host runs its ctrl-c teardown
    /// — tears down capture, closes the endpoint), with a ~2 s grace period
    /// before a hard kill. Idempotent.
    pub fn stop(&mut self) {
        if matches!(self.child.try_wait(), Ok(Some(_))) {
            return; // already exited
        }
        let _ = kill(Pid::from_raw(self.child.id() as i32), Signal::SIGINT);
        for _ in 0..40 {
            if matches!(self.child.try_wait(), Ok(Some(_))) {
                return;
            }
            std::thread::sleep(Duration::from_millis(50));
        }
        let _ = self.child.kill();
        let _ = self.child.wait();
    }
 }
 impl Drop for ChildProc {
    fn drop(&mut self) {
-        // Leaving a host/viewer screen, or closing the window, must not orphan
+        // Closing the window (dropping the app, hence the session) must not
-        // a live child — but it must also not *block*. eframe runs this drop
+        // orphan a live host child streaming to viewers.
-        // synchronously while it destroys the window, so a grace-period wait
+        self.stop();
        // here freezes the window mid-close: the first click looks like it did
        // nothing (the stream just drops) and the window only goes away on a
        // second click. So SIGINT now — synchronously, so the host always gets
        // its ctrl-c teardown (capture down, endpoint closed) even if we exit
        // right after — then reap on a detached thread instead of waiting.
        let Some(mut child) = self.child.take() else {
            return;
        };
        if matches!(child.try_wait(), Ok(Some(_))) {
            return; // already exited; nothing to signal or reap
        }
        let _ = kill(Pid::from_raw(child.id() as i32), Signal::SIGINT);
        std::thread::spawn(move || {
            for _ in 0..40 {
                if matches!(child.try_wait(), Ok(Some(_))) {
                    return;
                }
                std::thread::sleep(Duration::from_millis(50));
            }
            let _ = child.kill();
            let _ = child.wait();
        });
    }
 }
@@ -247,7 +222,7 @@ mod tests {
    }
    #[test]
-    fn viewer_join_leave_round_trip() {
+    fn viewer_events_round_trips() {
        assert!(matches!(
            parse(Event::ViewerJoined { id: "nodeXYZ", active: 2, max: 4 }),
            ChildEvent::ViewerJoined { id, active: 2, max: 4 } if id == "nodeXYZ"
@@ -261,20 +236,12 @@ mod tests {
    #[test]
    fn capture_state_round_trips() {
        assert!(matches!(
-            parse(Event::Capture {
+            parse(Event::Capture { state: EmitState::Started }),
-                state: EmitState::Started
+            ChildEvent::Capture { state: CaptureState::Started }
            }),
            ChildEvent::Capture {
                state: CaptureState::Started
            }
        ));
        assert!(matches!(
-            parse(Event::Capture {
+            parse(Event::Capture { state: EmitState::Stopped }),
-                state: EmitState::Stopped
+            ChildEvent::Capture { state: CaptureState::Stopped }
            }),
            ChildEvent::Capture {
                state: CaptureState::Stopped
            }
        ));
    }
@@ -1,88 +0,0 @@
 //! Share-code wrapping: carrying the host's stable friend id alongside the
 //! one-shot video ticket.
 //!
 //! A bare video ticket identifies only the host's *ephemeral* video endpoint,
 //! so two people who meet over one can't learn each other's stable friend id —
 //! the thing the friends system needs. The GUI host therefore wraps its ticket
 //! with its control-plane [`EndpointId`]; the viewer unwraps it, dials the
 //! video ticket as before, and now also knows who to befriend (and announces
 //! itself back over the control plane so the host learns the viewer in turn).
 //!
 //! Format: `pixelpassF1:<host-control-id>.<bare-ticket>`. Both the id and the
 //! ticket are base32 text with no `.`, so a single `.` separator is
 //! unambiguous. [`unwrap`] is lenient: anything without the prefix is treated
 //! as a bare ticket, so a plain CLI ticket pasted into the GUI still works (it
 //! just offers no friend option). The host name isn't carried here — the
 //! viewer's announcement triggers a name exchange over the control plane.
 use std::str::FromStr;
 use iroh::EndpointId;
 /// Prefix marking a wrapped friend code. The `F1` is the wrap-format version,
 /// bumped if the layout ever changes.
 const MAGIC: &str = "pixelpassF1:";
 /// Wrap a bare ticket with the host's control id, for display/copy/QR.
 pub fn wrap(host_id: EndpointId, ticket: &str) -> String {
    format!("{MAGIC}{host_id}.{ticket}")
 }
 /// Split an input into `(host control id if it was a wrapped code, bare
 /// ticket)`. A bare or unrecognised input yields `(None, trimmed input)` so the
 /// viewer path stays identical to before for plain tickets.
 pub fn unwrap(code: &str) -> (Option<EndpointId>, String) {
    let code = code.trim();
    if let Some(rest) = code.strip_prefix(MAGIC)
        && let Some((id_str, ticket)) = rest.split_once('.')
        && let Ok(id) = EndpointId::from_str(id_str)
        && !ticket.is_empty()
    {
        return (Some(id), ticket.to_string());
    }
    (None, code.to_string())
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    fn sample_id() -> EndpointId {
        iroh::SecretKey::generate().public()
    }
    #[test]
    fn wrap_unwrap_round_trips() {
        let id = sample_id();
        let ticket = "endpointaabwxjexzensznfvuudiapn5tyzws3angd2merarm";
        let code = wrap(id, ticket);
        let (got_id, got_ticket) = unwrap(&code);
        assert_eq!(got_id, Some(id));
        assert_eq!(got_ticket, ticket);
    }
    #[test]
    fn bare_ticket_passes_through() {
        let ticket = "endpointaabwxjexzensznfvuudiapn5tyzws3angd2merarm";
        let (id, got) = unwrap(ticket);
        assert_eq!(id, None);
        assert_eq!(got, ticket);
    }
    #[test]
    fn trims_surrounding_whitespace() {
        let ticket = "endpointaabwxjex";
        let (id, got) = unwrap(&format!("  {}  ", wrap(sample_id(), ticket)));
        assert!(id.is_some());
        assert_eq!(got, ticket);
    }
    #[test]
    fn malformed_wrapped_code_falls_back_to_bare() {
        // Prefix present but the id isn't a valid EndpointId → treat the whole
        // thing as a (doomed) bare ticket rather than panicking.
        let (id, got) = unwrap("pixelpassF1:not-an-id.endpointaa");
        assert_eq!(id, None);
        assert_eq!(got, "pixelpassF1:not-an-id.endpointaa");
    }
 }
@@ -1,299 +0,0 @@
 //! The always-on friends presence service.
 //!
 //! A control-plane iroh endpoint ([`endpoint::bind_control`]) that lives for the
 //! whole GUI session on its own thread with a current-thread tokio runtime — the
 //! GUI is a synchronous winit/egui loop, so iroh's async work can't run on it
 //! (the same reason [`super::tray`] has its own thread + runtime).
 //!
 //! Inbound control messages are forwarded over a std mpsc channel the UI drains
 //! each [`super::PixelPassApp::tick`]; the [`Waker`] is pinged on arrival so a
 //! message wakes the loop even while the window is hidden to the tray — the same
 //! trick the headless-child reader uses.
 use std::sync::Arc;
 use std::sync::mpsc::{self, Receiver};
 use std::thread;
 use iroh::{Endpoint, EndpointId};
 use tokio::sync::mpsc as tmpsc;
 use super::Waker;
 use crate::common::{
    control::{self, ControlMsg, Inbound},
    endpoint, identity,
 };
 /// A command the UI hands the presence service over [`PresenceHandle`].
 enum Command {
    /// Deliver one message, once, fire-and-forget (friend request/accept/decline
    /// and the presence `Hello`). A failure is logged, not retried.
    Send { peer: EndpointId, msg: ControlMsg },
    /// Begin — or replace — a share campaign: push `msg` (a
    /// [`ControlMsg::ShareCode`]) to every peer in `peers`, retrying the ones
    /// that are offline until they're reached or the campaign is stopped. Each
    /// success emits a [`PresenceEvent::ShareDelivered`]. Replaces any campaign
    /// already running (a fresh host session supersedes the previous code).
    StartShare {
        msg: ControlMsg,
        peers: Vec<EndpointId>,
    },
    /// Stop the active share campaign — the host stopped or left the screen, so
    /// the perishable code is no longer valid and offline friends shouldn't keep
    /// being chased.
    StopShare,
 }
 /// Something the service surfaces to the UI, drained each tick.
 pub enum PresenceEvent {
    /// A control message arrived from a peer.
    Message(Inbound),
    /// A share-campaign code reached `peer` (its ACK came back). Lets the host
    /// screen flip that friend's row from "retrying" to "delivered."
    ShareDelivered { peer: EndpointId },
 }
 /// How long to wait before re-attempting delivery to friends who were offline
 /// on the previous round of a share campaign.
 const SHARE_RETRY: std::time::Duration = std::time::Duration::from_secs(5);
 /// Handle the GUI holds for the presence service. Dropping it doesn't stop the
 /// service (the thread is detached; the endpoint closes when the process exits)
 /// — it just stops the UI from draining inbound messages.
 pub struct PresenceHandle {
    /// Our stable control-plane id — what friends know us by, and what we embed
    /// in a wrapped share code so a viewer can find us.
    id: EndpointId,
    /// Service events (inbound messages + share receipts), drained by
    /// [`PresenceHandle::drain`] each tick.
    rx: Receiver<PresenceEvent>,
    /// Commands handed to the service thread. Unbounded tokio sender so the sync
    /// UI can enqueue without blocking or being inside the runtime.
    out_tx: tmpsc::UnboundedSender<Command>,
 }
 impl PresenceHandle {
    /// Our stable control-plane id.
    pub fn id(&self) -> EndpointId {
        self.id
    }
    /// Pull every service event received since the last call. Collected by the
    /// caller so it can take `&mut self` while handling them.
    pub fn drain(&self) -> Vec<PresenceEvent> {
        std::iter::from_fn(|| self.rx.try_recv().ok()).collect()
    }
    /// Enqueue a one-shot message for delivery to `peer`. Fire-and-forget from
    /// the UI's view; the service connects, delivers, and logs a failure. A send
    /// error here only means the service thread is gone.
    pub fn send(&self, peer: EndpointId, msg: ControlMsg) {
        self.command(Command::Send { peer, msg });
    }
    /// Begin (or replace) a share campaign pushing `msg` to `peers`, retrying
    /// offline friends until [`PresenceHandle::stop_share`] or the next call.
    pub fn start_share(&self, msg: ControlMsg, peers: Vec<EndpointId>) {
        self.command(Command::StartShare { msg, peers });
    }
    /// Stop the active share campaign (host stopped — the code is now stale).
    pub fn stop_share(&self) {
        self.command(Command::StopShare);
    }
    fn command(&self, cmd: Command) {
        if self.out_tx.send(cmd).is_err() {
            tracing::warn!("presence: service thread gone; dropping command");
        }
    }
 }
 /// Start the presence service. Returns `None` if the persistent identity can't
 /// be loaded — the GUI then simply runs without friends features rather than
 /// refusing to start. The endpoint binds asynchronously on the spawned thread;
 /// our id is known immediately because it derives from the saved key, so we can
 /// fail-fast and log it without waiting on the relay handshake.
 pub fn start(waker: Waker, relay: Option<String>) -> Option<PresenceHandle> {
    let id: EndpointId = match identity::load_or_create() {
        Ok(key) => key.public(),
        Err(e) => {
            tracing::warn!("presence: no identity, friends features disabled: {e:#}");
            return None;
        }
    };
    tracing::info!(%id, "presence: starting control service");
    let (tx, rx) = mpsc::channel::<PresenceEvent>();
    let (out_tx, out_rx) = tmpsc::unbounded_channel::<Command>();
    thread::Builder::new()
        .name("pixelpass-presence".into())
        .spawn(move || run(relay, id, tx, out_rx, waker))
        .map_err(|e| tracing::warn!("presence: could not spawn service thread: {e}"))
        .ok()?;
    Some(PresenceHandle { id, rx, out_tx })
 }
 /// Thread body: a current-thread tokio runtime that binds the control endpoint,
 /// runs the accept loop, bridges inbound messages to the UI channel, and
 /// delivers outbound messages the UI enqueues.
 fn run(
    relay: Option<String>,
    id: EndpointId,
    tx: mpsc::Sender<PresenceEvent>,
    mut out_rx: tmpsc::UnboundedReceiver<Command>,
    waker: Waker,
 ) {
    let rt = match tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()
    {
        Ok(rt) => rt,
        Err(e) => {
            tracing::error!("presence: failed to build runtime: {e}");
            return;
        }
    };
    rt.block_on(async move {
        let ep = match endpoint::bind_control(relay.as_deref()).await {
            Ok(ep) => ep,
            Err(e) => {
                tracing::error!("presence: failed to bind control endpoint: {e:#}");
                return;
            }
        };
        tracing::info!(%id, "presence: control endpoint online");
        // One async→sync bridge for *everything* the UI sees: every producer
        // (the accept loop and the share campaign) pushes a `PresenceEvent` into
        // `ui_tx`; this task drains it onto the std channel and wakes the loop so
        // the event lands even while the window is hidden to the tray.
        let (ui_tx, mut ui_rx) = tmpsc::channel::<PresenceEvent>(64);
        let forward = tokio::spawn(async move {
            while let Some(event) = ui_rx.recv().await {
                if tx.send(event).is_err() {
                    break; // UI gone
                }
                waker.wake();
            }
        });
        // Wrap inbound control messages as events and feed the bridge.
        let (itx, mut irx) = tmpsc::channel::<Inbound>(32);
        let inbound_ui = ui_tx.clone();
        let inbound = tokio::spawn(async move {
            while let Some(msg) = irx.recv().await {
                if inbound_ui.send(PresenceEvent::Message(msg)).await.is_err() {
                    break;
                }
            }
        });
        // Handle UI commands: one-shot sends each on their own task, and a single
        // abortable share campaign (StartShare replaces it, StopShare cancels it).
        let cmd_ep = ep.clone();
        let commands = tokio::spawn(async move {
            let mut share: Option<tokio::task::JoinHandle<()>> = None;
            while let Some(cmd) = out_rx.recv().await {
                match cmd {
                    Command::Send { peer, msg } => {
                        let ep = cmd_ep.clone();
                        tokio::spawn(async move {
                            if let Err(e) = control::send(&ep, peer, &msg).await {
                                tracing::warn!(%peer, "presence: outbound send failed: {e:#}");
                            }
                        });
                    }
                    Command::StartShare { msg, peers } => {
                        if let Some(t) = share.take() {
                            t.abort();
                        }
                        let ep = cmd_ep.clone();
                        let ui = ui_tx.clone();
                        share = Some(tokio::spawn(run_share(ep, msg, peers, ui)));
                    }
                    Command::StopShare => {
                        if let Some(t) = share.take() {
                            t.abort();
                        }
                    }
                }
            }
        });
        control::serve(ep, itx).await;
        forward.abort();
        inbound.abort();
        commands.abort();
    });
 }
 /// Push `msg` to every peer in `peers`, retrying the ones that are offline every
 /// [`SHARE_RETRY`] until all are delivered (or the task is aborted by a
 /// StartShare/StopShare). Emits one [`PresenceEvent::ShareDelivered`] per peer
 /// the moment its ACK comes back — that ACK *is* the delivery signal.
 ///
 /// Each round fires all still-pending peers **concurrently**, so a single
 /// offline friend's ~10s connect timeout doesn't serialise the whole round
 /// (which it did when peers were tried one at a time).
 async fn run_share(
    ep: Endpoint,
    msg: ControlMsg,
    mut pending: Vec<EndpointId>,
    ui: tmpsc::Sender<PresenceEvent>,
 ) {
    // The code is immutable for the campaign's life; share it across the
    // per-peer tasks via an `Arc` rather than re-cloning the payload each round.
    let msg = Arc::new(msg);
    while !pending.is_empty() {
        let mut round = tokio::task::JoinSet::new();
        for peer in pending {
            let ep = ep.clone();
            let msg = Arc::clone(&msg);
            round.spawn(async move {
                match control::send(&ep, peer, &msg).await {
                    Ok(()) => (peer, true),
                    Err(e) => {
                        tracing::debug!(%peer, "presence: share not yet delivered: {e:#}");
                        (peer, false)
                    }
                }
            });
        }
        let mut still = Vec::new();
        while let Some(joined) = round.join_next().await {
            let (peer, delivered) = match joined {
                Ok(outcome) => outcome,
                // A send task panicking is unexpected; log and drop that peer
                // from the campaign rather than abort the whole round. (A
                // campaign-level abort drops this future entirely — we never
                // observe that as a JoinError here.)
                Err(e) => {
                    tracing::warn!("presence: share task failed: {e}");
                    continue;
                }
            };
            if delivered {
                tracing::info!(%peer, "presence: shared code delivered");
                if ui
                    .send(PresenceEvent::ShareDelivered { peer })
                    .await
                    .is_err()
                {
                    return; // UI gone — nothing left to report to
                }
            } else {
                still.push(peer);
            }
        }
        if still.is_empty() {
            break;
        }
        pending = still;
        tokio::time::sleep(SHARE_RETRY).await;
    }
    tracing::info!("presence: share campaign complete");
 }
@@ -1,456 +0,0 @@
 //! User-customisable colour themes for the GUI.
 //!
 //! A theme is a small, curated *semantic* palette — backgrounds, text, an
 //! accent, and the handful of status colours the app uses (streaming, waiting,
 //! success, warning, error). That's deliberately a fixed set rather than a
 //! passthrough of every [`egui::Visuals`] field: it's easy to author by hand,
 //! covers the whole look of the app, and stays stable across egui upgrades.
 //!
 //! Themes serialise to TOML with colours as `#rrggbb` hex strings. Three
 //! themes ship built in; users drop their own `*.toml` files in
 //! `~/.config/pixelpass/themes/` (or save one from the in-app editor) and they
 //! show up alongside the built-ins. A user file whose `name` matches a built-in
 //! overrides it.
 use std::path::PathBuf;
 use anyhow::{Context, Result};
 use directories::ProjectDirs;
 use eframe::egui::{self, Color32};
 use serde::{Deserialize, Serialize};
 /// One colour theme: a curated semantic palette.
 ///
 /// `#[serde(default)]` on the container means any field missing from a TOML
 /// file falls back to the corresponding field of [`Theme::default`] (the
 /// built-in Default Dark), so a partial or hand-trimmed file still loads.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(default)]
 pub struct Theme {
    /// Display name, shown in the picker and used as the file stem on save.
    pub name: String,
    /// Base egui defaults to start from before applying the palette overrides.
    pub dark: bool,
    // ── chrome ────────────────────────────────────────────────────────
    /// Window background.
    #[serde(with = "hex")]
    pub window_bg: Color32,
    /// Panel / frame background.
    #[serde(with = "hex")]
    pub panel_bg: Color32,
    /// Text-input and read-only field background (the ticket box, etc.).
    #[serde(with = "hex")]
    pub input_bg: Color32,
    /// Primary text.
    #[serde(with = "hex")]
    pub text: Color32,
    /// Secondary / de-emphasised text (hints, the version line).
    #[serde(with = "hex")]
    pub weak_text: Color32,
    /// Accent: selection, hyperlinks, and the active/pressed widget fill.
    #[serde(with = "hex")]
    pub accent: Color32,
    /// Button (and other interactive widget) resting background.
    #[serde(with = "hex")]
    pub button_bg: Color32,
    /// Button background on hover.
    #[serde(with = "hex")]
    pub button_hovered: Color32,
    // ── semantic status colours ───────────────────────────────────────
    /// "● Streaming" indicator.
    #[serde(with = "hex")]
    pub streaming: Color32,
    /// "● Waiting for viewers…" indicator.
    #[serde(with = "hex")]
    pub waiting: Color32,
    /// Success notes, e.g. "✓ Copied to clipboard".
    #[serde(with = "hex")]
    pub success: Color32,
    /// Non-fatal warnings, e.g. a host-full refusal.
    #[serde(with = "hex")]
    pub warning: Color32,
    /// Errors.
    #[serde(with = "hex")]
    pub error: Color32,
 }
 impl Default for Theme {
    fn default() -> Self {
        default_dark()
    }
 }
 impl Theme {
    /// Build the egui [`Visuals`](egui::Visuals) this theme describes. Starts
    /// from egui's dark or light defaults (so anything the palette doesn't name
    /// stays sensible) and overrides the curated fields.
    pub fn visuals(&self) -> egui::Visuals {
        use egui::{Stroke, Visuals};
        let mut v = if self.dark {
            Visuals::dark()
        } else {
            Visuals::light()
        };
        v.dark_mode = self.dark;
        v.window_fill = self.window_bg;
        v.panel_fill = self.panel_bg;
        v.faint_bg_color = self.panel_bg;
        v.extreme_bg_color = self.input_bg;
        v.override_text_color = Some(self.text);
        // `.weak()` text resolves via `weak_text_color()`, which derives from
        // `text` unless this is set — so without it the weak-text field is dead.
        v.weak_text_color = Some(self.weak_text);
        v.hyperlink_color = self.accent;
        v.error_fg_color = self.error;
        v.warn_fg_color = self.warning;
        // A translucent accent reads well as a selection highlight on either a
        // light or dark base.
        v.selection.bg_fill =
            Color32::from_rgba_unmultiplied(self.accent.r(), self.accent.g(), self.accent.b(), 96);
        v.selection.stroke = Stroke::new(1.0, self.accent);
        let text_stroke = Stroke::new(1.0, self.text);
        let weak_stroke = Stroke::new(1.0, self.weak_text);
        v.widgets.noninteractive.bg_fill = self.panel_bg;
        v.widgets.noninteractive.weak_bg_fill = self.panel_bg;
        v.widgets.noninteractive.fg_stroke = weak_stroke;
        v.widgets.inactive.bg_fill = self.button_bg;
        v.widgets.inactive.weak_bg_fill = self.button_bg;
        v.widgets.inactive.fg_stroke = text_stroke;
        v.widgets.hovered.bg_fill = self.button_hovered;
        v.widgets.hovered.weak_bg_fill = self.button_hovered;
        v.widgets.hovered.fg_stroke = text_stroke;
        v.widgets.active.bg_fill = self.accent;
        v.widgets.active.weak_bg_fill = self.accent;
        v.widgets.active.fg_stroke = text_stroke;
        v
    }
 }
 // ── built-in themes ───────────────────────────────────────────────────────
 /// Names of the built-in themes, in picker order.
 pub const BUILTIN_NAMES: [&str; 3] = ["Default Dark", "Catppuccin Mocha", "Catppuccin Latte"];
 /// Parse a built-in's hex literal, panicking on a typo (these are compile-time
 /// constants we control, so a bad value is a bug, not user input).
 fn c(hex: &str) -> Color32 {
    parse_hex(hex).expect("built-in theme hex is valid")
 }
 /// The default theme — a neutral dark palette. Also [`Theme::default`].
 pub fn default_dark() -> Theme {
    Theme {
        name: "Default Dark".to_string(),
        dark: true,
        window_bg: c("#1b1b1f"),
        panel_bg: c("#242429"),
        input_bg: c("#141417"),
        text: c("#e6e6ea"),
        weak_text: c("#a0a0a8"),
        accent: c("#5aa0f2"),
        button_bg: c("#33333a"),
        button_hovered: c("#44444d"),
        streaming: c("#6fdc8c"),
        waiting: c("#f2c14e"),
        success: c("#6fdc8c"),
        warning: c("#f0a85a"),
        error: c("#f2756f"),
    }
 }
 /// Catppuccin Mocha (dark). <https://github.com/catppuccin/catppuccin>
 fn catppuccin_mocha() -> Theme {
    Theme {
        name: "Catppuccin Mocha".to_string(),
        dark: true,
        window_bg: c("#1e1e2e"),
        panel_bg: c("#181825"),
        input_bg: c("#11111b"),
        text: c("#cdd6f4"),
        weak_text: c("#a6adc8"),
        accent: c("#cba6f7"),
        button_bg: c("#313244"),
        button_hovered: c("#45475a"),
        streaming: c("#a6e3a1"),
        waiting: c("#f9e2af"),
        success: c("#a6e3a1"),
        warning: c("#fab387"),
        error: c("#f38ba8"),
    }
 }
 /// Catppuccin Latte (light). <https://github.com/catppuccin/catppuccin>
 fn catppuccin_latte() -> Theme {
    Theme {
        name: "Catppuccin Latte".to_string(),
        dark: false,
        window_bg: c("#eff1f5"),
        panel_bg: c("#e6e9ef"),
        input_bg: c("#dce0e8"),
        text: c("#4c4f69"),
        weak_text: c("#6c6f85"),
        accent: c("#8839ef"),
        button_bg: c("#ccd0da"),
        button_hovered: c("#bcc0cc"),
        streaming: c("#40a02b"),
        waiting: c("#df8e1d"),
        success: c("#40a02b"),
        warning: c("#fe640b"),
        error: c("#d20f39"),
    }
 }
 /// The built-in themes, in [`BUILTIN_NAMES`] order.
 pub fn builtins() -> Vec<Theme> {
    vec![default_dark(), catppuccin_mocha(), catppuccin_latte()]
 }
 /// Whether `name` is one of the built-ins (which are read-only — the editor
 /// nudges you to save under a new name).
 pub fn is_builtin(name: &str) -> bool {
    BUILTIN_NAMES.contains(&name)
 }
 // ── on-disk themes ──────────────────────────────────────────────────────────
 /// `~/.config/pixelpass/themes/` (or the XDG equivalent). Not created until a
 /// theme is saved.
 pub fn themes_dir() -> Result<PathBuf> {
    let dirs = ProjectDirs::from("", "", "pixelpass")
        .context("could not locate a config directory for pixelpass")?;
    Ok(dirs.config_dir().join("themes"))
 }
 /// Parse every `*.toml` in the themes dir into a [`Theme`]. A file that fails
 /// to parse is logged and skipped rather than aborting the whole list, so one
 /// bad file can't hide the rest. Returns themes sorted by name.
 pub fn list_user_themes() -> Vec<Theme> {
    let Ok(dir) = themes_dir() else {
        return Vec::new();
    };
    let Ok(entries) = std::fs::read_dir(&dir) else {
        return Vec::new(); // dir doesn't exist yet → no user themes
    };
    let mut out = Vec::new();
    for entry in entries.flatten() {
        let path = entry.path();
        if path.extension().and_then(|e| e.to_str()) != Some("toml") {
            continue;
        }
        match std::fs::read_to_string(&path) {
            Ok(s) => match toml::from_str::<Theme>(&s) {
                Ok(mut t) => {
                    // Fall back to the file stem if the file omits a name.
                    if t.name.trim().is_empty() {
                        t.name = path
                            .file_stem()
                            .and_then(|s| s.to_str())
                            .unwrap_or("Unnamed")
                            .to_string();
                    }
                    out.push(t);
                }
                Err(e) => tracing::warn!("skipping theme {}: {e}", path.display()),
            },
            Err(e) => tracing::warn!("could not read theme {}: {e}", path.display()),
        }
    }
    out.sort_by_key(|t| t.name.to_lowercase());
    out
 }
 /// Built-ins plus user themes, in picker order: built-ins first (a user file
 /// with a matching `name` overrides the built-in's colours in place), then any
 /// remaining user themes alphabetically.
 pub fn all_themes() -> Vec<Theme> {
    let users = list_user_themes();
    let mut out: Vec<Theme> = builtins()
        .into_iter()
        .map(|b| {
            users
                .iter()
                .find(|u| u.name == b.name)
                .cloned()
                .unwrap_or(b)
        })
        .collect();
    for u in users {
        if !is_builtin(&u.name) {
            out.push(u);
        }
    }
    out
 }
 /// The theme with this `name`, or Default Dark if it can't be found (e.g. the
 /// config names a theme whose file was deleted).
 pub fn load_named(name: &str) -> Theme {
    all_themes()
        .into_iter()
        .find(|t| t.name == name)
        .unwrap_or_else(default_dark)
 }
 /// Write `theme` to `<themes_dir>/<slug>.toml` and return the path. Overwrites
 /// an existing file with the same slug (i.e. saving a tweaked theme under the
 /// same name updates it in place).
 pub fn save_theme(theme: &Theme) -> Result<PathBuf> {
    let dir = themes_dir()?;
    std::fs::create_dir_all(&dir).with_context(|| format!("failed to create {}", dir.display()))?;
    let slug = slugify(&theme.name);
    let path = dir.join(format!("{slug}.toml"));
    let body = toml::to_string_pretty(theme).context("failed to serialise theme to TOML")?;
    let contents = format!(
        "# PixelPass theme. Colours are #rrggbb hex strings.\n\
         # Edit and re-pick it in Settings, or drop more .toml files in this folder.\n\n\
         {body}"
    );
    std::fs::write(&path, contents)
        .with_context(|| format!("failed to write {}", path.display()))?;
    Ok(path)
 }
 /// Lowercase, replace runs of non-alphanumerics with a single hyphen, trim
 /// hyphens. Empty input becomes `theme`.
 fn slugify(name: &str) -> String {
    let mut slug = String::new();
    let mut prev_hyphen = false;
    for ch in name.trim().chars() {
        if ch.is_ascii_alphanumeric() {
            slug.push(ch.to_ascii_lowercase());
            prev_hyphen = false;
        } else if !prev_hyphen {
            slug.push('-');
            prev_hyphen = true;
        }
    }
    let slug = slug.trim_matches('-').to_string();
    if slug.is_empty() {
        "theme".to_string()
    } else {
        slug
    }
 }
 // ── hex colour parsing ────────────────────────────────────────────────────
 /// Parse `#rrggbb` into an opaque [`Color32`] (the leading `#` is optional).
 /// An 8-digit `#rrggbbaa` is accepted leniently but its alpha is ignored —
 /// theme colours are opaque, and `Color32`'s premultiplied storage can't
 /// round-trip a straight alpha losslessly anyway. Returns `None` on malformed
 /// input.
 pub fn parse_hex(s: &str) -> Option<Color32> {
    let s = s.trim();
    let s = s.strip_prefix('#').unwrap_or(s);
    if !matches!(s.len(), 6 | 8) || !s.bytes().all(|b| b.is_ascii_hexdigit()) {
        return None;
    }
    let byte = |i: usize| u8::from_str_radix(&s[i..i + 2], 16).ok();
    Some(Color32::from_rgb(byte(0)?, byte(2)?, byte(4)?))
 }
 /// Format a [`Color32`] as opaque `#rrggbb`.
 pub fn to_hex(c: Color32) -> String {
    let [r, g, b, _] = c.to_srgba_unmultiplied();
    format!("#{r:02x}{g:02x}{b:02x}")
 }
 /// serde adaptor so `Color32` fields round-trip as hex strings in TOML.
 mod hex {
    use super::{parse_hex, to_hex};
    use eframe::egui::Color32;
    use serde::{Deserialize, Deserializer, Serializer, de::Error};
    pub fn serialize<S: Serializer>(c: &Color32, s: S) -> Result<S::Ok, S::Error> {
        s.serialize_str(&to_hex(*c))
    }
    pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Color32, D::Error> {
        let s = String::deserialize(d)?;
        parse_hex(&s).ok_or_else(|| {
            D::Error::custom(format!(
                "invalid hex colour {s:?} (expected #rrggbb or #rrggbbaa)"
            ))
        })
    }
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    #[test]
    fn hex_round_trips() {
        for (input, expect) in [
            ("#1e1e2e", Color32::from_rgb(0x1e, 0x1e, 0x2e)),
            ("aabbcc", Color32::from_rgb(0xaa, 0xbb, 0xcc)),
            // 8-digit is accepted but the alpha is dropped (opaque rgb).
            ("#11223344", Color32::from_rgb(0x11, 0x22, 0x33)),
        ] {
            assert_eq!(parse_hex(input).expect("parses"), expect);
        }
        assert_eq!(to_hex(Color32::from_rgb(0x1e, 0x1e, 0x2e)), "#1e1e2e");
        // Opaque colours round-trip exactly.
        let c = Color32::from_rgb(0xab, 0xcd, 0xef);
        assert_eq!(parse_hex(&to_hex(c)), Some(c));
    }
    #[test]
    fn hex_rejects_garbage() {
        for bad in ["", "#fff", "#12345", "nothex", "#gggggg", "#1234567"] {
            assert!(parse_hex(bad).is_none(), "{bad:?} should not parse");
        }
    }
    #[test]
    fn theme_toml_round_trips() {
        let original = catppuccin_mocha();
        let toml = toml::to_string_pretty(&original).unwrap();
        let parsed: Theme = toml::from_str(&toml).unwrap();
        assert_eq!(original, parsed);
        // Colours serialise as hex strings, not RGBA tables.
        assert!(toml.contains("window_bg = \"#1e1e2e\""), "{toml}");
    }
    #[test]
    fn partial_toml_fills_from_default() {
        // Only a name and one colour; everything else must fall back to Default Dark.
        let parsed: Theme = toml::from_str("name = \"Partial\"\naccent = \"#ff0000\"").unwrap();
        let base = default_dark();
        assert_eq!(parsed.name, "Partial");
        assert_eq!(parsed.accent, Color32::from_rgb(0xff, 0, 0));
        assert_eq!(parsed.window_bg, base.window_bg); // filled from default
        assert_eq!(parsed.text, base.text);
    }
    #[test]
    fn slugify_is_filesystem_safe() {
        assert_eq!(slugify("Catppuccin Mocha"), "catppuccin-mocha");
        assert_eq!(slugify("  My  Theme!! "), "my-theme");
        assert_eq!(slugify("***"), "theme");
        assert_eq!(slugify("Solarized/Dark"), "solarized-dark");
    }
    #[test]
    fn builtins_match_names() {
        let names: Vec<String> = builtins().iter().map(|t| t.name.clone()).collect();
        let expected: Vec<String> = BUILTIN_NAMES.iter().map(|s| s.to_string()).collect();
        assert_eq!(names, expected);
        for t in builtins() {
            assert!(is_builtin(&t.name));
        }
    }
 }
@@ -1,257 +0,0 @@
 //! System-tray (StatusNotifierItem) integration for the GUI.
 //!
 //! The tray runs on its **own dedicated thread** with its own current-thread
 //! tokio runtime, fully decoupled from the winit event loop (which owns the
 //! main thread) and from the process-wide `#[tokio::main]` runtime. It talks to
 //! the egui app purely over winit's event channel and a status channel:
 //!
 //!   * tray → app: a [`super::UserEvent::Tray`] carrying a [`TrayAction`]
 //!     (Show / Quit), pushed through the [`winit::event_loop::EventLoopProxy`].
 //!     Using the proxy (not egui's repaint) is essential: a tray click must
 //!     wake the winit loop even when the window has been **dropped** (hidden to
 //!     tray), so the loop can recreate it.
 //!   * app → tray: [`TrayStatus`] (idle / hosting / viewing), pushed on change.
 //!
 //! Why a separate thread instead of `Handle::current().spawn`: updating the
 //! tray from the egui thread would need `block_on`, which panics when called
 //! from inside the running runtime. Keeping ksni's async wholly on its own
 //! runtime sidesteps that and keeps the frame loop non-blocking.
 use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};
 use ksni::TrayMethods;
 use winit::event_loop::EventLoopProxy;
 use super::UserEvent;
 /// What the user picked from the tray icon or its menu (tray thread → app),
 /// delivered as a [`UserEvent::Tray`].
 pub enum TrayAction {
    /// Left-click, or the "Show window" item: bring the window back.
    Show,
    /// The "Quit" item: really exit (the close button only hides to tray).
    Quit,
 }
 /// What the tray icon's tooltip/menu reflect (app → tray thread).
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub enum TrayStatus {
    Idle,
    Hosting { active: u32, max: u32 },
    Viewing,
 }
 fn status_text(status: TrayStatus) -> String {
    match status {
        TrayStatus::Idle => "Idle".to_string(),
        TrayStatus::Hosting { active, max } => {
            format!("Hosting — {active} of {max} viewer(s) connected")
        }
        TrayStatus::Viewing => "Viewing a stream".to_string(),
    }
 }
 /// Handle held by the egui app for the lifetime of the window. Dropping it
 /// closes the app→tray channel, which ends the tray thread and removes the icon.
 pub struct TrayHandle {
    status_tx: tokio::sync::mpsc::UnboundedSender<TrayStatus>,
    /// Set true once the tray actually registered with a StatusNotifier host.
    /// The app must not divert the window's close to a tray that never appeared.
    registered: Arc<AtomicBool>,
    /// Last status pushed, so we don't spam D-Bus with no-op updates.
    last_sent: Option<TrayStatus>,
 }
 impl TrayHandle {
    /// Whether a system tray is actually showing our icon. Until this is true,
    /// hiding the window would strand it with no way back.
    pub fn registered(&self) -> bool {
        self.registered.load(Ordering::Acquire)
    }
    /// Push a status change to the tray, deduped against the last one sent.
    pub fn set_status(&mut self, status: TrayStatus) {
        if self.last_sent != Some(status) {
            let _ = self.status_tx.send(status);
            self.last_sent = Some(status);
        }
    }
 }
 struct PixelPassTray {
    status: TrayStatus,
    /// ARGB pixmap, so the icon shows even where the themed "pixelpass" name
    /// can't be resolved (e.g. running the dev binary before `make install`).
    icon: Vec<ksni::Icon>,
    /// Wakes the winit loop and delivers the action — works even when the
    /// window has been dropped to the tray (no egui frame is running then).
    proxy: EventLoopProxy<UserEvent>,
    /// Shared with [`TrayHandle`]; kept in sync with the watcher's presence via
    /// the `watcher_online`/`watcher_offline` callbacks so the app never diverts
    /// a close to a tray that has since disappeared.
    registered: Arc<AtomicBool>,
 }
 impl PixelPassTray {
    fn notify(&self, action: TrayAction) {
        let _ = self.proxy.send_event(UserEvent::Tray(action));
    }
 }
 impl ksni::Tray for PixelPassTray {
    fn id(&self) -> String {
        "pixelpass".to_string()
    }
    fn title(&self) -> String {
        "PixelPass".to_string()
    }
    // Themed icon (matches the installed hicolor/scalable/apps/pixelpass.svg);
    // icon_pixmap below is the always-works fallback.
    fn icon_name(&self) -> String {
        "pixelpass".to_string()
    }
    fn icon_pixmap(&self) -> Vec<ksni::Icon> {
        self.icon.clone()
    }
    fn status(&self) -> ksni::Status {
        ksni::Status::Active
    }
    fn tool_tip(&self) -> ksni::ToolTip {
        ksni::ToolTip {
            title: "PixelPass".to_string(),
            description: status_text(self.status),
            icon_name: "pixelpass".to_string(),
            icon_pixmap: Vec::new(),
        }
    }
    fn activate(&mut self, _x: i32, _y: i32) {
        self.notify(TrayAction::Show);
    }
    /// The StatusNotifierWatcher came back (e.g. the panel restarted). Mark the
    /// tray live again so close-to-tray can resume hiding the window.
    fn watcher_online(&self) {
        self.registered.store(true, Ordering::Release);
    }
    /// The watcher went away (panel restart, tray plugin disabled, …). Clear the
    /// flag so a subsequent close quits normally instead of destroying the window
    /// into a tray that no longer exists, and force the window back now in case
    /// it was already hidden (otherwise it'd be stranded with no way to restore).
    /// Returning `true` keeps the service alive so it re-registers if the watcher
    /// returns.
    fn watcher_offline(&self, reason: ksni::OfflineReason) -> bool {
        tracing::warn!("tray: StatusNotifierWatcher offline ({reason:?}); restoring window");
        self.registered.store(false, Ordering::Release);
        self.notify(TrayAction::Show);
        true
    }
    fn menu(&self) -> Vec<ksni::MenuItem<Self>> {
        use ksni::menu::{MenuItem, StandardItem};
        vec![
            // Non-clickable status line.
            StandardItem {
                label: status_text(self.status),
                enabled: false,
                ..Default::default()
            }
            .into(),
            MenuItem::Separator,
            StandardItem {
                label: "Show window".to_string(),
                activate: Box::new(|t: &mut Self| t.notify(TrayAction::Show)),
                ..Default::default()
            }
            .into(),
            StandardItem {
                label: "Quit PixelPass".to_string(),
                icon_name: "application-exit".to_string(),
                activate: Box::new(|t: &mut Self| t.notify(TrayAction::Quit)),
                ..Default::default()
            }
            .into(),
        ]
    }
 }
 /// Decode the embedded PNG (RGBA) and convert to the ARGB pixmap ksni wants.
 /// Reuses eframe's PNG decoder so we don't take a direct `image` dependency.
 fn load_icon() -> Option<Vec<ksni::Icon>> {
    let icon =
        eframe::icon_data::from_png_bytes(include_bytes!("../../assets/pixelpass-256.png")).ok()?;
    let mut data = icon.rgba; // RGBA8, row-major
    for px in data.chunks_exact_mut(4) {
        px.rotate_right(1); // [r,g,b,a] -> [a,r,g,b], network byte order
    }
    Some(vec![ksni::Icon {
        width: icon.width as i32,
        height: icon.height as i32,
        data,
    }])
 }
 /// Start the tray on its own thread. Returns a handle for the app to drive it,
 /// or `None` if the icon couldn't be decoded or the thread couldn't spawn (in
 /// which case the GUI simply runs without a tray — close behaves as before).
 pub fn start(proxy: EventLoopProxy<UserEvent>) -> Option<TrayHandle> {
    let icon = load_icon()?;
    let (status_tx, mut status_rx) = tokio::sync::mpsc::unbounded_channel::<TrayStatus>();
    let registered = Arc::new(AtomicBool::new(false));
    let registered_thread = registered.clone();
    std::thread::Builder::new()
        .name("pixelpass-tray".to_string())
        .spawn(move || {
            let rt = match tokio::runtime::Builder::new_current_thread()
                .enable_all()
                .build()
            {
                Ok(rt) => rt,
                Err(e) => {
                    tracing::warn!("tray: could not build runtime: {e}");
                    return;
                }
            };
            rt.block_on(async move {
                let tray = PixelPassTray {
                    status: TrayStatus::Idle,
                    icon,
                    proxy,
                    registered: registered_thread.clone(),
                };
                let handle = match tray.spawn().await {
                    Ok(handle) => handle,
                    Err(e) => {
                        // No StatusNotifier host (no system tray) — degrade
                        // gracefully: the window keeps its normal close.
                        tracing::warn!("tray: not available, running without it: {e}");
                        return;
                    }
                };
                registered_thread.store(true, Ordering::Release);
                // Apply status changes until the app drops its sender (on quit),
                // which ends this loop, the runtime, the thread, and the icon.
                while let Some(status) = status_rx.recv().await {
                    let _ = handle
                        .update(move |t: &mut PixelPassTray| t.status = status)
                        .await;
                }
            });
        })
        .ok()?;
    Some(TrayHandle {
        status_tx,
        registered,
        last_sent: None,
    })
 }
@@ -52,8 +52,9 @@ impl Routing {
        let pid = std::process::id();
        let sink_name = format!("pixelpass_capture_{pid}");
-        let sink_module = load_module(&["module-null-sink", &format!("sink_name={sink_name}")])
+        let sink_module =
-            .context("failed to load module-null-sink")?;
+            load_module(&["module-null-sink", &format!("sink_name={sink_name}")])
                .context("failed to load module-null-sink")?;
        // 20ms loopback latency keeps the mirrored audio tight; pactl's
        // default of 200ms is enough to be perceptible.
@@ -140,10 +141,7 @@ impl Routing {
    /// Stop the stream router (if any), then unload loopback (if still
    /// loaded), then unload the null-sink. Order matters: PipeWire can
    /// leave zombie links if you destroy a sink with active inputs.
-    ///
+    pub fn shutdown(mut self) {
    /// Every step is a `take()`, so this is idempotent — `Drop` calls it again
    /// as a backstop and the second run is a no-op.
    fn cleanup(&mut self) {
        if let Some(router) = self.stream_router.take() {
            router.shutdown();
        }
@@ -157,17 +155,22 @@ impl Routing {
            unload_module(id);
        }
    }
    /// Consume the routing and tear it all down now. `Drop` is the backstop;
    /// the real work lives in [`cleanup`](Self::cleanup).
    pub fn shutdown(mut self) {
        self.cleanup();
    }
 }
 impl Drop for Routing {
    fn drop(&mut self) {
-        self.cleanup();
+        if let Some(router) = self.stream_router.take() {
            router.shutdown();
        }
        if let Some(task) = self.event_task.take() {
            task.abort();
        }
        if let Some(id) = self.loopback_module.lock().unwrap().take() {
            unload_module(id);
        }
        if let Some(id) = self.sink_module.take() {
            unload_module(id);
        }
    }
 }
@@ -204,9 +207,7 @@ fn parse_sink_inputs(stdout: &[u8]) -> Result<Vec<App>> {
        serde_json::from_slice(stdout).context("pactl returned unparseable JSON")?;
    let mut counts: BTreeMap<String, u32> = BTreeMap::new();
    for entry in entries {
-        let Some(name) = entry.properties.application_name else {
+        let Some(name) = entry.properties.application_name else { continue };
            continue;
        };
        let trimmed = name.trim();
        if trimmed.is_empty() {
            continue;
@@ -360,14 +361,16 @@ fn run_router(
 ) -> Result<()> {
    use pipewire::{self as pw, types::ObjectType};
-    let main_loop =
+    let main_loop = pw::main_loop::MainLoopRc::new(None)
-        pw::main_loop::MainLoopRc::new(None).context("pw main loop construction failed")?;
+        .context("pw main loop construction failed")?;
-    let context =
+    let context = pw::context::ContextRc::new(&main_loop, None)
-        pw::context::ContextRc::new(&main_loop, None).context("pw context construction failed")?;
+        .context("pw context construction failed")?;
    let core = context
        .connect_rc(None)
        .context("pw core connect failed (is the daemon running?)")?;
-    let registry = core.get_registry_rc().context("pw get_registry failed")?;
+    let registry = core
        .get_registry_rc()
        .context("pw get_registry failed")?;
    let state = Rc::new(RefCell::new(RouterState {
        sink_serial: None,
@@ -408,21 +411,20 @@ fn run_router(
    let _reg_listener = registry
        .add_listener_local()
        .global(move |obj| {
-            let Some(reg) = registry_weak.upgrade() else {
+            let Some(reg) = registry_weak.upgrade() else { return };
                return;
            };
            match obj.type_ {
                ObjectType::Node => {
-                    let Some(props) = obj.props.as_ref() else {
+                    let Some(props) = obj.props.as_ref() else { return };
                        return;
                    };
                    if props.get("node.name") == Some(sink_name_owned.as_str()) {
                        if let Some(serial) = props
                            .get("object.serial")
                            .and_then(|s| s.parse::<u32>().ok())
                        {
                            state_for_reg.borrow_mut().sink_serial = Some(serial);
-                            tracing::info!(serial, "audio routing: pixelpass sink registered");
+                            tracing::info!(
                                serial,
                                "audio routing: pixelpass sink registered"
                            );
                            try_flush(&state_for_reg, &event_tx_for_reg);
                        }
                        return;
@@ -430,9 +432,7 @@ fn run_router(
                    if props.get("media.class") != Some("Stream/Output/Audio") {
                        return;
                    }
-                    let Some(app) = props.get("application.name") else {
+                    let Some(app) = props.get("application.name") else { return };
                        return;
                    };
                    if !app.eq_ignore_ascii_case(&filter_lower) {
                        return;
                    }
@@ -445,9 +445,7 @@ fn run_router(
                    try_flush(&state_for_reg, &event_tx_for_reg);
                }
                ObjectType::Metadata => {
-                    let Some(props) = obj.props.as_ref() else {
+                    let Some(props) = obj.props.as_ref() else { return };
                        return;
                    };
                    if props.get("metadata.name") != Some("default") {
                        return;
                    }
@@ -7,33 +7,29 @@ mod wayland;
 mod x11;
 use anyhow::{Result, bail};
-use iroh::endpoint::Connection;
+use iroh::endpoint::{Connection, presets};
 use iroh::{Endpoint, EndpointAddr};
 use iroh_tickets::endpoint::EndpointTicket;
 use std::collections::HashMap;
 use std::time::Duration;
 use tokio::io::{AsyncBufReadExt, BufReader};
 use tokio::sync::{mpsc, oneshot};
 use tokio_util::sync::CancellationToken;
 use crate::cli::HostOpts;
 use crate::common::{
-    bandwidth, config, config::BandwidthStatus, deps, display::DisplayServer, endpoint, output,
+    alpn::ALPN, bandwidth, config, config::BandwidthStatus, deps, display::DisplayServer, output,
    signal, tunnel,
 };
 use self::pipeline::CaptureHandle;
 use self::quality::EffectiveQuality;
-/// Messages from per-viewer tasks (and the GUI command channel) to the
+/// Messages from per-viewer tasks to the capture supervisor.
 /// capture supervisor.
 // The shared `Viewer` suffix is the point — these are all viewer lifecycle
 // messages — so keep the descriptive names.
 #[allow(clippy::enum_variant_names)]
 enum SupervisorMsg {
-    /// A new viewer wants in. Supervisor replies with the local capture HTTP
+    /// A new viewer wants in. Supervisor replies with the local capture
-    /// port to connect to, or an error string if the host is full or capture
+    /// HTTP port to connect to, or an error string if the host is full or
-    /// spawn failed. `cancel` is the viewer's own token — the supervisor keeps
+    /// capture spawn failed.
    /// it so a later `KickViewer` can tear this viewer's stream down.
    AddViewer {
        id: String,
        cancel: CancellationToken,
@@ -42,9 +38,7 @@ enum SupervisorMsg {
    /// A viewer's session ended. Supervisor decrements the count and tears
    /// down capture if it just hit zero.
    RemoveViewer { id: String },
-    /// Host asked (via the GUI command channel) to disconnect a viewer by
+    /// Request to kick a specific viewer.
    /// endpoint id. Cancels that viewer's token; the normal teardown path then
    /// emits the `ViewerLeft`.
    KickViewer { id: String },
 }
@@ -74,7 +68,10 @@ pub async fn run(opts: HostOpts) -> Result<()> {
    let cancel = signal::install_ctrl_c();
-    let endpoint = endpoint::bind(opts.relay.as_deref()).await?;
+    let endpoint = Endpoint::builder(presets::N0)
        .alpns(vec![ALPN.to_vec()])
        .bind()
        .await?;
    // Relay-only ticket: wait for the home relay to connect, then keep only
    // the endpoint id + relay URL and drop the direct IP candidates. The relay
@@ -124,14 +121,16 @@ pub async fn run(opts: HostOpts) -> Result<()> {
        sup_rx,
    ));
-    // Command channel for the GUI front-end: read `kick <endpoint-id>` lines
+    // Stdin listener for "kick <id>"
-    // off stdin. Only when machine-driven (`--output json`) — a human host has
+    let stdin_sup_tx = sup_tx.clone();
-    // nothing to type here, and we don't want to swallow terminal input. Runs
+    tokio::spawn(async move {
-    // on a plain OS thread (not a tokio task) so a read parked on stdin can't
+        let mut lines = BufReader::new(tokio::io::stdin()).lines();
-    // hold up runtime shutdown on Ctrl+C; the thread dies with the process.
+        while let Ok(Some(line)) = lines.next_line().await {
-    if output::json_enabled() {
+            if let Some(id) = line.strip_prefix("kick ") {
-        spawn_kick_listener(sup_tx.clone());
+                let _ = stdin_sup_tx.send(SupervisorMsg::KickViewer { id: id.trim().to_string() }).await;
-    }
+            }
        }
    });
    accept_loop(&endpoint, sup_tx.clone(), cancel.clone()).await;
@@ -179,18 +178,11 @@ async fn handle_peer(
    cancel: CancellationToken,
 ) {
    let remote = conn.remote_id();
-    let id = remote.to_string();
+    let id_str = remote.to_string();
    // This viewer's own kill switch: the supervisor holds a clone so a `kick`
    // can cancel it, and the stream select! below watches it.
    let peer_cancel = CancellationToken::new();
    let (reply_tx, reply_rx) = oneshot::channel();
-    let add = SupervisorMsg::AddViewer {
+    if sup_tx.send(SupervisorMsg::AddViewer { id: id_str.clone(), cancel: peer_cancel.clone(), reply: reply_tx }).await.is_err() {
        id: id.clone(),
        cancel: peer_cancel.clone(),
        reply: reply_tx,
    };
    if sup_tx.send(add).await.is_err() {
        tracing::warn!(%remote, "supervisor channel closed; dropping peer");
        return;
    }
@@ -211,7 +203,7 @@ async fn handle_peer(
        Ok(s) => s,
        Err(e) => {
            tracing::warn!(%remote, "accept_bi failed: {e:#}");
-            let _ = sup_tx.send(SupervisorMsg::RemoveViewer { id }).await;
+            let _ = sup_tx.send(SupervisorMsg::RemoveViewer { id: id_str }).await;
            return;
        }
    };
@@ -222,7 +214,7 @@ async fn handle_peer(
        Ok(t) => t,
        Err(e) => {
            tracing::warn!(%remote, "connect_to_capture failed: {e:#}");
-            let _ = sup_tx.send(SupervisorMsg::RemoveViewer { id }).await;
+            let _ = sup_tx.send(SupervisorMsg::RemoveViewer { id: id_str }).await;
            return;
        }
    };
@@ -242,30 +234,7 @@ async fn handle_peer(
    }
    eprintln!("[pixelpass] viewer disconnected: {remote}");
-    let _ = sup_tx.send(SupervisorMsg::RemoveViewer { id }).await;
+    let _ = sup_tx.send(SupervisorMsg::RemoveViewer { id: id_str }).await;
 }
 /// Read `kick <endpoint-id>` lines off stdin and forward them to the
 /// supervisor. Runs on a detached OS thread (see the call site for why). Ends
 /// when stdin hits EOF (the GUI closed the pipe) or the supervisor is gone.
 fn spawn_kick_listener(sup_tx: mpsc::Sender<SupervisorMsg>) {
    use std::io::BufRead;
    std::thread::spawn(move || {
        let stdin = std::io::stdin();
        for line in stdin.lock().lines().map_while(Result::ok) {
            let Some(id) = line.trim().strip_prefix("kick ") else {
                continue;
            };
            let msg = SupervisorMsg::KickViewer {
                id: id.trim().to_string(),
            };
            // blocking_send is valid here: this is a plain thread, not inside
            // the tokio runtime. An Err means the supervisor closed — stop.
            if sup_tx.blocking_send(msg).is_err() {
                break;
            }
        }
    });
 }
 /// Owns the single shared CaptureHandle and the active viewer count. Spawns
@@ -280,15 +249,12 @@ async fn supervise(
    mut rx: mpsc::Receiver<SupervisorMsg>,
 ) {
    let mut handle: Option<CaptureHandle> = None;
-    // Active viewers, keyed by endpoint id, holding each one's kill switch.
+    let mut count: u32 = 0;
    // The count is just `viewers.len()`. (A given endpoint connecting twice is
    // a non-case here: each viewer process uses a fresh ephemeral identity.)
    let mut viewers: HashMap<String, CancellationToken> = HashMap::new();
    while let Some(msg) = rx.recv().await {
        match msg {
            SupervisorMsg::AddViewer { id, cancel, reply } => {
                let count = viewers.len() as u32;
                if count >= max_viewers {
                    let reason =
                        format!("host is full ({count} of {max_viewers} viewers connected)");
@@ -314,30 +280,18 @@ async fn supervise(
                }
                let port = handle.as_ref().expect("handle was just set").local_port();
                count += 1;
                viewers.insert(id.clone(), cancel);
                let active = viewers.len() as u32;
                let _ = reply.send(Ok(port));
-                output::emit(output::Event::ViewerJoined {
+                output::emit(output::Event::ViewerJoined { id: &id, active: count, max: max_viewers });
-                    id: &id,
+                tracing::info!(active = count, cap = max_viewers, "viewer joined");
                    active,
                    max: max_viewers,
                });
                tracing::info!(active, cap = max_viewers, "viewer joined");
            }
            SupervisorMsg::RemoveViewer { id } => {
-                // A given viewer task only ever sends RemoveViewer once, but the
+                viewers.remove(&id);
-                // map remove is the source of truth either way.
+                count = count.saturating_sub(1);
-                if viewers.remove(&id).is_none() {
+                output::emit(output::Event::ViewerLeft { id: &id, active: count, max: max_viewers });
-                    continue;
+                tracing::info!(active = count, cap = max_viewers, "viewer left");
-                }
+                if count == 0
                let active = viewers.len() as u32;
                output::emit(output::Event::ViewerLeft {
                    id: &id,
                    active,
                    max: max_viewers,
                });
                tracing::info!(active, cap = max_viewers, "viewer left");
                if active == 0
                    && let Some(h) = handle.take()
                {
                    tracing::info!("last viewer left — tearing down capture");
@@ -348,14 +302,9 @@ async fn supervise(
                }
            }
            SupervisorMsg::KickViewer { id } => {
-                match viewers.get(&id) {
+                if let Some(cancel) = viewers.get(&id) {
-                    // Cancel the viewer's token; its handle_peer select! wakes,
+                    tracing::info!(%id, "kicking viewer");
-                    // sends RemoveViewer, and the leave is emitted there.
+                    cancel.cancel();
                    Some(cancel) => {
                        tracing::info!(%id, "kicking viewer");
                        cancel.cancel();
                    }
                    None => tracing::debug!(%id, "kick for unknown/already-gone viewer"),
                }
            }
        }
@@ -382,25 +331,10 @@ fn print_host_banner(
    eprintln!("┌─ PixelPass · host ─────────────────────────────────────────");
    eprintln!("│  display server : {display:?}");
    eprintln!("│  capture        : {}", capture_summary(opts));
-    eprintln!(
+    eprintln!("│  quality        : {} — {}", quality.label, quality.dimensions_summary());
        "│  quality        : {} — {}",
        quality.label,
        quality.dimensions_summary()
    );
    eprintln!("│                   ({})", quality.note);
-    eprintln!(
+    eprintln!("│  hw encode      : {}", if opts.no_hwencode { "off (software x264)" } else { "on (VAAPI H.264)" });
-        "│  hw encode      : {}",
+    eprintln!("│  max viewers    : {} ({})", resolution.value, resolution.source.label());
        if opts.no_hwencode {
            "off (software x264)"
        } else {
            "on (VAAPI H.264)"
        }
    );
    eprintln!(
        "│  max viewers    : {} ({})",
        resolution.value,
        resolution.source.label()
    );
    eprintln!("│");
    if clipboard_ok {
        eprintln!("│  Your share code has been copied to your clipboard.");
@@ -464,9 +398,7 @@ fn resolve_max_viewers(opts: &HostOpts, effective_bitrate: u32) -> MaxViewersRes
        let n = bandwidth::recommended_max_viewers(upstream, effective_bitrate);
        return MaxViewersResolution {
            value: n,
-            source: MaxViewersSource::BandwidthMeasurement {
+            source: MaxViewersSource::BandwidthMeasurement { safe_mbps: upstream },
                safe_mbps: upstream,
            },
        };
    }
    MaxViewersResolution {
@@ -308,9 +308,7 @@ async fn default_audio_monitor() -> Result<String> {
        .arg("get-default-sink")
        .output()
        .await
-        .context(
+        .context("failed to run `pactl get-default-sink` (install pulseaudio-utils or pipewire-pulse)")?;
            "failed to run `pactl get-default-sink` (install pulseaudio-utils or pipewire-pulse)",
        )?;
    if !output.status.success() {
        bail!(
            "pactl get-default-sink failed: {}",
@@ -27,26 +27,10 @@ impl Quality {
    /// values and resolves to one of the others at runtime (see [`resolve_auto`]).
    fn preset(self) -> Option<Preset> {
        let p = match self {
-            Quality::Source => Preset {
+            Quality::Source => Preset { max_height: None, bitrate: 6000, framerate: 30 },
-                max_height: None,
+            Quality::High => Preset { max_height: Some(1080), bitrate: 4000, framerate: 30 },
-                bitrate: 6000,
+            Quality::Medium => Preset { max_height: Some(720), bitrate: 2500, framerate: 30 },
-                framerate: 30,
+            Quality::Low => Preset { max_height: Some(480), bitrate: 1000, framerate: 30 },
            },
            Quality::High => Preset {
                max_height: Some(1080),
                bitrate: 4000,
                framerate: 30,
            },
            Quality::Medium => Preset {
                max_height: Some(720),
                bitrate: 2500,
                framerate: 30,
            },
            Quality::Low => Preset {
                max_height: Some(480),
                bitrate: 1000,
                framerate: 30,
            },
            Quality::Auto => return None,
        };
        Some(p)
@@ -65,12 +49,7 @@ impl Quality {
 /// Fixed presets in descending quality order — Auto walks this to find the
 /// best one whose per-viewer bitrate fits the measured upstream budget.
-const AUTO_LADDER: [Quality; 4] = [
+const AUTO_LADDER: [Quality; 4] = [Quality::Source, Quality::High, Quality::Medium, Quality::Low];
    Quality::Source,
    Quality::High,
    Quality::Medium,
    Quality::Low,
 ];
 /// Auto's fallback when there is no usable bandwidth measurement.
 const AUTO_FALLBACK: Quality = Quality::Medium;
@@ -167,9 +146,7 @@ fn resolve_auto(safe_mbps: Option<f64>, sizing_viewers: u32) -> (Preset, String,
            (
                preset,
                format!("Auto → {}", chosen.name()),
-                format!(
+                format!("auto: {safe_mbps:.1} Mbps safe ÷ {n} viewer(s) = {budget_mbps:.1} Mbps each"),
                    "auto: {safe_mbps:.1} Mbps safe ÷ {n} viewer(s) = {budget_mbps:.1} Mbps each"
                ),
            )
        }
        None => {
@@ -177,8 +154,7 @@ fn resolve_auto(safe_mbps: Option<f64>, sizing_viewers: u32) -> (Preset, String,
            (
                preset,
                format!("Auto → {}", AUTO_FALLBACK.name()),
-                "auto fallback — no bandwidth measurement (run `pixelpass --reconfigure`)"
+                "auto fallback — no bandwidth measurement (run `pixelpass --reconfigure`)".to_string(),
                    .to_string(),
            )
        }
    }
@@ -213,7 +189,6 @@ mod tests {
            no_hwencode: false,
            max_viewers,
            interactive: false,
            relay: None,
        }
    }
@@ -130,11 +130,8 @@ async fn run_accept_loop(listener: TcpListener, tx: broadcast::Sender<Arc<Vec<u8
        let sock = match listener.accept().await {
            Ok((s, _)) => s,
            Err(e) => {
-                // Most accept errors are transient (EMFILE from a brief FD spike,
+                tracing::warn!("capture HTTP accept failed: {e}");
-                // EINTR, etc.). Bailing on the first one would kill the entire
+                return;
                // viewer fanout for the rest of the session.
                tracing::warn!("capture HTTP accept failed (continuing): {e}");
                continue;
            }
        };
        let rx = tx.subscribe();
@@ -26,11 +26,7 @@ pub async fn start(opts: &HostOpts, quality: &EffectiveQuality) -> Result<Captur
        .context("could not reach the xdg-desktop-portal ScreenCast interface")?;
    let session = proxy.create_session().await?;
-    let source = if opts.window {
+    let source = if opts.window { SourceType::Window } else { SourceType::Monitor };
        SourceType::Window
    } else {
        SourceType::Monitor
    };
    proxy
        .select_sources(
            &session,
@@ -74,16 +70,10 @@ pub async fn start(opts: &HostOpts, quality: &EffectiveQuality) -> Result<Captur
        "do-timestamp=true".to_string(),
    ];
-    pipeline::spawn(
+    pipeline::spawn(opts, quality, Some((w as u32, h as u32)), source_args, move || {
-        opts,
+        // Parent no longer needs the pipewire fd — gst inherited its own copy.
-        quality,
+        let _ = close(raw_fd);
-        Some((w as u32, h as u32)),
+    })
        source_args,
        move || {
            // Parent no longer needs the pipewire fd — gst inherited its own copy.
            let _ = close(raw_fd);
        },
    )
    .await
 }
@@ -13,7 +13,7 @@ pub async fn run(cli: Cli) -> Result<()> {
    let theme = ColorfulTheme::default();
    let choice = Select::with_theme(&theme)
        .with_prompt("What do you want to do?")
-        .items([
+        .items(&[
            "Host (share my screen)",
            "View (watch someone else's screen)",
        ])
@@ -112,7 +112,7 @@ fn pick_quality(theme: &ColorfulTheme) -> Result<Quality> {
    let choice = Select::with_theme(theme)
        .with_prompt("What quality should the viewer(s) get?")
-        .items(items)
+        .items(&items)
        .default(0)
        .interact()?;
@@ -138,7 +138,7 @@ pub async fn run_reconfigure() -> Result<()> {
 async fn preflight_if_needed(theme: &ColorfulTheme) {
    let mut cfg = config::load().unwrap_or_default();
    match cfg.bandwidth.status {
-        config::BandwidthStatus::Measured | config::BandwidthStatus::Skipped => (),
+        config::BandwidthStatus::Measured | config::BandwidthStatus::Skipped => return,
        config::BandwidthStatus::Unmeasured => {
            eprintln!();
            eprintln!("First-time setup");
@@ -154,7 +154,7 @@ async fn preflight_if_needed(theme: &ColorfulTheme) {
            let Ok(choice) = Select::with_theme(theme)
                .with_prompt("What would you like to do?")
-                .items([
+                .items(&[
                    "Run the bandwidth test (recommended)",
                    "Skip — use the conservative default",
                ])
@@ -180,7 +180,10 @@ async fn preflight_if_needed(theme: &ColorfulTheme) {
            eprintln!();
            let Ok(choice) = Select::with_theme(theme)
                .with_prompt("Last bandwidth test failed. Try again?")
-                .items(["Yes — retry now", "No — use the conservative default"])
+                .items(&[
                    "Yes — retry now",
                    "No — use the conservative default",
                ])
                .default(0)
                .interact()
            else {
@@ -338,12 +341,8 @@ pub fn prompt_player() -> Result<Player> {
    let theme = ColorfulTheme::default();
    let choice = Select::with_theme(&theme)
        .with_prompt("Connected. Pick a player to launch")
-        .items(["mpv", "VLC"])
+        .items(&["mpv", "VLC"])
        .default(0)
        .interact()?;
-    Ok(if choice == 0 {
+    Ok(if choice == 0 { Player::Mpv } else { Player::Vlc })
        Player::Mpv
    } else {
        Player::Vlc
    })
 }
@@ -25,7 +25,7 @@ async fn main() -> Result<()> {
    if cli.gui {
        #[cfg(feature = "gui")]
        {
-            return gui::run(cli.relay);
+            return gui::run();
        }
        #[cfg(not(feature = "gui"))]
        {
@@ -73,11 +73,7 @@ async fn main() -> Result<()> {
 }
 fn init_tracing(verbose: bool) {
-    let default = if verbose {
+    let default = if verbose { "pixelpass=trace,iroh=info" } else { "pixelpass=info,iroh=warn" };
        "pixelpass=trace,iroh=info"
    } else {
        "pixelpass=info,iroh=warn"
    };
    let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new(default));
    // Tracing MUST write to stderr. `tracing_subscriber::fmt()` defaults its
    // writer to stdout, but with `--output json` stdout carries the JSON event
@@ -110,7 +110,9 @@ pub async fn run() -> Result<()> {
    }
    if live_skipped > 0 {
-        println!("[pixelpass] --repair: left {live_skipped} live pixelpass host(s) alone.");
+        println!(
            "[pixelpass] --repair: left {live_skipped} live pixelpass host(s) alone."
        );
    }
    if failed > 0 {
@@ -152,9 +154,7 @@ fn list_modules() -> Result<Vec<Module>> {
    for line in text.lines() {
        let mut parts = line.splitn(4, '\t');
        let Some(id_str) = parts.next() else { continue };
-        let Ok(id) = id_str.parse::<u32>() else {
+        let Ok(id) = id_str.parse::<u32>() else { continue };
            continue;
        };
        let Some(name) = parts.next() else { continue };
        let args = parts.next().unwrap_or("").to_string();
        modules.push(Module {
@@ -1,10 +1,12 @@
 use anyhow::{Context, Result, bail};
 use iroh::Endpoint;
 use iroh::endpoint::presets;
 use iroh_tickets::endpoint::EndpointTicket;
 use std::time::Duration;
 use tokio::net::TcpListener;
 use crate::cli::ViewerOpts;
-use crate::common::{alpn::ALPN, endpoint, output, signal};
+use crate::common::{alpn::ALPN, output, signal};
 /// Cap on the initial QUIC connect. `endpoint.connect()` has no built-in
 /// deadline, so an offline host / stale code / unreachable relay otherwise
@@ -15,7 +17,10 @@ const CONNECT_TIMEOUT: Duration = Duration::from_secs(15);
 pub async fn run(ticket: EndpointTicket, opts: ViewerOpts) -> Result<()> {
    let cancel = signal::install_ctrl_c();
-    let endpoint = endpoint::bind(opts.relay.as_deref()).await?;
+    let endpoint = Endpoint::builder(presets::N0)
        .alpns(vec![ALPN.to_vec()])
        .bind()
        .await?;
    let addr = ticket.endpoint_addr().clone();
    tracing::info!(remote = %addr.id, "connecting to host");
@@ -45,41 +50,34 @@ pub async fn run(ticket: EndpointTicket, opts: ViewerOpts) -> Result<()> {
            }
        },
    };
-    // Everything past the established connection runs in one block so any error
+    let (quic_send, quic_recv) = conn.open_bi().await?;
    // (open_bi, bind, local_addr, accept) is captured rather than `?`-propagated
    // straight out of the function — that would skip the close below and leak the
    // endpoint. The connect-phase arms above close explicitly for the same reason.
    let result = async {
        let (quic_send, quic_recv) = conn.open_bi().await?;
-        let listener = TcpListener::bind(("127.0.0.1", opts.port)).await?;
+    let listener = TcpListener::bind(("127.0.0.1", opts.port)).await?;
-        let port = listener.local_addr()?.port();
+    let port = listener.local_addr()?.port();
-        let url = format!("http://127.0.0.1:{port}");
+    let url = format!("http://127.0.0.1:{port}");
-        output::emit(output::Event::Connected { url: &url });
+    output::emit(output::Event::Connected { url: &url });
-        if opts.interactive {
+    if opts.interactive {
-            let player = crate::interactive::prompt_player()?;
+        let player = crate::interactive::prompt_player()?;
-            player
+        player
-                .spawn(&url)
+            .spawn(&url)
-                .with_context(|| "failed to launch player")?;
+            .with_context(|| "failed to launch player")?;
-            print_viewer_banner_interactive();
+        print_viewer_banner_interactive();
-        } else {
+    } else {
-            print_viewer_banner(&url);
+        print_viewer_banner(&url);
        }
        tokio::select! {
            accepted = listener.accept() => {
                let (tcp, peer) = accepted?;
                tracing::info!(%peer, "local viewer connected");
                crate::common::tunnel::bridge(quic_send, quic_recv, tcp).await
            }
            _ = cancel.cancelled() => {
                tracing::info!("ctrl-c received before local viewer connected");
                Ok(())
            }
        }
    }
-    .await;
+
    let result = tokio::select! {
        accepted = listener.accept() => {
            let (tcp, peer) = accepted?;
            tracing::info!(%peer, "local viewer connected");
            crate::common::tunnel::bridge(quic_send, quic_recv, tcp).await
        }
        _ = cancel.cancelled() => {
            tracing::info!("ctrl-c received before local viewer connected");
            Ok(())
        }
    };
    endpoint.close().await;
    result
Author	SHA1	Message	Date
mollusk	2e39251189	On feat/gemini-branch-ux-polish: gemini ux-polish WIP: viewer-list/kick/notifications/tray (review baseline)	2026-05-25 15:20:10 -04:00
mollusk	c2d04b35ba	index on feat/gemini-branch-ux-polish: `e8f86b0` feat(gui): focus the viewer code field when the View screen opens	2026-05-25 15:20:10 -04:00
mollusk	b4be8deb46	untracked files on feat/gemini-branch-ux-polish: `e8f86b0` feat(gui): focus the viewer code field when the View screen opens	2026-05-25 15:20:10 -04:00