Shotlog - Screenshot Log

@@ -27,6 +27,81 @@ fn surface_label(surfaces: &[String]) -> String { }  const SKILL_MD: &str = include_str!("../SKILL.md");+const READ_HOOK_SH: &str = include_str!("../hooks/shotlog-on-read.sh");++/// Install/verify the shipped PostToolUse(Read) hook: the hook FILE and its+/// REGISTRATION in ~/.claude/settings.json. Runs at `install` and at every+/// `serve` startup, so the auto-capture pipeline can never silently rot.+/// Surgical + idempotent: never touches other hooks; backs up settings once+/// per change to settings.json.shotlog-bak.+fn ensure_read_hook() {+    let home = std::env::var("HOME").unwrap_or_else(|_| "/home/adom".to_string());+    let dir = format!("{home}/.claude/hooks");+    let path = format!("{dir}/shotlog-on-read.sh");+    let _ = std::fs::create_dir_all(&dir);+    let mut file_changed = false;+    if std::fs::read_to_string(&path).unwrap_or_default() != READ_HOOK_SH {+        if std::fs::write(&path, READ_HOOK_SH).is_ok() {+            use std::os::unix::fs::PermissionsExt;+            let _ = std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o755));+            file_changed = true;+        }+    }++    let sp = format!("{home}/.claude/settings.json");+    let raw = std::fs::read_to_string(&sp).unwrap_or_else(|_| "{}".to_string());+    let Ok(mut v) = serde_json::from_str::<serde_json::Value>(&raw) else {+        warn("read-hook: ~/.claude/settings.json is not valid JSON - hook file installed but NOT registered.");+        return;+    };+    let mut reg_changed = false;+    let mut registered = false;+    if let Some(obj) = v.as_object_mut() {+        let hooks = obj.entry("hooks").or_insert_with(|| serde_json::json!({}));+        if let Some(hobj) = hooks.as_object_mut() {+            let ptu = hobj.entry("PostToolUse").or_insert_with(|| serde_json::json!([]));+            if let Some(arr) = ptu.as_array_mut() {+                let mut found_read_group = false;+                for g in arr.iter_mut() {+                    if g.get("matcher").and_then(|m| m.as_str()) == Some("Read") {+                        found_read_group = true;+                        if let Some(gobj) = g.as_object_mut() {+                            let hs = gobj.entry("hooks").or_insert_with(|| serde_json::json!([]));+                            if let Some(list) = hs.as_array_mut() {+                                if list.iter().any(|h| h.get("command").and_then(|c| c.as_str())+                                    .map(|c| c.contains("shotlog-on-read.sh")).unwrap_or(false)) {+                                    registered = true;+                                } else {+                                    list.push(serde_json::json!({"type": "command", "command": path}));+                                    registered = true;+                                    reg_changed = true;+                                }+                            }+                        }+                        break;+                    }+                }+                if !found_read_group {+                    arr.push(serde_json::json!({"matcher": "Read",+                        "hooks": [{"type": "command", "command": path}]}));+                    registered = true;+                    reg_changed = true;+                }+            }+        }+    }+    if reg_changed {+        let _ = std::fs::write(format!("{sp}.shotlog-bak"), &raw);+        if let Ok(pretty) = serde_json::to_string_pretty(&v) {+            let _ = std::fs::write(&sp, pretty);+        }+    }+    match (file_changed || reg_changed, registered) {+        (true, _) => ok("read-hook installed/updated: every image any AI thread Reads is auto-captured to the 'read-captures' channel (PostToolUse hook + settings registration)."),+        (false, true) => ok("read-hook verified: auto-capture of every image any AI Reads is active."),+        (false, false) => warn("read-hook file present but could not verify registration in settings.json."),+    }+}  #[derive(Parser)] #[command(name = "adom-shotlog", version, about = "Screenshot log viewer and CLI")]@@ -408,15 +483,42 @@ async fn run_server(port: u16, data_dir: PathBuf) {         ok("Retention active: max 200 shots/channel on disk (SHOTLOG_MAX_SHOTS), idle channels pruned after 30d (SHOTLOG_RETENTION_DAYS, 0=off)");     } +    // The auto-capture read-hook is part of shotlog: verify (or heal) it at+    // every launch so the pipeline can never silently rot.+    ensure_read_hook();+     let state = Arc::new(server::AppState { store, port, next_viewer_id: std::sync::atomic::AtomicU64::new(1) });     let app = server::create_router(state);      let addr = format!("0.0.0.0:{port}");     ok(&format!("Listening on {addr}")); -    let listener = tokio::net::TcpListener::bind(&addr)-        .await-        .expect("Failed to bind port");+    let listener = match tokio::net::TcpListener::bind(&addr).await {+        Ok(l) => l,+        Err(e) if e.kind() == std::io::ErrorKind::AddrInUse => {+            // SINGLE-INSTANCE: exactly one broker per port. If a healthy broker+            // already owns it, defer gracefully (racing self-heals are normal).+            match http_get(port, "/health") {+                Ok(v) => {+                    let rv = v["version"].as_str().unwrap_or("unknown").to_string();+                    ok(&format!("Broker already running on port {port} (v{rv}) - single instance enforced, deferring to it."));+                    if rv != env!("CARGO_PKG_VERSION") {+                        warn(&format!("Running broker is v{rv}, this binary is v{}. To upgrade: kill that `adom-shotlog serve` pid (targeted, never pkill) and start serve again.", env!("CARGO_PKG_VERSION")));+                    }+                    std::process::exit(0);+                }+                Err(_) => {+                    err(&format!("Port {port} is held by something that is NOT a shotlog broker."));+                    hint(&format!("Identify it: ss -ltnp | grep {port}"));+                    std::process::exit(1);+                }+            }+        }+        Err(e) => {+            err(&format!("Failed to bind {addr}: {e}"));+            std::process::exit(1);+        }+    };     axum::serve(listener, app)         .await         .expect("Server error");@@ -612,9 +714,13 @@ fn run_health(port: u16) {     match http_get(port, "/health") {         Ok(val) => {             let channels = val["channels"].as_array().map(|a| a.len()).unwrap_or(0);+            let rv = val["version"].as_str().unwrap_or("unknown");             ok(&format!(-                "Shotlog server running on port {port} with {channels} channel(s)"+                "Shotlog broker v{rv} running on port {port} with {channels} channel(s)"             ));+            if rv != "unknown" && rv != env!("CARGO_PKG_VERSION") {+                warn(&format!("Broker is v{rv} but this CLI is v{} - restart the broker to match (kill its pid, then `adom-shotlog serve &`).", env!("CARGO_PKG_VERSION")));+            }         }         Err(e) => {             err(&format!("Cannot connect to shotlog on port {port}"));@@ -729,6 +835,7 @@ fn run_channels(port: u16, since_min: Option<i64>, limit: usize) { }  fn run_install() {+    ensure_read_hook();     let home = std::env::var("HOME").unwrap_or_else(|_| "/home/adom".to_string());      // 1. Install skill