Adom Library

@@ -523,23 +523,40 @@ pub fn running_version(port: u16) -> Option<String> {     None } -/// Our own serve processes, matched by EXACT argv shape (binary named adom-lbr,-/// then `dashboard serve` or `manage`), never by substring: a substring match-/// also hits the shell whose command text mentions this program.-fn serve_pids() -> Vec<i32> {+/// Our own SERVER processes, matched by EXACT argv shape: a binary named+/// adom-lbr running `dashboard serve ... --foreground` (the backgrounded+/// child) or `manage` (the pre-2.11 Manager). A launcher (`dashboard serve+/// --print-url` without --foreground) is never a victim, and neither are this+/// process or its parent: on ConfRoomROG (2026-08-23) the second launch+/// SIGTERMed itself and died with exit 143 and no output.+fn serve_pids(port: u16) -> Vec<i32> {     let me = std::process::id() as i32;+    let parent = std::fs::read_to_string("/proc/self/stat").ok()+        .and_then(|st| st.rsplit(')').next().map(|s| s.to_string()))+        .and_then(|tail| tail.split_whitespace().nth(1).and_then(|p| p.parse::<i32>().ok()))+        .unwrap_or(-1);     let mut out = vec![];     let Ok(rd) = std::fs::read_dir("/proc") else { return out };     for ent in rd.flatten() {         let Ok(pid) = ent.file_name().to_string_lossy().parse::<i32>() else { continue };-        if pid == me { continue; }+        if pid == me || pid == parent { continue; }         let Ok(raw) = std::fs::read(ent.path().join("cmdline")) else { continue };         let argv: Vec<&[u8]> = raw.split(|b| *b == 0).filter(|s| !s.is_empty()).collect();         if argv.len() < 2 { continue; }         let base = argv[0].rsplit(|b| *b == b'/').next().unwrap_or(argv[0]);         if base != b"adom-lbr" { continue; }-        let is_serve = argv[1] == b"manage" || (argv.len() >= 3 && argv[1] == b"dashboard" && argv[2] == b"serve");-        if is_serve { out.push(pid); }+        let is_manage = argv[1] == b"manage";+        let is_server = argv.len() >= 3 && argv[1] == b"dashboard" && argv[2] == b"serve"+            && argv.iter().any(|a| *a == b"--foreground");+        if !(is_manage || is_server) { continue; }+        // Scoped to THIS port: a foreign owner on one port must never get our+        // healthy servers on other ports killed (caught in testing, 2026-08-23).+        let their_port: u16 = argv.iter().position(|a| *a == b"--port")+            .and_then(|i| argv.get(i + 1))+            .and_then(|p| std::str::from_utf8(p).ok())+            .and_then(|p| p.parse().ok())+            .unwrap_or(8785);+        if their_port == port { out.push(pid); }     }     out }@@ -552,8 +569,15 @@ fn kill(pid: i32, sig: &str) { /// reason to skip serving: version-blind reuse pinned users to a stale server /// no reinstall could fix. Returns true when the port is free afterwards. fn retire_stale(port: u16, theirs: &str) -> bool {-    eprintln!("adom-lbr dashboard {theirs} is serving on {port} but this is {VERSION}; retiring the stale instance");-    let victims = serve_pids();+    let victims = serve_pids(port);+    if victims.is_empty() {+        // Something answers on the port but no server process of ours exists:+        // it is not ours to kill, and waiting would not change that.+        eprintln!("adom-lbr dashboard: port {port} answers ({theirs}) but no adom-lbr server process exists; something else owns it");+        return false;+    }+    eprintln!("adom-lbr dashboard {theirs} is serving on {port} but this is {VERSION}; retiring the stale instance (pid {})",+        victims.iter().map(|p| p.to_string()).collect::<Vec<_>>().join(", "));     for pid in &victims { kill(*pid, "-TERM"); }     for _ in 0..40 {         if !port_in_use(port) { return true; }@@ -564,15 +588,14 @@ fn retire_stale(port: u16, theirs: &str) -> bool {     !port_in_use(port) } -/// Does anything accept a TCP connection on the port? curl exit 7 is-/// "could not connect"; any other outcome means someone is listening.+/// Does anything ACCEPT a TCP connection on the port? Only a completed+/// connect counts. Refused means free, and so does a timeout: under WSL2+/// mirrored networking a connect to a free loopback port can hang instead of+/// refusing (ConfRoomROG, 2026-08-23), which the old curl-exit-code check read+/// as "in use" and then spent 40 s failing to retire nothing. fn port_in_use(port: u16) -> bool {-    Command::new("curl")-        .args(["-s", "-o", "/dev/null", "--max-time", "1", &format!("http://127.0.0.1:{port}/")])-        .stdout(Stdio::null()).stderr(Stdio::null())-        .status()-        .map(|s| s.code() != Some(7))-        .unwrap_or(false)+    let addr = std::net::SocketAddr::from(([127, 0, 0, 1], port));+    std::net::TcpStream::connect_timeout(&addr, Duration::from_millis(500)).is_ok() }  /// Take ownership of the dock's pre-opened webview tab. The dock sets@@ -616,8 +639,13 @@ fn ask_server_to_claim(port: u16) { pub fn serve_entry(port: u16, print_url: bool, foreground: bool) -> anyhow::Result<bool> {     let mut theirs = running_version(port);     // A pre-2.11 Manager has no /api/status, so it cannot identify itself; but-    // it is still one of our serve processes by argv, and it must make way.-    if theirs.is_none() && port_in_use(port) && !serve_pids().is_empty() {+    // it is still one of our server processes by argv, and it must make way.+    // Only a port that actually ACCEPTS a connection can hold one; refused or+    // timed out means free, and we simply bind.+    if theirs.is_none() && port_in_use(port) {+        if serve_pids(port).is_empty() {+            anyhow::bail!("port {port} is taken by something that is not adom-lbr; pick another with --port");+        }         if !retire_stale(port, "pre-2.11") {             anyhow::bail!("an older adom-lbr Manager owns port {port} and would not exit; kill it and relaunch");         }