@tryinget/pi-activity-strip 0.3.0 → 0.5.0

package/src/client/session-telemetry.mjs

@@ -5,6 +5,7 @@
 // ---
 
 /** @typedef {import("../common/contracts.ts").SessionSnapshot} SessionSnapshot */
+/** @typedef {import("../common/contracts.ts").TurnEndEventLike} TurnEndEventLike */
 /** @typedef {import("../common/contracts.ts").SessionTelemetryOptions} SessionTelemetryOptions */
 /** @typedef {import("../common/contracts.ts").SessionStartContextLike} SessionStartContextLike */
 /** @typedef {import("../common/contracts.ts").BeforeAgentStartEventLike} BeforeAgentStartEventLike */
@@ -12,6 +13,7 @@
 /** @typedef {import("../common/contracts.ts").MessageUpdateEventLike} MessageUpdateEventLike */
 /** @typedef {import("../common/contracts.ts").ToolExecutionEventLike} ToolExecutionEventLike */
 import {
+  ACTIVITY_STRIP_FLUSH_RETRY_DELAYS_MS,
   ACTIVITY_STRIP_HEARTBEAT_MS,
   ACTIVITY_STRIP_SEND_THROTTLE_MS,
 } from "../common/constants.mjs";
@@ -28,6 +30,7 @@ import {
   extractToolResultText,
   summarizeToolResult,
 } from "../common/telemetry.mjs";
