@tryinget/pi-activity-strip 0.8.0 → 0.9.0

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;