@tryinget/pi-activity-strip 0.4.0 → 0.6.0

package/native/panel/src/protocol.rs

@@ -0,0 +1,297 @@
+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 AkTask {
+    #[serde(default)]
+    pub id: i64,
+    #[serde(default)]
+    pub title: String,
+    #[serde(default)]
+    pub state: String,
+}
+
+impl AkTask {
+    /// Only an `active` chip is a button: the card's own session holds a live claim, so clicking
+    /// it focuses that session's Ghostty window. Every other state is a badge and never fires.
+    pub fn is_active(&self) -> bool {
+        self.state == "active"
+    }
+}
+
+#[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,
+    /// Set for tabs running an agent other than Pi, which publish no telemetry of their own.
+    #[serde(default)]
+    pub agent_label: String,
+    /// Read-only AK task references joined onto this card by the controller. `active` chips are
+    /// clickable and focus this card's terminal; the rest are inert badges.
+    #[serde(default)]
+    pub ak_tasks: Vec<AkTask>,
+    /// How many further AK references exist beyond the rendered chips.
+    #[serde(default)]
+    pub ak_task_overflow: u32,
+    /// `Some(false)` marks a tab hidden behind another tab of its Ghostty window; the controller
+    /// placed it through its host process, so activation presents the tab before focusing.
+    #[serde(default)]
+    pub surface_visible: Option<bool>,
+}
+
+impl Card {
+    pub fn id(&self) -> &str {
+        if self.card_id.is_empty() {
+            &self.session_id
+        } else {
+            &self.card_id
+        }
+    }
+
+    pub fn hidden_tab(&self) -> bool {
+        self.surface_visible == Some(false)
+    }
+
+    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,
+                ak_tasks: vec![AkTask {
+                    id: 5701,
+                    title: "Show clickable AK-task references on the activity ribbon".into(),
+                    state: "active".into(),
+                }],
+                ak_task_overflow: 1,
+                ..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,
+        agent_label: String::new(),
+        ak_tasks: Vec::new(),
+        ak_task_overflow: 0,
+        surface_visible: None,
+    }
+}
+
+#[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);
+        assert!(view.sessions[0].ak_tasks.is_empty());
+        assert_eq!(view.sessions[0].ak_task_overflow, 0);
+    }
+
+    #[test]
+    fn ak_task_chips_parse_with_states() {
+        let view: ViewMessage = serde_json::from_str(
+            r#"{"protocol":1,"type":"view","revision":8,"sessions":[{"cardId":"card-a","akTasks":[{"id":5701,"title":"Show clickable AK-task references","state":"active"},{"id":5432,"title":"Preserve safe NEXUS recovery reasons","state":"orphaned"},{"id":4220,"title":"Control Decision 77 epoch admissions","state":"deferred"}],"akTaskOverflow":3}]}"#,
+        )
+        .expect("view should parse");
+        let card = &view.sessions[0];
+        assert_eq!(card.ak_tasks.len(), 3);
+        assert!(card.ak_tasks[0].is_active());
+        assert!(!card.ak_tasks[1].is_active());
+        assert!(!card.ak_tasks[2].is_active());
+        assert_eq!(card.ak_task_overflow, 3);
+    }
+
+    #[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,151 @@
+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};
+
+/// Colour definitions used until the controller reports what Ghostty is showing.
+const FALLBACK_DEFINITIONS: &str = concat!(
+    "@define-color pi_background #1e2326;\n",
+    "@define-color pi_foreground #d3c6aa;\n",
+    "@define-color pi_accent #7fbbb3;\n",
+    "@define-color pi_thinking #7fbbb3;\n",
+    "@define-color pi_tool #dbbc7f;\n",
+    "@define-color pi_waiting #e69875;\n",
+    "@define-color pi_success #a7c080;\n",
+    "@define-color pi_error #e67e80;\n",
+);
+
+thread_local! {
+    static THEME_PROVIDER: gtk::CssProvider = gtk::CssProvider::new();
+}
+
+/// The stylesheet derives every shade from a handful of named colours, so following the terminal's
+/// theme is a matter of redefining those names and reloading one provider.
+#[allow(deprecated)]
+pub fn install_css() {
+    apply_theme(FALLBACK_DEFINITIONS);
+    THEME_PROVIDER.with(|provider| {
+        if let Some(display) = gtk::gdk::Display::default() {
+            gtk::style_context_add_provider_for_display(
+                &display,
+                provider,
+                gtk::STYLE_PROVIDER_PRIORITY_APPLICATION,
+            );
+        }
+    });
+}
+
+/// Replace the active colour definitions. Definitions must sit in the same provider as the rules
+/// that reference them, so both are loaded together.
+#[allow(deprecated)]
+pub fn apply_theme(definitions: &str) {
+    let css = format!("{definitions}\n{}", include_str!("style.css"));
+    THEME_PROVIDER.with(|provider| provider.load_from_data(&css));
+}
+
+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("theme") => {
+            let definitions = value
+                .get("definitions")
+                .and_then(|item| item.as_str())
+                .unwrap_or_default()
+                .to_owned();
+            if definitions.is_empty() {
+                let _ = sender.send(AppMsg::InputError(
+                    "theme message carried no colours".into(),
+                ));
+            } else {
+                let _ = sender.send(AppMsg::Theme(definitions));
+            }
+        }
+        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
+}

