@tryinget/pi-activity-strip 0.9.0 → 0.10.0

package/src/native/panel-binary.mjs

@@ -8,6 +8,7 @@ import { createHash } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { PANEL_PROTOCOL } from "./panel-protocol.mjs";
 
 const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
 
@@ -15,13 +16,24 @@ const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "
 export function resolvePanelBinary(env) {
   const override = env.PI_ACTIVITY_STRIP_NATIVE_PANEL_BIN?.trim();
   const allowUnverified = env.PI_ACTIVITY_STRIP_ALLOW_UNVERIFIED_PANEL === "1";
-  const candidates = [
-    ...(override ? [override] : []),
-    path.join(packageRoot, "native", "bin", "linux-x64-gnu", "pi-activity-strip-panel"),
-    ...(allowUnverified
-      ? [path.join(packageRoot, "native", "panel", "target", "release", "pi-activity-strip-panel")]
-      : []),
-  ].filter(Boolean);
+  // An explicit selection is binding: losing it must not silently choose another build.
+  const candidates = override
+    ? [override]
+    : [
+        path.join(packageRoot, "native", "bin", "linux-x64-gnu", "pi-activity-strip-panel"),
+        ...(allowUnverified
+          ? [
+              path.join(
+                packageRoot,
+                "native",
+                "panel",
+                "target",
+                "release",
+                "pi-activity-strip-panel",
+              ),
+            ]
+          : []),
+      ];
   const binary = candidates.find((candidate) => {
     try {
       fs.accessSync(candidate, fs.constants.X_OK);
@@ -33,7 +45,6 @@ export function resolvePanelBinary(env) {
   if (!binary) {
     throw new Error(`Native panel binary is unavailable. Checked: ${candidates.join(", ")}`);
   }
-  if (allowUnverified) return binary;
   if (process.platform !== "linux" || process.arch !== "x64") {
     throw new Error(`Native panel requires Linux x64, got ${process.platform} ${process.arch}.`);
   }
@@ -44,6 +55,12 @@ export function resolvePanelBinary(env) {
   } catch {
     throw new Error(`Native panel receipt is unavailable: ${artifactPath}`);
   }
+  if (artifact.panelProtocol !== PANEL_PROTOCOL) {
+    throw new Error(
+      `Native panel private protocol mismatch in receipt: expected ${PANEL_PROTOCOL}, received ${String(artifact.panelProtocol)} (${artifactPath}). Rebuild/use a matching panel.`,
+    );
+  }
+  if (allowUnverified) return binary;
   const digest = createHash("sha256").update(fs.readFileSync(binary)).digest("hex");
   if (
     artifact.schema !== "pi-activity-strip-native-artifact.v1" ||

package/src/native/panel-neutral-source.mjs

@@ -0,0 +1,53 @@
+// ---
+// summary: "pins and rechecks the exact presence-app window behind neutral keyboard authorization"
+// read_when:
+//   - "changing neutral-source lifetime across panel NULL focus or delayed jumps"
+// ---
+
+import { classifyAdmittedWindowFocus } from "../common/workspace-view.mjs";
+import { sourceIdentity } from "./interaction-context.mjs";
+
+/** A presence app is a source window, not a card. Copy its process/app facts at admission so a
+ * fallback refresh cannot silently transfer an existing grant to a reused or relocated window.
+ * Niri reports `pid: null` for a client whose process it does not know; that null is pinned like a
+ * number, so the window keeps its presence and a pid that later differs still revokes it.
+ * @param {(id: number) => Record<string, unknown> | null} getWindowFacts
+ * @param {NodeJS.ProcessEnv} env
+ */
+export function createNeutralSource(getWindowFacts, env) {
+  /** @type {Record<string, unknown> | null} */
+  let source = null;
+  return {
+    /** @param {Record<string, unknown> | null} facts */
+    admit(facts) {
+      source = facts ? { ...facts } : null;
+    },
+    clear() {
+      source = null;
+    },
+    /** @param {unknown} workspaceId @param {number | null} windowId
+     * @param {Record<string, unknown>[]} sessions */
+    holds(workspaceId, windowId, sessions) {
+      if (!source || windowId === null) return false;
+      const current = getWindowFacts(windowId);
+      return (
+        source.id === windowId &&
+        source.workspace_id === workspaceId &&
+        (source.pid === null || Number.isInteger(source.pid)) &&
+        current?.id === windowId &&
+        current.workspace_id === workspaceId &&
+        current.pid === source.pid &&
+        current.app_id === source.app_id &&
+        classifyAdmittedWindowFocus(windowId, sessions, current, env) === "neutral"
+      );
+    },
+    /** @param {unknown} workspaceId @param {number | null} windowId */
+    context(workspaceId, windowId) {
+      return JSON.stringify([
+        sourceIdentity(workspaceId, windowId, undefined),
+        source?.pid,
+        source?.app_id,
+      ]);
+    },
+  };
+}

package/src/native/panel-presentation.mjs

@@ -0,0 +1,137 @@
+// ---
+// summary: "keeps an already-visible ribbon mapped across a proven eligible handoff, without input authority"
+// read_when:
+//   - "Changing passive presentation during selected-window / seat-focus event ordering."
+// ---
+import { projectSessionCards } from "../common/session-cards.mjs";
+import { classifyAdmittedWindowFocus } from "../common/workspace-view.mjs";
+import {
+  publisherSet,
+  selectionContradictsSource,
+  sourceIdentity,
+  visibleCardsForWindow,
+} from "./interaction-context.mjs";
+
+/** Presentation only: no request, epoch, source admission, or keyboard eligibility is stored here.
+ * Both ends must retain exact complete-window admission and process/publisher identities.
+ * @param {{getWindowFacts: (id: number) => Record<string, unknown> | null;
+ * getCards: () => Record<string, unknown>[]; getRawSessions: () => Record<string, unknown>[];
+ * env: NodeJS.ProcessEnv}} options
+ */
+export function createPanelPresentation({ getWindowFacts, getCards, getRawSessions, env }) {
+  /** @type {ReturnType<typeof proof>} */
+  let source = null;
+  /** @type {{source: NonNullable<ReturnType<typeof proof>>; target: NonNullable<ReturnType<typeof proof>>} | null} */
+  let handoff = null;
+  /** @type {((workspace: Record<string, unknown>) => {sessions: Record<string, unknown>[]; focusKind?: string} | null) | null} */
+  let resolveView = null;
+
+  /** @param {Record<string, unknown> | null} workspace @param {number | null} id
+   * @param {Record<string, unknown>[]} cards */
+  function proof(workspace, id, cards) {
+    if (workspace?.is_focused !== true || id === null) return null;
+    const facts = getWindowFacts(id);
+    if (
+      facts?.id !== id ||
+      facts.workspace_id !== workspace.id ||
+      !(facts.pid === null || Number.isInteger(facts.pid)) ||
+      typeof facts.app_id !== "string"
+    )
+      return null;
+    const kind = classifyAdmittedWindowFocus(id, cards, facts, env);
+    if (kind !== "agent" && kind !== "neutral") return null;
+    const owner = visibleCardsForWindow(cards, id)[0];
+    if (kind === "agent") {
+      // A complete admission result, not an arbitrary legacy display card, is required to bridge.
+      if (owner?.surfaceVisible !== true || typeof owner.placement !== "string") return null;
+      const raw = projectSessionCards(getRawSessions(), null).find(
+        (card) => card.cardId === owner.cardId,
+      );
+      if (JSON.stringify(publisherSet(owner)) !== JSON.stringify(publisherSet(raw))) return null;
+    }
+    return {
+      id,
+      workspaceId: workspace.id,
+      pid: facts.pid,
+      appId: facts.app_id,
+      kind,
+      identity: sourceIdentity(workspace.id, id, owner),
+    };
+  }
+
+  function clear() {
+    source = null;
+    handoff = null;
+    resolveView = null;
+  }
+
+  /** @param {Record<string, unknown> | null} workspace
+   * @param {NonNullable<typeof resolveView>} [resolver] */
+  function holds(workspace, resolver) {
+    if (resolver) resolveView = resolver;
+    if (!handoff) return true;
+    if (
+      Object.hasOwn(workspace ?? {}, "active_window_id") &&
+      ![handoff.source.id, handoff.target.id].some((id) => id === workspace?.active_window_id)
+    )
+      return false;
+    const cached = workspace && resolveView?.(workspace);
+    if (!cached || !["agent", "neutral", "none"].includes(cached.focusKind ?? "unknown"))
+      return false;
+    return [handoff.source, handoff.target].every((pinned) =>
+      [getCards(), cached.sessions].every(
+        (cards) => JSON.stringify(proof(workspace, pinned.id, cards)) === JSON.stringify(pinned),
+      ),
+    );
+  }
+
+  /** A selection can keep an existing surface, never create a surface or input grant.
+   * @param {Record<string, unknown> | null} workspace @param {number | null} id
+   * @param {NonNullable<typeof resolveView>} resolver */
+  function prepare(workspace, id, resolver) {
+    resolveView = resolver;
+    if (source?.id === id) return;
+    const cached = workspace && resolver(workspace);
+    const target = cached ? proof(workspace, id, cached.sessions) : null;
+    if (!source || !target) {
+      clear();
+      return;
+    }
+    handoff = { source, target };
+    if (!holds(workspace)) clear();
+  }
+
+  return {
+    clear,
+    holds,
+    prepare,
+    /** Full reads can interleave the same way as incremental focus/selection events.
+     * @param {{workspace: Record<string, unknown> | null; sessions: Record<string, unknown>[]; focusKind?: string}} view
+     * @param {number | null} sourceId */
+    prepareView(view, sourceId) {
+      if (!["agent", "neutral", "none"].includes(view.focusKind ?? "unknown")) clear();
+      else if (selectionContradictsSource(view.workspace, sourceId))
+        prepare(
+          view.workspace,
+          Number.isSafeInteger(view.workspace?.active_window_id)
+            ? Number(view.workspace?.active_window_id)
+            : null,
+          () => view,
+        );
+    },
+    /** @param {number} id */
+    involves: (id) => handoff?.source.id === id || handoff?.target.id === id,
+    /** @param {boolean} eligible @param {Record<string, unknown> | null} workspace
+     * @param {number | null} id */
+    visible(eligible, workspace, id) {
+      if (eligible) {
+        source = proof(workspace, id, getCards());
+        handoff = null;
+        return true;
+      }
+      if (handoff && holds(workspace)) return true;
+      clear();
+      return false;
+    },
+  };
+}