@tryinget/pi-activity-strip 0.5.0 → 0.7.0

package/src/common/contracts.ts

@@ -19,6 +19,15 @@ export interface SessionSnapshot {
   publisherCount?: number;
   publisherIds?: string[];
   publisherRecordKeys?: string[];
+  publisherSessionIds?: string[];
+  akTasks?: AkTaskChip[];
+  akTaskOverflow?: number;
+  /** Niri window id; for a hidden tab, the window hosting it. */
+  windowId?: number | null;
+  /** Niri workspace `idx`, the number the operator sees, never the internal workspace id. */
+  workspaceIdx?: number | null;
+  placement?: "title" | "host" | "binding";
+  surfaceVisible?: boolean;
   cwd: string;
   repoLabel: string;
   sessionName: string;
@@ -38,6 +47,32 @@ export interface SessionSnapshot {
   errorMessage: string;
 }
 
+export type AkTaskChipState = "active" | "deferred" | "orphaned";
+
+/** One read-only AK task reference joined onto a terminal card by the native projection. */
+export interface AkTaskChip {
+  id: number;
+  title: string;
+  state: AkTaskChipState;
+}
+
+/** A live-lease task claim parsed from read-only `ak task list` output. */
+export interface AkTaskClaim {
+  id: number;
+  title: string;
+  repo: string;
+  sessionId: string;
+  leaseExpiresAt: number;
+  claimedAt: number;
+}
+
+/** A task with an active deferral parsed from read-only `ak task deferred` output. */
+export interface AkTaskDeferred {
+  id: number;
+  title: string;
+  repo: string;
+}
+
 export interface BrokerSnapshot {
   generatedAt: number;
   sessions: SessionSnapshot[];
@@ -57,6 +92,30 @@ export interface ActivityStripRuntimeStatus {
   alignmentMode?: "layer-shell";
   rendererCardCount?: number;
   rendererCardIds?: string[];
+  rendererHiddenTabCardCount?: number;
+  surfaceBindingCount?: number;
+  unplacedSurfaceCount?: number;
+  agentTabCount?: number;
+  themeScheme?: "dark" | "light" | "unknown";
+  themeName?: string | null;
+  themeSource?: string | null;
+  themeFingerprint?: string;
+  themeError?: string;
+  agentScanError?: string | null;
+  heightRepairState?: "enabled" | "disabled";
+  heightRepairCount?: number;
+  lastHeightRepairAt?: number;
+  tabInventoryState?: "pending" | "ready" | "failed" | "unavailable" | "disabled";
+  tabInventoryDetail?: string | null;
+  tabInventoryFrameCount?: number;
+  tabInventoryTabCount?: number;
+  tabInventoryProbedAt?: number | null;
+  akTaskState?: "pending" | "ok" | "unavailable" | "disabled";
+  akTaskError?: string | null;
+  akTaskClaimCount?: number;
+  akTaskDeferredCount?: number;
+  akTaskOrphanCount?: number;
+  akTaskRenderedCount?: number;
   rendererVisibilityTransitionCount?: number;
   controllerPid?: number;
   panelPid?: number | null;
@@ -98,7 +157,13 @@ export interface ActivityStripBrokerOptions {
     remove(sessionId: string, publisherId?: string): boolean;
   };
   getRuntimeStatus?: () => ActivityStripRuntimeStatus | undefined;
-  focusSession?: (targetId: string) => Promise<{ ok: boolean; error?: string; windowId?: number }>;
+  focusSession?: (targetId: string) => Promise<{
+    ok: boolean;
+    error?: string;
+    windowId?: number;
+    presented?: boolean;
+    verified?: boolean;
+  }>;
   focusStrip?: () => Promise<{ ok: boolean; error?: string }>;
 }
 
@@ -196,6 +261,7 @@ export interface ActivityStripCompatibilityReport {
   alignmentMode: "layer-shell";
   primaryDisplayOnly: boolean;
   clickThroughDefault: boolean;
+  tabInventory?: { available: boolean; detail: string };
   blockers: string[];
   warnings: string[];
 }

package/src/common/ghostty-present.mjs

@@ -0,0 +1,100 @@
+// ---
+// summary: "presents one Ghostty surface through the running process's session-bus present-surface action"
+// read_when:
+//   - "changing hidden-tab activation, Ghostty D-Bus targeting, or its fail-closed conditions"
+// ---
+
+import { normalizeGhosttySurfaceId } from "./terminal-identity.mjs";
+
+const GHOSTTY_OBJECT_PATHS = new Map([
+  ["main", "/com/mitchellh/ghostty"],
+  ["legacy", "/com/tryinget/ghosttysidequest"],
+]);
+export const GHOSTTY_PRESENT_SURFACE_TIMEOUT_MS = 2000;
+
+/** @typedef {(file: string, args: string[], options: object) => Promise<{stdout?: string}>} ExecFileAsync */
+/** @typedef {{ok: true; busName: string} | {ok: false; error: string}} PresentSurfaceResult */
+
+/** @param {unknown} family */
+export function ghosttyObjectPathForFamily(family) {
+  return GHOSTTY_OBJECT_PATHS.get(String(family ?? "")) ?? "";
+}
+
+/**
+ * Every running Ghostty process, single-instance server or standalone window, exports
+ * `org.gtk.Actions` on its unique bus name. `present-surface` selects the tab owning the surface
+ * and presents its window; a surface id the process does not own is ignored by Ghostty itself.
+ * The target is the exact host process already proven to contain the surface, never a
+ * well-known name that another build could claim.
+ * @param {{execFileAsync: ExecFileAsync; env?: NodeJS.ProcessEnv; hostPid: number; terminalFamily: unknown; surfaceId: unknown; timeout?: number}} options
+ * @returns {Promise<PresentSurfaceResult>}
+ */
+export async function presentGhosttySurface({
+  execFileAsync,
+  env = process.env,
+  hostPid,
+  terminalFamily,
+  surfaceId,
+  timeout = GHOSTTY_PRESENT_SURFACE_TIMEOUT_MS,
+}) {
+  const objectPath = ghosttyObjectPathForFamily(terminalFamily);
+  const normalizedSurfaceId = normalizeGhosttySurfaceId(surfaceId);
+  if (
+    !objectPath ||
+    !normalizedSurfaceId ||
+    normalizedSurfaceId === "0" ||
+    !Number.isInteger(hostPid) ||
+    hostPid <= 0
+  ) {
+    return { ok: false, error: "the surface target is incomplete" };
+  }
+
+  let rows;
+  try {
+    const { stdout } = await execFileAsync(
+      "busctl",
+      ["--user", "list", "--no-pager", "--no-legend"],
+      { env, timeout },
+    );
+    rows = String(stdout ?? "")
+      .split("\n")
+      .map((line) => line.trim().split(/\s+/));
+  } catch {
+    return { ok: false, error: "the session bus is unavailable" };
+  }
+  const uniqueNames = rows
+    .filter(
+      (fields) => fields[0]?.startsWith(":") && Number.parseInt(fields[1] ?? "", 10) === hostPid,
+    )
+    .map((fields) => String(fields[0]));
+  if (uniqueNames.length === 0) {
+    return { ok: false, error: "the Ghostty process is not on the session bus" };
+  }
+  if (uniqueNames.length > 1) {
+    return { ok: false, error: "the Ghostty process owns several bus connections" };
+  }
+
+  try {
+    await execFileAsync(
+      "busctl",
+      [
+        "--user",
+        "call",
+        uniqueNames[0],
+        objectPath,
+        "org.gtk.Actions",
+        "Activate",
+        "sava{sv}",
+        "present-surface",
+        "1",
+        "t",
+        normalizedSurfaceId,
+        "0",
+      ],
+      { env, timeout },
+    );
+    return { ok: true, busName: uniqueNames[0] };
+  } catch {
+    return { ok: false, error: "Ghostty rejected present-surface" };
+  }
+}

package/src/common/ghostty-theme.mjs

@@ -0,0 +1,149 @@
+// ---
+// summary: "resolves the colours Ghostty is currently using into the ribbon's palette"
+// read_when:
+//   - "changing how the ribbon follows the Ghostty theme or the day/night switch"
+// ---
+
+/**
+ * Ghostty writes its palette as `key = value` lines, in its config and in each theme file. A theme
+ * setting may name one theme, or one per colour scheme as `light:Name,dark:Name`. The ribbon reads
+ * the same files the terminal does, so the two always agree without any configuration of its own.
+ */
+
+const HEX_COLOR = /^#?([0-9a-f]{3}|[0-9a-f]{6})$/i;
+export const PALETTE_SIZE = 16;
+
+/** @typedef {{background: string; foreground: string; accent: string; thinking: string; tool: string; waiting: string; success: string; error: string}} RibbonPalette */
+
+/** Everforest-neutral defaults, used only when no theme can be read. */
+/** @type {RibbonPalette} */
+export const FALLBACK_PALETTE = Object.freeze({
+  background: "#1e2326",
+  foreground: "#d3c6aa",
+  accent: "#7fbbb3",
+  thinking: "#7fbbb3",
+  tool: "#dbbc7f",
+  waiting: "#e69875",
+  success: "#a7c080",
+  error: "#e67e80",
+});
+
+/** @param {unknown} value */
+export function normalizeHexColor(value) {
+  const raw = String(value ?? "").trim();
+  if (!HEX_COLOR.test(raw)) return "";
+  const body = raw.replace(/^#/, "").toLowerCase();
+  const full =
+    body.length === 3
+      ? body
+          .split("")
+          .map((character) => character + character)
+          .join("")
+      : body;
+  return `#${full}`;
+}
+
+/**
+ * Read every `key = value` pair, ignoring comments and blank lines. Repeated keys are kept in
+ * order, because `palette` appears once per colour index.
+ * @param {string} text
+ */
+export function parseGhosttyConfig(text) {
+  /** @type {Map<string, string[]>} */
+  const entries = new Map();
+  for (const line of String(text ?? "").split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const separator = trimmed.indexOf("=");
+    if (separator <= 0) continue;
+    const key = trimmed.slice(0, separator).trim().toLowerCase();
+    const value = trimmed.slice(separator + 1).trim();
+    entries.set(key, [...(entries.get(key) ?? []), value]);
+  }
+  return entries;
+}
+
+/**
+ * Names of the themes a config selects. `light:A,dark:B` follows the desktop's colour scheme; a
+ * bare name is used for both.
+ * @param {string} value
+ * @returns {{light: string; dark: string}}
+ */
+export function parseThemeSetting(value) {
+  const raw = String(value ?? "").trim();
+  if (!raw) return { light: "", dark: "" };
+  if (!/(^|,)\s*(light|dark)\s*:/i.test(raw)) return { light: raw, dark: raw };
+  const themes = { light: "", dark: "" };
+  for (const part of raw.split(",")) {
+    const match = part.match(/^\s*(light|dark)\s*:\s*(.+?)\s*$/i);
+    if (match) themes[match[1].toLowerCase() === "dark" ? "dark" : "light"] = match[2];
+  }
+  return themes;
+}
+
+/**
+ * Colours from a theme file or a config that carries them inline.
+ * @param {string} text
+ */
+export function parseGhosttyTheme(text) {
+  const entries = parseGhosttyConfig(text);
+  /** @type {string[]} */
+  const palette = new Array(PALETTE_SIZE).fill("");
+  for (const value of entries.get("palette") ?? []) {
+    const match = String(value).match(/^\s*(\d+)\s*=\s*(.+?)\s*$/);
+    if (!match) continue;
+    const index = Number.parseInt(match[1], 10);
+    const color = normalizeHexColor(match[2]);
+    if (Number.isInteger(index) && index >= 0 && index < PALETTE_SIZE && color) {
+      palette[index] = color;
+    }
+  }
+  /** @param {string} key */
+  const single = (key) => normalizeHexColor((entries.get(key) ?? []).at(-1));
+  return {
+    background: single("background"),
+    foreground: single("foreground"),
+    cursor: single("cursor-color"),
+    selectionBackground: single("selection-background"),
+    palette,
+  };
+}
+
+/** @param {ReturnType<typeof parseGhosttyTheme>} theme @param {number} index @param {string} fallback */
+function paletteColor(theme, index, fallback) {
+  return theme?.palette?.[index] || fallback;
+}
+
+/**
+ * Map terminal colours onto the ribbon's roles. State colours reuse the terminal's own semantics,
+ * so a card reads the same way as output in the tab it points at: green settled, yellow working,
+ * red failed, and the cursor colour for a session that wants the operator.
+ * @param {ReturnType<typeof parseGhosttyTheme> | null} theme
+ * @returns {RibbonPalette}
+ */
+export function buildRibbonPalette(theme) {
+  if (!theme?.background || !theme?.foreground) return { ...FALLBACK_PALETTE };
+  const blue = paletteColor(theme, 4, FALLBACK_PALETTE.thinking);
+  return {
+    background: theme.background,
+    foreground: theme.foreground,
+    accent: blue,
+    thinking: blue,
+    tool: paletteColor(theme, 3, FALLBACK_PALETTE.tool),
+    waiting: theme.cursor || paletteColor(theme, 5, FALLBACK_PALETTE.waiting),
+    success: paletteColor(theme, 2, FALLBACK_PALETTE.success),
+    error: paletteColor(theme, 1, FALLBACK_PALETTE.error),
+  };
+}
+
+/**
+ * The GTK colour definitions the panel prepends to its stylesheet. Everything else the ribbon
+ * draws is derived from these in CSS, so a theme change is a handful of values.
+ * @param {RibbonPalette} palette
+ */
+export function paletteDefinitions(palette) {
+  const colors = { ...FALLBACK_PALETTE, ...(palette ?? {}) };
+  return Object.entries(colors)
+    .map(([name, value]) => `@define-color pi_${name} ${normalizeHexColor(value) || "#000000"};`)
+    .join("\n");
+}