@tryinget/pi-activity-strip 0.4.0 → 0.5.0

package/native/panel/src/card_view.rs

@@ -0,0 +1,303 @@
+use crate::app::AppMsg;
+use crate::protocol::Card;
+use relm4::Sender;
+use relm4::gtk;
+use relm4::gtk::gdk;
+use relm4::gtk::glib;
+use relm4::gtk::prelude::*;
+
+pub struct CardView {
+    pub root: gtk::Button,
+    phase: gtk::Label,
+    repo: gtk::Label,
+    state: gtk::Label,
+    tool: gtk::Label,
+    elapsed: gtk::Label,
+    detail: gtk::Label,
+    prompt: gtk::Label,
+    reply: gtk::Label,
+    path: gtk::Label,
+    activation: gtk::Label,
+    inspector: gtk::Grid,
+}
+
+impl CardView {
+    pub fn new(id: &str, sender: &Sender<AppMsg>) -> Self {
+        let root = gtk::Button::new();
+        root.add_css_class("card");
+        root.set_focusable(true);
+        root.set_can_focus(true);
+        root.set_width_request(224);
+        root.set_height_request(60);
+
+        let content = gtk::Box::new(gtk::Orientation::Vertical, 0);
+        let header = gtk::Box::new(gtk::Orientation::Horizontal, 8);
+        let label_box = gtk::Box::new(gtk::Orientation::Vertical, 3);
+        label_box.set_hexpand(true);
+        let repo = label("card-repo", gtk::Align::Start);
+        let phase = label("card-phase", gtk::Align::Start);
+        label_box.append(&repo);
+        label_box.append(&phase);
+        let state = label("card-state", gtk::Align::End);
+        header.append(&label_box);
+        header.append(&state);
+
+        let footer = gtk::Box::new(gtk::Orientation::Horizontal, 8);
+        footer.set_margin_top(5);
+        let tool = label("card-tool", gtk::Align::Start);
+        tool.set_hexpand(true);
+        let elapsed = label("card-elapsed", gtk::Align::End);
+        footer.append(&tool);
+        footer.append(&elapsed);
+
+        let inspector = gtk::Grid::new();
+        inspector.add_css_class("inspector");
+        inspector.set_row_spacing(6);
+        inspector.set_column_spacing(8);
+        inspector.set_margin_top(10);
+        inspector.set_visible(false);
+        let detail = inspector_row(&inspector, 0, "detail");
+        let prompt = inspector_row(&inspector, 1, "prompt");
+        let reply = inspector_row(&inspector, 2, "reply");
+        let path = inspector_row(&inspector, 3, "path");
+        let activation = label("activation", gtk::Align::Start);
+        activation.set_visible(false);
+        inspector.attach(&activation, 0, 4, 2, 1);
+
+        content.append(&header);
+        content.append(&footer);
+        content.append(&inspector);
+        root.set_child(Some(&content));
+
+        let card_id = id.to_owned();
+        let tx = sender.clone();
+        root.connect_clicked(move |_| {
+            let _ = tx.send(AppMsg::Activate(card_id.clone()));
+        });
+
+        let motion = gtk::EventControllerMotion::new();
+        let card_id = id.to_owned();
+        let tx = sender.clone();
+        motion.connect_enter(move |_, _, _| {
+            let _ = tx.send(AppMsg::Hover(card_id.clone(), true));
+        });
+        let card_id = id.to_owned();
+        let tx = sender.clone();
+        motion.connect_leave(move |_| {
+            let _ = tx.send(AppMsg::Hover(card_id.clone(), false));
+        });
+        root.add_controller(motion);
+
+        let focus = gtk::EventControllerFocus::new();
+        let card_id = id.to_owned();
+        let tx = sender.clone();
+        focus.connect_enter(move |_| {
+            let _ = tx.send(AppMsg::Focus(card_id.clone(), true));
+        });
+        let card_id = id.to_owned();
+        let tx = sender.clone();
+        focus.connect_leave(move |_| {
+            let _ = tx.send(AppMsg::Focus(card_id.clone(), false));
+        });
+        root.add_controller(focus);
+
+        let keys = gtk::EventControllerKey::new();
+        let card_id = id.to_owned();
+        let tx = sender.clone();
+        keys.connect_key_pressed(move |_, key, _, modifiers| {
+            let direction = if key == gdk::Key::Left {
+                -1
+            } else if key == gdk::Key::Right {
+                1
+            } else if key == gdk::Key::Escape {
+                let _ = tx.send(AppMsg::Collapse);
+                return glib::Propagation::Stop;
+            } else if key == gdk::Key::space || key == gdk::Key::KP_Space {
+                return glib::Propagation::Stop;
+            } else {
+                return glib::Propagation::Proceed;
+            };
+            let manual = modifiers.contains(gdk::ModifierType::SHIFT_MASK);
+            let _ = tx.send(AppMsg::Navigate(card_id.clone(), direction, manual));
+            glib::Propagation::Stop
+        });
+        root.add_controller(keys);
+
+        Self {
+            root,
+            phase,
+            repo,
+            state,
+            tool,
+            elapsed,
+            detail,
+            prompt,
+            reply,
+            path,
+            activation,
+            inspector,
+        }
+    }
+
+    pub fn update(&self, card: &Card, focused: bool, duplicate_label: bool, now_ms: i64) {
+        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 {
+            card.last_event_at
+        } else {
+            card.updated_at
+        };
+        let stalled = card.stalled(now_ms);
+        self.state.set_text(if stalled {
+            "stalled"
+        } else {
+            state_label(&card.state)
+        });
+        self.tool.set_text(text_or(
+            if card.tool_name.is_empty() {
+                &card.tool_target
+            } else {
+                &card.tool_name
+            },
+            "monitoring",
+        ));
+        self.elapsed.set_text(&format!(
+            "{} · {}",
+            duration(now_ms, card.agent_started_at.unwrap_or(card.started_at)),
+            duration(now_ms, real_event_at)
+        ));
+        self.detail.set_text(text_or(&card.detail, "Ready"));
+        self.prompt
+            .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, "—"));
+
+        for class in [
+            "state-idle",
+            "state-thinking",
+            "state-tool",
+            "state-waiting",
+            "state-success",
+            "state-error",
+            "current",
+            "stalled",
+        ] {
+            self.root.remove_css_class(class);
+        }
+        self.root.add_css_class(&format!(
+            "state-{}",
+            if stalled {
+                "waiting"
+            } else {
+                state_class(&card.state)
+            }
+        ));
+        if focused {
+            self.root.add_css_class("current");
+        }
+        if stalled {
+            self.root.add_css_class("stalled");
+        }
+        self.root.set_tooltip_text(Some(&format!(
+            "Focus {}",
+            text_or(&card.repo_label, "Pi session")
+        )));
+        let accessible_label = format!(
+            "{}, {}, press Enter to focus its Ghostty window",
+            text_or(&card.repo_label, "Pi session"),
+            if stalled {
+                "stalled"
+            } else {
+                text_or(&card.phase, "idle")
+            }
+        );
+        self.root
+            .update_property(&[gtk::accessible::Property::Label(&accessible_label)]);
+        self.root
+            .update_state(&[gtk::accessible::State::Selected(Some(focused))]);
+    }
+
+    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 });
+        self.inspector.set_visible(expanded);
+        if expanded {
+            self.root.add_css_class("open");
+        } else {
+            self.root.remove_css_class("open");
+        }
+    }
+
+    pub fn set_activation(&self, ok: bool, message: &str) {
+        self.activation.set_text(message);
+        self.activation.set_visible(true);
+        self.activation.remove_css_class("success");
+        self.activation.remove_css_class("error");
+        self.activation
+            .add_css_class(if ok { "success" } else { "error" });
+        self.root
+            .update_property(&[gtk::accessible::Property::Description(message)]);
+        self.root
+            .announce(message, gtk::AccessibleAnnouncementPriority::Medium);
+    }
+}
+
+fn label(class: &str, align: gtk::Align) -> gtk::Label {
+    let value = gtk::Label::new(None);
+    value.add_css_class(class);
+    value.set_halign(align);
+    value.set_ellipsize(relm4::gtk::pango::EllipsizeMode::End);
+    value.set_xalign(if align == gtk::Align::End { 1.0 } else { 0.0 });
+    value
+}
+
+fn inspector_row(grid: &gtk::Grid, row: i32, key: &str) -> gtk::Label {
+    let key_label = label("inspector-key", gtk::Align::Start);
+    key_label.set_text(key);
+    key_label.set_width_chars(7);
+    let value = label("inspector-value", gtk::Align::Start);
+    value.set_wrap(true);
+    value.set_lines(2);
+    value.set_hexpand(true);
+    grid.attach(&key_label, 0, row, 1, 1);
+    grid.attach(&value, 1, row, 1, 1);
+    value
+}
+
+fn display_repo(card: &Card, duplicate: bool) -> String {
+    if duplicate && card.pid > 0 {
+        format!(
+            "{} · {:04}",
+            text_or(&card.repo_label, "Pi session"),
+            card.pid % 10_000
+        )
+    } else {
+        text_or(&card.repo_label, "Pi session").to_owned()
+    }
+}
+
+fn state_label(state: &str) -> &str {
+    match state {
+        "success" => "done",
+        "thinking" | "tool" | "waiting" | "error" | "idle" => state,
+        _ => "idle",
+    }
+}
+
+fn state_class(state: &str) -> &str {
+    match state {
+        "thinking" | "tool" | "waiting" | "success" | "error" => state,
+        _ => "idle",
+    }
+}
+
+fn text_or<'a>(value: &'a str, fallback: &'a str) -> &'a str {
+    if value.is_empty() { fallback } else { value }
+}
+
+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)
+}

