Shotlog - Screenshot Log

@@ -140,9 +140,10 @@ enum Commands {         port: u16,     },     /// Verify a HUMAN is actually watching a channel's viewer (live WebSocket-    /// presence). Exits 0 if ≥1 viewer is connected, 3 if none — so an AI can-    /// gate on it without a round of guessing. Prints the connected surfaces-    /// (webview / pup / mobile / browser).+    /// presence + Page Visibility). Exit 0 = ≥1 viewer ON-SCREEN, 4 = viewer(s)+    /// connected but ALL backgrounded/minimized, 3 = nobody connected — so an AI+    /// can gate precisely without guessing. Prints the surfaces (webview / pup /+    /// mobile / browser).     Viewers {         /// Channel name         #[arg(short, long)]@@ -442,19 +443,30 @@ fn run_inject(                     }                 }                 // Presence check — is the human ACTUALLY seeing this, and where?-                if let Some(viewers) = val.get("viewers").and_then(|v| v.as_u64()) {-                    let surfaces: Vec<String> = val.get("surfaces").and_then(|v| v.as_array())+                let getvec = |key: &str| -> Vec<String> {+                    val.get(key).and_then(|v| v.as_array())                         .map(|a| a.iter().filter_map(|s| s.as_str().map(String::from)).collect())-                        .unwrap_or_default();-                    if viewers > 0 {-                        let surf = if surfaces.is_empty() { String::new() } else { format!(" [{}]", surface_label(&surfaces)) };-                        ok(&format!("{viewers} live viewer(s) connected to '{channel}'{surf}"));-                        hint("Are you sure the human is seeing the shotlog? Is it open in a webview or pup? Have you verified it's truly showing?");-                        hint("Connected ≠ necessarily visible: if the surface could be a background tab / minimized window, confirm it's the human's foreground surface.");+                        .unwrap_or_default()+                };+                if let Some(viewers) = val.get("viewers").and_then(|v| v.as_u64()) {+                    let surfaces = getvec("surfaces");+                    let visible = val.get("visible_viewers").and_then(|v| v.as_u64()).unwrap_or(0);+                    let vis_surf = getvec("visible_surfaces");+                    // The hint the human asked to ride on EVERY inject.+                    let verify = "Are you sure the human is seeing the shotlog? Is it open in a webview or pup? Have you verified it's truly showing?";+                    if visible > 0 {+                        let s = if vis_surf.is_empty() { String::new() } else { format!(" [{}]", surface_label(&vis_surf)) };+                        ok(&format!("{visible} of {viewers} viewer(s) ON-SCREEN{s} — a human can see this shot."));+                        hint(verify);+                    } else if viewers > 0 {+                        let s = if surfaces.is_empty() { String::new() } else { format!(" [{}]", surface_label(&surfaces)) };+                        warn(&format!("{viewers} viewer(s) connected to '{channel}'{s} but ALL are BACKGROUNDED / minimized — the human is NOT looking right now."));+                        hint(verify);+                        hint(&format!("Bring the viewer to the FOREGROUND (the pup window / webview tab / phone), then re-check: `shotlog viewers -c {channel}`."));                     } else {                         warn(&format!("NO live viewer is connected to '{channel}' — the human is NOT seeing this shot."));-                        hint("Are you sure the human is seeing the shotlog? Is it open in a webview or pup? Have you verified it's truly showing?");-                        hint(&format!("Open it, then RE-CHECK before continuing: `shotlog open -c {channel}` (Hydrogen webview) — or load the viewer in pup / on the phone — then `shotlog viewers -c {channel}` (exits non-zero until a viewer is live)."));+                        hint(verify);+                        hint(&format!("Open it, then RE-CHECK before continuing: `shotlog open -c {channel}` (Hydrogen webview) — or load the viewer in pup / on the phone — then `shotlog viewers -c {channel}`."));                         hint("A viewer was force-opened as a fallback, but do NOT assume the human sees it — verify their actual surface.");                     }                 }@@ -535,9 +547,14 @@ fn run_viewers(channel: &str, port: u16, url: Option<&str>) {         }     };     let viewers = val["viewers"].as_u64().unwrap_or(0);-    let surfaces: Vec<String> = val["surfaces"].as_array()-        .map(|a| a.iter().filter_map(|s| s.as_str().map(String::from)).collect())-        .unwrap_or_default();+    let visible = val["visible"].as_u64().unwrap_or(0);+    let getvec = |key: &str| -> Vec<String> {+        val[key].as_array()+            .map(|a| a.iter().filter_map(|s| s.as_str().map(String::from)).collect())+            .unwrap_or_default()+    };+    let surfaces = getvec("surfaces");+    let vis_surf = getvec("visible_surfaces");      // Optional: the AI passes the endpoint it opened; we confirm it's reachable.     if let Some(u) = url {@@ -558,11 +575,16 @@ fn run_viewers(channel: &str, port: u16, url: Option<&str>) {         }     } -    if viewers > 0 {-        let surf = if surfaces.is_empty() { String::new() } else { format!(" [{}]", surface_label(&surfaces)) };-        ok(&format!("{viewers} live viewer(s) watching '{channel}'{surf} — a human can see it."));-        hint("Connected ≠ necessarily visible: if a surface could be a background tab / minimized window, confirm it's foregrounded before trusting it.");+    // Three states: on-screen (0), open-but-backgrounded (4), nobody (3).+    if visible > 0 {+        let surf = if vis_surf.is_empty() { String::new() } else { format!(" [{}]", surface_label(&vis_surf)) };+        ok(&format!("{visible} of {viewers} viewer(s) ON-SCREEN{surf} watching '{channel}' — a human can see it."));         std::process::exit(0);+    } else if viewers > 0 {+        let surf = if surfaces.is_empty() { String::new() } else { format!(" [{}]", surface_label(&surfaces)) };+        warn(&format!("{viewers} viewer(s) connected to '{channel}'{surf} but ALL are BACKGROUNDED / minimized — the human isn't looking right now."));+        hint(&format!("Bring the viewer to the FOREGROUND (pup window / webview tab / phone), then re-run `shotlog viewers -c {channel}`."));+        std::process::exit(4);     } else {         warn(&format!("NO live viewer connected to '{channel}' — nothing you inject here is being seen."));         hint(&format!("Open it: `shotlog open -c {channel}` (Hydrogen webview), or load the viewer in pup / on the phone, then re-run `shotlog viewers -c {channel}`."));

