Shotlog - Screenshot Log

@@ -349,10 +349,15 @@ struct CanvasCloseRequest { /// STAGE 3 of the tracked switch (or a rollback): close ONE surface of a /// channel. surface = "webview" closes the Hydrogen tab; "pup" closes the tab /// in the shared shotlog pup window.-async fn canvas_close(Json(req): Json<CanvasCloseRequest>) -> Json<serde_json::Value> {+async fn canvas_close(+    State(state): State<Arc<AppState>>,+    Json(req): Json<CanvasCloseRequest>,+) -> Json<serde_json::Value> {     if req.channel.contains("..") || req.channel.contains('/') || req.channel.is_empty() {         return Json(serde_json::json!({"ok": false, "error": "invalid channel"}));     }+    let channel = req.channel.clone();+    let surface = req.surface.clone();     let v = tokio::task::spawn_blocking(move || {         if req.surface == "webview" {             let ok = std::process::Command::new("adom-cli")@@ -369,6 +374,14 @@ async fn canvas_close(Json(req): Json<CanvasCloseRequest>) -> Json<serde_json::V     })     .await     .unwrap_or_else(|_| serde_json::json!({"ok": false, "error": "spawn failed"}));+    // Closing one surface while the OTHER is live means the other is now the+    // channel's canvas - keep the pref honest (covers rollbacks too).+    if v.get("ok").and_then(|b| b.as_bool()).unwrap_or(false) {+        let other = if surface == "pup" { "webview" } else { "pup" };+        if state.store.viewer_infos(&channel).await.iter().any(|i| i.surface == other) {+            state.store.set_canvas_pref(&channel, other).await;+        }+    }     Json(v) } @@ -1041,6 +1054,7 @@ async fn ws_connection(mut socket: WebSocket, channel: String, state: Arc<AppSta     let vid = state         .next_viewer_id         .fetch_add(1, std::sync::atomic::Ordering::Relaxed);+    let mut conn_surface: String = "browser".into();     state.store.register_viewer(&channel, vid, "browser".into(), true, None).await;      loop {@@ -1072,6 +1086,7 @@ async fn ws_connection(mut socket: WebSocket, channel: String, state: Arc<AppSta                                     let surface = v.get("surface").and_then(|x| x.as_str()).unwrap_or("browser").to_string();                                     let visible = v.get("visible").and_then(|x| x.as_bool()).unwrap_or(true);                                     let session = v.get("session").and_then(|x| x.as_str()).map(String::from);+                                    conn_surface = surface.clone();                                     state.store.register_viewer(&channel, vid, surface, visible, session).await;                                 }                                 Some("vis") => {@@ -1089,6 +1104,53 @@ async fn ws_connection(mut socket: WebSocket, channel: String, state: Arc<AppSta     }      state.store.unregister_viewer(&channel, vid).await;++    // USER-CLOSED-PUP DETECTION. A pup viewer vanishing can be a blip (reload,+    // network, laptop sleep) or the user deliberately closing the tab/window.+    // Grace-wait for a reconnect, then probe whether the tab still exists:+    // gone + no reconnect = the user closed it = their canvas choice CHANGED.+    // Revert the channel to webview so the next auto-open lands in the slim+    // panel instead of shoving a fresh pup window at them. (Swap flows are+    // immune: they re-point the pref BEFORE closing, so pref!=pup here.)+    if conn_surface == "pup" {+        let store = state.store.clone();+        let ch = channel.clone();+        tokio::spawn(async move {+            if store.canvas_pref(&ch).await.as_deref() != Some("pup") {+                return;+            }+            tokio::time::sleep(std::time::Duration::from_secs(8)).await;+            if store.viewer_infos(&ch).await.iter().any(|i| i.surface == "pup") {+                return; // reconnected - just a blip+            }+            let ch2 = ch.clone();+            let tab_gone = tokio::task::spawn_blocking(move || {+                let mut cmd = std::process::Command::new("adom-desktop");+                if let Ok(t) = std::env::var("SHOTLOG_AD_TARGET") {+                    cmd.args(["--target", &t]);+                }+                match cmd.args(["browser_list_tabs", "{\"sessionId\":\"shotlog\"}"]).output() {+                    Ok(o) => {+                        let out = String::from_utf8_lossy(&o.stdout).to_string();+                        match serde_json::from_str::<serde_json::Value>(&out) {+                            Ok(v) => !v.get("tabs").and_then(|t| t.as_array())+                                .map(|tabs| tabs.iter().any(|t| t.get("url").and_then(|u| u.as_str())+                                    .map(|u| u.contains(&format!("/log/{ch2}/"))).unwrap_or(false)))+                                .unwrap_or(false),+                            Err(_) => true, // session itself is gone -> tabs gone+                        }+                    }+                    Err(_) => false, // cannot probe: never flip on uncertainty+                }+            })+            .await+            .unwrap_or(false);+            if tab_gone && !store.viewer_infos(&ch).await.iter().any(|i| i.surface == "pup") {+                store.set_canvas_pref(&ch, "webview").await;+                println!("OK: pup tab for '{ch}' was closed by the user - canvas preference reverted to webview (next auto-open uses the slim panel).");+            }+        });+    } }  async fn serve_image(