Keep the toast's fade-in, and join the test's threads on failure

From the review: opening the toast popover with .show already set skipped the
fade-in; it now opens hidden and then shows. And the superseded-test test now
joins its threads in finally, so a failure can't leave them running into
cleanup.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

README.md

@@ -189,7 +189,7 @@ entry to `~/.ssh/config` and keys at `~/.ssh/id_ed25519_frame` and
 
 This is a first public test, so reports are really useful, especially from
 Windows and Linux. The quickest way is **Report a problem** in the app (the
-warning-sign button at the top, or **Help → Report a Problem…**). It adds
+speech-bubble button at the top, or **Help → Report a Problem…**). It adds
 diagnostics with personal details removed, shows you exactly what's included,
 and sends it privately to the maintainer; nothing is published. Without the app,
 use the [feedback form](https://frame-control.pages.dev/feedback/). Please include:

app/main.js

@@ -1,7 +1,7 @@
 // Frame Control as a desktop app (macOS, Windows, Linux): starts ui/server.py on
 // a free loopback port and shows it in a native window. The server does all the
 // work over the `frame` SSH alias; this file only hosts it.
-const { app, BrowserWindow, Menu, Notification, clipboard, dialog, ipcMain, nativeImage, shell } = require("electron");
+const { app, BrowserWindow, Menu, Notification, clipboard, dialog, ipcMain, shell } = require("electron");
 const { execFile, spawn } = require("child_process");
 const { promisify } = require("util");
 const fs = require("fs");
@@ -149,7 +149,7 @@ async function startServer() {
   const target = `http://127.0.0.1:${port}/`;
   for (let i = 0; i < 100; i++) {
     if (exited !== null) throw new Error(`The server exited (${exited}). See ${LOG}.`);
-    if (await ping(target)) { url = target; serverStarted = Date.now(); return; }
+    if (await ping(target)) { url = target; return; }
     await new Promise((r) => setTimeout(r, 100));
   }
   if (server === child) server = null;
@@ -175,27 +175,18 @@ function stopServer() {
   if (server) endServer(server);
 }
 
-function errorPage(message, title = "Frame Control couldn't start") {
+function errorPage(message) {
   const esc = (s) => s.replace(/[&<>]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;" }[c]));
   const html = `<!doctype html><meta charset="utf-8"><body style="margin:0;height:100vh;display:grid;
     place-items:center;background:${BG};color:#e6edf3;font:14px -apple-system,sans-serif">
-    <div style="max-width:560px;padding:32px;line-height:1.5"><h2>${esc(title)}</h2>
-    <p>${esc(message)}</p>
-    <p><button onclick="this.disabled = true; frameApp.restartServer()" style="font:inherit;padding:6px 16px;
-      border-radius:6px;border:1px solid #30363d;background:#21262d;color:inherit;cursor:pointer">Try Again</button></p>
-    <p style="color:#8b98a8">Frame → Restart Server does the same.</p></div>`;
+    <div style="max-width:560px;padding:32px;line-height:1.5"><h2>Frame Control couldn't start</h2>
+    <p>${esc(message)}</p><p style="color:#8b98a8">Fix it, then choose Frame → Restart Server.</p></div>`;
   return "data:text/html;charset=utf-8," + encodeURIComponent(html);
 }
 
-// A server that had been running starts again by itself (something stopped it: a
-// signal, a crash). One that stops again within a minute shows the error instead,
-// so a server that can't stay up doesn't restart forever.
-let serverStarted = 0;
 function serverDied(why) {
   url = null;
-  if (!win) return;
-  if (Date.now() - serverStarted > 60000) restartServer();
-  else win.loadURL(errorPage(`Its server stopped unexpectedly (${why}). See ${LOG}.`, "Frame Control stopped"));
+  if (win) win.loadURL(errorPage(`The server stopped unexpectedly (${why}). See ${LOG}.`));
 }
 
 // Restarts that overlap share one: two could each start a server, and the one
@@ -272,20 +263,7 @@ function fromUi(e) {
   } catch { return false; }
 }
 
-// The error page's Try Again button. The error page is the only data: page the window
-// shows (`url` can still be set then: the server answered but the page failed to load).
-ipcMain.handle("server:restart", (e) => {
-  if (win && e.sender === win.webContents && e.senderFrame && e.senderFrame.url.startsWith("data:")) restartServer();
-});
 ipcMain.handle("clipboard:read", (e) => fromUi(e) ? clipboard.readText() : "");
-// A PNG or JPEG (a screenshot) onto the clipboard as an image.
-ipcMain.handle("clipboard:writeImage", (e, bytes) => {
-  if (!fromUi(e) || !(bytes instanceof Uint8Array)) return false;
-  const img = nativeImage.createFromBuffer(Buffer.from(bytes));
-  if (img.isEmpty()) throw new Error("not an image");
-  clipboard.writeImage(img);
-  return true;
-});
 ipcMain.handle("connection:setup", (e) => { if (fromUi(e)) setUpConnection(); });
 ipcMain.on("keys:capture", (e, on) => { if (fromUi(e)) win.webContents.setIgnoreMenuShortcuts(on === true); });
 ipcMain.handle("update:get", (e) => fromUi(e) ? publicUpdate() : null);

app/preload.js

@@ -2,8 +2,8 @@
 // to the Frame needs no pbpaste, PowerShell, xclip or wl-clipboard. Also tells
 // the page where a dropped file or folder lives, so a folder can be sideloaded
 // as a title without zipping it (the local server reads it from there).
-// It can put a screenshot on the clipboard as an image, open Set Up Connection when
-// the headset can't be reached, and keeps the Frame menu's list of headsets up to date.
+// It can open Set Up Connection when the headset can't be reached, and keeps the
+// Frame menu's list of headsets up to date.
 // It also receives frame-control://install links (docs/web-install.md): only
 // what the link asked for, never an install; the page asks the user first.
 // And it passes update state both ways: see app/updater.js.
@@ -12,9 +12,7 @@ const { contextBridge, ipcRenderer, webUtils } = require("electron");
 contextBridge.exposeInMainWorld("frameApp", {
   notify: (message, request) => ipcRenderer.invoke("comfort:notify", message, request),
   readClipboard: () => ipcRenderer.invoke("clipboard:read"),
-  writeImage: (bytes) => ipcRenderer.invoke("clipboard:writeImage", bytes),
   setUpConnection: () => ipcRenderer.invoke("connection:setup"),
-  restartServer: () => ipcRenderer.invoke("server:restart"),  // the "couldn't start" page's Try Again
   // The Frame menu's headset switcher: the page tells it the headsets, and hears picks.
   devicesChanged: (list) => ipcRenderer.send("devices:changed", list),
   onUseDevice: (cb) => {

docs/devices.md

@@ -3,8 +3,9 @@
 Frame Control can manage more than one Steam Frame, and each headset can be
 reached at more than one address: a LAN IP at home, another at the office, its
 mDNS name (`frame.local`), its Tailscale IP or MagicDNS name. The **Devices**
-tab (key 5) lists them, and the connection pill in the header shows what the
-app is doing to reach the one in use, step by step, as it happens.
+tab (key 5) lists them. The connection pill in the header says whether the one in
+use is connected and how (Tailscale, or the network's name); click it to add,
+edit or reorder that headset's addresses, or to see each step of connecting.
 
 The code is in three modules, all stdlib-only Python on your computer:
 
@@ -57,7 +58,7 @@ and ranks them:
 5. addresses that only ever worked on other networks;
 6. Tailscale addresses while Tailscale is off.
 
-Your order on the Devices tab breaks ties. The best-ranked address that answers
+Your order (on the Devices tab, or in the pill's dialog) breaks ties. The best-ranked address that answers
 wins; one that answers first waits up to 0.35 s for a better-ranked one that is
 still trying. If SSH to the winner fails in a way another address could fix
 (a different device answered there, or the link dropped), the next one that
@@ -72,6 +73,16 @@ status --json`, including the Mac app's own CLI) with buttons to add their
 MagicDNS name or IP. **Find on this network** asks mDNS for SteamOS devkit
 services and checks `ALIAS.local` and `frame.local`.
 
+**The pill's dialog** lists the same addresses, with what each one answered, and
+can add, edit, reorder and remove them without leaving the page you're on. When
+the headset reports a LAN IP on the same network as this computer and that IP
+isn't saved, it offers to add it. The offer puts the address first in the list,
+so on that network it wins over the Tailscale name; away from home the Tailscale
+name still leads. A new or edited address is tested straight away. While
+connected, **Reconnect** applies your changes now rather than at the next
+connection: it tries the addresses again, ranked as above, and the best-ranked
+one that answers promptly wins. It doesn't pick a particular address.
+
 ## Networks
 
 A network is told apart by its default gateway: the router's IP address plus its
@@ -122,7 +133,8 @@ file per headset instead, so saving or forgetting one headset's key never touche
 another's: a different device answering at one of its
 addresses is refused, and the pill says so. A headset's first connection trusts
 the key it shows, as Set Up Connection does. After reinstalling SteamOS the
-headset has a new key; **Forget identity** on the Devices tab lets the next
+headset has a new key; **Forget identity** (Devices tab → **Advanced**, with the
+SSH alias, user and port) lets the next
 connection save the new one.
 
 ## One server at a time

docs/frame-control.md

@@ -22,9 +22,9 @@ The window has five tabs: **Home** (headset view, status, screenshots),
 the catalogue, display settings, reports), **Tools** (sending files and text,
 Flatpaks, remote and power) and **Devices** (your headsets and their addresses).
 Keys 1–5 switch between them. Files can be dropped anywhere in the window. A
-connection pill in the header always shows which headset, which network this
-computer is on, the address in use or being tried, and each step of connecting
-as it happens; click it for the whole timeline. When the Frame can't be
+connection pill in the header always shows which headset and whether it's
+connected, and how (Tailscale, or the network's name). Click it to add, edit or
+reorder the headset's addresses, or to see each step of connecting. When the Frame can't be
 reached, a banner says why in plain words, what was tried, and counts down to
 the next try, filling everything in once it answers. Flatpak and Android installs run in the background; the bottom bar
 counts them while they run.
@@ -88,13 +88,8 @@ counts them while they run.
   name your networks, and switch headsets. See [devices.md](devices.md).
 - **One-click tools**: SSH or SFTP in a terminal window, Steam Link, and remote
   desktop (Windows App on macOS, Remote Desktop on Windows, Remmina or FreeRDP on
-  Linux). Remote desktop first checks that the Frame's xrdp answers on port
-  3389 (Developer Mode turns it on). On Windows it opens a connection file for
-  user `steamos`, because `mstsc /v:` alone offers your Windows account, which
-  xrdp turns away. Accept the warning about the Frame's own certificate, then
-  sign in with the Developer Mode password. Sleep, restart and
-  shut down open a terminal window because SteamOS asks for the sudo password
-  over SSH.
+  Linux). Sleep, restart and shut down open a terminal window because SteamOS
+  asks for the sudo password over SSH.
 
 ## How it works
 

docs/privacy.md

@@ -97,16 +97,14 @@ The same error is sent at most once every 10 minutes.
 
 ## Report a problem
 
-**Report a problem** is the warning-sign button in the header, also in the
+**Report a problem** is the speech-bubble button in the header, also in the
 Privacy panel and under **Help → Report a Problem…**. It sends the report
 privately to Frame Control's PostHog project as a `problem_report` event, the
 same way as the analytics above, so only the maintainer can read it and
 nothing is published. It works whatever the analytics settings are, because
 the person sends it deliberately. The report has the kind, title and text you
-wrote, a short reference shown after sending, and the diagnostics below. Your
-email address goes with it only if you tick **The maintainer may contact me
-with follow-up questions** (the report then carries `contact_followup: true`);
-it's filled in from **Contact email** below when you've agreed there. It has its own random id, so it isn't linked to
+wrote, how to reach you if you gave it, a short reference shown after sending,
+and the diagnostics below. It has its own random id, so it isn't linked to
 your analytics events.
 
 With **Include diagnostics** ticked (the default), the report adds:
@@ -130,60 +128,11 @@ The maintainer reads reports on the Frame Control dashboard in PostHog, or
 with `python3 ui/frame_report.py inbox [days]`, which uses the same personal
 API key as `frame_compat_db.py sync`.
 
-## Contact email (optional)
-
-Frame Control never needs an email address. If you'd like to leave one, there
-are two separate choices, both off until you tick them:
-
-| Choice | What it's for |
-|---|---|
-| **Email me about Frame Control updates** | Occasional notices about new releases and updates |
-| **The maintainer may contact me with follow-up questions** | Questions about problem reports you send, mostly |
-
-You're asked once, in a bar at the top of the page, after the Frame has
-connected for the first time, and never while or straight after the
-first-run privacy notice is showing. **No thanks** hides it for good, and it isn't
-shown again even if you ignore it. **Contact email** in **Privacy & updates**
-is where you add, change or remove the address and either choice at any time.
-
-**What's sent, and where.** The address and the two choices go privately to
-Frame Control's PostHog project, the same place as problem reports, as a
-`contact_consent` event with `email`, `updates`, `followup`, `action` (`set`
-or `withdraw`) and the common properties above. Only the maintainer can read
-that project, and nothing in it is published or shared. It's sent only when
-you save, whatever the analytics settings are, because you chose to. It
-carries its own random contact id, not the analytics id, so it isn't linked
-to your usage events, and a `rev` number that goes up with each change, so
-the newest choice always wins. Like everything else sent, it's listed under
-**Show what's been sent**. On this computer the address and choices are kept in
-`contact/contact.json` in Frame Control's data folder. An address is only
-kept with at least one choice ticked.
-
-**Removing it.** **Remove my email** (or clearing the address and saving)
-deletes it from this computer, including from the **Show what's been sent**
-log (in earlier contact events and problem reports), and sends a `withdraw`
-event with no address in it. The maintainer's list only uses the newest event from each copy, so from
-then on the address isn't listed for either choice. Unticking one choice
-works the same way for that choice. If you're offline, the change waits on
-this computer and is sent when PostHog can be reached. The earlier event
-stays in PostHog until its data retention removes it; to have it deleted
-sooner, ask the maintainer (for example in a problem report).
-
-Nothing sends email yet: this only records who agreed to what. The
-maintainer lists the addresses with
-`python3 ui/frame_report.py contacts [updates|followup]`, which uses the same
-personal API key as `inbox`.
-
 ## Turning it all off
 
 Untick the boxes, or set `DO_NOT_TRACK=1` or `FRAME_CONTROL_TELEMETRY=0` in
 the environment that starts Frame Control. A copy run from a source checkout
-never sends analytics unless `FRAME_CONTROL_TELEMETRY=1` is set.
-
-These switches cover the analytics above. A problem report or a contact email
-is sent only because you pressed its Send or Save button, so those still go
-when you choose to send them (a contact change saved while offline is sent
-by itself once PostHog can be reached); if you don't, nothing is sent.
+never sends anything unless `FRAME_CONTROL_TELEMETRY=1` is set.
 
 ## Update checks
 

docs/streaming.md

@@ -25,20 +25,6 @@ The confidence labels are the same as in [ssh.md](ssh.md).
 documents it. Use Windows App (RDP) when you want a proper Linux desktop on the
 Mac with keyboard, mouse, and clipboard.
 
-**Verified 2026-09-30** (Frame BUILD_ID 20260925.6191901, Windows 11 25H2,
-Remote Desktop Connection): signing in to xrdp as `steamos` with the Developer
-Mode password opens a Plasma (X11) desktop within about 6 seconds.
-
-- xrdp has no NLA, so the client shows a certificate warning (xrdp's own
-  `www.xrdp.org` certificate) and then xrdp's own login box. Frame Control
-  fills in `steamos` there on Windows, Remmina and FreeRDP.
-- The desktop is a separate login session (Xorg on display `:10`), not the
-  headset's view. It uses about 1.3 GB of the Frame's memory.
-- Closing the client leaves the session running, and the next login
-  reconnects to it. To end it over SSH, find it with `loginctl list-sessions`
-  and run `loginctl terminate-session <id>`. That doesn't touch the headset's
-  gamescope or SteamVR session.
-
 ## B. Show the Mac's desktop inside the Frame
 
 The Frame's VR streaming uses **SteamVR** on the host. Linux hosts had

docs/vr-utilities.md

@@ -26,7 +26,7 @@ it twice reuses the existing process.
 | Compositor CPU | OpenVR compositor render CPU milliseconds, not game CPU time. |
 | System CPU | `/proc/stat` busy-time delta across the sample, with guest time counted once and iowait treated as idle. |
 | GPU clock | `3d00000.gpu/cur_freq`, converted from Hz to MHz; frequency is not load. |
-| Hottest sensor / battery | Existing thermal-zone and battery sysfs reads from `frame_status.py`. |
+| Hottest sensor / battery | Existing thermal-zone and battery sysfs reads from `frame_status.py`. In the headset HUD only: the app shows them once, in the battery menu at the top. |
 
 OpenVR uses background application mode, which does not start SteamVR or keep
 it running. This mode also returned live timing in a read-only device probe.

tests/test_contact.py

@@ -1,280 +0,0 @@
-"""A contact email (ui/frame_contact.py): kept only with a matching choice, sent privately,
-withdrawn when removed, never lost offline, and the one-time prompt stays dismissed.
-
-Run: python3 -m unittest discover -s tests
-"""
-import sandbox  # noqa: F401  (first: keeps tests off real data and services)
-import sys
-import threading
-import time
-import unittest
-from pathlib import Path
-from unittest import mock
-
-ROOT = Path(__file__).resolve().parent.parent
-sys.path.insert(0, str(ROOT / "ui"))
-sys.path.insert(0, str(Path(__file__).resolve().parent))
-
-import frame_compat_db as db  # noqa: E402
-import frame_contact as fc  # noqa: E402
-import frame_report as fr  # noqa: E402
-import frame_telemetry as tm  # noqa: E402
-from test_telemetry import Base, ReportProblem  # noqa: E402
-
-REPORT = {"title": "RDP not working", "message": "It never connects on Windows."}
-
-
-class Contact(Base):
-    """Base's temp telemetry state, ReportProblem's PostHog stand-in, and a temp contact file."""
-    serve = ReportProblem.serve
-
-    def setUp(self):
-        super().setUp()
-        self.addCleanup(fc._removed.clear)
-        for name, value in (("STATE", tm.STATE / "contact"), ("FILE", tm.STATE / "contact" / "contact.json")):
-            p = mock.patch.object(fc, name, value)
-            p.start()
-            self.addCleanup(p.stop)
-        self.got = self.serve()
-
-    def events(self):
-        return [body["batch"][0] for _, body in self.got]
-
-    def offline(self):
-        return mock.patch.object(tm, "post", side_effect=tm.SendError("couldn't reach PostHog"))
-
-    # ---- storage and consent flags
-
-    def test_nothing_is_kept_or_sent_until_chosen(self):
-        s = fc.state()
-        self.assertEqual((s["email"], s["updates"], s["followup"], s["waiting"]), ("", False, False, False))
-        self.assertFalse(fc.FILE.exists())
-        self.assertEqual(self.got, [])
-
-    def test_an_address_needs_a_choice_and_a_real_address(self):
-        with self.assertRaisesRegex(ValueError, "tick"):
-            fc.save({"email": "me@example.com"})
-        with self.assertRaisesRegex(ValueError, "email address"):
-            fc.save({"email": "not an address", "updates": True})
-        self.assertEqual(fc.load()["email"], "")
-        self.assertEqual(self.got, [])
-
-    def test_each_choice_is_sent_privately_on_its_own(self):
-        fc.save({"email": " me@example.com ", "updates": True})
-        fc.save({"email": "me@example.com", "updates": False, "followup": True})
-        first, second = self.events()
-        self.assertEqual(first["event"], "contact_consent")
-        self.assertEqual({k: first["properties"][k] for k in ("email", "updates", "followup", "action")},
-                         {"email": "me@example.com", "updates": True, "followup": False, "action": "set"})
-        self.assertEqual((second["properties"]["updates"], second["properties"]["followup"]), (False, True))
-        self.assertEqual(first["distinct_id"], second["distinct_id"])  # one contact id, newest wins
-        self.assertNotEqual(first["distinct_id"], tm.settings()["id"])  # not the analytics id
-        self.assertEqual((first["properties"]["$process_person_profile"], first["properties"]["$geoip_disable"]),
-                         (False, True))
-        self.assertEqual([e["event"] for e in tm._read_lines(tm.SENT)], ["contact_consent"] * 2)
-
-    def test_sent_whatever_the_analytics_settings(self):
-        tm.update_settings({"usage": False})
-        fc.save({"email": "me@example.com", "followup": True})
-        self.assertEqual(len(self.got), 1)
-
-    def test_saving_the_same_choice_again_sends_nothing(self):
-        fc.save({"email": "me@example.com", "updates": True})
-        fc.save({"email": "me@example.com", "updates": True})
-        self.assertEqual(len(self.got), 1)
-
-    # ---- withdrawal
-
-    def test_removing_the_address_sends_a_withdrawal_without_it(self):
-        fc.save({"email": "me@example.com", "updates": True, "followup": True})
-        s = fc.save({"email": "", "updates": True, "followup": True})
-        self.assertEqual((s["email"], s["updates"], s["followup"]), ("", False, False))
-        withdrawal = self.events()[-1]["properties"]
-        self.assertEqual((withdrawal["action"], withdrawal["email"], withdrawal["updates"], withdrawal["followup"]),
-                         ("withdraw", "", False, False))
-        self.assertNotIn("me@example.com", fc.FILE.read_text())
-
-    def test_an_address_still_waiting_is_withdrawn_too(self):
-        with self.offline():
-            fc.save({"email": "me@example.com", "updates": True})  # may already be on its way
-        with mock.patch.object(tm, "post") as post:
-            fc.save({"email": ""})
-        self.assertEqual([c.args[0][0]["properties"]["action"] for c in post.call_args_list], ["withdraw"])
-        self.assertFalse(fc.state()["waiting"])
-
-    def test_offline_the_newest_choice_waits_and_a_withdrawal_is_never_lost(self):
-        fc.save({"email": "me@example.com", "updates": True})
-        with self.offline():
-            s = fc.save({"email": ""})
-            self.assertTrue(s["waiting"])
-            self.assertFalse(fc._send_pending())
-        self.assertEqual(fc.load()["pending"]["properties"]["action"], "withdraw")
-        self.assertTrue(fc._send_pending())
-        self.assertFalse(fc.state()["waiting"])
-        self.assertEqual([e["properties"]["action"] for e in self.events()], ["set", "withdraw"])
-
-    def test_removing_the_address_wipes_it_from_the_sent_log_too(self):
-        fc.save({"email": "me@example.com", "followup": True})
-        fr.send({**REPORT, "contact": "me@example.com", "contactFollowup": True})
-        self.assertIn("me@example.com", tm.SENT.read_text())
-        fc.save({"email": ""})
-        self.assertNotIn("me@example.com", tm.SENT.read_text())
-        self.assertEqual([e["properties"].get("action") for e in tm._read_lines(tm.SENT)
-                          if e["event"] == "contact_consent"], ["set", "withdraw"])
-
-    def test_each_change_has_a_higher_rev_so_the_newest_wins_whatever_the_clock(self):
-        fc.save({"email": "me@example.com", "updates": True})
-        fc.save({"email": "new@example.com", "updates": True})
-        fc.save({"email": ""})
-        self.assertEqual([e["properties"]["rev"] for e in self.events()], [1, 2, 3])
-
-    def test_a_withdrawal_during_a_send_goes_after_it(self):
-        started, release, order = threading.Event(), threading.Event(), []
-        real = tm.post
-
-        def slow(batch, timeout=20):
-            order.append(batch[0]["properties"]["action"])
-            if len(order) == 1:
-                started.set()
-                release.wait(5)
-            real(batch, timeout)
-
-        with mock.patch.object(tm, "post", side_effect=slow):
-            t = threading.Thread(target=fc.save, args=({"email": "me@example.com", "updates": True},))
-            t.start()
-            self.assertTrue(started.wait(5))
-            w = threading.Thread(target=fc.save, args=({"email": ""},))
-            w.start()
-            for _ in range(500):  # the withdrawal is saved while the first send is still out
-                if fc.load()["rev"] == 2:
-                    break
-                time.sleep(0.01)
-            self.assertEqual(fc.load()["pending"]["properties"]["action"], "withdraw")
-            release.set()
-            t.join(5)
-            w.join(5)
-        self.assertEqual(order, ["set", "withdraw"])
-        self.assertEqual([e["properties"]["action"] for e in self.events()], ["set", "withdraw"])
-        self.assertFalse(fc.state()["waiting"])
-        self.assertNotIn("me@example.com", tm.SENT.read_text())
-
-    def test_a_report_still_sending_when_its_address_is_removed_is_logged_without_it(self):
-        fc.save({"email": "me@example.com", "followup": True})
-        real = tm.post
-
-        def remove_meanwhile(batch, timeout=20):
-            real(batch, timeout)
-            fc.save({"email": ""})  # removed while the report is on its way, before it's logged
-
-        with mock.patch.object(tm, "post", side_effect=remove_meanwhile):
-            fr.send({**REPORT, "contact": "me@example.com", "contactFollowup": True})
-        self.assertNotIn("me@example.com", tm.SENT.read_text())
-        fr.send({**REPORT, "contact": "me@example.com", "contactFollowup": True})
-        self.assertIn("me@example.com", tm.SENT.read_text())  # sent again after removal: logged as sent
-
-    def test_only_reports_started_before_the_removal_are_redacted_even_within_a_second(self):
-        fc._removed["me@example.com"] = 1790000000.3
-        event = lambda: {"timestamp": "2026-09-21T12:53:20Z", "properties": {"contact": "me@example.com"}}
-        before, after = event(), event()  # the same whole second as the removal
-        fc.redact_removed(before, 1790000000.1)
-        fc.redact_removed(after, 1790000000.6)
-        self.assertEqual((before["properties"]["contact"], after["properties"]["contact"]),
-                         ("<removed>", "me@example.com"))
-
-    def test_saving_during_a_slow_send_returns_at_once(self):
-        busy = fc._send_lock
-        busy.acquire()
-        try:
-            s = fc.save({"email": "me@example.com", "updates": True})
-        finally:
-            busy.release()
-        self.assertTrue(s["waiting"])  # left for the send under way (or the retry) to take
-        self.assertEqual(self.got, [])
-        self.assertTrue(fc._send_pending())
-        self.assertEqual(len(self.got), 1)
-
-    def test_a_change_saved_as_a_send_finishes_is_not_left_behind(self):
-        real = fc._send_lock
-
-        class Lock:  # a Save lands after the sender found nothing waiting, before it lets go
-            saved = False
-
-            def acquire(self, blocking=True):
-                return real.acquire(blocking)
-
-            def release(self):
-                if not Lock.saved:
-                    Lock.saved = True
-                    s = threading.Thread(target=fc.save, args=({"email": "me@example.com", "updates": True},))
-                    s.start()
-                    s.join(5)
-                    assert not s.is_alive()  # the change is saved while the sender still holds the lock
-                real.release()
-
-        with mock.patch.object(fc, "_send_lock", Lock()):
-            self.assertTrue(fc._send_pending())
-        self.assertEqual([e["properties"]["email"] for e in self.events()], ["me@example.com"])
-        self.assertFalse(fc.state()["waiting"])
-
-    # ---- the one-time prompt
-
-    def test_the_prompt_waits_for_a_working_setup_then_stays_dismissed(self):
-        self.assertFalse(fc.state()["showPrompt"])  # a new install: the Frame hasn't connected yet
-        tm.frame_seen("20260901.1", "3.8")
-        self.assertTrue(fc.state()["showPrompt"])
-        fc.prompt({"prompt": "dismissed"})
-        fc.prompt({"prompt": "shown"})  # a later session can't bring it back
-        self.assertEqual(fc.load()["prompt"], "dismissed")
-        self.assertFalse(fc.state()["showPrompt"])
-        self.assertEqual(self.got, [])  # No thanks sends nothing
-        with self.assertRaises(ValueError):
-            fc.prompt({"prompt": "reset"})
-
-    def test_the_prompt_is_shown_once_and_saving_answers_it(self):
-        tm.frame_seen("20260901.1", "3.8")
-        fc.prompt({"prompt": "shown"})
-        self.assertFalse(fc.state()["showPrompt"])
-        fc.save({"email": "me@example.com", "followup": True, "fromPrompt": True})
-        self.assertEqual(fc.load()["prompt"], "answered")
-
-    # ---- reports and the maintainer's list
-
-    def test_a_report_carries_the_address_only_with_follow_up_consent(self):
-        fr.send({**REPORT, "contact": "me@example.com"})
-        fr.send({**REPORT, "contact": "me@example.com", "contactFollowup": True})
-        without, with_ = (e["properties"] for e in self.events())
-        self.assertEqual((without["contact"], without["contact_followup"]), ("", False))
-        self.assertEqual((with_["contact"], with_["contact_followup"]), ("me@example.com", True))
-        with self.assertRaisesRegex(ValueError, "email address"):
-            fr.send({**REPORT, "contact": "discord:me", "contactFollowup": True})
-
-    def test_contacts_lists_the_newest_choice_per_copy_by_consent(self):
-        rows = [["a", "both@example.com", True, "true", "2026-09-01T10:00:00Z"],
-                ["b", "news@example.com", "true", False, "2026-09-02T10:00:00Z"],
-                ["c", "", False, False, "2026-09-03T10:00:00Z"],  # withdrawn
-                ["d", "not-an-address", True, True, "2026-09-03T10:00:00Z"], ["short"]]
-        with mock.patch.object(db, "_posthog_query", return_value={"results": rows}) as q:
-            found = fr.contacts()
-        self.assertIn("argMax(properties.email, tuple(ifNull(toInt(properties.rev), 0), timestamp))",
-                      q.call_args.args[0])
-        self.assertEqual(found, {"updates": [("both@example.com", "2026-09-01"), ("news@example.com", "2026-09-02")],
-                                 "followup": [("both@example.com", "2026-09-01")]})
-        with mock.patch.object(fr, "contacts", return_value=found), \
-             mock.patch.object(sys, "argv", ["frame_report.py", "contacts", "followup"]), \
-             mock.patch("builtins.print") as out:
-            fr.main()
-        printed = " ".join(str(c.args[0]) for c in out.call_args_list if c.args)
-        self.assertIn("both@example.com", printed)
-        self.assertNotIn("news@example.com", printed)
-
-    def test_the_page_can_reach_it(self):
-        import server
-        self.assertIs(server.POST["/api/contact"], fc.save)
-        self.assertIs(server.POST["/api/contact/prompt"], fc.prompt)
-
-
-# Run these once, in test_telemetry, not again through the import above.
-del Base, ReportProblem
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_devices.py

@@ -17,7 +17,6 @@ ROOT = Path(__file__).resolve().parent.parent
 sys.path.insert(0, str(ROOT / "ui"))
 
 import frame_devices as fd  # noqa: E402
-import frame_host  # noqa: E402
 
 CONFIG = """Host lxso1
   HostName 192.168.1.109
@@ -275,8 +274,7 @@ class Pins(Base):
     def test_hashed_and_non_default_port_entries(self):
         kh = self.ssh / "known_hosts"
         kh.write_text(f"[frame.local]:2222 {KEY}\n")
-        frame_host.run_ssh(["ssh-keygen", "-H", "-f", str(kh)], capture_output=True,
-                           stdin=subprocess.DEVNULL, check=True, timeout=10)
+        subprocess.run(["ssh-keygen", "-H", "-f", str(kh)], capture_output=True, check=True)
         self.assertFalse(fd.seed_pin("d3", ["frame.local"]))  # port 22: not that entry
         self.assertTrue(fd.seed_pin("d3", ["frame.local"], port=2222))
         self.assertIn(f"frame-control-d3 {KEY}", fd.known_hosts("d3").read_text())
@@ -285,8 +283,7 @@ class Pins(Base):
         target = fd.known_hosts("d4")
         target.parent.mkdir(parents=True, exist_ok=True)
         target.write_text(f"frame-control-d4 {KEY}\n")
-        frame_host.run_ssh(["ssh-keygen", "-H", "-f", str(target)], capture_output=True,
-                           stdin=subprocess.DEVNULL, check=True, timeout=10)
+        subprocess.run(["ssh-keygen", "-H", "-f", str(target)], capture_output=True, check=True)
         self.assertNotIn("frame-control-d4", target.read_text())
         self.assertTrue(fd.pinned("d4"))
         self.assertTrue(fd.forget_pin("d4"))
@@ -299,6 +296,20 @@ class Pins(Base):
 
 
 class Registry(Base):
+    def test_an_address_added_first_wins_on_its_own_network(self):
+        # The page's "Add 192.168.x.x" offer: the headset is reached over Tailscale, which has
+        # worked here before. The LAN address has to go ahead of it to be used at home.
+        d = self.reg.add_device("frame-4", hosts=["frame.tail1234.ts.net"])
+        self.reg.record_success(d["id"], "frame.tail1234.ts.net", "n-home", 6.0)
+        self.reg.add_address(d["id"], "192.168.1.40", kind="lan", first=True)
+        self.reg.record_success(d["id"], "192.168.1.40", "n-home", 1.0)  # Test now found it
+        addrs = self.reg.get(d["id"])["addresses"]
+        self.assertEqual([a["host"] for a in addrs], ["192.168.1.40", "frame.tail1234.ts.net"])
+        at_home = [a["host"] for a, _ in fd.order_addresses(addrs, "n-home", True)]
+        self.assertEqual(at_home[0], "192.168.1.40")
+        away = [a["host"] for a, _ in fd.order_addresses(addrs, "n-cafe", True)]
+        self.assertEqual(away[0], "frame.tail1234.ts.net")  # elsewhere Tailscale still leads
+
     def test_address_editing(self):
         d = self.reg.add_device("frame-3", hosts=["192.168.1.40"])
         a = self.reg.add_address(d["id"], "frame-3.local", label="mDNS")

tests/test_frame_android_data.py

@@ -63,7 +63,7 @@ class ObbTests(unittest.TestCase):
                 with self.assertRaisesRegex(android.FrameError, 'start this app'):
                     data.install_obb(PKG, [path])
                 stream.assert_not_called()
-            with patch.object(data.frame_host, 'run_ssh', return_value=subprocess.CompletedProcess([], 1, b'', b'bad hash')):
+            with patch.object(subprocess, 'run', return_value=subprocess.CompletedProcess([], 1, b'', b'bad hash')):
                 with self.assertRaisesRegex(android.FrameError, 'bad hash'):
                     data._stream('command')
 

tests/test_frame_host.py

@@ -1,87 +0,0 @@
-"""Captured OpenSSH output keeps working on Windows and POSIX hosts."""
-import sandbox  # noqa: F401
-import os
-import shutil
-import subprocess
-import sys
-import tempfile
-import unittest
-from pathlib import Path
-from unittest import mock
-
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "ui"))
-import frame_host
-
-
-class CapturedSSH(unittest.TestCase):
-    def run_command(self, source, **kwargs):
-        with mock.patch.object(frame_host, "WINDOWS", True):
-            return frame_host.run_ssh([sys.executable, "-c", source], timeout=5, **kwargs)
-
-    def test_binary_output_and_input(self):
-        result = self.run_command("import sys; sys.stdout.buffer.write(sys.stdin.buffer.read()); "
-                                  "sys.stderr.buffer.write(b'error\\r\\n')",
-                                  capture_output=True, input=b"data\x00\xff")
-        self.assertEqual(result.stdout, b"data\x00\xff")
-        self.assertEqual(result.stderr, b"error\r\n")
-
-    def test_text_output_normalizes_newlines(self):
-        result = self.run_command("import sys; sys.stdout.write(sys.stdin.read()); "
-                                  "sys.stderr.buffer.write(b'first\\r\\nsecond\\rthird\\n')",
-                                  capture_output=True, input="hello\n", text=True)
-        self.assertEqual(result.stdout, "hello\n")
-        self.assertEqual(result.stderr, "first\nsecond\nthird\n")
-
-    def test_explicit_encoding_and_errors(self):
-        result = self.run_command("import sys; sys.stderr.buffer.write(b'\\xe9\\xff')",
-                                  capture_output=True, encoding="ascii", errors="replace")
-        self.assertEqual(result.stderr, "\ufffd\ufffd")
-
-    def test_check_preserves_error_output(self):
-        with self.assertRaises(subprocess.CalledProcessError) as caught:
-            self.run_command("import sys; print('out'); print('err', file=sys.stderr); sys.exit(7)",
-                             capture_output=True, text=True, check=True)
-        self.assertEqual(caught.exception.returncode, 7)
-        self.assertEqual(caught.exception.stdout, "out\n")
-        self.assertEqual(caught.exception.stderr, "err\n")
-
-    def test_timeout_preserves_partial_stderr(self):
-        with self.assertRaises(subprocess.TimeoutExpired) as caught:
-            with mock.patch.object(frame_host, "WINDOWS", True):
-                frame_host.run_ssh([sys.executable, "-c", "import sys, time; "
-                                    "sys.stderr.write('waiting'); sys.stderr.flush(); time.sleep(10)"],
-                                   capture_output=True, text=True, timeout=1)
-        self.assertEqual(caught.exception.stderr, b"waiting")
-
-    def test_streamed_stdout_is_kept_separate(self):
-        with tempfile.TemporaryFile() as output:
-            result = self.run_command("import sys; sys.stdout.buffer.write(b'file'); "
-                                      "sys.stderr.buffer.write(b'error')",
-                                      stdout=output, stderr=subprocess.PIPE)
-            output.seek(0)
-            self.assertEqual(output.read(), b"file")
-        self.assertIsNone(result.stdout)
-        self.assertEqual(result.stderr, b"error")
-
-    def test_uncaptured_windows_call_is_unchanged(self):
-        with mock.patch.object(frame_host, "WINDOWS", True), mock.patch.object(subprocess, "run") as run:
-            frame_host.run_ssh(["ssh", "-V"], stderr=subprocess.DEVNULL, timeout=5)
-        run.assert_called_once_with(["ssh", "-V"], stderr=subprocess.DEVNULL, timeout=5)
-
-    def test_posix_call_is_unchanged(self):
-        with mock.patch.object(frame_host, "WINDOWS", False), mock.patch.object(subprocess, "run") as run:
-            frame_host.run_ssh(["ssh", "-V"], capture_output=True, check=True, timeout=5)
-        run.assert_called_once_with(["ssh", "-V"], capture_output=True, check=True, timeout=5)
-
-    def test_capture_rejects_explicit_streams(self):
-        for stream in ("stdout", "stderr"):
-            with self.subTest(stream=stream), self.assertRaises(ValueError):
-                self.run_command("", capture_output=True, **{stream: subprocess.DEVNULL})
-
-    @unittest.skipUnless(shutil.which("ssh"), "needs OpenSSH")
-    def test_real_ssh_failure_returns_stderr_without_hanging(self):
-        result = frame_host.run_ssh(["ssh", "-F", os.devnull, "-o", "BatchMode=yes",
-                                    "-o", "ConnectTimeout=2", "frame-control-test.invalid", "true"],
-                                   capture_output=True, stdin=subprocess.DEVNULL, text=True, timeout=5)
-        self.assertEqual(result.returncode, 255)
-        self.assertIn("Could not resolve hostname", result.stderr)

tests/test_link.py

@@ -457,6 +457,47 @@ class Connecting(unittest.TestCase):
         self.assertEqual(self.routes, [])
         self.assertTrue(all("ControlPath=none" in c for c in self.calls() if "-G" not in c))
 
+    def test_a_test_started_earlier_cant_overwrite_a_newer_one(self):
+        d = self.device("nothing.invalid")
+        entered = {1: threading.Event(), 2: threading.Event()}
+        release = {1: threading.Event(), 2: threading.Event()}
+        calls = []
+
+        def probe(host, port, update=None):
+            calls.append(host)
+            n = len(calls)
+            entered[n].set()
+            release[n].wait(10)
+            return {"state": "refused", "detail": f"test {n}", "ip": None, "rtt_ms": None}
+
+        tests = [threading.Thread(target=self.link.test, args=(d["id"],), daemon=True) for _ in range(2)]
+        with mock.patch.object(fl, "probe", probe):
+            try:
+                tests[0].start()
+                self.assertTrue(entered[1].wait(5), "the first test never probed")
+                tests[1].start()
+                self.assertTrue(entered[2].wait(5), "the second test never probed")
+                # The first finishes while the second is still probing: it mustn't show its
+                # rows or mark the second done.
+                release[1].set()
+                tests[0].join(10)
+                self.assertFalse(tests[0].is_alive())
+                running = self.link.snapshot()["tests"][d["id"]]
+                self.assertFalse(running["done"])
+                self.assertEqual(running["rows"][0]["detail"], "Waiting")
+                release[2].set()
+                tests[1].join(10)
+                self.assertFalse(tests[1].is_alive())
+            finally:
+                for e in release.values():
+                    e.set()
+                for t in tests:
+                    if t.ident:  # started
+                        t.join(10)
+        result = self.link.snapshot()["tests"][d["id"]]
+        self.assertTrue(result["done"])
+        self.assertEqual(result["rows"][0]["detail"], "test 2")
+
     def test_switching_to_a_headset_that_never_answers_stops_using_the_last_one(self):
         self.device("localhost")
         self.hosts({"localhost": "ok"})

tests/test_rdp.py

@@ -1,161 +0,0 @@
-"""Remote desktop to the Frame (frame_host.open_rdp) on each computer, with the client
-launch stubbed and a real socket standing in for the Frame's xrdp. Also the server
-staying quiet when the page goes away mid-reply, which on Windows is
-ConnectionAbortedError (WinError 10053).
-
-Run: python3 -m unittest discover -s tests
-"""
-import sandbox  # noqa: F401  (first: keeps tests off real data and services)
-import email.message
-import io
-import socket
-import sys
-import tempfile
-import unittest
-from pathlib import Path
-from unittest import mock
-
-ROOT = Path(__file__).resolve().parent.parent
-sys.path.insert(0, str(ROOT / "ui"))
-
-import frame_host  # noqa: E402
-import server  # noqa: E402
-
-
-def platform(name):
-    """Patches frame_host to behave as on `name` ("mac", "windows" or "linux")."""
-    return mock.patch.multiple(frame_host, MAC=name == "mac", WINDOWS=name == "windows",
-                               LINUX=name == "linux")
-
-
-class OpenRdp(unittest.TestCase):
-    def setUp(self):
-        self.xrdp = socket.socket()
-        self.xrdp.bind(("127.0.0.1", 0))
-        self.xrdp.listen(4)
-        self.addCleanup(self.xrdp.close)
-        port = mock.patch.object(frame_host, "RDP_PORT", self.xrdp.getsockname()[1])
-        port.start()
-        self.addCleanup(port.stop)
-        self.spawned = []
-        spawn = mock.patch.object(frame_host, "_spawn", self.spawned.append)
-        spawn.start()
-        self.addCleanup(spawn.stop)
-        cache = tempfile.TemporaryDirectory()
-        self.addCleanup(cache.cleanup)
-        self.cache = Path(cache.name)
-        where = mock.patch.object(frame_host, "cache_dir", lambda *p: self.cache.joinpath(*p))
-        where.start()
-        self.addCleanup(where.stop)
-
-    def test_windows_signs_in_as_steamos(self):
-        # The report: mstsc /v:HOST alone offers the Windows account, which xrdp rejects.
-        with platform("windows"):
-            message = frame_host.open_rdp("frame", "127.0.0.1")
-        self.assertEqual(len(self.spawned), 1)
-        argv = self.spawned[0]
-        self.assertEqual(argv[0], "mstsc.exe")
-        self.assertNotIn("/v:127.0.0.1", argv)
-        rdp = Path(argv[1])
-        self.assertEqual(rdp.suffix, ".rdp")
-        data = rdp.read_bytes()  # CRLF lines, as mstsc writes them, however this OS ends lines
-        self.assertNotIn(b"\r\r", data)
-        lines = data.decode("utf-8").split("\r\n")
-        self.assertIn("full address:s:127.0.0.1", lines)
-        self.assertIn("username:s:steamos", lines)
-        self.assertIn("steamos", message)
-        self.assertIn("Developer Mode password", message)
-        self.assertIn("certificate", message)
-        self.assertIn("Connect", message)
-
-    def test_nothing_listening_says_why_and_opens_nothing(self):
-        self.xrdp.close()
-        for name in ("windows", "mac", "linux"):
-            with self.subTest(name), platform(name), self.assertRaises(frame_host.Unreachable) as cm:
-                frame_host.open_rdp("frame", "127.0.0.1")
-            self.assertIn("Developer Mode", str(cm.exception))
-            self.assertIn(f"port {frame_host.RDP_PORT} refused", str(cm.exception))
-        self.assertEqual(self.spawned, [])
-
-    def test_says_which_way_it_failed(self):
-        # Only a refused port says xrdp is off; a wrong address or a silent network say so instead.
-        for error, says in ((socket.gaierror(8, "nodename nor servname provided"), "Devices tab"),
-                            (socket.timeout("timed out"), "didn't answer"),
-                            (OSError(65, "No route to host"), "didn't answer")):
-            with self.subTest(says), mock.patch.object(frame_host.socket, "create_connection", side_effect=error), \
-                    platform("windows"), self.assertRaises(frame_host.Unreachable) as cm:
-                frame_host.open_rdp("frame", "frame.local")
-            self.assertIn(says, str(cm.exception))
-            self.assertNotIn("refused", str(cm.exception))
-        self.assertEqual(self.spawned, [])
-
-    def test_server_says_it_as_the_persons_to_fix(self):
-        # A 400 with the message, not a 500 filed as an error diagnostic.
-        self.xrdp.close()
-        with mock.patch.multiple(server, LOCAL=False, LINK=None, HOST_OPTS=["-o", "HostName=127.0.0.1"]), \
-                self.assertRaises(server.Failure) as cm:
-            server.open_thing({"what": "rdp"})
-        self.assertEqual(cm.exception.status, 400)
-        self.assertIn("Developer Mode", str(cm.exception))
-
-    def test_one_file_per_address(self):
-        with platform("windows"):
-            a, b = frame_host.rdp_file("192.168.1.5"), frame_host.rdp_file("fe80::1%eth0")
-            c, d = frame_host.rdp_file("fe80::1%2"), frame_host.rdp_file("fe80::1:2")
-        self.assertEqual(len({a, b, c, d}), 4)
-        self.assertIn(b"full address:s:192.168.1.5\r\n", a.read_bytes())
-        self.assertIn(b"full address:s:fe80::1%eth0\r\n", b.read_bytes())
-
-    def test_address_cant_add_lines_to_the_file(self):
-        with platform("windows"), self.assertRaises(frame_host.HostError):
-            frame_host.rdp_file("frame\r\nusername:s:root")
-        self.assertEqual(list(self.cache.iterdir()), [])
-
-    def test_linux_clients_get_the_user(self):
-        with platform("linux"), mock.patch.object(frame_host, "which",
-                                                  lambda n, *e: "/usr/bin/xfreerdp" if n == "xfreerdp" else None):
-            message = frame_host.open_rdp("frame", "127.0.0.1")
-        self.assertEqual(self.spawned, [["xfreerdp", "/v:127.0.0.1", "/u:steamos", "/dynamic-resolution"]])
-        self.assertIn("steamos", message)
-
-
-class PageGoneAway(unittest.TestCase):
-    """The report's server log: the page closed while index.html was being sent, and the
-    server logged it as a 500, tried to answer anyway, and filed an error diagnostic."""
-
-    def handler(self, path="/"):
-        h = server.Handler.__new__(server.Handler)
-        h.command, h.path, h.request_version = "GET", path, "HTTP/1.1"
-        h.requestline, h.client_address = f"GET {path} HTTP/1.1", ("127.0.0.1", 1)
-        h.headers = email.message.Message()
-        h.headers["Host"] = "127.0.0.1:1"
-        h.wfile = mock.Mock(write=mock.Mock(side_effect=ConnectionAbortedError(10053, "aborted")))
-        h.close_connection = True
-        return h
-
-    def test_not_a_server_error(self):
-        h = self.handler()
-        with mock.patch.object(server.frame_telemetry, "diagnostic") as diagnostic, \
-                mock.patch.object(sys, "stderr", io.StringIO()), self.assertRaises(server.ClientGone):
-            h.do_GET()
-        diagnostic.assert_not_called()
-        self.assertEqual(h.wfile.write.call_count, 1)  # no second, 500 reply
-
-    def test_server_logs_nothing(self):
-        srv = server.LoopbackServer.__new__(server.LoopbackServer)
-        err = io.StringIO()
-        with mock.patch.object(sys, "stderr", err):
-            try:
-                raise server.ClientGone()
-            except server.ClientGone:
-                srv.handle_error(None, ("127.0.0.1", 1))
-            self.assertEqual(err.getvalue(), "")
-            try:
-                raise RuntimeError("real")
-            except RuntimeError:
-                srv.handle_error(None, ("127.0.0.1", 1))
-        self.assertIn("RuntimeError: real", err.getvalue())
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_server.py

@@ -111,8 +111,6 @@ class ServerGuards(unittest.TestCase):
             ("/api/volume", {"level": 1.5}),
             ("/api/clipboard", {"text": ""}),
             ("/api/open", {"what": "anything-else"}),
-            ("/api/open", {"what": "shot", "id": "1/250820/../../.ssh/id_ed25519"}),
-            ("/api/open", {"what": "shot"}),
             ("/api/shots/save", {"ids": []}),
             ("/api/shots/save", {"ids": "1/250820/20260925225208_1.jpg"}),
             ("/api/shots/save", {"ids": [1]}),
@@ -123,10 +121,6 @@ class ServerGuards(unittest.TestCase):
             status, payload = self.post(path, body)
             self.assertEqual(status, 400, f"{path} {body} -> {payload}")
 
-    def test_showing_a_shot_needs_it_saved_here(self):
-        status, payload = self.post("/api/open", {"what": "shot", "id": "1/250820/19990101000000_1.jpg"})
-        self.assertEqual(status, 404, payload)
-
     def test_screenshot_ids_checked_before_ssh(self):
         for shot in ("../../etc/passwd", "1/250820/x.jpg", "1/2/20260925225208_1.jpg;id", "1/250820/20260925225208_1.gif"):
             status, _, _ = self.request("GET", f"/api/shots/image?id={quote(shot)}", headers={"X-Frame-UI": "1"})
@@ -285,18 +279,6 @@ class OneServer(unittest.TestCase):
         r = conn.getresponse()
         self.assertEqual(r.status, 403, r.read())
 
-    @unittest.skipIf(os.name == "nt", "no SIGTERM on Windows")
-    def test_sigterm_while_the_app_holds_stdin_exits_cleanly(self):
-        """The app keeps stdin open; a stop signal used to abort Python (SIGABRT) at exit."""
-        env = {**os.environ, "FRAME_CONTROL_DATA_DIR": tempfile.mkdtemp(prefix="frame-one-server-"),
-               "FRAME_ALIAS": "frame-control-test.invalid"}
-        proc = subprocess.Popen([sys.executable, str(ROOT / "ui" / "server.py"), "--port", "0", "--exit-on-eof"],
-                                env=env, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
-        self.addCleanup(lambda: (proc.stdin.close(), proc.stdout.close()))
-        self.assertIn("Frame Control on", proc.stdout.readline())
-        proc.terminate()
-        self.assertEqual(proc.wait(30), 0, proc.stdout.read())
-
 
 class ArtworkSettings(unittest.TestCase):
     """The settings panel's endpoints, with and without the page's X-Frame-UI key."""

tests/test_telemetry.py

@@ -392,14 +392,13 @@ class ReportProblem(Base):
         got = self.serve()
         tm.update_settings({"usage": False})  # analytics off: a deliberate report still goes
         res = fr.send({"kind": "idea", "title": "Live view stops", "message": "It stops after a minute.",
-                       "contact": "me@example.com", "contactFollowup": True})
+                       "contact": "me@example.com"})
         path, body = got[0]
         event = body["batch"][0]
         self.assertEqual((path, body["api_key"], event["event"]), ("/batch/", "phc_test", "problem_report"))
         props = event["properties"]
         self.assertEqual((props["kind"], props["title"], props["message"], props["contact"], props["report_id"]),
                          ("idea", "Live view stops", "It stops after a minute.", "me@example.com", res["id"]))
-        self.assertIs(props["contact_followup"], True)
         self.assertEqual((props["$process_person_profile"], props["$geoip_disable"]), (False, True))
         self.assertNotEqual(event["distinct_id"], tm.settings()["id"])  # not linked to the analytics
         self.assertIn(res["id"], res["message"])
@@ -422,9 +421,8 @@ class ReportProblem(Base):
 
     def test_the_inbox_skips_malformed_reports(self):
         good = ["2026-09-28T09:50:00Z", "AB12CD34", "bug", "Live view stops", "It stops.", None,
-                "0.4.0", "macOS", "", "", None]
-        rows = [["2026-09-28T10:00:00Z", "X", "bug", "Hand-made", None, None, None, None, None, None, None],
-                ["short"], good]
+                "0.4.0", "macOS", "", ""]
+        rows = [["2026-09-28T10:00:00Z", "X", "bug", "Hand-made", None, None, None, None, None, None], ["short"], good]
         with mock.patch.object(db, "_posthog_query", return_value={"results": rows}), \
              mock.patch.object(sys, "argv", ["frame_report.py", "inbox"]), \
              mock.patch("builtins.print") as out:

ui/frame_android.py

@@ -47,8 +47,8 @@ def ssh(cmd, input=None, timeout=120):
     try:
         # No inherited stdin (see server.ssh): Windows' ssh.exe would wait on it.
         feed = {'input': input} if input is not None else {'stdin': subprocess.DEVNULL}
-        p = frame_host.run_ssh(['ssh', *SSH_OPTS, FRAME, cmd], capture_output=True, **feed,
-                               timeout=timeout, text=isinstance(input, str) or input is None)
+        p = subprocess.run(['ssh', *SSH_OPTS, FRAME, cmd], capture_output=True, **feed,
+                           timeout=timeout, text=isinstance(input, str) or input is None)
     except subprocess.TimeoutExpired:
         raise FrameError(f'timed out talking to {FRAME}')
     if p.returncode != 0:
@@ -120,7 +120,7 @@ def _copy(src, dest, executable=False, timeout=600):
     else:
         cmd = ['scp', *SSH_OPTS, src, f'{FRAME}:{dest}']
     try:
-        frame_host.run_ssh(cmd, check=True, capture_output=True, stdin=subprocess.DEVNULL, text=True, timeout=timeout)
+        subprocess.run(cmd, check=True, capture_output=True, stdin=subprocess.DEVNULL, text=True, timeout=timeout)
     except subprocess.TimeoutExpired:
         raise FrameError(f'copying {name} to the Frame timed out')
     except subprocess.CalledProcessError as e:

ui/frame_android_data.py

@@ -11,17 +11,16 @@ import tempfile
 import uuid
 
 import frame_android as android
-import frame_host
 
 REMOTE = Path(android.ROOT) / 'frame/android/app-data.py'
 
 
 def _stream(command, src=None, dst=None):
     try:
-        result = frame_host.run_ssh(['ssh', *android.SSH_OPTS, android.FRAME, command],
-                                    stdin=src if src else subprocess.DEVNULL,
-                                    stdout=dst if dst else subprocess.PIPE,
-                                    stderr=subprocess.PIPE, timeout=1800)
+        result = subprocess.run(['ssh', *android.SSH_OPTS, android.FRAME, command],
+                                stdin=src if src else subprocess.DEVNULL,
+                                stdout=dst if dst else subprocess.PIPE,
+                                stderr=subprocess.PIPE, timeout=1800)
     except subprocess.TimeoutExpired:
         raise android.FrameError('app-data transfer timed out')
     except OSError as error:

ui/frame_connect.py

@@ -24,8 +24,6 @@ import urllib.error
 import urllib.request
 from pathlib import Path
 
-import frame_host
-
 FRAME_USER = os.environ.get("FRAME_USER", "steamos")
 USER_FROM_ENV = "FRAME_USER" in os.environ
 FRAME_ALIAS = os.environ.get("FRAME_ALIAS", "frame")
@@ -351,9 +349,9 @@ def _write_config(host, port, user):
 
 def key_login_works():
     # accept-new: trust a first-seen host key (as the copy step does); a changed one still fails.
-    return frame_host.run_ssh(["ssh", "-o", "BatchMode=yes", "-o", "ConnectTimeout=5",
-                               "-o", "StrictHostKeyChecking=accept-new", FRAME_ALIAS, "true"],
-                              capture_output=True).returncode == 0
+    return subprocess.run(["ssh", "-o", "BatchMode=yes", "-o", "ConnectTimeout=5",
+                           "-o", "StrictHostKeyChecking=accept-new", FRAME_ALIAS, "true"],
+                          capture_output=True).returncode == 0
 
 
 def configured_user():

ui/frame_contact.py

@@ -1,218 +0,0 @@
-"""An email address the person chooses to leave, and what it may be used for. Python stdlib only.
-
-Two separate opt-in choices, both off until ticked:
-
-- updates: occasional notices about Frame Control releases and updates
-- followup: the maintainer may ask follow-up questions, mainly about problem reports
-
-The address and the choices are kept on this computer (frame_host.data_dir('contact')) and
-sent privately to Frame Control's PostHog project as a `contact_consent` event, the same way
-as problem reports (frame_report.py), so only the maintainer can read them. Every change
-sends a new event under this copy's own random contact id (not the analytics id), numbered
-by `rev`, and the highest rev for an id is the one that counts, whatever the clocks say:
-removing the address sends a withdrawal with no address in it, and wipes the address from
-the local log of what was sent. The maintainer lists who agreed to what with
-`python3 ui/frame_report.py contacts`. Nothing here sends email.
-
-A change that can't be sent (offline) waits in the state file and is retried in the
-background, so a withdrawal is never lost. The page's one-time prompt is remembered here
-too: once it has been shown or dismissed it never comes back.
-"""
-import json
-import os
-import re
-import threading
-import time
-import uuid
-
-import frame_host
-import frame_telemetry
-
-STATE = frame_host.data_dir('contact')
-FILE = STATE / 'contact.json'
-EMAIL_MAX = 254
-EMAIL_RE = re.compile(r'[^@\s]+@[^@\s]+\.[^@\s.]+')
-PROMPTS = ('new', 'shown', 'dismissed', 'answered')
-RETRY_EVERY = 600
-
-_lock = threading.RLock()
-_send_lock = threading.Lock()  # one send at a time, so events reach PostHog in rev order
-_removed = {}  # address (lower case) -> when it was removed, for reports still being sent then
-_wake = threading.Event()
-_retrier = None
-
-
-def _defaults():
-    return {'id': str(uuid.uuid4()), 'email': '', 'updates': False, 'followup': False,
-            'prompt': 'new', 'pending': None, 'rev': 0}
-
-
-def load():
-    with _lock:
-        s = _defaults()
-        try:
-            with open(FILE) as f:
-                saved = json.load(f)
-            if isinstance(saved, dict):
-                s.update({k: v for k, v in saved.items() if k in s})
-        except (OSError, ValueError):
-            pass
-        return s
-
-
-def _save(s):
-    STATE.mkdir(parents=True, exist_ok=True)
-    tmp = FILE.with_suffix('.tmp')
-    tmp.write_text(json.dumps(s, indent=1))
-    os.replace(tmp, FILE)
-
-
-def valid_email(email):
-    return len(email) <= EMAIL_MAX and bool(EMAIL_RE.fullmatch(email))
-
-
-def state():
-    """What the page shows. showPrompt: the one-time prompt hasn't been shown or answered yet,
-    and the Frame has connected at least once (setup worked), so it never greets a new install."""
-    s = load()
-    set_up = bool(frame_telemetry.settings().get('frames_seen'))
-    return {'email': s['email'], 'updates': s['updates'], 'followup': s['followup'],
-            'waiting': s['pending'] is not None, 'showPrompt': s['prompt'] == 'new' and set_up}
-
-
-def _event(s):
-    email = s['email'] if s['updates'] or s['followup'] else ''
-    return {'event': 'contact_consent', 'distinct_id': s['id'], 'uuid': str(uuid.uuid4()),
-            'timestamp': time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()),
-            'properties': {**frame_telemetry.common(), 'email': email, 'updates': bool(email and s['updates']),
-                           'followup': bool(email and s['followup']),
-                           'action': 'set' if email else 'withdraw', 'rev': s['rev'], 'level': 'contact'}}
-
-
-def _send_pending(block=True):
-    """Send what's waiting, including changes made while sending. True if nothing is left
-    waiting. Without block, a send already under way is left to pick up the newest change."""
-    if not _send_lock.acquire(blocking=block):
-        return False
-    try:
-        while True:
-            with _lock:
-                event = load()['pending']
-            if event is None:
-                break
-            try:
-                frame_telemetry.post([event], timeout=30)
-            except frame_telemetry.SendError:
-                return False
-            _sent(event)
-    finally:
-        _send_lock.release()
-    # A change saved just as this finished found the lock still held and left it to us.
-    with _lock:
-        left = load()['pending'] is not None
-    return _send_pending(block=False) if left else True
-
-
-def _sent(event):
-    with _lock:
-        s = load()
-        if s['pending'] and s['pending'].get('uuid') == event['uuid']:  # not replaced meanwhile
-            s['pending'] = None
-            _save(s)
-        # A withdrawal, or the address still in use: not an old one removed while this was on its way.
-        if event['properties']['email'] in ('', s['email']):
-            try:
-                frame_telemetry.record_sent([event])
-            except OSError:
-                pass
-
-
-def _forget_locally(email):
-    """Take a removed address out of the log of what was sent (contact events and reports)."""
-    with frame_telemetry._lock:
-        _removed[email.lower()] = time.time()
-        rows = frame_telemetry._read_lines(frame_telemetry.SENT)
-        hit = False
-        for e in rows:
-            p = e.get('properties') or {}
-            for k in ('email', 'contact'):
-                if p.get(k) and str(p[k]).strip().lower() == email.lower():
-                    p[k], hit = '<removed>', True
-        if hit:
-            frame_telemetry._write_lines(frame_telemetry.SENT, rows)
-
-
-def redact_removed(event, started):
-    """Before logging a report (started at time.time() `started`) whose address was removed
-    while it was being sent: take the address out. Call with frame_telemetry._lock held, so a
-    removal can't slip between this and the log."""
-    p = event.get('properties') or {}
-    removed_at = _removed.get(str(p.get('contact') or '').strip().lower())
-    if removed_at is not None and started <= removed_at:
-        p['contact'] = '<removed>'
-
-
-def save(body):
-    """Set, change or remove the address and the two choices. An address needs at least one
-    choice ticked; an empty address (or neither ticked) removes it and withdraws both."""
-    email = str(body.get('email') or '').strip()
-    updates, followup = bool(body.get('updates')), bool(body.get('followup'))
-    if email and not valid_email(email):
-        raise ValueError("that doesn't look like an email address")
-    if email and not (updates or followup):
-        raise ValueError('tick what the address may be used for, or remove it')
-    if not email:
-        updates = followup = False
-    with _lock:
-        s = load()
-        old = s['email']
-        changed = (email, updates, followup) != (s['email'], s['updates'], s['followup'])
-        s.update(email=email, updates=updates, followup=followup)
-        if body.get('fromPrompt') or email:
-            s['prompt'] = 'answered'
-        if changed:
-            # Only the newest choice matters, so it replaces anything still waiting. A withdrawal
-            # is sent even for an address still waiting here: its send may already be under way.
-            s['rev'] += 1
-            s['pending'] = _event(s)
-        _save(s)
-        if old and old.lower() != email.lower():
-            try:
-                _forget_locally(old)
-            except OSError:
-                pass
-    if changed and not _send_pending(block=False):
-        _wake.set()  # offline, or a send under way that will take this change with it
-    return state()
-
-
-def prompt(body):
-    """The one-time prompt was shown, or dismissed with No thanks. Either way it stays gone."""
-    action = body.get('prompt')
-    if action not in ('shown', 'dismissed'):
-        raise ValueError('unknown prompt action')
-    with _lock:
-        s = load()
-        if s['prompt'] in ('new', 'shown'):
-            s['prompt'] = action
-            _save(s)
-    return state()
-
-
-def start():
-    """Retry a change that couldn't be sent, from now on in the background."""
-    global _retrier
-    if _retrier:
-        return
-
-    def loop():
-        while True:
-            try:
-                _send_pending()
-            except Exception:
-                pass
-            _wake.wait(RETRY_EVERY)
-            _wake.clear()
-
-    _retrier = threading.Thread(target=loop, name='contact', daemon=True)
-    _retrier.start()

ui/frame_devices.py

@@ -333,8 +333,8 @@ def remove_block(alias, path=None):
 def effective_port(alias, config):
     """The port ssh uses for ALIAS with this config file (`ssh -F FILE -G ALIAS`), else 22."""
     try:
-        out = frame_host.run_ssh(["ssh", "-F", str(config), "-G", alias], capture_output=True, text=True,
-                                 stdin=subprocess.DEVNULL, timeout=10).stdout
+        out = subprocess.run(["ssh", "-F", str(config), "-G", alias], capture_output=True, text=True,
+                             stdin=subprocess.DEVNULL, timeout=10).stdout
     except (OSError, subprocess.TimeoutExpired):
         return 22
     m = re.search(r"^port (\d+)$", out, re.M)
@@ -346,8 +346,8 @@ def effective_port(alias, config):
 
 def _keygen(*args):
     try:
-        return frame_host.run_ssh(["ssh-keygen", *args], capture_output=True, stdin=subprocess.DEVNULL, text=True,
-                                  timeout=10)
+        return subprocess.run(["ssh-keygen", *args], capture_output=True, stdin=subprocess.DEVNULL, text=True,
+                              timeout=10)
     except (OSError, subprocess.TimeoutExpired):
         return None
 
@@ -623,7 +623,9 @@ class Registry:
                 return a
         raise DeviceError(f"{host} isn't one of this headset's addresses")
 
-    def add_address(self, device_id, host, kind=None, label=""):
+    def add_address(self, device_id, host, kind=None, label="", first=False):
+        """Add an address at the end of the list, or at the front (first=True), where the
+        user's order makes it win over the others that work on the same network."""
         with self._changing():
             d = self._find(device_id)
             a = new_address(host, kind, label)
@@ -631,7 +633,7 @@ class Registry:
                 raise DeviceError(f"{a['host']} is already on the list")
             if len(d["addresses"]) >= 32:
                 raise DeviceError("That's enough addresses for one headset")
-            d["addresses"].append(a)
+            d["addresses"].insert(0 if first else len(d["addresses"]), a)
             self.save()
             return copy.deepcopy(a)
 

ui/frame_host.py

@@ -5,16 +5,12 @@ Everything here runs on your computer, not the Frame. Python stdlib only.
 CLI (used by the Electron app, so terminal handling lives in one place):
   python3 ui/frame_host.py terminal -- CMD [ARG...]   # open CMD in a terminal window
 """
-import hashlib
-import io
 import os
 import shlex
 import shutil
-import socket
 import ssl
 import subprocess
 import sys
-import tempfile
 from pathlib import Path
 
 MAC = sys.platform == "darwin"
@@ -36,45 +32,6 @@ class HostError(RuntimeError):
     pass
 
 
-class Unreachable(HostError):
-    """The Frame, or a service on it, didn't answer: the person's to sort out, not a fault here."""
-
-
-def run_ssh(argv, **kwargs):
-    """Run an OpenSSH tool without Windows' redirected-stderr pipe hang.
-
-    A real temporary file avoids OpenSSH's blocked asynchronous stderr writes,
-    while keeping subprocess.run's captured output, text, check and timeout API.
-    """
-    if not WINDOWS:
-        return subprocess.run(argv, **kwargs)
-    if kwargs.pop("capture_output", False):
-        if kwargs.get("stdout") is not None or kwargs.get("stderr") is not None:
-            raise ValueError("stdout and stderr arguments may not be used with capture_output")
-        kwargs.update(stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    if kwargs.get("stderr") != subprocess.PIPE:
-        return subprocess.run(argv, **kwargs)
-    check = kwargs.pop("check", False)
-    text = any(kwargs.get(key) for key in ("text", "universal_newlines", "encoding", "errors"))
-    with tempfile.TemporaryFile() as stderr:
-        kwargs["stderr"] = stderr
-        try:
-            result = subprocess.run(argv, **kwargs)
-        except subprocess.TimeoutExpired as error:
-            stderr.seek(0)
-            error.stderr = stderr.read()
-            raise
-        stderr.seek(0)
-        if text:
-            with io.TextIOWrapper(stderr, encoding=kwargs.get("encoding"), errors=kwargs.get("errors")) as reader:
-                result.stderr = reader.read()
-        else:
-            result.stderr = stderr.read()
-    if check:
-        result.check_returncode()
-    return result
-
-
 def data_dir(*parts):
     """Per-user app data: ~/Library/Application Support, %APPDATA% or $XDG_DATA_HOME
     (or $FRAME_CONTROL_DATA_DIR, which the tests point at a throwaway directory)."""
@@ -196,19 +153,6 @@ def open_path(path):
                      stderr=subprocess.DEVNULL, **DETACHED)
 
 
-def reveal_path(path):
-    """Show a file selected in its folder (Linux file managers vary, so there the folder opens)."""
-    path = Path(path)
-    if MAC:
-        cmd = ["open", "-R", str(path)]
-    elif WINDOWS:
-        cmd = f'explorer /select,"{path}"'  # as one string: Explorer wants the quotes after the comma
-    else:
-        return open_path(path.parent)
-    subprocess.Popen(cmd, stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL,
-                     stderr=subprocess.DEVNULL, **DETACHED)
-
-
 open_url = open_path  # the same openers hand URLs to the default browser
 
 
@@ -287,7 +231,7 @@ def clipboard_text():
 def ssh_hostname(alias):
     """The real host name an ssh alias points at (`ssh -G`), for non-SSH clients like RDP."""
     try:
-        out = run_ssh(["ssh", "-G", alias], capture_output=True, stdin=subprocess.DEVNULL, text=True, timeout=10).stdout
+        out = subprocess.run(["ssh", "-G", alias], capture_output=True, stdin=subprocess.DEVNULL, text=True, timeout=10).stdout
     except (OSError, subprocess.TimeoutExpired):
         return alias
     for line in out.splitlines():
@@ -320,65 +264,24 @@ def open_steam_link():
     return "Steam Link isn't installed; opened its download page"
 
 
-RDP_PORT = 3389
-RDP_USER = "steamos"  # xrdp signs in with the Developer Mode password, not this computer's
-# xrdp's certificate is its own, so every client warns about it first.
-RDP_LOGIN = (f"accept the warning about the Frame's certificate, then sign in as {RDP_USER} "
-             "with your Developer Mode password")
-
-
-def check_rdp(host, timeout=3):
-    """Raise Unreachable, saying why, unless the Frame's RDP port takes a connection."""
-    try:
-        with socket.create_connection((host, RDP_PORT), timeout=timeout):
-            return
-    except ConnectionRefusedError:
-        raise Unreachable(f"The Frame at {host} is on but isn't accepting remote desktop (port {RDP_PORT} "
-                          "refused). Turn on Developer Mode in Steam Settings > System on the headset, "
-                          "then restart it and try again.") from None
-    except socket.gaierror:
-        raise Unreachable(f"Can't find {host} on the network for remote desktop. Check the headset's "
-                          "address on the Devices tab.") from None
-    except OSError as e:
-        raise Unreachable(f"The Frame didn't answer remote desktop at {host} ({e}). It may be asleep, "
-                          "switched off or on another network; if it's on, check Developer Mode is on "
-                          "in Steam Settings > System.") from None
-
-
-def rdp_file(host):
-    """A Remote Desktop connection file for the Frame. mstsc /v: alone offers this
-    computer's Windows account, which xrdp turns away; the file names steamos instead."""
-    if any(c in host for c in "\r\n"):
-        raise HostError("That headset address can't be used for remote desktop")
-    # One file per address, so two launches close together can't swap headsets.
-    path = cache_dir(f"frame-{hashlib.sha256(host.encode()).hexdigest()[:16]}.rdp")
-    path.parent.mkdir(parents=True, exist_ok=True)
-    with open(path, "w", encoding="utf-8", newline="\r\n") as f:  # Path.write_text(newline=) is 3.10+
-        f.write(f"full address:s:{host}\nusername:s:{RDP_USER}\n")
-    return path
-
-
 def open_rdp(alias, host=None):
     """Remote desktop to the Frame's xrdp (user steamos), at `host` or where the alias points."""
     host = host or ssh_hostname(alias)
-    # The client would open either way and then fail on its own, with nothing said here.
-    check_rdp(host)
     if MAC:
         if subprocess.run(["open", "-a", "Windows App"], capture_output=True).returncode == 0:
-            return f"Opened Windows App: connect to {host} and {RDP_LOGIN}"
+            return "Opened Windows App"
         open_url("https://apps.apple.com/app/windows-app/id1295203466")
         return "Windows App isn't installed; opened its App Store page"
     if WINDOWS:
-        _spawn(["mstsc.exe", str(rdp_file(host))])
-        # Windows asks about the unsigned connection file first.
-        return f"Opened Remote Desktop to {host}: choose Connect, {RDP_LOGIN}"
+        _spawn(["mstsc.exe", f"/v:{host}"])
+        return f"Opened Remote Desktop to {host}"
     if which("remmina"):
-        _spawn(["remmina", "-c", f"rdp://{RDP_USER}@{host}"])
-        return f"Opened Remmina to {host}: {RDP_LOGIN}"
+        _spawn(["remmina", "-c", f"rdp://steamos@{host}"])
+        return f"Opened Remmina to {host}"
     for name in ("xfreerdp3", "xfreerdp"):
         if which(name):
-            _spawn([name, f"/v:{host}", f"/u:{RDP_USER}", "/dynamic-resolution"])
-            return f"Opened FreeRDP to {host}: {RDP_LOGIN}"
+            _spawn([name, f"/v:{host}", "/u:steamos", "/dynamic-resolution"])
+            return f"Opened FreeRDP to {host}"
     raise HostError("No RDP client found: install Remmina or FreeRDP")
 
 

ui/frame_link.py

@@ -74,8 +74,8 @@ def ssh_g(alias):
     """(hostname, port, user, proxied) from `ssh -G ALIAS`, for a headset that's only an
     ssh alias. proxied: it goes through ProxyJump or ProxyCommand, so only ssh can reach it."""
     try:
-        out = frame_host.run_ssh(["ssh", "-G", alias], capture_output=True, stdin=subprocess.DEVNULL, text=True,
-                                 timeout=10).stdout
+        out = subprocess.run(["ssh", "-G", alias], capture_output=True, stdin=subprocess.DEVNULL, text=True,
+                             timeout=10).stdout
     except (OSError, subprocess.TimeoutExpired):
         out = ""
     got = {}
@@ -169,6 +169,7 @@ class Link:
         self.version = 0
         self.stopped = False
         self.kicks = []                 # reasons someone asked for a (re)connect
+        self.test_gen = {}              # device id -> its newest test of the addresses (see test())
         self.busy = False               # the loop is handling kicks
         self.state = {"phase": "idle", "reason": None, "device": None, "network": None, "stages": [],
                       "probes": [], "via": None, "error": None, "retry_at": None, "attempt": 0,
@@ -765,8 +766,8 @@ class Link:
         if not self.control:
             return False
         try:
-            return frame_host.run_ssh([*self.mux_base, *opts, "-O", "check", alias or self.alias], capture_output=True,
-                                      stdin=subprocess.DEVNULL, timeout=5).returncode == 0
+            return subprocess.run([*self.mux_base, *opts, "-O", "check", alias or self.alias], capture_output=True,
+                                  stdin=subprocess.DEVNULL, timeout=5).returncode == 0
         except (OSError, subprocess.TimeoutExpired):
             return False
 
@@ -777,8 +778,8 @@ class Link:
             pending.kill()
         if self.control and self.alias:
             try:
-                frame_host.run_ssh([*self.mux_base, *self.opts, "-O", "exit", self.alias], capture_output=True,
-                                   stdin=subprocess.DEVNULL, timeout=5)
+                subprocess.run([*self.mux_base, *self.opts, "-O", "exit", self.alias], capture_output=True,
+                               stdin=subprocess.DEVNULL, timeout=5)
             except (OSError, subprocess.TimeoutExpired):
                 pass
         if proc and proc.poll() is None:
@@ -955,9 +956,13 @@ class Link:
         started = now()
         rows = [{"host": a["host"], "kind": a["kind"], "state": "waiting", "detail": "Waiting", "ip": None,
                  "rtt_ms": None, "ssh": None} for a in device["addresses"]]
+        with self.cond:
+            gen = self.test_gen[device_id] = self.test_gen.get(device_id, 0) + 1
 
         def put(**fields):
             with self.cond:
+                if gen != self.test_gen[device_id]:
+                    return  # a newer test has started: its results are the ones to show
                 self.state["tests"][device_id] = dict({"started": started, "done": False, "rows": rows}, **fields)
                 self.version += 1
                 self.cond.notify_all()
@@ -983,8 +988,8 @@ class Link:
                     *self.host_opts(device, ssh_target(a["host"], res.get("ip"))),
                     "-o", "StrictHostKeyChecking=yes", device["alias"], "true"]
             try:
-                r = frame_host.run_ssh(argv, capture_output=True, stdin=subprocess.DEVNULL, text=True,
-                                       errors="replace", timeout=20)
+                r = subprocess.run(argv, capture_output=True, stdin=subprocess.DEVNULL, text=True,
+                                   errors="replace", timeout=20)
                 err = r.stderr.strip()
                 if r.returncode == 0:
                     rows[i].update(ssh="ok", detail=f"{lead} · SSH works")
@@ -1111,7 +1116,8 @@ def devices_action(link, body, open_setup, busy=lambda: 0):
                 raise frame_devices.DeviceError(f"Removed, but couldn't edit ~/.ssh/config: {e}")
         msg = f"Removed {d['name']}" + (f" and its '{d['alias']}' entry in ~/.ssh/config" if removed else "")
     elif action == "address-add":
-        a = reg.add_address(did, body.get("host"), body.get("kind") or None, body.get("label") or "")
+        a = reg.add_address(did, body.get("host"), body.get("kind") or None, body.get("label") or "",
+                            first=body.get("first") is True)
         if is_active and link.state["phase"] == "failed":
             link.kick("retry")
         msg = f"Added {a['host']}"

ui/frame_report.py

@@ -6,10 +6,6 @@ project as a `problem_report` event: only the maintainer can read it, and
 nothing is published. It is sent whatever the analytics settings are, because
 the person sends it deliberately. Diagnostics are scrubbed first
 (frame_telemetry.scrub); the person's own words are sent as written.
-
-An email address goes with a report only when the person ticks "may contact me with
-follow-up questions" (contact_followup). Standing choices made in Settings are
-frame_contact.py's `contact_consent` events; `contacts` lists them.
 """
 import os
 import platform
@@ -17,7 +13,6 @@ import sys
 import time
 import uuid
 
-import frame_contact
 import frame_host
 import frame_telemetry
 
@@ -112,26 +107,19 @@ def send(body):
     """Send the report to PostHog. Returns {"id", "message"}; raises ReportError."""
     kind = body.get('kind') if body.get('kind') in KINDS else 'bug'
     title, text, diag = compose(body)
-    followup = bool(body.get('contactFollowup'))
-    contact = str(body.get('contact') or '').strip() if followup else ''
-    if followup and not frame_contact.valid_email(contact):
-        raise ValueError('add your email address for follow-up questions, or untick that box')
     ref = uuid.uuid4().hex[:8].upper()
     props = {**frame_telemetry.common(), 'kind': kind, 'title': title, 'message': text,
-             'contact': contact, 'contact_followup': followup, 'diagnostics': diag,
+             'contact': str(body.get('contact') or '').strip()[:120], 'diagnostics': diag,
              'report_id': ref, 'steamos': str(frame.get('build') or '')[:120], 'level': 'report'}
     # Its own random id: a report can carry contact details, so it isn't linked to this copy's analytics.
     event = {'event': 'problem_report', 'distinct_id': str(uuid.uuid4()), 'uuid': str(uuid.uuid4()),
              'timestamp': time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()), 'properties': props}
-    started = time.time()
     try:
         frame_telemetry.post([event], timeout=30)
     except frame_telemetry.SendError as e:
         raise ReportError(str(e))
     try:
-        with frame_telemetry._lock:  # the lock a removal holds while wiping its address
-            frame_contact.redact_removed(event, started)
-            frame_telemetry.record_sent([event])
+        frame_telemetry.record_sent([event])
     except OSError:
         pass  # it was sent; failing to log it here mustn't make the person send it again
     return {'id': ref, 'message': f'Sent privately to the Frame Control developer (report {ref}).'}
@@ -147,71 +135,22 @@ def inbox(days=30):
     import frame_compat_db
     res = frame_compat_db._posthog_query(
         "SELECT timestamp, properties.report_id, properties.kind, properties.title, properties.message, "
-        "properties.contact, properties.app_version, properties.os, properties.steamos, properties.diagnostics, "
-        "properties.contact_followup "
+        "properties.contact, properties.app_version, properties.os, properties.steamos, properties.diagnostics "
         f"FROM events WHERE event = 'problem_report' AND timestamp > now() - INTERVAL {int(days)} DAY "
         "ORDER BY timestamp DESC LIMIT 200")
     return res.get('results') or []
 
 
-def _yes(v):
-    return v is True or str(v).lower() in ('true', '1')
-
-
-def contacts():
-    """{'updates': [(email, since)], 'followup': [...]}: the addresses whose newest
-    contact_consent event agrees to each, oldest first. A withdrawal, or a change to another
-    address, replaces what came before, so withdrawn addresses are never listed. "Newest" is
-    the highest rev from that copy (then time), so every field comes from the same event
-    whatever order they arrived in or what the clocks said."""
-    import frame_compat_db
-    newest = "tuple(ifNull(toInt(properties.rev), 0), timestamp)"
-    res = frame_compat_db._posthog_query(
-        f"SELECT distinct_id, argMax(properties.email, {newest}), argMax(properties.updates, {newest}), "
-        f"argMax(properties.followup, {newest}), argMax(timestamp, {newest}) FROM events "
-        "WHERE event = 'contact_consent' GROUP BY distinct_id ORDER BY max(timestamp) LIMIT 100000")
-    out = {'updates': [], 'followup': []}
-    for row in res.get('results') or []:
-        if not isinstance(row, list) or len(row) != 5:
-            continue
-        _, email, updates, followup, ts = row
-        email = str(email or '').strip()
-        if not frame_contact.valid_email(email):
-            continue
-        for kind, agreed in (('updates', updates), ('followup', followup)):
-            if _yes(agreed):
-                out[kind].append((email, str(ts or '')[:10]))
-    return out
-
-
-USAGE = 'usage: frame_report.py inbox [days] | contacts [updates|followup]'
-
-
 def main():
     cmd, *args = sys.argv[1:] or ['inbox']
-    if cmd == 'contacts':
-        kinds = args[:1] or ['updates', 'followup']
-        if not set(kinds) <= {'updates', 'followup'}:
-            sys.exit(USAGE)
-        found = contacts()
-        for kind in kinds:
-            print(f"== {'Release and update notices' if kind == 'updates' else 'Follow-up questions'}"
-                  f" ({len(found[kind])})")
-            for email, since in found[kind]:
-                print(f"   {email}  (since {since})")
-            print()
-        return
     if cmd != 'inbox':
-        sys.exit(USAGE)
+        sys.exit('usage: frame_report.py inbox [days]')
     for row in inbox(*(args[:1] or [30])):
-        if not isinstance(row, list) or len(row) != 11:
+        if not isinstance(row, list) or len(row) != 10:
             continue
-        ts, ref, kind, title, text, contact, version, osname, steamos, diag = (str(v or '') for v in row[:10])
-        # Reports from before contact_followup existed only carried an address given for a reply.
-        reply = contact and (row[10] is None or _yes(row[10]))
+        ts, ref, kind, title, text, contact, version, osname, steamos, diag = (str(v or '') for v in row)
         print(f"== {ts[:16].replace('T', ' ')}  {ref}  [{kind}] {title}")
-        print(f"   {version} on {osname}, SteamOS {steamos or 'unknown'}"
-              f"{', may follow up at ' + contact if reply else ''}")
+        print(f"   {version} on {osname}, SteamOS {steamos or 'unknown'}{', reply to ' + contact if contact else ''}")
         print('   ' + text.replace('\n', '\n   '))
         if diag:
             print('   --- diagnostics\n   ' + diag.replace('\n', '\n   '))

ui/server.py

@@ -50,7 +50,6 @@ import frame_catalog  # noqa: E402
 import frame_devices  # noqa: E402
 import frame_steamgriddb
 import frame_comfort  # noqa: E402
-import frame_contact  # noqa: E402
 import frame_host  # noqa: E402
 import frame_link  # noqa: E402
 import frame_macview  # noqa: E402
@@ -333,8 +332,8 @@ def ssh(remote, *, stdin=None, timeout=30, text=True):
         # Never let ssh inherit our stdin: under the app it's the pipe held open for
         # --exit-on-eof, and Windows' ssh.exe waits on it forever.
         feed = {"input": stdin} if stdin is not None else {"stdin": subprocess.DEVNULL}
-        r = frame_host.run_ssh([*SSH, FRAME, remote], capture_output=True, **feed,
-                               text=text, errors="replace" if text else None, timeout=timeout)
+        r = subprocess.run([*SSH, FRAME, remote], capture_output=True, **feed,
+                           text=text, errors="replace" if text else None, timeout=timeout)
     except subprocess.TimeoutExpired:
         raise Failure(f"Timed out talking to {FRAME}")
     if r.returncode != 0:
@@ -504,8 +503,8 @@ def save_shots(body):
         incoming = Path(tempfile.mkdtemp(prefix=".incoming-", dir=SHOTS_DIR))
         try:
             try:
-                r = frame_host.run_ssh(["scp", "-p", *SSH[1:], *(f"{FRAME}:{p}" for p in todo), str(incoming)],
-                                       capture_output=True, stdin=subprocess.DEVNULL, text=True, timeout=300)
+                r = subprocess.run(["scp", "-p", *SSH[1:], *(f"{FRAME}:{p}" for p in todo), str(incoming)],
+                                   capture_output=True, stdin=subprocess.DEVNULL, text=True, timeout=300)
             except subprocess.TimeoutExpired:
                 raise Failure("Copying screenshots timed out")
             if r.returncode != 0:
@@ -1193,14 +1192,6 @@ def open_thing(body):
             SHOTS_DIR.mkdir(parents=True, exist_ok=True)
             frame_host.open_path(SHOTS_DIR)
             return {"message": f"Opened {SHOTS_DIR} in {frame_host.FILE_MANAGER}"}
-        if what == "shot":
-            saved = SHOTS_DIR / shot_path(body.get("id")).rsplit("/", 1)[-1]
-            if not saved.exists():
-                raise Failure("That screenshot isn't saved on this computer yet", 404)
-            frame_host.reveal_path(saved)
-            return {"message": f"Showed {saved.name} in {frame_host.FILE_MANAGER}"}
-    except frame_host.Unreachable as e:
-        raise Failure(str(e), 400)  # theirs to turn on; nothing failed here
     except frame_host.HostError as e:
         raise Failure(str(e), 500)
     raise Failure("unknown target", 400)
@@ -2160,7 +2151,6 @@ POST = {
         "/api/webinstall/check": webinstall_check, "/api/webinstall/start": webinstall_start,
         "/api/webinstall/cancel": webinstall_cancel,
         "/api/telemetry": frame_telemetry.update_settings, "/api/telemetry/event": frame_telemetry.page_event,
-        "/api/contact": frame_contact.save, "/api/contact/prompt": frame_contact.prompt,
         "/api/report/preview": report_preview, "/api/report": report_send, "/api/macview": macview_action, "/api/panels": panels_action,
         "/api/devices": lambda body: devices_post(body)}
 
@@ -2256,7 +2246,7 @@ def push_file(path, dest="Downloads/"):
         else:
             # Modern scp uses SFTP, so the remote path isn't parsed by a shell.
             cmd = ["scp", *SSH[1:], "-r", str(path), f"{FRAME}:{dest}"]
-        r = frame_host.run_ssh(cmd, capture_output=True, stdin=subprocess.DEVNULL, text=True, errors="replace", timeout=3600)
+        r = subprocess.run(cmd, capture_output=True, stdin=subprocess.DEVNULL, text=True, errors="replace", timeout=3600)
     except subprocess.TimeoutExpired:
         raise Failure(f"Copying {name} timed out")
     if r.returncode != 0:
@@ -2264,11 +2254,6 @@ def push_file(path, dest="Downloads/"):
     return f"Sent {name} to ~/{dest}"
 
 
-class ClientGone(Exception):
-    """The page went away (a reload, the app quitting) before its reply was written:
-    nobody to answer, and nothing went wrong here."""
-
-
 class Handler(BaseHTTPRequestHandler):
     server_version = "FrameControl/1"
     timeout = 60  # per socket operation, so a stalled client can't hold a thread
@@ -2301,11 +2286,8 @@ class Handler(BaseHTTPRequestHandler):
         # Nobody may frame the UI (clickjacking).
         self.send_header("X-Frame-Options", "DENY")
         self.send_header("Content-Security-Policy", "frame-ancestors 'none'")
-        try:
-            self.end_headers()
-            self.wfile.write(data)
-        except ConnectionError as e:  # Windows says ConnectionAbortedError, others BrokenPipeError
-            raise ClientGone() from e
+        self.end_headers()
+        self.wfile.write(data)
 
     def send_json(self, obj, status=200):
         self.send_bytes(json.dumps(obj).encode(), "application/json", status)
@@ -2348,8 +2330,6 @@ class Handler(BaseHTTPRequestHandler):
                 from apk_sources import _images
                 try:
                     self.send_bytes(*_images.image(path.rsplit("/", 1)[-1]))
-                except ClientGone:
-                    raise
                 except Exception:
                     self.send_json({"error": "Artwork unavailable"}, 404)
             elif path == "/api/sources/details":
@@ -2400,8 +2380,6 @@ class Handler(BaseHTTPRequestHandler):
                 self.send_json(macview_state(parse_qs(url.query)))
             elif path == "/api/telemetry":
                 self.send_json(frame_telemetry.state())
-            elif path == "/api/contact":
-                self.send_json(frame_contact.state())
             elif path == "/api/computer/state":
                 self.send_json(json.loads(ssh("python3 -", stdin=(HERE / "frame_computer.py").read_text(), timeout=20)))
             elif path == "/api/status":
@@ -2427,8 +2405,6 @@ class Handler(BaseHTTPRequestHandler):
                                 headers=[("X-Capture-Source", "gamescope")])
             else:
                 self.send_json({"error": "not found"}, 404)
-        except ClientGone:
-            raise
         except Failure as e:
             self.send_error_json(str(e), e.status, e.apk)
         except ValueError as e:
@@ -2463,8 +2439,6 @@ class Handler(BaseHTTPRequestHandler):
             with (contextlib.nullcontext() if path == "/api/devices" else working(meant)):
                 result = handler(body)
             self.send_json(result)
-        except ClientGone:
-            raise
         except Failure as e:
             if e.status >= 500:
                 frame_telemetry.diagnostic(f"POST {path} {action_of(body)}", e)
@@ -2640,10 +2614,6 @@ class LoopbackServer(ThreadingHTTPServer):
         socketserver.TCPServer.server_bind(self)
         self.server_name, self.server_port = "127.0.0.1", self.server_address[1]
 
-    def handle_error(self, request, client_address):
-        if not isinstance(sys.exc_info()[1], ClientGone):
-            super().handle_error(request, client_address)
-
 
 _ONE_SERVER = None
 
@@ -2674,7 +2644,6 @@ def main():
     sweep_tmp()
     threading.Thread(target=apk_search.warm, daemon=True).start()  # big indexes download before the first search
     frame_telemetry.start()
-    frame_contact.start()
     global LINK, _ONE_SERVER
     if not LOCAL:
         if not PRIVATE:  # a private server only uses the headsets (see one_server)
@@ -2687,16 +2656,12 @@ def main():
         signal.signal(signal.SIGTERM, lambda *_: (_ for _ in ()).throw(KeyboardInterrupt))
     if args.exit_on_eof:
         def watch_stdin():
-            # os.read, not sys.stdin.buffer.read: a buffered read holds stdin's lock,
-            # and if a signal stops the server first, Python aborts (SIGABRT) at exit
-            # when it can't take that lock back from this thread.
-            while os.read(0, 4096):
-                pass
+            sys.stdin.buffer.read()
             threading.Thread(target=httpd.shutdown, daemon=True).start()
         threading.Thread(target=watch_stdin, daemon=True).start()
+    # The real port, which --port 0 leaves to the system (the iPhone app reads it from here).
+    print(f"Frame Control on http://127.0.0.1:{httpd.server_address[1]}  (alias: {FRAME}; Ctrl-C to stop)", flush=True)
     try:
-        # The real port, which --port 0 leaves to the system (the iPhone app reads it from here).
-        print(f"Frame Control on http://127.0.0.1:{httpd.server_address[1]}  (alias: {FRAME}; Ctrl-C to stop)", flush=True)
         httpd.serve_forever()
     except KeyboardInterrupt:
         pass