package/native/panel/src/style.css

@@ -0,0 +1,250 @@
+/*
+ * Every colour here derives from the handful of names the controller defines from Ghostty's own
+ * theme, so the ribbon follows the terminal into light and dark without a second palette to keep
+ * in sync. mix() against the background and alpha() against the foreground both invert correctly
+ * between schemes: a raised surface is lighter on a dark theme and darker on a light one.
+ */
+
+/* biome-ignore lint/correctness/noUnknownTypeSelector: GTK CSS uses widget node names. */
+window {
+  background: transparent;
+  color: @pi_foreground;
+  font-family: "IBM Plex Sans", "Inter", "Segoe UI", sans-serif;
+}
+
+/* One surface on the same rhythm and radius as tiled windows, so it reads as a peer of them. */
+.band {
+  /* Solid: the ribbon is the one surface that never dims, so it reads as the fixed ground. */
+  background: @pi_background;
+  border: 1px solid alpha(@pi_foreground, 0.16);
+  border-radius: 12px;
+  padding: 0 14px 0 16px;
+}
+
+.brand {
+  border-right: 1px solid alpha(@pi_foreground, 0.12);
+  margin-right: 12px;
+  padding: 11px 14px 11px 0;
+}
+
+.brand-eyebrow,
+.meta,
+.card-state,
+.card-tool,
+.card-elapsed,
+.inspector-key {
+  font-family: "IBM Plex Mono", "JetBrains Mono", monospace;
+}
+
+.brand-eyebrow {
+  color: alpha(@pi_accent, 0.9);
+  font-size: 9px;
+  font-weight: 600;
+  letter-spacing: 1.4px;
+}
+
+.brand-title {
+  color: @pi_foreground;
+  font-size: 17px;
+  font-weight: 650;
+  letter-spacing: -0.2px;
+}
+
+.meta {
+  color: alpha(@pi_foreground, 0.56);
+  font-size: 9px;
+}
+
+/* biome-ignore lint/correctness/noUnknownTypeSelector: GTK CSS uses widget node names. */
+.cards-panel,
+.cards-panel > viewport {
+  background: transparent;
+  padding: 0;
+}
+
+/* biome-ignore lint/correctness/noUnknownTypeSelector: GTK CSS uses widget node names. */
+.cards-panel scrollbar {
+  opacity: 0;
+  min-width: 0;
+  min-height: 0;
+}
+
+.card {
+  color: @pi_foreground;
+  background: mix(@pi_background, @pi_foreground, 0.07);
+  border: 1px solid alpha(@pi_foreground, 0.1);
+  border-left: 3px solid alpha(@pi_foreground, 0.35);
+  border-radius: 12px;
+  padding: 7px 11px 7px 10px;
+  transition:
+    background 120ms ease,
+    border-color 120ms ease;
+}
+
+.card:hover,
+.card:focus-visible,
+.card.open {
+  background: mix(@pi_background, @pi_foreground, 0.14);
+  border-color: alpha(@pi_accent, 0.5);
+}
+
+/* The tab the compositor is actually showing, marked by weight rather than another border. */
+.card.current {
+  background: mix(@pi_background, @pi_foreground, 0.16);
+  border-color: alpha(@pi_accent, 0.42);
+  box-shadow: inset 0 0 0 1px alpha(@pi_accent, 0.22);
+}
+
+.card.hidden-tab {
+  background: alpha(@pi_background, 0.55);
+  border-style: dashed;
+}
+
+.card.hidden-tab .card-repo {
+  color: alpha(@pi_foreground, 0.78);
+}
+
+.card.stalled {
+  opacity: 0.62;
+}
+
+.card.stalled .card-phase {
+  text-decoration-line: line-through;
+}
+
+.card.state-thinking {
+  border-left-color: @pi_thinking;
+}
+.card.state-tool {
+  border-left-color: @pi_tool;
+}
+.card.state-waiting {
+  border-left-color: @pi_waiting;
+}
+.card.state-success {
+  border-left-color: @pi_success;
+}
+.card.state-error {
+  border-left-color: @pi_error;
+}
+
+.card-repo {
+  color: @pi_foreground;
+  font-size: 12px;
+  font-weight: 650;
+}
+
+.card-phase,
+.inspector-value {
+  color: alpha(@pi_foreground, 0.74);
+  font-size: 10px;
+}
+
+/* A quiet pill: the state is carried mostly by the card's left edge. */
+.card-state {
+  background: alpha(@pi_foreground, 0.07);
+  border: 1px solid alpha(@pi_foreground, 0.16);
+  border-radius: 999px;
+  color: alpha(@pi_foreground, 0.68);
+  font-size: 8px;
+  letter-spacing: 0.4px;
+  padding: 3px 7px;
+}
+
+.state-thinking .card-state {
+  background: alpha(@pi_thinking, 0.14);
+  border-color: alpha(@pi_thinking, 0.38);
+  color: @pi_thinking;
+}
+.state-tool .card-state {
+  background: alpha(@pi_tool, 0.14);
+  border-color: alpha(@pi_tool, 0.38);
+  color: @pi_tool;
+}
+.state-waiting .card-state {
+  background: alpha(@pi_waiting, 0.16);
+  border-color: alpha(@pi_waiting, 0.42);
+  color: @pi_waiting;
+}
+.state-success .card-state {
+  background: alpha(@pi_success, 0.14);
+  border-color: alpha(@pi_success, 0.38);
+  color: @pi_success;
+}
+.state-error .card-state {
+  background: alpha(@pi_error, 0.16);
+  border-color: alpha(@pi_error, 0.44);
+  color: @pi_error;
+}
+
+.card-tool,
+.card-elapsed,
+.inspector-key {
+  color: alpha(@pi_foreground, 0.55);
+  font-size: 8px;
+}
+
+.inspector {
+  border-top: 1px solid alpha(@pi_foreground, 0.12);
+  padding-top: 9px;
+}
+
+.inspector-value {
+  line-height: 1.3;
+}
+
+.activation {
+  color: alpha(@pi_foreground, 0.7);
+  font-size: 9px;
+}
+
+.activation.success {
+  color: @pi_success;
+}
+
+.activation.error {
+  color: @pi_error;
+}
+
+/*
+ * AK task references. An active chip is the one clickable element inside a card besides the card
+ * itself: it reuses the card's activation, so it carries the accent colour and a pointer cursor.
+ * Badge states (a claim that outlives its session, a deferred task) are deliberately inert pills.
+ */
+.ak-task {
+  background: alpha(@pi_foreground, 0.07);
+  border: 1px solid alpha(@pi_foreground, 0.16);
+  border-radius: 999px;
+  color: alpha(@pi_foreground, 0.68);
+  font-family: "IBM Plex Mono", "JetBrains Mono", monospace;
+  font-size: 8px;
+  padding: 3px 8px;
+}
+
+.ak-task.ak-active {
+  background: alpha(@pi_accent, 0.14);
+  border-color: alpha(@pi_accent, 0.42);
+  color: @pi_accent;
+}
+
+.ak-task.ak-active:hover {
+  background: alpha(@pi_accent, 0.26);
+}
+
+.ak-task.ak-orphaned {
+  background: alpha(@pi_error, 0.12);
+  border: 1px dashed alpha(@pi_error, 0.4);
+  color: alpha(@pi_error, 0.92);
+}
+
+.ak-task.ak-deferred {
+  background: alpha(@pi_tool, 0.12);
+  border: 1px dashed alpha(@pi_tool, 0.4);
+  color: alpha(@pi_tool, 0.92);
+}
+
+.ak-overflow {
+  color: alpha(@pi_foreground, 0.5);
+  font-family: "IBM Plex Mono", "JetBrains Mono", monospace;
+  font-size: 8px;
+}