package/native/panel/src/main.rs

@@ -0,0 +1,31 @@
+mod app;
+mod card_view;
+mod protocol;
+mod runtime;
+
+use app::{App, AppInit};
+use relm4::RelmApp;
+
+#[cfg(target_os = "linux")]
+fn bind_lifetime_to_parent() {
+    unsafe {
+        libc::prctl(libc::PR_SET_PDEATHSIG, libc::SIGTERM);
+        if libc::getppid() == 1 {
+            std::process::exit(1);
+        }
+    }
+}
+
+#[cfg(not(target_os = "linux"))]
+fn bind_lifetime_to_parent() {}
+
+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);
+    app.run::<App>(AppInit {
+        demo,
+        click_through,
+    });
+}

package/native/panel/src/protocol.rs

@@ -0,0 +1,234 @@
+use serde::Deserialize;
+use serde_json::{Value, json};
+use std::io::{self, Write};
+use std::sync::{Mutex, OnceLock};
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Card {
+    #[serde(default)]
+    pub card_id: String,
+    #[serde(default)]
+    pub session_id: String,
+    #[serde(default)]
+    pub repo_label: String,
+    #[serde(default)]
+    pub phase: String,
+    #[serde(default)]
+    pub state: String,
+    #[serde(default)]
+    pub tool_name: String,
+    #[serde(default)]
+    pub tool_target: String,
+    #[serde(default)]
+    pub detail: String,
+    #[serde(default)]
+    pub last_prompt_preview: String,
+    #[serde(default)]
+    pub assistant_preview: String,
+    #[serde(default)]
+    pub cwd: String,
+    #[serde(default)]
+    pub started_at: i64,
+    #[serde(default)]
+    pub agent_started_at: Option<i64>,
+    #[serde(default)]
+    pub last_event_at: i64,
+    #[serde(default)]
+    pub updated_at: i64,
+    #[serde(default)]
+    pub agent_active: bool,
+    #[serde(default, rename = "processId")]
+    pub pid: i64,
+}
+
+impl Card {
+    pub fn id(&self) -> &str {
+        if self.card_id.is_empty() {
+            &self.session_id
+        } else {
+            &self.card_id
+        }
+    }
+
+    pub fn active(&self) -> bool {
+        self.agent_active || matches!(self.state.as_str(), "thinking" | "tool" | "waiting")
+    }
+
+    pub fn monitoring(&self) -> bool {
+        self.state == "success" && self.tool_name.is_empty() && self.tool_target.is_empty()
+    }
+
+    pub fn stalled(&self, now_ms: i64) -> bool {
+        let real_event_at = if self.last_event_at > 0 {
+            self.last_event_at
+        } else {
+            self.updated_at
+        };
+        self.agent_active
+            && matches!(self.state.as_str(), "thinking" | "tool" | "waiting")
+            && real_event_at > 0
+            && now_ms.saturating_sub(real_event_at) > 900_000
+    }
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ViewMessage {
+    #[serde(default = "protocol_version")]
+    pub protocol: u8,
+    #[serde(rename = "type")]
+    pub message_type: String,
+    pub revision: u64,
+    #[serde(default)]
+    pub visible: bool,
+    #[serde(default)]
+    pub focused_card_id: Option<String>,
+    #[serde(default)]
+    pub sessions: Vec<Card>,
+}
+
+fn protocol_version() -> u8 {
+    1
+}
+
+static OUTPUT: OnceLock<Mutex<io::Stdout>> = OnceLock::new();
+
+pub fn emit(event: Value) {
+    let stdout = OUTPUT.get_or_init(|| Mutex::new(io::stdout()));
+    if let Ok(mut output) = stdout.lock() {
+        let _ = serde_json::to_writer(&mut *output, &event);
+        let _ = output.write_all(b"\n");
+        let _ = output.flush();
+    }
+}
+
+pub fn emit_ready() {
+    emit(json!({
+        "protocol": 1,
+        "type": "ready",
+        "pid": std::process::id(),
+        "namespace": "pi-activity-strip"
+    }));
+}
+
+pub fn emit_error(message: impl Into<String>) {
+    emit(json!({ "protocol": 1, "type": "error", "message": message.into() }));
+}
+
+pub fn demo_view() -> ViewMessage {
+    let now = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_millis() as i64;
+    ViewMessage {
+        protocol: 1,
+        message_type: "view".into(),
+        revision: 1,
+        visible: true,
+        focused_card_id: Some("demo-tool".into()),
+        sessions: vec![
+            Card {
+                card_id: "demo-monitor".into(),
+                session_id: "demo-monitor".into(),
+                repo_label: "activity-strip".into(),
+                phase: "Monitoring".into(),
+                state: "success".into(),
+                tool_name: String::new(),
+                detail: "Native layer-shell panel online".into(),
+                cwd: "/home/tryinget/ai-society/softwareco/owned/pi-extensions".into(),
+                started_at: now - 135_000,
+                last_event_at: now - 4_000,
+                updated_at: now,
+                ..empty_card()
+            },
+            Card {
+                card_id: "demo-tool".into(),
+                session_id: "demo-tool".into(),
+                repo_label: "native-dogfood".into(),
+                phase: "Rendering GTK cards".into(),
+                state: "tool".into(),
+                tool_name: "gtk4-layer-shell".into(),
+                tool_target: "top surface".into(),
+                detail: "Exclusive zone remains 84px while details expand".into(),
+                last_prompt_preview: "Replace Electron without losing the ribbon UX".into(),
+                assistant_preview: "Native panel fixture is active.".into(),
+                cwd: "/home/tryinget/ai-society/softwareco/owned/pi-extensions/packages/pi-activity-strip".into(),
+                started_at: now - 42_000,
+                agent_started_at: Some(now - 42_000),
+                last_event_at: now - 1_000,
+                updated_at: now,
+                agent_active: true,
+                ..empty_card()
+            },
+        ],
+    }
+}
+
+fn empty_card() -> Card {
+    Card {
+        card_id: String::new(),
+        session_id: String::new(),
+        repo_label: String::new(),
+        phase: String::new(),
+        state: String::new(),
+        tool_name: String::new(),
+        tool_target: String::new(),
+        detail: String::new(),
+        last_prompt_preview: String::new(),
+        assistant_preview: String::new(),
+        cwd: String::new(),
+        started_at: 0,
+        agent_started_at: None,
+        last_event_at: 0,
+        updated_at: 0,
+        agent_active: false,
+        pid: 0,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn view_messages_accept_current_node_projection_shape() {
+        let view: ViewMessage = serde_json::from_str(
+            r#"{"protocol":1,"type":"view","revision":7,"visible":true,"focusedCardId":"card-a","sessions":[{"cardId":"card-a","sessionId":"session-a","state":"tool","agentActive":true,"agentStartedAt":null,"processId":4242}]}"#,
+        )
+        .expect("view should parse");
+        assert_eq!(view.revision, 7);
+        assert_eq!(view.sessions[0].id(), "card-a");
+        assert!(view.sessions[0].active());
+        assert_eq!(view.sessions[0].agent_started_at, None);
+        assert_eq!(view.sessions[0].pid, 4242);
+    }
+
+    #[test]
+    fn monitoring_cards_are_distinct_from_active_work() {
+        let mut card = empty_card();
+        card.state = "success".into();
+        assert!(card.monitoring());
+        card.tool_target = "old target".into();
+        assert!(!card.monitoring());
+        card.tool_target.clear();
+        assert!(!card.active());
+    }
+
+    #[test]
+    fn stalled_requires_agent_active_and_uses_real_event_time() {
+        let mut card = empty_card();
+        card.state = "tool".into();
+        card.last_event_at = 1_000;
+        card.updated_at = 1_000_000;
+        assert!(!card.stalled(1_000_001));
+        card.agent_active = true;
+        assert!(card.stalled(1_000_001));
+        card.state = "success".into();
+        assert!(!card.stalled(1_000_001));
+        card.state = "tool".into();
+        card.last_event_at = 0;
+        card.updated_at = 0;
+        assert!(!card.stalled(1_000_001));
+    }
+}

package/native/panel/src/runtime.rs

@@ -0,0 +1,110 @@
+use crate::app::AppMsg;
+use crate::protocol::{Card, ViewMessage};
+use relm4::gtk;
+use std::collections::{HashMap, HashSet};
+use std::io::{BufRead, BufReader};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+#[allow(deprecated)]
+pub fn install_css() {
+    let provider = gtk::CssProvider::new();
+    provider.load_from_data(include_str!("style.css"));
+    if let Some(display) = gtk::gdk::Display::default() {
+        gtk::style_context_add_provider_for_display(
+            &display,
+            &provider,
+            gtk::STYLE_PROVIDER_PRIORITY_APPLICATION,
+        );
+    }
+}
+
+pub fn start_input_reader(sender: relm4::Sender<AppMsg>) {
+    std::thread::spawn(move || {
+        for line in BufReader::new(std::io::stdin()).lines() {
+            match line {
+                Ok(line) if !line.trim().is_empty() => consume_line(&sender, &line),
+                Ok(_) => {}
+                Err(error) => {
+                    let _ = sender.send(AppMsg::InputError(format!("panel input failed: {error}")));
+                    break;
+                }
+            }
+        }
+        let _ = sender.send(AppMsg::ParentGone);
+    });
+}
+
+fn consume_line(sender: &relm4::Sender<AppMsg>, line: &str) {
+    let value = match serde_json::from_str::<serde_json::Value>(line) {
+        Ok(value) => value,
+        Err(error) => {
+            let _ = sender.send(AppMsg::InputError(format!(
+                "invalid panel message: {error}"
+            )));
+            return;
+        }
+    };
+    match value.get("type").and_then(|kind| kind.as_str()) {
+        Some("view") => match serde_json::from_value::<ViewMessage>(value) {
+            Ok(view) => {
+                let _ = sender.send(AppMsg::View(view));
+            }
+            Err(error) => {
+                let _ = sender.send(AppMsg::InputError(format!("invalid view message: {error}")));
+            }
+        },
+        Some("focus-strip") => {
+            let _ = sender.send(AppMsg::FocusStrip);
+        }
+        Some("collapse") => {
+            let _ = sender.send(AppMsg::Collapse);
+        }
+        Some("activation-result") => {
+            let card_id = value
+                .get("cardId")
+                .and_then(|item| item.as_str())
+                .unwrap_or_default()
+                .to_owned();
+            let ok = value
+                .get("ok")
+                .and_then(|item| item.as_bool())
+                .unwrap_or(false);
+            let message = value
+                .get("message")
+                .and_then(|item| item.as_str())
+                .unwrap_or(if ok {
+                    "Focused Ghostty window."
+                } else {
+                    "Focus failed; nothing moved."
+                })
+                .to_owned();
+            let _ = sender.send(AppMsg::ActivationResult(card_id, ok, message));
+        }
+        Some(kind) => {
+            let _ = sender.send(AppMsg::InputError(format!(
+                "unsupported panel message: {kind}"
+            )));
+        }
+        None => {
+            let _ = sender.send(AppMsg::InputError("panel message type is required".into()));
+        }
+    }
+}
+
+pub fn duplicate_labels<'a>(cards: impl Iterator<Item = &'a Card>) -> HashSet<String> {
+    let mut counts = HashMap::new();
+    for card in cards {
+        *counts.entry(card.repo_label.clone()).or_insert(0usize) += 1;
+    }
+    counts
+        .into_iter()
+        .filter_map(|(label, count)| (count > 1).then_some(label))
+        .collect()
+}
+
+pub fn now_ms() -> i64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_millis() as i64
+}