+import { resolveTerminalIdentity as resolveTerminalIdentityDefault } from "../common/terminal-identity.mjs";
 import { publishSessionSnapshot, removeSession } from "./broker-client.mjs";
 
 function now() {
@@ -41,7 +44,17 @@ function extractAssistantDelta(event) {
 }
 
 /** @param {SessionTelemetryOptions} [options] */
-export function createSessionTelemetry({ pi, cwd = process.cwd(), sessionName = "" } = {}) {
+export function createSessionTelemetry({
+  pi,
+  cwd = process.cwd(),
+  sessionName = "",
+  env = process.env,
+  stdinIsTTY = Boolean(process.stdin.isTTY),
+  resolveTerminalIdentity = resolveTerminalIdentityDefault,
+  transport,
+} = {}) {
+  const publish = transport?.publish ?? publishSessionSnapshot;
+  const removePublisher = transport?.remove ?? removeSession;
   /** @type {SessionSnapshot} */
   let snapshot = createInitialSnapshot({ cwd, sessionName });
   /** @type {NodeJS.Timeout | null} */
@@ -50,29 +63,88 @@ export function createSessionTelemetry({ pi, cwd = process.cwd(), sessionName =
   let flushTimer = null;
   let disposed = false;
   let pendingAssistant = "";
+  let lastStopReason = "";
+  let confirmedSignature = "";
+  let retryIndex = 0;
+  /** @type {Promise<void> | null} */
+  let flushPromise = null;
+  let flushAgain = false;
 
-  async function flush() {
+  /** Signature of the display-relevant fields, used to detect lost transitions. */
+  function publishSignature() {
+    return [
+      snapshot.sessionId,
+      snapshot.state,
+      snapshot.phase,
+      snapshot.detail,
+      snapshot.agentActive,
+      snapshot.turnIndex,
+      snapshot.toolName,
+      snapshot.toolTarget,
+      snapshot.errorMessage,
+      snapshot.terminalKey,
+    ].join("\u001f");
+  }
+
+  function clearScheduledFlush() {
+    if (!flushTimer) return;
+    clearTimeout(flushTimer);
     flushTimer = null;
-    if (disposed) return;
+  }
+
+  async function publishLatest() {
+    // Heartbeats refresh transport liveness only; lastEventAt remains the last real event.
     snapshot.updatedAt = now();
+    snapshot.publisherSequence += 1;
     snapshot.repoLabel = formatRepoLabel(
       snapshot.cwd,
       pi?.getSessionName?.() ?? snapshot.sessionName,
     );
     snapshot.sessionName = compactWhitespace(pi?.getSessionName?.() ?? snapshot.sessionName);
+    const signature = publishSignature();
     try {
-      await publishSessionSnapshot(snapshot);
+      await publish({ ...snapshot });
+      confirmedSignature = signature;
+      retryIndex = 0;
     } catch {
-      // Broker is optional at runtime; silent failure keeps pi stable.
+      if (
+        !disposed &&
+        signature !== confirmedSignature &&
+        retryIndex < ACTIVITY_STRIP_FLUSH_RETRY_DELAYS_MS.length
+      ) {
+        const delayMs = ACTIVITY_STRIP_FLUSH_RETRY_DELAYS_MS[retryIndex];
+        retryIndex += 1;
+        scheduleFlush(delayMs);
+      }
     }
   }
 
-  function scheduleFlush(delayMs = ACTIVITY_STRIP_SEND_THROTTLE_MS) {
+  async function flush() {
+    clearScheduledFlush();
     if (disposed) return;
-    if (flushTimer) return;
+    if (flushPromise) {
+      flushAgain = true;
+      return flushPromise;
+    }
+    flushPromise = (async () => {
+      do {
+        flushAgain = false;
+        if (disposed) break;
+        await publishLatest();
+      } while (flushAgain && !disposed);
+    })().finally(() => {
+      flushPromise = null;
+    });
+    return flushPromise;
+  }
+
+  function scheduleFlush(delayMs = ACTIVITY_STRIP_SEND_THROTTLE_MS) {
+    if (disposed || flushTimer) return;
     flushTimer = setTimeout(() => {
+      flushTimer = null;
       flush().catch(() => {});
     }, delayMs);
+    flushTimer.unref?.();
   }
 
   function startHeartbeat() {
@@ -95,6 +167,7 @@ export function createSessionTelemetry({ pi, cwd = process.cwd(), sessionName =
       ...snapshot,
       ...partial,
       updatedAt: now(),
+      lastEventAt: now(),
     };
     scheduleFlush();
   }
@@ -107,8 +180,15 @@ export function createSessionTelemetry({ pi, cwd = process.cwd(), sessionName =
     async onSessionStart(ctx) {
       const exactSessionId = String(ctx?.sessionManager?.getSessionId?.() ?? "").trim();
       const nextCwd = ctx?.cwd ?? snapshot.cwd;
+      const terminalIdentity = resolveTerminalIdentity({
+        env,
+        hasUI: Boolean(ctx?.hasUI),
+        stdinIsTTY,
+        processId: process.pid,
+      });
       update({
         ...(exactSessionId ? { sessionId: exactSessionId } : {}),
+        ...terminalIdentity,
         cwd: nextCwd,
         sessionName: pi?.getSessionName?.() ?? snapshot.sessionName,
         detail: previewPath(nextCwd, 72) || "Ready",
@@ -185,8 +265,32 @@ export function createSessionTelemetry({ pi, cwd = process.cwd(), sessionName =
         toolName,
       });
     },
-    onTurnEnd() {
+    /** @param {TurnEndEventLike} event */
+    onTurnEnd(event) {
       if (!snapshot.agentActive) return;
+      const rawMessage = event?.message;
+      const message =
+        rawMessage && typeof rawMessage === "object"
+          ? /** @type {Record<string, unknown>} */ (rawMessage)
+          : null;
+      const stopReason = String(message?.stopReason ?? "");
+      if (stopReason) lastStopReason = stopReason;
+      if (stopReason === "error") {
+        const errorText = previewText(message?.errorMessage, 104) || "Provider error";
+        update({
+          state: "error",
+          phase: "Needs attention",
+          detail: errorText,
+          errorMessage: errorText,
+        });
+        return;
+      }
+      if (stopReason === "aborted") {
+        update({
+          detail: snapshot.assistantPreview || snapshot.detail || "Stopped",
+        });
+        return;
+      }
       update({
         state: snapshot.errorMessage ? "error" : "thinking",
         phase: snapshot.errorMessage ? "Needs attention" : "Thinking",
@@ -196,11 +300,12 @@ export function createSessionTelemetry({ pi, cwd = process.cwd(), sessionName =
     onAgentSettled() {
       const detail =
         snapshot.errorMessage || snapshot.assistantPreview || snapshot.lastPromptPreview || "Done";
+      const aborted = !snapshot.errorMessage && lastStopReason === "aborted";
       update({
         agentActive: false,
         agentStartedAt: null,
         state: snapshot.errorMessage ? "error" : "success",
-        phase: snapshot.errorMessage ? "Stopped" : "Done",
+        phase: snapshot.errorMessage ? "Stopped" : aborted ? "Stopped" : "Done",
         detail,
         toolName: "",
         toolTarget: "",
@@ -209,12 +314,17 @@ export function createSessionTelemetry({ pi, cwd = process.cwd(), sessionName =
     async shutdown() {
       disposed = true;
       stopHeartbeat();
-      if (flushTimer) {
-        clearTimeout(flushTimer);
-        flushTimer = null;
+      clearScheduledFlush();
+      try {
+        await flushPromise;
+      } catch {
+        // Broker absence remains non-fatal; publisher removal is still attempted below.
       }
       try {
-        await removeSession(snapshot.sessionId);
+        await removePublisher({
+          sessionId: snapshot.sessionId,
+          publisherId: snapshot.publisherId,
+        });
       } catch {
         // ignore broker absence on shutdown
       }

package/src/common/activity-order.mjs

@@ -6,6 +6,11 @@
 
 const ACTIVE_STATES = new Set(["thinking", "tool", "waiting"]);
 
+/** @param {{cardId?: string; sessionId?: string}} session */
+export function activityCardKey(session) {
+  return String(session?.cardId ?? session?.sessionId ?? "");
+}
+
 /** @param {{ state?: string; agentActive?: boolean }} session */
 export function isActiveSession(session) {
   return Boolean(session?.agentActive || ACTIVE_STATES.has(String(session?.state ?? "")));
@@ -24,18 +29,19 @@ export function isMonitoringSession(session) {
  * Reconcile at the calm clock: green settled/monitoring cards first, then active cards,
  * then other inactive cards. Preserve previous/manual order inside each group and append
  * new cards deterministically.
- * @param {Array<{ sessionId: string; state?: string; agentActive?: boolean; toolName?: string; toolTarget?: string; updatedAt?: number }>} sessions
+ * @param {Array<{ sessionId: string; cardId?: string; state?: string; agentActive?: boolean; toolName?: string; toolTarget?: string; updatedAt?: number }>} sessions
  * @param {string[]} previousOrder
  * @param {{ regroup?: boolean }} [options]
  */
 export function reconcileActivityOrder(sessions, previousOrder = [], { regroup = true } = {}) {
-  const byId = new Map(sessions.map((session) => [session.sessionId, session]));
+  const byId = new Map(sessions.map((session) => [activityCardKey(session), session]));
   const surviving = previousOrder.filter((id) => byId.has(id));
   const known = new Set(surviving);
   for (const session of sessions) {
-    if (!session.sessionId || known.has(session.sessionId)) continue;
-    surviving.push(session.sessionId);
-    known.add(session.sessionId);
+    const id = activityCardKey(session);
+    if (!id || known.has(id)) continue;
+    surviving.push(id);
+    known.add(id);
   }
   if (!regroup) return surviving;
 
@@ -45,16 +51,16 @@ export function reconcileActivityOrder(sessions, previousOrder = [], { regroup =
     const rightPriority = isMonitoringSession(right) ? 2 : isActiveSession(right) ? 1 : 0;
     const groupDelta = rightPriority - leftPriority;
     if (groupDelta) return groupDelta;
-    const leftPrior = priorIndex.get(left.sessionId);
-    const rightPrior = priorIndex.get(right.sessionId);
+    const leftPrior = priorIndex.get(activityCardKey(left));
+    const rightPrior = priorIndex.get(activityCardKey(right));
     if (leftPrior != null || rightPrior != null) {
       return (leftPrior ?? Number.MAX_SAFE_INTEGER) - (rightPrior ?? Number.MAX_SAFE_INTEGER);
     }
     const updateDelta = Number(right.updatedAt ?? 0) - Number(left.updatedAt ?? 0);
     if (updateDelta) return updateDelta;
-    return left.sessionId.localeCompare(right.sessionId);
+    return activityCardKey(left).localeCompare(activityCardKey(right));
   });
-  return ordered.map((session) => session.sessionId).filter((id) => byId.has(id));
+  return ordered.map(activityCardKey).filter((id) => byId.has(id));
 }
 
 /** @param {string[]} order @param {string} sessionId @param {-1 | 1} delta */

package/src/common/alignment-controller.mjs

@@ -1,35 +1,9 @@
 // ---
-// summary: "coalesces native-window alignment so stale async work cannot overwrite newer geometry"
+// summary: "coalesces asynchronous reconciliation so stale work cannot publish over newer state"
 // read_when:
-//   - "changing Electron/Niri geometry reconciliation or testing rapid expansion transitions"
+//   - "changing latest-only native workspace reconciliation"
 // ---
 
-/**
- * @param {{ is_floating?: boolean, layout?: { tile_pos_in_workspace_view?: unknown } } | null | undefined} window
- */
-export function hasNiriFloatingPosition(window) {
-  const position = window?.layout?.tile_pos_in_workspace_view;
-  return window?.is_floating === true && Array.isArray(position) && position.length >= 2;
-}
-
-/**
- * @param {{ is_floating?: boolean, layout?: { tile_pos_in_workspace_view?: unknown, window_size?: unknown } } | null | undefined} window
- * @param {{x: number, y: number, width: number, height: number}} target
- */
-export function isNiriWindowAligned(window, target) {
-  if (!hasNiriFloatingPosition(window)) return false;
-  const position = window?.layout?.tile_pos_in_workspace_view;
-  const size = window?.layout?.window_size;
-  return Boolean(
-    Array.isArray(position) &&
-      Array.isArray(size) &&
-      Number(size[0]) === target.width &&
-      Number(size[1]) === target.height &&
-      Math.abs(Number(position[0]) - target.x) < 1 &&
-      Math.abs(Number(position[1]) - target.y) < 1,
-  );
-}
-
 /**
  * @param {(attempt: { generation: number, isCurrent: () => boolean }) => Promise<void>} run
  */
@@ -37,34 +11,42 @@ export function createLatestOnlyRunner(run) {
   if (typeof run !== "function") throw new TypeError("run must be a function");
 
   let requestedGeneration = 0;
+  let completedGeneration = 0;
   /** @type {Promise<void> | null} */
   let worker = null;
 
+  function ensureWorker() {
+    if (!worker) worker = drain();
+  }
+
   async function drain() {
-    while (true) {
-      const generation = requestedGeneration;
-      const isCurrent = () => generation === requestedGeneration;
-      try {
-        await run({ generation, isCurrent });
-      } catch {
-        // Alignment is best effort. A newer request must still be allowed to reconcile the window.
+    try {
+      while (completedGeneration < requestedGeneration) {
+        const generation = requestedGeneration;
+        const isCurrent = () => generation === requestedGeneration;
+        try {
+          await run({ generation, isCurrent });
+        } catch {
+          // Alignment is best effort. A newer request must still be allowed to reconcile the window.
+        }
+        completedGeneration = generation;
       }
-      if (isCurrent()) return;
+    } finally {
+      worker = null;
+      // A request can arrive after the loop condition was checked but before this finally block.
+      // Hand it to a successor synchronously so no requested generation is lost.
+      if (completedGeneration < requestedGeneration) ensureWorker();
     }
   }
 
   function request() {
     requestedGeneration += 1;
-    if (!worker) {
-      worker = drain().finally(() => {
-        worker = null;
-      });
-    }
+    ensureWorker();
     return requestedGeneration;
   }
 
   async function waitForIdle() {
-    await worker;
+    while (worker) await worker;
   }
 
   return {

package/src/common/card-display.mjs

@@ -0,0 +1,53 @@
+// ---
+// summary: "derives card display facts that depend on more than one session field"
+// read_when:
+//   - "changing stalled-session detection, duplicate label disambiguation, or card label rendering"
+// ---
+
+/**
+ * A session is stalled when it claims to be mid-activity but no lifecycle
+ * event has arrived for longer than the stall threshold. Wedged streams keep
+ * heartbeating liveness, so only real event time can expose them.
+ * @param {Record<string, unknown>} session
+ * @param {number} nowMs
+ * @param {number} stallMs
+ */
+export function isStalledSession(session, nowMs, stallMs) {
+  if (!session.agentActive) return false;
+  const state = String(session.state ?? "");
+  if (state !== "thinking" && state !== "tool" && state !== "waiting") return false;
+  const anchor = Number(session.lastEventAt || session.updatedAt || 0);
+  return anchor > 0 && nowMs - anchor > stallMs;
+}
+
+/**
+ * @param {Array<Record<string, unknown>>} sessions
+ * @returns {Set<string>}
+ */
+export function findDuplicateLabels(sessions) {
+  const counts = new Map();
+  for (const session of sessions) {
+    const label = String(session.repoLabel || "pi session");
+    counts.set(label, (counts.get(label) || 0) + 1);
+  }
+  return new Set([...counts.entries()].filter(([, count]) => count > 1).map(([label]) => label));
+}
+
+/**
+ * Two live processes can share one repo label; append a short process suffix
+ * so their cards stay distinguishable at a glance.
+ * @param {Record<string, unknown>} session
+ * @param {Set<string>} duplicateLabels
+ */
+export function disambiguatedRepoLabel(session, duplicateLabels) {
+  const label = String(session.repoLabel || "pi session");
+  const processId = Number(session.processId ?? 0);
+  return duplicateLabels.has(label) && processId > 0
+    ? `${label} · ${String(processId).slice(-4)}`
+    : label;
+}
+
+/** @param {{hovered?: boolean; activeElement?: boolean; documentFocused?: boolean}} state */
+export function shouldRetainExpandedCard({ hovered, activeElement, documentFocused }) {
+  return Boolean(hovered || (documentFocused && activeElement));
+}

package/src/common/compatibility.mjs

@@ -1,12 +1,11 @@
 // ---
-// summary: "detects desktop and Electron prerequisites and formats actionable activity-strip compatibility reports"
+// summary: "detects native layer-shell prerequisites and formats actionable activity-strip compatibility reports"
 // read_when:
 //   - "changing host detection, compatibility blockers, warnings, or doctor output"
 // ---
 
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { locateElectron } from "./electron.mjs";
 
 const execFileAsync = promisify(execFile);
 
@@ -67,14 +66,17 @@ export async function detectDisplayCount(options = {}) {
 /**
  * @param {{
  *   env?: NodeJS.ProcessEnv;
- *   locateElectronImpl?: typeof locateElectron;
  *   execFileAsyncImpl?: typeof execFileAsync;
+ *   platform?: NodeJS.Platform;
+ *   arch?: string;
  * }} [options]
  * @returns {Promise<import("./contracts.ts").ActivityStripCompatibilityReport>}
  */
 export async function assessActivityStripCompatibility(options = {}) {
   const env = options.env || process.env;
-  const locateElectronImpl = options.locateElectronImpl || locateElectron;
+  const backend = "native";
+  const platform = options.platform ?? process.platform;
+  const arch = options.arch ?? process.arch;
   const displayServer = detectDisplayServer(env);
   const windowManager = detectWindowManager(env);
   const displayCount = await detectDisplayCount({
@@ -83,7 +85,6 @@ export async function assessActivityStripCompatibility(options = {}) {
   });
   const blockers = [];
   const warnings = [];
-  let electronPath = null;
 
   if (displayServer === "headless") {
     blockers.push(
@@ -97,10 +98,11 @@ export async function assessActivityStripCompatibility(options = {}) {
     );
   }
 
-  try {
-    electronPath = await locateElectronImpl();
-  } catch (error) {
-    blockers.push(error instanceof Error ? error.message : String(error));
+  if (displayServer !== "headless" && displayServer !== "wayland") {
+    blockers.push("The native Activity Strip panel requires a Wayland session.");
+  }
+  if (platform !== "linux" || arch !== "x64") {
+    blockers.push(`The packaged native panel requires Linux x64; detected ${platform} ${arch}.`);
   }
 
   if (displayCount && displayCount > 1) {
@@ -111,17 +113,17 @@ export async function assessActivityStripCompatibility(options = {}) {
 
   if (windowManager !== "niri") {
     warnings.push(
-      "Top-edge repair is optimized for Niri. Other window managers fall back to generic Electron bounds and may need manual adjustment.",
+      "Workspace-local projection is optimized for Niri; other layer-shell compositors show the global card view.",
     );
   }
 
   return {
     ok: blockers.length === 0,
+    backend,
     displayServer,
     windowManager: typeof windowManager === "string" ? windowManager : null,
-    electronPath,
     displayCount,
-    alignmentMode: windowManager === "niri" ? "niri" : "generic",
+    alignmentMode: "layer-shell",
     primaryDisplayOnly: true,
     clickThroughDefault: env.PI_ACTIVITY_STRIP_CLICK_THROUGH === "1",
     blockers,
@@ -137,7 +139,7 @@ export function formatCompatibilityReport(report) {
     `Compatibility: ${report.ok ? "compatible" : "blocked"}`,
     `Display server: ${report.displayServer}`,
     `Window manager: ${report.windowManager || "unknown"}`,
-    `Electron: ${report.electronPath || "not found"}`,
+    `Backend: ${report.backend}`,
     `Alignment mode: ${report.alignmentMode}`,
     `Primary-display only: ${report.primaryDisplayOnly ? "yes" : "no"}`,
     `Click-through mode: ${report.clickThroughDefault ? "enabled by environment" : "disabled (interactive default)"}`,

package/src/common/constants.mjs

@@ -1,5 +1,5 @@
 // ---
-// summary: "defines shared socket paths, window dimensions, timing thresholds, and Electron binary candidates"
+// summary: "defines shared broker paths, timing thresholds, and transport bounds"
 // read_when:
 //   - "tuning activity-strip runtime defaults or locating shared configuration values"
 // ---
@@ -8,38 +8,22 @@ import os from "node:os";
 import path from "node:path";
 
 export const ACTIVITY_STRIP_NAME = "pi-activity-strip";
-export const ACTIVITY_STRIP_SOCKET_DIR = path.join(
-  os.homedir(),
-  ".pi",
-  "agent",
-  "state",
-  ACTIVITY_STRIP_NAME,
-);
-export const ACTIVITY_STRIP_SOCKET_PATH = path.join(
-  ACTIVITY_STRIP_SOCKET_DIR,
-  "activity-strip.sock",
-);
-export const ACTIVITY_STRIP_WIDTH_PADDING = 16;
-export const ACTIVITY_STRIP_HEIGHT = 84;
-export const ACTIVITY_STRIP_EXPANDED_HEIGHT = 252;
+export const ACTIVITY_STRIP_SOCKET_DIR =
+  process.env.PI_ACTIVITY_STRIP_SOCKET_DIR?.trim() ||
+  path.join(os.homedir(), ".pi", "agent", "state", ACTIVITY_STRIP_NAME);
+export const ACTIVITY_STRIP_SOCKET_PATH =
+  process.env.PI_ACTIVITY_STRIP_SOCKET_PATH?.trim() ||
+  path.join(ACTIVITY_STRIP_SOCKET_DIR, "activity-strip.sock");
 export const ACTIVITY_STRIP_ORDER_REFRESH_MS = 15_000;
 export const ACTIVITY_STRIP_WORKSPACE_SYNC_MS = 1500;
-export const ACTIVITY_STRIP_NIRI_ANIMATION_SETTLE_MS = 450;
 export const ACTIVITY_STRIP_HEARTBEAT_MS = 2500;
 export const ACTIVITY_STRIP_STALE_AFTER_MS = 12000;
+export const ACTIVITY_STRIP_MAX_SESSIONS = 256;
+export const ACTIVITY_STRIP_MAX_MESSAGE_BYTES = 256 * 1024;
+export const ACTIVITY_STRIP_CLIENT_IDLE_TIMEOUT_MS = 2000;
 export const ACTIVITY_STRIP_BROADCAST_TICK_MS = 1000;
 export const ACTIVITY_STRIP_SEND_THROTTLE_MS = 120;
 export const ACTIVITY_STRIP_CONNECT_TIMEOUT_MS = 450;
 export const ACTIVITY_STRIP_START_TIMEOUT_MS = 5000;
-export const DEFAULT_ELECTRON_CANDIDATES = [
-  "electron",
-  "electron39",
-  "electron38",
-  "electron37",
-  "electron36",
-  "electron35",
-  "electron34",
-  "electron33",
-  "electron32",
-  "electron31",
-];
+export const ACTIVITY_STRIP_EVENT_STALL_MS = 15 * 60_000;
+export const ACTIVITY_STRIP_FLUSH_RETRY_DELAYS_MS = [250, 750];