@tryinget/pi-activity-strip 0.7.0 → 0.9.0

package/native/panel/src/runtime.rs

@@ -45,20 +45,36 @@ pub fn apply_theme(definitions: &str) {
     THEME_PROVIDER.with(|provider| provider.load_from_data(&css));
 }
 
+/// Read controller messages from stdin on their own thread. The thread is detached on purpose: it
+/// lives exactly as long as stdin, and on EOF it reports the parent gone, which closes the panel.
 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 reader_sender = sender.clone();
+    let spawned = std::thread::Builder::new()
+        .name("panel-input".into())
+        .spawn(move || read_input(reader_sender));
+    match spawned {
+        Ok(handle) => drop(handle),
+        Err(error) => {
+            let _ = sender.send(AppMsg::InputError(format!(
+                "could not start the panel input reader: {error}"
+            )));
+            let _ = sender.send(AppMsg::ParentGone);
+        }
+    }
+}
+
+fn read_input(sender: relm4::Sender<AppMsg>) {
+    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);
-    });
+    }
+    let _ = sender.send(AppMsg::ParentGone);
 }
 
 fn consume_line(sender: &relm4::Sender<AppMsg>, line: &str) {
@@ -121,6 +137,22 @@ fn consume_line(sender: &relm4::Sender<AppMsg>, line: &str) {
                 .to_owned();
             let _ = sender.send(AppMsg::ActivationResult(card_id, ok, message));
         }
+        Some("jump-result") => {
+            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 { "Jumped." } else { "Nothing moved." })
+                .to_owned();
+            let window_id = value
+                .get("windowId")
+                .and_then(|item| item.as_i64())
+                .unwrap_or(-1);
+            let _ = sender.send(AppMsg::JumpResult(window_id, ok, message));
+        }
         Some(kind) => {
             let _ = sender.send(AppMsg::InputError(format!(
                 "unsupported panel message: {kind}"

package/native/panel/src/style.css

@@ -89,11 +89,14 @@ window {
   border-color: alpha(@pi_accent, 0.5);
 }
 
-/* The tab the compositor is actually showing, marked by weight rather than another border. */
+/*
+ * The tab the compositor is actually showing: the card the brand block names. A solid accent ring
+ * rather than a tint, so it never reads as the hover state and survives soft light themes.
+ */
 .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);
+  background: mix(@pi_background, @pi_accent, 0.14);
+  border-color: @pi_accent;
+  box-shadow: inset 0 0 0 1px @pi_accent;
 }
 
 .card.hidden-tab {
@@ -224,6 +227,7 @@ window {
  * 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.
  */
+/* Footer-sized: a bare task number with no vertical padding, like the window chip beside it. */
 .ak-task {
   background: alpha(@pi_foreground, 0.07);
   border: 1px solid alpha(@pi_foreground, 0.16);
@@ -231,7 +235,7 @@ window {
   color: alpha(@pi_foreground, 0.68);
   font-family: "IBM Plex Mono", "JetBrains Mono", monospace;
   font-size: 8px;
-  padding: 3px 8px;
+  padding: 0 5px;
 }
 
 .ak-task.ak-active {
@@ -261,3 +265,88 @@ window {
   font-family: "IBM Plex Mono", "JetBrains Mono", monospace;
   font-size: 8px;
 }
+
+/*
+ * The brand block's window list: every agent window on every workspace, as its card's first line
+ * and its Niri window number. The number is the thing you type, so it carries the accent.
+ */
+.directory {
+  border-top: 1px solid alpha(@pi_foreground, 0.12);
+  padding-top: 7px;
+}
+
+.jump-line {
+  color: @pi_accent;
+  font-family: "IBM Plex Mono", "JetBrains Mono", monospace;
+  font-size: 10px;
+  font-weight: 600;
+}
+
+/* biome-ignore lint/correctness/noUnknownTypeSelector: GTK CSS uses widget node names. */
+.directory-scroller,
+.directory-scroller > viewport {
+  background: transparent;
+}
+
+/* Same as the card row: scrolls by wheel or touchpad without a visible bar. */
+/* biome-ignore lint/correctness/noUnknownTypeSelector: GTK CSS uses widget node names. */
+.directory-scroller scrollbar {
+  opacity: 0;
+  min-width: 0;
+  min-height: 0;
+}
+
+.directory-header {
+  color: alpha(@pi_foreground, 0.5);
+  font-family: "IBM Plex Mono", "JetBrains Mono", monospace;
+  font-size: 8px;
+  letter-spacing: 1px;
+  margin-top: 5px;
+}
+
+.directory-row {
+  background: transparent;
+  border: 1px solid transparent;
+  border-radius: 6px;
+  color: @pi_foreground;
+  min-height: 0;
+  padding: 2px 6px;
+}
+
+.directory-row:hover,
+.directory-row:focus-visible {
+  background: mix(@pi_background, @pi_foreground, 0.1);
+}
+
+/* The window you are in: the same accent ring as its card. */
+.directory-row.current {
+  border-color: @pi_accent;
+}
+
+.directory-label {
+  font-size: 11px;
+}
+
+.directory-id {
+  color: @pi_accent;
+  font-family: "IBM Plex Mono", "JetBrains Mono", monospace;
+  font-size: 10px;
+  font-weight: 600;
+}
+
+.directory-empty {
+  color: alpha(@pi_foreground, 0.5);
+  font-size: 10px;
+}
+
+/* Which workspace a row's window is on; quieter than the number you type. */
+.directory-workspace {
+  color: alpha(@pi_foreground, 0.5);
+  font-family: "IBM Plex Mono", "JetBrains Mono", monospace;
+  font-size: 9px;
+}
+
+/* The row Enter would open: a typed name always shows where it leads. */
+.directory-row.chosen {
+  background: alpha(@pi_accent, 0.16);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tryinget/pi-activity-strip",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "pi extension package for activity-strip workflows in monorepo runtime",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE",
@@ -92,9 +92,8 @@
     "@earendil-works/pi-ai": "0.84.4",
     "@earendil-works/pi-coding-agent": "0.84.4",
     "@types/node": "22.14.0",
-    "@typescript/native-preview": "7.0.0-dev.20260417.1",
     "typebox": "1.3.7",
-    "typescript": "5.9.2"
+    "typescript": "7.0.2"
   },
   "overrides": {
     "fast-xml-parser": "5.7.0"

package/src/common/contracts.d.ts

@@ -99,6 +99,7 @@ export interface ActivityStripRuntimeStatus {
   clickThrough?: boolean;
   panelMoveCount?: number;
   panelActivationCount?: number;
+  panelJumpCount?: number;
   panelRestartCount?: number;
   lastMovedCardId?: string | null;
   warnings?: string[];

package/src/common/contracts.ts

@@ -123,6 +123,7 @@ export interface ActivityStripRuntimeStatus {
   clickThrough?: boolean;
   panelMoveCount?: number;
   panelActivationCount?: number;
+  panelJumpCount?: number;
   panelRestartCount?: number;
   lastMovedCardId?: string | null;
   warnings?: string[];

package/src/common/workspace-view.mjs

@@ -149,6 +149,70 @@ export function resolveFocusedWorkspaceView(windows, workspaces, sessions, optio
   return workspace ? resolveWorkspaceView(windows, workspace, sessions, options) : null;
 }
 
+/**
+ * @typedef {{
+ *   cardId: string;
+ *   label: string;
+ *   windowId: number;
+ *   workspaceId: number;
+ *   workspaceIdx: number | null;
+ *   workspaceName: string | null;
+ *   hiddenTab: boolean;
+ *   current: boolean;
+ * }} WindowDirectoryEntry
+ */
+
+/**
+ * Every agent window on every workspace, for the ribbon's window list. It reuses the per-workspace
+ * card projection, so an entry exists exactly when that workspace would show the card. Ordered
+ * alphabetically by project name, then by window number; each entry carries its workspace.
+ * @param {Array<Record<string, unknown>>} windows
+ * @param {Array<Record<string, unknown>>} workspaces
+ * @param {Array<Record<string, unknown>>} sessions
+ * @param {ResolveOptions} [options]
+ * @returns {{entries: WindowDirectoryEntry[]; cards: Map<string, Record<string, unknown>>}}
+ */
+export function resolveWindowDirectory(windows, workspaces, sessions, options = {}) {
+  const ordered = workspaces
+    .filter((workspace) => Number.isInteger(workspace?.id))
+    .sort(
+      (a, b) =>
+        String(a.output ?? "").localeCompare(String(b.output ?? "")) ||
+        Number(a.idx ?? 0) - Number(b.idx ?? 0),
+    );
+  /** @type {WindowDirectoryEntry[]} */
+  const entries = [];
+  /** @type {Map<string, Record<string, unknown>>} */
+  const cards = new Map();
+  for (const workspace of ordered) {
+    const view = resolveWorkspaceView(windows, workspace, sessions, options);
+    if (!view) continue;
+    const placed = view.sessions
+      .filter((card) => Number.isInteger(card.windowId))
+      .sort((a, b) => Number(a.windowId) - Number(b.windowId));
+    for (const card of placed) {
+      const cardId = String(card.cardId ?? "");
+      if (!cardId || cards.has(cardId)) continue;
+      cards.set(cardId, card);
+      entries.push({
+        cardId,
+        label: String(card.repoLabel || "session"),
+        windowId: Number(card.windowId),
+        workspaceId: Number(workspace.id),
+        workspaceIdx: Number.isInteger(card.workspaceIdx) ? Number(card.workspaceIdx) : null,
+        workspaceName: typeof workspace.name === "string" ? workspace.name : null,
+        hiddenTab: card.surfaceVisible === false,
+        current: cardId === view.focusedCardId,
+      });
+    }
+  }
+  entries.sort(
+    (a, b) =>
+      a.label.localeCompare(b.label, undefined, { sensitivity: "base" }) || a.windowId - b.windowId,
+  );
+  return { entries, cards };
+}
+
 /** @param {Array<Record<string, unknown>>} workspaces */
 export function resolveFocusedNiriWorkspace(workspaces) {
   const matches = workspaces.filter(

package/src/native/main.mjs

@@ -13,7 +13,7 @@ import { pruneClaudeEventRecords } from "../common/claude-events.mjs";
 import { ACTIVITY_STRIP_WORKSPACE_SYNC_MS } from "../common/constants.mjs";
 import { focusNiriSession, readNiriWindows, readNiriWorkspaces } from "../common/niri-focus.mjs";
 import { haveSameRecordMembership } from "../common/session-cards.mjs";
-import { resolveFocusedWorkspaceView } from "../common/workspace-view.mjs";
+import { resolveFocusedWorkspaceView, resolveWindowDirectory } from "../common/workspace-view.mjs";
 import { discoverAgentTabs } from "./agent-discovery.mjs";
 import { startAkTaskProjection } from "./ak-runtime.mjs";
 import { createHeightRepair } from "./height-repair.mjs";
@@ -158,6 +158,37 @@ async function focusSession(targetId) {
   return result;
 }
 
+/**
+ * Jump to a window by the number Niri gives it, as typed into the window list. Only a window that
+ * exists right now is focused; any other number does nothing.
+ * @param {number} windowId
+ * @returns {Promise<{ok: boolean; error?: string}>}
+ */
+async function jumpToWindow(windowId) {
+  if (!isNiriSession()) return { ok: false, error: "Niri is not available; nothing moved." };
+  if (!Number.isInteger(windowId) || windowId < 0) {
+    return { ok: false, error: "Not a window number; nothing moved." };
+  }
+  let windows;
+  try {
+    windows = await getNiriWindows();
+  } catch {
+    return { ok: false, error: "Could not read Niri windows; nothing moved." };
+  }
+  if (!windows.some((window) => window?.id === windowId)) {
+    return { ok: false, error: `No window #${windowId}; nothing moved.` };
+  }
+  try {
+    await execFileAsync("niri", ["msg", "action", "focus-window", "--id", String(windowId)], {
+      env: process.env,
+    });
+  } catch {
+    return { ok: false, error: `Niri refused to focus #${windowId}; nothing moved.` };
+  }
+  reconcileRunner.request();
+  return { ok: true };
+}
+
 async function focusStrip() {
   if (runtimeStatus.clickThrough) {
     return { ok: false, error: "Keyboard entry is disabled in click-through mode." };
@@ -231,6 +262,17 @@ function consumePanelEvents(child, chunk) {
                 : result.error || "Focus failed; nothing moved.",
             }),
           );
+        } else if (event.type === "jump") {
+          runtimeStatus.panelJumpCount = (runtimeStatus.panelJumpCount ?? 0) + 1;
+          const windowId = Number(event.windowId);
+          void jumpToWindow(windowId).then((result) =>
+            writePanel({
+              type: "jump-result",
+              windowId,
+              ok: result.ok === true,
+              message: result.ok ? `Jumped to #${windowId}.` : result.error || "Nothing moved.",
+            }),
+          );
         } else if (event.type === "moved") {
           runtimeStatus.panelMoveCount = (runtimeStatus.panelMoveCount ?? 0) + 1;
           runtimeStatus.lastMovedCardId = String(event.cardId ?? "") || null;
@@ -362,6 +404,7 @@ const reconcileRunner = createLatestOnlyRunner(async ({ isCurrent }) => {
   runtimeStatus.unplacedSurfaceCount = placement.countUnplaced(windows, sessions);
   const view = resolveFocusedWorkspaceView(windows, workspaces, sessions, placement.options);
   if (view) placement.learnFromPlacements(view.sessions, windows);
+  projection.setDirectory(resolveWindowDirectory(windows, workspaces, sessions, placement.options));
   projection.publishWorkspaceView(
     view ?? { workspace: null, sessions: [], focusedSessionId: null, focusedCardId: null },
   );

package/src/native/panel-projection.mjs

@@ -36,6 +36,11 @@ export function createNativePanelProjection({ isNiriSession, publish }) {
   /** Read-only AK task claims joined onto cards; absent until the first successful AK read. */
   /** @type {{claims: import("../common/contracts.ts").AkTaskClaim[]; deferred: import("../common/contracts.ts").AkTaskDeferred[]} | null} */
   let akTasks = null;
+  /** Every agent window on every workspace, for the brand block's window list. */
+  /** @type {import("../common/workspace-view.mjs").WindowDirectoryEntry[]} */
+  let directory = [];
+  /** @type {Map<string, SessionRecord>} */
+  let directoryCards = new Map();
   let revision = 0;
 
   function allSessions() {
@@ -83,6 +88,7 @@ export function createNativePanelProjection({ isNiriSession, publish }) {
       focusedCardId,
       generatedAt: snapshot.generatedAt,
       sessions,
+      windows: directory,
     };
   }
 
@@ -117,8 +123,24 @@ export function createNativePanelProjection({ isNiriSession, publish }) {
       akTasks = state;
       send();
     },
-    /** @param {string} targetId */
-    resolveTarget: (targetId) => resolveSnapshotSession(getDisplaySessions(), targetId),
+    /**
+     * A card on this workspace, or else an entry of the window list, which spans every workspace.
+     * @param {string} targetId
+     */
+    resolveTarget: (targetId) =>
+      resolveSnapshotSession(getDisplaySessions(), targetId) ??
+      directoryCards.get(targetId) ??
+      null,
+    /** @param {number} windowId */
+    hasDirectoryWindow: (windowId) => directory.some((entry) => entry.windowId === windowId),
+    /**
+     * Replace the window list; it is published with the next view.
+     * @param {{entries: import("../common/workspace-view.mjs").WindowDirectoryEntry[]; cards: Map<string, SessionRecord>}} next
+     */
+    setDirectory(next) {
+      directory = next.entries;
+      directoryCards = next.cards;
+    },
     /** @param {WorkspaceView} view */
     publishWorkspaceView(view) {
       workspace = view.workspace ?? null;