@tryinget/pi-activity-strip 0.4.0 → 0.6.0

package/src/native/codex-discovery.mjs

@@ -0,0 +1,128 @@
+// ---
+// summary: "binds a running Codex process to its session thread and rollout file"
+// read_when:
+//   - "changing Codex session identification or its thread-index reader"
+// ---
+
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+
+const requireBuiltin = createRequire(import.meta.url);
+
+/**
+ * Codex keeps an index of its sessions in a versioned SQLite database under its home, one row per
+ * thread with the rollout path, working directory and title. It only opens the rollout once a task
+ * runs, so the index is what links a live process to its session before any work starts.
+ */
+
+export const CODEX_STATE_DB = /^state_(\d+)\.sqlite$/;
+export const CODEX_THREAD_LIMIT = 400;
+/** A thread is created moments after its process starts; allow for clock and rounding slack. */
+export const CODEX_THREAD_START_SLACK_MS = 5000;
+
+/** @typedef {{id: string; rolloutPath: string; cwd: string; title: string; createdAtMs: number; updatedAtMs: number}} CodexThread */
+
+/**
+ * Newest thread-index database in a Codex home. The suffix is a schema version, so the highest one
+ * is current; a home with none yields "".
+ * @param {string} codexHome
+ * @param {Pick<typeof fs, "readdirSync">} [fsImpl]
+ */
+export function resolveCodexStateDb(codexHome, fsImpl = fs) {
+  let best = { version: -1, file: "" };
+  let entries = [];
+  try {
+    entries = fsImpl.readdirSync(codexHome);
+  } catch {
+    return "";
+  }
+  for (const entry of entries) {
+    const match = CODEX_STATE_DB.exec(entry);
+    if (!match) continue;
+    const version = Number.parseInt(match[1] ?? "", 10);
+    if (Number.isInteger(version) && version > best.version) best = { version, file: entry };
+  }
+  return best.file ? path.join(codexHome, best.file) : "";
+}
+
+/**
+ * Read the thread index. The database belongs to a running application, so it is opened read-only
+ * and every failure — a missing file, a locked database, or a runtime without `node:sqlite` —
+ * yields an empty index rather than an error.
+ * @param {string} databasePath
+ * @returns {CodexThread[]}
+ */
+export function readCodexThreads(databasePath) {
+  if (!databasePath) return [];
+  try {
+    // Loaded here so a runtime without the built-in SQLite module simply reports no threads.
+    const { DatabaseSync } = requireBuiltin("node:sqlite");
+    const db = new DatabaseSync(databasePath, { readOnly: true });
+    try {
+      const rows = db
+        .prepare(
+          "SELECT id, rollout_path, cwd, title, created_at_ms, updated_at_ms FROM threads WHERE archived = 0 ORDER BY created_at_ms DESC LIMIT ?",
+        )
+        .all(CODEX_THREAD_LIMIT);
+      return rows.map(
+        /** @param {any} row */ (row) => ({
+          id: String(row.id ?? ""),
+          rolloutPath: String(row.rollout_path ?? ""),
+          cwd: String(row.cwd ?? ""),
+          title: String(row.title ?? ""),
+          createdAtMs: Number(row.created_at_ms ?? 0),
+          updatedAtMs: Number(row.updated_at_ms ?? 0),
+        }),
+      );
+    } finally {
+      db.close();
+    }
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Bind one Codex process to its thread. An open rollout descriptor is exact proof and wins. With
+ * no descriptor, a thread qualifies only when it was created after the process started and in the
+ * same directory; anything ambiguous binds nothing rather than guessing.
+ * @param {{processId: number; cwd: string; startedAt: number; openPaths?: string[]}} process
+ * @param {CodexThread[]} threads
+ * @returns {CodexThread | null}
+ */
+export function bindCodexThread({ cwd, startedAt, openPaths = [] }, threads) {
+  const open = new Set(openPaths.filter(Boolean));
+  if (open.size > 0) {
+    const byRollout = threads.filter(
+      (thread) => thread.rolloutPath && open.has(thread.rolloutPath),
+    );
+    if (byRollout.length === 1) return byRollout[0];
+    if (byRollout.length > 1) return null;
+  }
+  const normalizedCwd = String(cwd ?? "").trim();
+  if (!normalizedCwd || !Number.isFinite(startedAt) || startedAt <= 0) return null;
+  const candidates = threads.filter(
+    (thread) =>
+      thread.cwd === normalizedCwd &&
+      thread.createdAtMs > 0 &&
+      thread.createdAtMs >= startedAt - CODEX_THREAD_START_SLACK_MS,
+  );
+  return candidates.length === 1 ? candidates[0] : null;
+}
+
+/**
+ * Rollout files a process currently holds open, which is exact evidence of the session it is
+ * running.
+ * @param {number} processId
+ * @param {{readDir: (path: string) => string[]; readLink: (path: string) => string}} procfs
+ */
+export function openRolloutPaths(processId, procfs) {
+  const fdDir = path.join("/proc", String(processId), "fd");
+  const paths = [];
+  for (const entry of procfs.readDir(fdDir)) {
+    const target = procfs.readLink(path.join(fdDir, entry));
+    if (target.includes("/sessions/") && target.endsWith(".jsonl")) paths.push(target);
+  }
+  return paths;
+}

package/src/native/ghostty-tab-inventory.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+# ---
+# summary: "enumerates Ghostty windows and their tab labels through AT-SPI for hidden-tab placement"
+# read_when:
+#   - "changing how the activity strip discovers tabs hidden behind another Ghostty tab"
+# ---
+"""Print one JSON document describing every AT-SPI frame of the given process ids.
+
+Usage: ghostty-tab-inventory.py <pid> [<pid> ...]
+
+Output: {"ok": true, "frames": [{"pid": int, "name": str, "tabs": [str, ...]}, ...]}
+Exit 3 with {"ok": false, "error": ...} when the AT-SPI Python bindings are unavailable.
+The script only reads accessibility state; it never activates, selects, or focuses anything.
+"""
+
+import json
+import sys
+
+MAX_NODES_PER_FRAME = 20000
+MAX_DEPTH = 40
+
+
+def main() -> int:
+    try:
+        import gi
+
+        gi.require_version("Atspi", "2.0")
+        from gi.repository import Atspi
+    except Exception as error:  # noqa: BLE001 - any import failure means the capability is absent
+        print(json.dumps({"ok": False, "error": f"AT-SPI bindings unavailable: {error}"}))
+        return 3
+
+    pids = {int(argument) for argument in sys.argv[1:] if argument.isdigit()}
+    if not pids:
+        print(json.dumps({"ok": True, "frames": []}))
+        return 0
+
+    def tab_labels(frame):
+        labels = []
+        stack = [(frame, 0)]
+        seen = 0
+        while stack and seen < MAX_NODES_PER_FRAME:
+            node, depth = stack.pop()
+            seen += 1
+            try:
+                role = node.get_role()
+            except Exception:  # noqa: BLE001 - a vanished node is skipped
+                continue
+            if role == Atspi.Role.PAGE_TAB:
+                try:
+                    labels.append(node.get_name() or "")
+                except Exception:  # noqa: BLE001
+                    pass
+                continue
+            if depth >= MAX_DEPTH:
+                continue
+            try:
+                count = node.get_child_count()
+            except Exception:  # noqa: BLE001
+                continue
+            for index in range(count):
+                try:
+                    child = node.get_child_at_index(index)
+                except Exception:  # noqa: BLE001
+                    continue
+                if child is not None:
+                    stack.append((child, depth + 1))
+        return labels
+
+    frames = []
+    desktop = Atspi.get_desktop(0)
+    for index in range(desktop.get_child_count()):
+        application = desktop.get_child_at_index(index)
+        if application is None:
+            continue
+        try:
+            pid = application.get_process_id()
+        except Exception:  # noqa: BLE001
+            continue
+        if pid not in pids:
+            continue
+        for window_index in range(application.get_child_count()):
+            frame = application.get_child_at_index(window_index)
+            if frame is None:
+                continue
+            try:
+                if frame.get_role() != Atspi.Role.FRAME:
+                    continue
+                name = frame.get_name() or ""
+            except Exception:  # noqa: BLE001
+                continue
+            frames.append({"pid": pid, "name": name, "tabs": tab_labels(frame)})
+
+    print(json.dumps({"ok": True, "frames": frames}))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/src/native/height-repair.mjs

@@ -0,0 +1,154 @@
+// ---
+// summary: "restores tiled windows stranded at the wrong height when the ribbon's exclusive zone appears or disappears"
+// read_when:
+//   - "changing height repair, its evidence rules, or its safety bounds"
+// ---
+
+export const HEIGHT_REPAIR_SETTLE_MS = 300;
+export const HEIGHT_REPAIR_MAX_PER_TRANSITION = 48;
+
+/** @typedef {{id?: unknown; is_floating?: unknown; layout?: {window_size?: number[]}}} NiriWindow */
+/** @typedef {{id: number; height: number}} StaleWindow */
+
+/** @param {NiriWindow} window */
+function tiledHeight(window) {
+  if (window?.is_floating === true) return 0;
+  const height = Number(window?.layout?.window_size?.[1] ?? 0);
+  return Number.isFinite(height) && height > 0 ? height : 0;
+}
+
+/** @param {NiriWindow[]} windows */
+function heightsById(windows) {
+  /** @type {Map<number, number>} */
+  const heights = new Map();
+  for (const window of windows ?? []) {
+    if (!Number.isInteger(window?.id)) continue;
+    const height = tiledHeight(window);
+    if (height > 0) heights.set(Number(window.id), height);
+  }
+  return heights;
+}
+
+/**
+ * Decide which windows the compositor left behind. Changing the exclusive zone changes the output
+ * working area, so every window whose height is automatic moves. A window that did not move while
+ * others did is only treated as stale when it still sits at a height those movers just vacated:
+ * that is positive evidence of the old working area, so a deliberately chosen height of any other
+ * value is never touched.
+ * @param {NiriWindow[]} before
+ * @param {NiriWindow[]} after
+ * @returns {StaleWindow[]}
+ */
+export function findStaleWindows(before, after) {
+  const previous = heightsById(before);
+  const current = heightsById(after);
+  /** @type {Set<number>} */
+  const vacated = new Set();
+  for (const [id, height] of current) {
+    const wasHeight = previous.get(id);
+    if (wasHeight !== undefined && wasHeight !== height) vacated.add(wasHeight);
+  }
+  if (vacated.size === 0) return [];
+
+  /** @type {StaleWindow[]} */
+  const stale = [];
+  for (const [id, height] of current) {
+    const wasHeight = previous.get(id);
+    if (wasHeight === undefined || wasHeight !== height) continue;
+    if (vacated.has(height)) stale.push({ id, height });
+  }
+  return stale.sort((left, right) => left.id - right.id);
+}
+
+/**
+ * @param {{
+ *   execFileAsync: (file: string, args: string[], options: object) => Promise<{stdout?: string}>;
+ *   env?: NodeJS.ProcessEnv;
+ *   runtimeStatus: import("../common/contracts.ts").ActivityStripRuntimeStatus;
+ *   readWindows: () => Promise<NiriWindow[]>;
+ *   sleep?: (milliseconds: number) => Promise<void>;
+ *   settleMs?: number;
+ * }} options
+ */
+export function createHeightRepair({
+  execFileAsync,
+  env = process.env,
+  runtimeStatus,
+  readWindows,
+  sleep = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
+  settleMs = HEIGHT_REPAIR_SETTLE_MS,
+}) {
+  const enabled = env.PI_ACTIVITY_STRIP_HEIGHT_REPAIR !== "0";
+  /** @type {NiriWindow[]} */
+  let lastWindows = [];
+  /** Windows already reset at a given height, so one pass can never loop on one window. */
+  /** @type {Set<string>} */
+  const repaired = new Set();
+  let inFlight = false;
+  runtimeStatus.heightRepairState = enabled ? "enabled" : "disabled";
+  runtimeStatus.heightRepairCount = 0;
+  runtimeStatus.lastHeightRepairAt = 0;
+
+  /** @param {NiriWindow[]} windows */
+  function observe(windows) {
+    if (!Array.isArray(windows) || windows.length === 0) return;
+    // A window seen at a height other than the one it was reset at has moved since, so a future
+    // stranding there is a new event and must not be suppressed by the earlier repair.
+    for (const window of windows) {
+      if (!Number.isInteger(window?.id)) continue;
+      const height = tiledHeight(window);
+      if (height <= 0) continue;
+      for (const key of repaired) {
+        const [id, at] = key.split(":");
+        if (Number(id) === Number(window.id) && Number(at) !== height) repaired.delete(key);
+      }
+    }
+    lastWindows = windows;
+  }
+
+  /**
+   * Run after the panel reports that it applied a visibility change, which is the only moment the
+   * exclusive zone changes. One pass at a time; a pass never retries a window it already reset.
+   */
+  async function repairAfterZoneChange() {
+    if (!enabled || inFlight) return [];
+    const before = lastWindows;
+    if (before.length === 0) return [];
+    inFlight = true;
+    try {
+      await sleep(settleMs);
+      const after = await readWindows();
+      if (after.length === 0) return [];
+      lastWindows = after;
+      const stale = findStaleWindows(before, after).filter(
+        (window) => !repaired.has(`${window.id}:${window.height}`),
+      );
+      const bounded = stale.slice(0, HEIGHT_REPAIR_MAX_PER_TRANSITION);
+      /** @type {number[]} */
+      const applied = [];
+      for (const window of bounded) {
+        try {
+          await execFileAsync(
+            "niri",
+            ["msg", "action", "reset-window-height", "--id", String(window.id)],
+            { env },
+          );
+          repaired.add(`${window.id}:${window.height}`);
+          applied.push(window.id);
+        } catch {
+          // A window that closed mid-pass, or a rejected action, is left to the next transition.
+        }
+      }
+      if (applied.length > 0) {
+        runtimeStatus.heightRepairCount =
+          Number(runtimeStatus.heightRepairCount ?? 0) + applied.length;
+        runtimeStatus.lastHeightRepairAt = Date.now();
+      }
+      return applied;
+    } finally {
+      inFlight = false;
+    }
+  }
+
+  return { observe, repairAfterZoneChange, enabled };
+}