@@ -138,13 +138,18 @@ async fn viewer_status(     Query(q): Query<ChannelQuery>, ) -> Json<serde_json::Value> {     let channel = q.channel.unwrap_or_else(|| "default".into());-    let viewers = state.store.viewer_count(&channel).await;-    let surfaces = state.store.viewer_surfaces(&channel).await;+    let infos = state.store.viewer_infos(&channel).await;+    let viewers = infos.len();+    let surfaces: Vec<String> = infos.iter().map(|i| i.surface.clone()).collect();+    let visible: usize = infos.iter().filter(|i| i.visible).count();+    let visible_surfaces: Vec<String> = infos.iter().filter(|i| i.visible).map(|i| i.surface.clone()).collect();     Json(serde_json::json!({         "channel": channel,         "viewers": viewers,         "has_viewers": viewers > 0,         "surfaces": surfaces,+        "visible": visible,+        "visible_surfaces": visible_surfaces,     })) } @@ -265,6 +270,10 @@ struct InjectResponse {     /// can immediately tell whether the human is actually seeing this shot.     viewers: usize,     surfaces: Vec<String>,+    /// Of those, how many are actually ON-SCREEN (Page Visibility) vs a+    /// background tab / minimized window, and which surfaces those are.+    visible_viewers: usize,+    visible_surfaces: Vec<String>, }  async fn post_shots(@@ -325,9 +334,12 @@ async fn post_shots(         .await;      // Presence at inject time — the caller uses this to know if the human is-    // actually watching (and on which surface) without a round of guessing.-    let viewers = state.store.viewer_count(&req.channel).await;-    let surfaces = state.store.viewer_surfaces(&req.channel).await;+    // actually watching (and on which surface / on-screen) without guessing.+    let infos = state.store.viewer_infos(&req.channel).await;+    let viewers = infos.len();+    let surfaces: Vec<String> = infos.iter().map(|i| i.surface.clone()).collect();+    let visible_viewers = infos.iter().filter(|i| i.visible).count();+    let visible_surfaces: Vec<String> = infos.iter().filter(|i| i.visible).map(|i| i.surface.clone()).collect();      // If nobody is watching this channel, force-open a viewer so the user     // actually sees the shot instead of it landing invisibly in the log.@@ -348,6 +360,8 @@ async fn post_shots(         original_h: entry.orig_h,         viewers,         surfaces,+        visible_viewers,+        visible_surfaces,     })) } @@ -401,8 +415,11 @@ async fn post_paste(         .await;  -    let viewers = state.store.viewer_count(&req.channel).await;-    let surfaces = state.store.viewer_surfaces(&req.channel).await;+    let infos = state.store.viewer_infos(&req.channel).await;+    let viewers = infos.len();+    let surfaces: Vec<String> = infos.iter().map(|i| i.surface.clone()).collect();+    let visible_viewers = infos.iter().filter(|i| i.visible).count();+    let visible_surfaces: Vec<String> = infos.iter().filter(|i| i.visible).map(|i| i.surface.clone()).collect();      Ok(Json(InjectResponse {         ok: true,@@ -417,6 +434,8 @@ async fn post_paste(         original_h: if was_resized { Some(orig_h) } else { None },         viewers,         surfaces,+        visible_viewers,+        visible_surfaces,     })) } @@ -554,7 +573,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);-    state.store.register_viewer(&channel, vid, "browser".into()).await;+    state.store.register_viewer(&channel, vid, "browser".into(), true).await;      loop {         tokio::select! {@@ -577,12 +596,20 @@ async fn ws_connection(mut socket: WebSocket, channel: String, state: Arc<AppSta                 match msg {                     Some(Ok(Message::Close(_))) | None => break,                     Some(Ok(Message::Text(t))) => {-                        // {type:'hello', surface:'pup'|'webview'|'mobile'|'browser'}+                        // {type:'hello', surface, visible} on connect; {type:'vis', visible}+                        // whenever the tab is shown/hidden (Page Visibility).                         if let Ok(v) = serde_json::from_str::<serde_json::Value>(&t) {-                            if v.get("type").and_then(|x| x.as_str()) == Some("hello") {-                                if let Some(s) = v.get("surface").and_then(|x| x.as_str()) {-                                    state.store.register_viewer(&channel, vid, s.to_string()).await;+                            match v.get("type").and_then(|x| x.as_str()) {+                                Some("hello") => {+                                    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);+                                    state.store.register_viewer(&channel, vid, surface, visible).await;                                 }+                                Some("vis") => {+                                    let visible = v.get("visible").and_then(|x| x.as_bool()).unwrap_or(true);+                                    state.store.set_viewer_visibility(&channel, vid, visible).await;+                                }+                                _ => {}                             }                         }                     }