@tryinget/pi-activity-strip 0.5.0 → 0.7.0

package/native/panel/src/card_view.rs

@@ -1,24 +1,38 @@
 use crate::app::AppMsg;
-use crate::protocol::Card;
+use crate::protocol::{AkTask, Card};
 use relm4::Sender;
 use relm4::gtk;
 use relm4::gtk::gdk;
 use relm4::gtk::glib;
 use relm4::gtk::prelude::*;
+use std::cell::Cell;
+use std::rc::Rc;
+
+/// Rendered AK chips per card: at most two live-claim buttons plus two state badges.
+const AK_CHIP_SLOTS: usize = 4;
 
 pub struct CardView {
     pub root: gtk::Button,
     phase: gtk::Label,
     repo: gtk::Label,
     state: gtk::Label,
+    window: gtk::Label,
     tool: gtk::Label,
     elapsed: gtk::Label,
     detail: gtk::Label,
     prompt: gtk::Label,
     reply: gtk::Label,
     path: gtk::Label,
+    pid: gtk::Label,
+    window_detail: gtk::Label,
+    agent: gtk::Label,
+    task: gtk::Label,
     activation: gtk::Label,
     inspector: gtk::Grid,
+    ak_row: gtk::Box,
+    ak_chips: Vec<gtk::Label>,
+    ak_clickable: Vec<Rc<Cell<bool>>>,
+    ak_overflow: gtk::Label,
 }
 
 impl CardView {
@@ -38,15 +52,24 @@ impl CardView {
         let phase = label("card-phase", gtk::Align::Start);
         label_box.append(&repo);
         label_box.append(&phase);
+        let ak_row = gtk::Box::new(gtk::Orientation::Horizontal, 4);
+        ak_row.set_valign(gtk::Align::Center);
+        ak_row.set_visible(false);
         let state = label("card-state", gtk::Align::End);
         header.append(&label_box);
+        header.append(&ak_row);
         header.append(&state);
 
         let footer = gtk::Box::new(gtk::Orientation::Horizontal, 8);
         footer.set_margin_top(5);
+        // The Niri window id, so a window an agent or tool names by id can be found on the ribbon.
+        // It leads the footer so it sits at the same place on every card and costs the title nothing.
+        let window = label("card-window", gtk::Align::Start);
+        window.set_visible(false);
         let tool = label("card-tool", gtk::Align::Start);
         tool.set_hexpand(true);
         let elapsed = label("card-elapsed", gtk::Align::End);
+        footer.append(&window);
         footer.append(&tool);
         footer.append(&elapsed);
 
@@ -60,9 +83,16 @@ impl CardView {
         let prompt = inspector_row(&inspector, 1, "prompt");
         let reply = inspector_row(&inspector, 2, "reply");
         let path = inspector_row(&inspector, 3, "path");
+        let pid = inspector_row(&inspector, 4, "pid");
+        let window_detail = inspector_row(&inspector, 5, "window");
+        // Always one short line; a wrapping label would reserve a second line of height for it.
+        window_detail.set_wrap(false);
+        window_detail.set_lines(-1);
+        let agent = inspector_row(&inspector, 6, "agent");
+        let task = inspector_row(&inspector, 7, "task");
         let activation = label("activation", gtk::Align::Start);
         activation.set_visible(false);
-        inspector.attach(&activation, 0, 4, 2, 1);
+        inspector.attach(&activation, 0, 8, 2, 1);
 
         content.append(&header);
         content.append(&footer);
@@ -75,6 +105,36 @@ impl CardView {
             let _ = tx.send(AppMsg::Activate(card_id.clone()));
         });
 
+        // AK task chips: an `active` chip reuses the card's own activation, so clicking it focuses
+        // the exact Ghostty window of the session holding that task's live claim. Badge states stop
+        // propagation instead, so a non-actionable reference never fires anything.
+        let mut ak_chips = Vec::with_capacity(AK_CHIP_SLOTS);
+        let mut ak_clickable = Vec::with_capacity(AK_CHIP_SLOTS);
+        for _slot in 0..AK_CHIP_SLOTS {
+            let chip = label("ak-task", gtk::Align::End);
+            chip.set_ellipsize(relm4::gtk::pango::EllipsizeMode::End);
+            chip.set_max_width_chars(20);
+            chip.set_visible(false);
+            let clickable = Rc::new(Cell::new(false));
+            let click = gtk::GestureClick::new();
+            let card_id = id.to_owned();
+            let tx = sender.clone();
+            let chip_clickable = Rc::clone(&clickable);
+            click.connect_released(move |gesture, _, _, _| {
+                if chip_clickable.get() {
+                    let _ = tx.send(AppMsg::Activate(card_id.clone()));
+                }
+                gesture.set_state(gtk::EventSequenceState::Claimed);
+            });
+            chip.add_controller(click);
+            ak_row.append(&chip);
+            ak_chips.push(chip);
+            ak_clickable.push(clickable);
+        }
+        let ak_overflow = label("ak-overflow", gtk::Align::End);
+        ak_overflow.set_visible(false);
+        ak_row.append(&ak_overflow);
+
         let motion = gtk::EventControllerMotion::new();
         let card_id = id.to_owned();
         let tx = sender.clone();
@@ -128,18 +188,28 @@ impl CardView {
             phase,
             repo,
             state,
+            window,
             tool,
             elapsed,
             detail,
             prompt,
             reply,
             path,
+            pid,
+            window_detail,
+            agent,
+            task,
             activation,
             inspector,
+            ak_row,
+            ak_chips,
+            ak_clickable,
+            ak_overflow,
         }
     }
 
     pub fn update(&self, card: &Card, focused: bool, duplicate_label: bool, now_ms: i64) {
+        let hidden_tab = card.hidden_tab();
         self.repo.set_text(&display_repo(card, duplicate_label));
         self.phase.set_text(text_or(&card.phase, "Idle"));
         let real_event_at = if card.last_event_at > 0 {
@@ -171,6 +241,20 @@ impl CardView {
             .set_text(text_or(&card.last_prompt_preview, "—"));
         self.reply.set_text(text_or(&card.assistant_preview, "—"));
         self.path.set_text(text_or(&card.cwd, "—"));
+        self.pid.set_text(&pid_row(card, hidden_tab));
+        match window_chip_text(card) {
+            Some(text) => {
+                self.window.set_text(&text);
+                self.window.set_visible(true);
+            }
+            None => self.window.set_visible(false),
+        }
+        self.window_detail.set_text(&window_row(card));
+        self.agent
+            .set_text(text_or(&card.agent_label, "Pi session"));
+        self.task
+            .set_text(&ak_inspector_text(&card.ak_tasks, card.ak_task_overflow));
+        self.apply_ak_tasks(card);
 
         for class in [
             "state-idle",
@@ -181,9 +265,13 @@ impl CardView {
             "state-error",
             "current",
             "stalled",
+            "hidden-tab",
         ] {
             self.root.remove_css_class(class);
         }
+        if hidden_tab {
+            self.root.add_css_class("hidden-tab");
+        }
         self.root.add_css_class(&format!(
             "state-{}",
             if stalled {
@@ -198,18 +286,37 @@ impl CardView {
         if stalled {
             self.root.add_css_class("stalled");
         }
+        let pid_note = if card.pid > 0 {
+            format!("pid {}", card.pid)
+        } else {
+            "no pid".to_owned()
+        };
+        let ak_note = ak_accessible_note(&card.ak_tasks);
+        let window_note = window_note(card);
         self.root.set_tooltip_text(Some(&format!(
-            "Focus {}",
-            text_or(&card.repo_label, "Pi session")
+            "{} {} ({}{}{}){}",
+            if hidden_tab { "Present" } else { "Focus" },
+            text_or(&card.repo_label, "Pi session"),
+            pid_note,
+            window_note,
+            if hidden_tab { ", hidden tab" } else { "" },
+            ak_note
         )));
         let accessible_label = format!(
-            "{}, {}, press Enter to focus its Ghostty window",
+            "{}{}, {}, {}{}",
             text_or(&card.repo_label, "Pi session"),
+            window_note,
             if stalled {
                 "stalled"
             } else {
                 text_or(&card.phase, "idle")
-            }
+            },
+            if hidden_tab {
+                "hidden tab, press Enter to present it in its Ghostty window"
+            } else {
+                "press Enter to focus its Ghostty window"
+            },
+            ak_note
         );
         self.root
             .update_property(&[gtk::accessible::Property::Label(&accessible_label)]);
@@ -217,11 +324,45 @@ impl CardView {
             .update_state(&[gtk::accessible::State::Selected(Some(focused))]);
     }
 
+    fn apply_ak_tasks(&self, card: &Card) {
+        let chips = &card.ak_tasks;
+        for (index, chip) in self.ak_chips.iter().enumerate() {
+            let clickable = self.ak_clickable.get(index).map(Rc::as_ref);
+            match (chips.get(index), clickable) {
+                (Some(task), Some(flag)) => {
+                    chip.set_visible(true);
+                    chip.set_text(&ak_chip_text(task));
+                    for class in ["ak-active", "ak-deferred", "ak-orphaned"] {
+                        chip.remove_css_class(class);
+                    }
+                    chip.add_css_class(ak_chip_class(&task.state));
+                    chip.set_tooltip_text(Some(&ak_chip_tooltip(task)));
+                    flag.set(task.is_active());
+                }
+                _ => {
+                    chip.set_visible(false);
+                    chip.set_tooltip_text(None);
+                    if let Some(flag) = clickable {
+                        flag.set(false);
+                    }
+                }
+            }
+        }
+        self.ak_row.set_visible(!chips.is_empty());
+        if card.ak_task_overflow > 0 {
+            self.ak_overflow.set_visible(true);
+            self.ak_overflow
+                .set_text(&format!("+{} more", card.ak_task_overflow));
+        } else {
+            self.ak_overflow.set_visible(false);
+        }
+    }
+
     pub fn set_expanded(&self, expanded: bool) {
         self.root
             .update_state(&[gtk::accessible::State::Expanded(Some(expanded))]);
         self.root
-            .set_height_request(if expanded { 228 } else { 60 });
+            .set_height_request(if expanded { 252 } else { 60 });
         self.inspector.set_visible(expanded);
         if expanded {
             self.root.add_css_class("open");
@@ -267,14 +408,60 @@ fn inspector_row(grid: &gtk::Grid, row: i32, key: &str) -> gtk::Label {
 }
 
 fn display_repo(card: &Card, duplicate: bool) -> String {
+    let marker = if card.hidden_tab() { "⧉ " } else { "" };
     if duplicate && card.pid > 0 {
         format!(
-            "{} · {:04}",
+            "{}{} · {:04}",
+            marker,
             text_or(&card.repo_label, "Pi session"),
             card.pid % 10_000
         )
     } else {
-        text_or(&card.repo_label, "Pi session").to_owned()
+        format!("{}{}", marker, text_or(&card.repo_label, "Pi session"))
+    }
+}
+
+fn pid_row(card: &Card, hidden_tab: bool) -> String {
+    let pid = if card.pid > 0 {
+        card.pid.to_string()
+    } else {
+        "—".to_owned()
+    };
+    if hidden_tab {
+        format!("{pid} · hidden tab")
+    } else {
+        pid
+    }
+}
+
+/// Compact chip text: the bare Niri window id, as agents and tools print it.
+fn window_chip_text(card: &Card) -> Option<String> {
+    card.window_id.map(|id| format!("#{id}"))
+}
+
+/// Inspector row: the window id and the workspace number the operator sees. A hidden tab has no
+/// window of its own, so its id is marked as the window hosting it.
+fn window_row(card: &Card) -> String {
+    let Some(window_id) = card.window_id else {
+        return "—".to_owned();
+    };
+    let window = if card.hidden_tab() {
+        format!("host #{window_id}")
+    } else {
+        format!("#{window_id}")
+    };
+    match card.workspace_idx {
+        Some(workspace) => format!("{window} · workspace {workspace}"),
+        None => window,
+    }
+}
+
+/// Appended to the card's tooltip and accessible label when the window is known.
+fn window_note(card: &Card) -> String {
+    match card.window_id {
+        Some(id) if card.hidden_tab() => format!(", host window {id}"),
+        Some(id) => format!(", window {id}"),
+        None => String::new(),
     }
 }
 
@@ -293,6 +480,81 @@ fn state_class(state: &str) -> &str {
     }
 }
 
+/// CSS class for one AK chip state. Unknown states render as a muted, non-clickable chip.
+fn ak_chip_class(state: &str) -> &'static str {
+    match state {
+        "active" => "ak-active",
+        "deferred" => "ak-deferred",
+        "orphaned" => "ak-orphaned",
+        _ => "ak-unknown",
+    }
+}
+
+/// Compact chip text: task id plus as much title as the pill can hold.
+fn ak_chip_text(task: &AkTask) -> String {
+    format!("AK #{} · {}", task.id, task.title)
+}
+
+fn ak_chip_tooltip(task: &AkTask) -> String {
+    match task.state.as_str() {
+        "active" => format!(
+            "AK task #{} — {}. Click to focus the claiming session's Ghostty window.",
+            task.id, task.title
+        ),
+        "orphaned" => format!(
+            "AK task #{} — {}. Claim outlives its session (lease not expired); not clickable.",
+            task.id, task.title
+        ),
+        "deferred" => format!(
+            "AK task #{} — {}. Deferred by AK; not clickable.",
+            task.id, task.title
+        ),
+        _ => format!("AK task #{} — {}", task.id, task.title),
+    }
+}
+
+/// Inspector row: every joined reference with its state, plus the overflow count.
+fn ak_inspector_text(tasks: &[AkTask], overflow: u32) -> String {
+    if tasks.is_empty() && overflow == 0 {
+        return "—".to_owned();
+    }
+    let mut lines: Vec<String> = tasks
+        .iter()
+        .map(|task| {
+            format!(
+                "#{} [{}] {}",
+                task.id,
+                match task.state.as_str() {
+                    "active" => "live claim",
+                    "orphaned" => "claim outlives session",
+                    "deferred" => "deferred",
+                    _ => "unknown",
+                },
+                task.title
+            )
+        })
+        .collect();
+    if overflow > 0 {
+        lines.push(format!("+{overflow} more"));
+    }
+    lines.join("\n")
+}
+
+/// Appended to the card's tooltip and accessible label when AK references exist.
+fn ak_accessible_note(tasks: &[AkTask]) -> String {
+    match tasks.first() {
+        Some(task) if task.is_active() => format!(
+            ". AK task #{} {} (click the chip to focus the claiming session)",
+            task.id, task.title
+        ),
+        Some(task) => format!(
+            ". AK task #{} {} (badge only, not clickable)",
+            task.id, task.title
+        ),
+        None => String::new(),
+    }
+}
+
 fn text_or<'a>(value: &'a str, fallback: &'a str) -> &'a str {
     if value.is_empty() { fallback } else { value }
 }
@@ -301,3 +563,128 @@ fn duration(now_ms: i64, anchor_ms: i64) -> String {
     let seconds = now_ms.saturating_sub(anchor_ms.max(1)) / 1000;
     format!("{}:{:02}", seconds / 60, seconds % 60)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn card(json: serde_json::Value) -> Card {
+        serde_json::from_value(json).expect("card")
+    }
+
+    #[test]
+    fn hidden_tabs_carry_a_marker_and_pid_note() {
+        let agent = card(serde_json::json!({ "agentLabel": "Claude Code" }));
+        assert_eq!(agent.agent_label, "Claude Code");
+        assert_eq!(text_or(&agent.agent_label, "Pi session"), "Claude Code");
+        assert_eq!(
+            text_or(&card(serde_json::json!({})).agent_label, "Pi session"),
+            "Pi session"
+        );
+
+        let hidden = card(serde_json::json!({
+            "repoLabel": "dspx", "processId": 12345, "surfaceVisible": false
+        }));
+        assert!(hidden.hidden_tab());
+        assert_eq!(display_repo(&hidden, false), "⧉ dspx");
+        assert_eq!(display_repo(&hidden, true), "⧉ dspx · 2345");
+        assert_eq!(pid_row(&hidden, true), "12345 · hidden tab");
+
+        let visible = card(serde_json::json!({ "repoLabel": "dspx", "surfaceVisible": true }));
+        assert!(!visible.hidden_tab());
+        assert_eq!(display_repo(&visible, false), "dspx");
+        assert_eq!(pid_row(&visible, false), "—");
+
+        let legacy = card(serde_json::json!({ "repoLabel": "dspx" }));
+        assert!(
+            !legacy.hidden_tab(),
+            "controllers without placement never mark tabs hidden"
+        );
+    }
+
+    #[test]
+    fn window_chip_names_the_niri_window_and_the_detail_adds_its_workspace() {
+        let visible = card(serde_json::json!({
+            "repoLabel": "dspx", "windowId": 43, "workspaceIdx": 2, "surfaceVisible": true
+        }));
+        assert_eq!(window_chip_text(&visible).as_deref(), Some("#43"));
+        assert_eq!(window_row(&visible), "#43 · workspace 2");
+        assert_eq!(window_note(&visible), ", window 43");
+
+        let hidden = card(serde_json::json!({
+            "repoLabel": "dspx", "windowId": 43, "workspaceIdx": 2, "surfaceVisible": false
+        }));
+        assert_eq!(
+            window_chip_text(&hidden).as_deref(),
+            Some("#43"),
+            "a hidden tab shows the window hosting it"
+        );
+        assert_eq!(window_row(&hidden), "host #43 · workspace 2");
+        assert_eq!(window_note(&hidden), ", host window 43");
+
+        let unindexed = card(serde_json::json!({ "windowId": 43 }));
+        assert_eq!(window_row(&unindexed), "#43");
+
+        let unplaced = card(serde_json::json!({ "repoLabel": "dspx" }));
+        assert_eq!(
+            window_chip_text(&unplaced),
+            None,
+            "no chip without a window"
+        );
+        assert_eq!(window_row(&unplaced), "—");
+        assert_eq!(window_note(&unplaced), "");
+    }
+
+    #[test]
+    fn ak_chip_states_map_to_classes_and_only_active_is_clickable() {
+        let active = AkTask {
+            id: 5701,
+            title: "Show clickable AK-task references".into(),
+            state: "active".into(),
+        };
+        let orphaned = AkTask {
+            state: "orphaned".into(),
+            ..active.clone()
+        };
+        let deferred = AkTask {
+            state: "deferred".into(),
+            ..active.clone()
+        };
+        assert_eq!(ak_chip_class("active"), "ak-active");
+        assert_eq!(ak_chip_class("orphaned"), "ak-orphaned");
+        assert_eq!(ak_chip_class("deferred"), "ak-deferred");
+        assert_eq!(ak_chip_class("surprise"), "ak-unknown");
+        assert!(active.is_active());
+        assert!(!orphaned.is_active());
+        assert!(!deferred.is_active());
+        assert_eq!(
+            ak_chip_text(&active),
+            "AK #5701 · Show clickable AK-task references"
+        );
+        assert!(ak_chip_tooltip(&orphaned).contains("not clickable"));
+        assert!(ak_chip_tooltip(&active).contains("focus the claiming session"));
+    }
+
+    #[test]
+    fn ak_inspector_lists_every_reference_with_overflow() {
+        let tasks = vec![
+            AkTask {
+                id: 5701,
+                title: "Live claim task".into(),
+                state: "active".into(),
+            },
+            AkTask {
+                id: 4220,
+                title: "Deferred task".into(),
+                state: "deferred".into(),
+            },
+        ];
+        let text = ak_inspector_text(&tasks, 3);
+        assert!(text.contains("#5701 [live claim] Live claim task"));
+        assert!(text.contains("#4220 [deferred] Deferred task"));
+        assert!(text.contains("+3 more"));
+        assert_eq!(ak_inspector_text(&[], 0), "—");
+        assert!(ak_accessible_note(&tasks).starts_with(". AK task #5701"));
+        assert_eq!(ak_accessible_note(&[]), "");
+    }
+}

package/native/panel/src/main.rs

@@ -19,13 +19,76 @@ fn bind_lifetime_to_parent() {
 #[cfg(not(target_os = "linux"))]
 fn bind_lifetime_to_parent() {}
 
+const APPLICATION_ID: &str = "com.tryinget.pi-activity-strip.panel";
+/// Keeps the display element well inside the 255-byte limit of a D-Bus name.
+const DISPLAY_ELEMENT_MAX: usize = 64;
+
+/// GTK uniqueness is scoped to one Wayland display. A second panel on the same compositor is
+/// refused, so no second ribbon can reserve another band, while a panel inside a nested
+/// compositor (the demo, a preview, a test) runs on its own instead of handing itself off.
+fn application_id(wayland_display: Option<&str>) -> String {
+    // GTK connects to `wayland-0` when the variable is unset, and a socket path names the same
+    // compositor as its file name, so every spelling of one display shares one id.
+    let raw = wayland_display
+        .filter(|display| !display.is_empty())
+        .unwrap_or("wayland-0");
+    let name = raw.rsplit('/').next().unwrap_or(raw);
+    let display: String = name
+        .chars()
+        .take(DISPLAY_ELEMENT_MAX)
+        .map(|c| if c.is_ascii_alphanumeric() { c } else { '_' })
+        .collect();
+    format!("{APPLICATION_ID}.d_{display}")
+}
+
 fn main() {
     bind_lifetime_to_parent();
     let demo = std::env::var("PI_ACTIVITY_STRIP_PANEL_DEMO").as_deref() == Ok("1");
     let click_through = std::env::var("PI_ACTIVITY_STRIP_CLICK_THROUGH").as_deref() == Ok("1");
-    let app = RelmApp::new("com.tryinget.pi-activity-strip.panel").visible_on_activate(false);
+    let display = std::env::var("WAYLAND_DISPLAY").ok();
+    let app = RelmApp::new(&application_id(display.as_deref())).visible_on_activate(false);
     app.run::<App>(AppInit {
         demo,
         click_through,
     });
+    // A second panel on this display hands its activation to the first and returns without ever
+    // starting. It used to exit 0 having drawn nothing; say so and fail instead. Registration can
+    // also fail this way, so the message names the likely cause rather than asserting it.
+    if !protocol::was_ready() {
+        protocol::emit_error(
+            "The panel returned without starting; another activity-strip panel probably already runs on this Wayland display.",
+        );
+        std::process::exit(1);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::application_id;
+
+    #[test]
+    fn uniqueness_is_scoped_to_the_wayland_display() {
+        assert_eq!(
+            application_id(Some("wayland-1")),
+            "com.tryinget.pi-activity-strip.panel.d_wayland_1"
+        );
+        assert_ne!(
+            application_id(Some("wayland-1")),
+            application_id(Some("wayland-2")),
+            "a panel in a nested compositor never hands off to the live one"
+        );
+        assert_eq!(
+            application_id(Some("/run/user/1000/wayland-1")),
+            application_id(Some("wayland-1")),
+            "a socket path and its name are the same compositor"
+        );
+        assert_eq!(
+            application_id(None),
+            application_id(Some("wayland-0")),
+            "GTK connects to wayland-0 when the variable is unset"
+        );
+        assert_eq!(application_id(Some("")), application_id(Some("wayland-0")));
+        let long = application_id(Some(&"x".repeat(400)));
+        assert!(long.len() <= 255, "a D-Bus name is at most 255 bytes");
+    }
 }