@tryinget/pi-activity-strip 0.3.0 → 0.5.0

package/native/panel/src/style.css

@@ -0,0 +1,176 @@
+/* biome-ignore lint/correctness/noUnknownTypeSelector: GTK CSS uses widget node names. */
+window {
+  background: transparent;
+  color: rgba(247, 250, 255, 0.96);
+  font-family: "IBM Plex Sans", "Avenir Next", "Segoe UI", sans-serif;
+}
+
+.brand,
+.cards-panel {
+  background: linear-gradient(to bottom, rgba(12, 19, 33, 0.96), rgba(8, 13, 22, 0.92));
+  border: 1px solid rgba(255, 255, 255, 0.08);
+  border-radius: 20px;
+}
+
+.brand {
+  padding: 10px 12px;
+}
+
+.brand-eyebrow,
+.meta,
+.card-state,
+.card-tool,
+.inspector-key {
+  font-family: "IBM Plex Mono", "JetBrains Mono", monospace;
+}
+
+.brand-eyebrow {
+  color: #79b8ff;
+  font-size: 9px;
+  letter-spacing: 1px;
+}
+
+.brand-title {
+  color: rgba(247, 250, 255, 0.96);
+  font-size: 18px;
+  font-weight: 650;
+}
+
+.brand-subtitle {
+  color: rgba(194, 205, 224, 0.74);
+  font-size: 10px;
+}
+
+.meta {
+  color: rgba(167, 180, 203, 0.58);
+  font-size: 9px;
+}
+
+/* biome-ignore lint/correctness/noUnknownTypeSelector: GTK CSS uses widget node names. */
+.cards-panel > viewport {
+  background: linear-gradient(to bottom, rgba(10, 16, 28, 0.94), rgba(6, 10, 18, 0.9));
+  border-radius: 20px;
+  padding: 6px 8px 8px;
+}
+
+/* biome-ignore lint/correctness/noUnknownTypeSelector: GTK CSS uses widget node names. */
+.cards-panel scrollbar {
+  opacity: 0;
+  min-width: 0;
+  min-height: 0;
+}
+
+.card {
+  color: rgba(247, 250, 255, 0.96);
+  background: linear-gradient(to bottom, rgba(13, 20, 35, 0.98), rgba(9, 14, 24, 0.96));
+  border: 1px solid rgba(255, 255, 255, 0.14);
+  border-left: 3px solid #79b8ff;
+  border-radius: 16px;
+  padding: 8px 10px 8px 12px;
+  box-shadow: none;
+  transition: 120ms ease;
+}
+
+.card:hover,
+.card:focus-visible,
+.card.open {
+  background: linear-gradient(to bottom, rgba(18, 28, 47, 0.99), rgba(10, 16, 28, 0.97));
+  border-color: rgba(121, 184, 255, 0.72);
+}
+
+.card.current {
+  border-left-width: 5px;
+  border-color: rgba(150, 202, 255, 0.92);
+  outline: 1px solid rgba(121, 184, 255, 0.38);
+  outline-offset: -3px;
+}
+
+.card.stalled {
+  opacity: 0.72;
+}
+
+.card.stalled .card-phase {
+  text-decoration-line: line-through;
+}
+
+.card.state-thinking {
+  border-left-color: #8ab4ff;
+}
+.card.state-tool {
+  border-left-color: #ffd166;
+}
+.card.state-waiting {
+  border-left-color: #ff9f7a;
+}
+.card.state-success {
+  border-left-color: #57d9a3;
+}
+.card.state-error {
+  border-left-color: #ff7d7d;
+}
+
+.card-repo {
+  color: rgba(247, 250, 255, 0.96);
+  font-size: 12px;
+  font-weight: 650;
+}
+
+.card-phase,
+.inspector-value {
+  color: rgba(194, 205, 224, 0.76);
+  font-size: 10px;
+}
+
+.card-state {
+  border: 1px solid rgba(121, 184, 255, 0.36);
+  border-radius: 999px;
+  color: #79b8ff;
+  font-size: 8px;
+  padding: 4px 6px;
+}
+
+.state-tool .card-state {
+  color: #ffd166;
+  border-color: rgba(255, 209, 102, 0.42);
+}
+.state-waiting .card-state {
+  color: #ff9f7a;
+  border-color: rgba(255, 159, 122, 0.42);
+}
+.state-success .card-state {
+  color: #57d9a3;
+  border-color: rgba(87, 217, 163, 0.42);
+}
+.state-error .card-state {
+  color: #ff7d7d;
+  border-color: rgba(255, 125, 125, 0.42);
+}
+
+.card-tool,
+.card-elapsed,
+.inspector-key {
+  color: rgba(167, 180, 203, 0.58);
+  font-size: 8px;
+}
+
+.inspector {
+  border-top: 1px solid rgba(255, 255, 255, 0.08);
+  padding-top: 9px;
+}
+
+.inspector-value {
+  line-height: 1.25;
+}
+
+.activation {
+  color: rgba(167, 180, 203, 0.72);
+  font-size: 9px;
+}
+
+.activation.success {
+  color: #57d9a3;
+}
+
+.activation.error {
+  color: #ff7d7d;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tryinget/pi-activity-strip",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "pi extension package for activity-strip workflows in monorepo runtime",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE",
@@ -26,6 +26,12 @@
   "engines": {
     "node": ">=22.19.0"
   },
+  "os": [
+    "linux"
+  ],
+  "cpu": [
+    "x64"
+  ],
   "scripts": {
     "fix": "bash ./scripts/quality-gate.sh fix",
     "lint": "bash ./scripts/quality-gate.sh lint",
@@ -35,11 +41,13 @@
     "quality:ci": "bash ./scripts/quality-gate.sh ci",
     "check": "npm run quality:ci",
     "test": "npm run quality:ci",
-    "docs:list": "bash ./scripts/docs-list.sh",
-    "docs:list:workspace": "bash ./scripts/docs-list.sh --workspace --discover",
-    "docs:list:json": "bash ./scripts/docs-list.sh --json",
+    "docs:list": "node ~/ai-society/core/agent-scripts/scripts/docs-list.mjs",
+    "docs:list:workspace": "node ~/ai-society/core/agent-scripts/scripts/docs-list.mjs --workspace --discover",
+    "docs:list:json": "node ~/ai-society/core/agent-scripts/scripts/docs-list.mjs --json",
     "release:check": "bash ./scripts/release-check.sh",
     "release:check:quick": "SKIP_PI_SMOKE=1 bash ./scripts/release-check.sh",
+    "native:check": "cd native/panel && RUSTUP_TOOLCHAIN=stable cargo fmt --check && RUSTUP_TOOLCHAIN=stable cargo test",
+    "native:build": "bash ./scripts/build-native-panel.sh",
     "strip:open": "node ./bin/pi-activity-strip.mjs open",
     "strip:status": "node ./bin/pi-activity-strip.mjs status",
     "strip:doctor": "node ./bin/pi-activity-strip.mjs doctor",
@@ -56,6 +64,10 @@
     "extensions/activity-strip.js",
     "extensions/activity-strip.ts",
     "src",
+    "native/bin",
+    "native/panel/Cargo.toml",
+    "native/panel/Cargo.lock",
+    "native/panel/src",
     "prompts",
     "examples",
     "policy/security-policy.json"
@@ -76,15 +88,16 @@
   },
   "devDependencies": {
     "@biomejs/biome": "2.4.4",
-    "@earendil-works/pi-ai": "0.83.0",
-    "@earendil-works/pi-coding-agent": "0.83.0",
+    "@earendil-works/pi-agent-core": "0.84.3",
+    "@earendil-works/pi-ai": "0.84.3",
+    "@earendil-works/pi-coding-agent": "0.84.3",
     "@types/node": "22.14.0",
     "@typescript/native-preview": "7.0.0-dev.20260417.1",
     "typebox": "1.3.7",
     "typescript": "5.9.2"
   },
   "overrides": {
-    "fast-xml-parser": "5.3.6"
+    "fast-xml-parser": "5.7.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "*",

package/src/broker/server.mjs

@@ -10,6 +10,8 @@ import net from "node:net";
 /** @typedef {import("../common/contracts.ts").ActivityStripBrokerOptions} ActivityStripBrokerOptions */
 import {
   ACTIVITY_STRIP_BROADCAST_TICK_MS,
+  ACTIVITY_STRIP_CLIENT_IDLE_TIMEOUT_MS,
+  ACTIVITY_STRIP_MAX_MESSAGE_BYTES,
   ACTIVITY_STRIP_SOCKET_DIR,
   ACTIVITY_STRIP_SOCKET_PATH,
 } from "../common/constants.mjs";
@@ -49,6 +51,8 @@ export class ActivityStripBroker extends EventEmitter {
     this.getRuntimeStatus = options.getRuntimeStatus ?? (() => undefined);
     this.focusSession =
       options.focusSession ?? (async () => ({ ok: false, error: "Focus unavailable" }));
+    this.focusStrip =
+      options.focusStrip ?? (async () => ({ ok: false, error: "Strip focus unavailable" }));
     this.server = net.createServer((socket) => this.handleConnection(socket));
     this.tick = null;
   }
@@ -98,12 +102,18 @@ export class ActivityStripBroker extends EventEmitter {
   handleConnection(socket) {
     let buffer = "";
     socket.setEncoding("utf8");
+    socket.setTimeout?.(ACTIVITY_STRIP_CLIENT_IDLE_TIMEOUT_MS, () => socket.destroy());
     socket.on("error", (error) => {
       if (!isExpectedClientDisconnect(error)) this.emit("client-error", error);
     });
 
     socket.on("data", (chunk) => {
       buffer += chunk;
+      if (Buffer.byteLength(buffer, "utf8") > ACTIVITY_STRIP_MAX_MESSAGE_BYTES) {
+        this.reply(socket, { ok: false, error: "Activity strip broker message is too large." });
+        socket.destroy();
+        return;
+      }
       let newlineIndex = buffer.indexOf("\n");
       while (newlineIndex >= 0) {
         const line = buffer.slice(0, newlineIndex);
@@ -139,26 +149,52 @@ export class ActivityStripBroker extends EventEmitter {
         });
         return;
       case "focus":
-        Promise.resolve(this.focusSession(String(message.sessionId ?? "")))
+        Promise.resolve(this.focusSession(String(message.cardId ?? message.sessionId ?? "")))
           .then((result) => this.reply(socket, { type: "focus", ...result }))
           .catch(() =>
             this.reply(socket, { ok: false, type: "focus", error: "Focus failed closed." }),
           );
         return;
+      case "focus-strip":
+        Promise.resolve(this.focusStrip())
+          .then((result) => this.reply(socket, { type: "focus-strip", ...result }))
+          .catch(() =>
+            this.reply(socket, {
+              ok: false,
+              type: "focus-strip",
+              error: "Strip focus failed closed.",
+            }),
+          );
+        return;
       case "shutdown":
         this.reply(socket, { ok: true, type: "shutdown" });
         setTimeout(() => {
           this.emit("shutdown-requested");
         }, 20);
         return;
-      case "remove":
-        this.store.remove(message.sessionId);
-        this.emitSnapshot();
+      case "remove": {
+        const accepted = this.store.remove(
+          String(message.sessionId ?? ""),
+          String(message.publisherId ?? ""),
+        );
+        if (accepted) this.emitSnapshot();
+        this.reply(socket, {
+          ok: accepted,
+          type: "remove",
+          ...(accepted ? {} : { error: "Activity strip broker rejected remove." }),
+        });
         return;
-      case "upsert":
-        this.store.upsert(message.session);
-        this.emitSnapshot();
+      }
+      case "upsert": {
+        const accepted = this.store.upsert(message.session);
+        if (accepted) this.emitSnapshot();
+        this.reply(socket, {
+          ok: accepted,
+          type: "upsert",
+          ...(accepted ? {} : { error: "Activity strip broker rejected upsert." }),
+        });
         return;
+      }
       default:
         this.reply(socket, { ok: false, error: `Unsupported message type: ${message.type}` });
     }

package/src/broker/session-store.mjs

@@ -4,43 +4,85 @@
 //   - "changing session retention, upsert semantics, or broker snapshot ordering"
 // ---
 
-import { ACTIVITY_STRIP_STALE_AFTER_MS } from "../common/constants.mjs";
+import {
+  ACTIVITY_STRIP_MAX_SESSIONS,
+  ACTIVITY_STRIP_STALE_AFTER_MS,
+} from "../common/constants.mjs";
 import { normalizeSessionSnapshot, sortSessions } from "../common/protocol.mjs";
 
 /** @typedef {import("../common/contracts.ts").SessionSnapshot} SessionSnapshot */
 /** @typedef {import("../common/contracts.ts").SessionStoreOptions} SessionStoreOptions */
 /** @typedef {import("../common/contracts.ts").BrokerSnapshot} BrokerSnapshot */
 
+/**
+ * Stable store key. Sessions resumed into a second process keep publishing under
+ * their own publisherId so two live processes never fight over one card; legacy
+ * publishers without a publisherId keep the bare sessionId key.
+ * @param {SessionSnapshot} session
+ */
+function sessionKey(session) {
+  return session.publisherId ? `${session.sessionId}|${session.publisherId}` : session.sessionId;
+}
+
 export class SessionStore {
   /** @param {SessionStoreOptions} [options] */
   constructor(options = {}) {
     this.staleAfterMs = options.staleAfterMs ?? ACTIVITY_STRIP_STALE_AFTER_MS;
-    /** @type {Map<string, SessionSnapshot>} */
+    this.maxSessions = options.maxSessions ?? ACTIVITY_STRIP_MAX_SESSIONS;
+    /** @type {Map<string, {session: SessionSnapshot; receivedAt: number}>} */
     this.sessions = new Map();
+    /** @type {Map<string, number>} */
+    this.tombstones = new Map();
   }
 
-  /** @param {Partial<SessionSnapshot> | Record<string, unknown>} session */
-  upsert(session) {
+  /** @param {Partial<SessionSnapshot> | Record<string, unknown>} session @param {number} [receivedAt] */
+  upsert(session, receivedAt = Date.now()) {
+    if (!session || typeof session !== "object") return false;
+    this.purge(receivedAt);
     const normalized = normalizeSessionSnapshot(session);
     if (!normalized.sessionId) return false;
-    this.sessions.set(normalized.sessionId, normalized);
+    const key = sessionKey(normalized);
+    if (this.tombstones.has(key)) return false;
+    const current = this.sessions.get(key);
+    if (
+      current &&
+      current.session.publisherSequence > 0 &&
+      (normalized.publisherSequence === 0 ||
+        normalized.publisherSequence <= current.session.publisherSequence)
+    ) {
+      return false;
+    }
+    if (!current && this.sessions.size >= this.maxSessions) return false;
+    this.sessions.set(key, { session: normalized, receivedAt });
     return true;
   }
 
-  /** @param {string} sessionId */
-  remove(sessionId) {
-    return this.sessions.delete(String(sessionId ?? ""));
+  /** @param {string} sessionId @param {string} [publisherId] @param {number} [removedAt] */
+  remove(sessionId, publisherId, removedAt = Date.now()) {
+    const id = String(sessionId ?? "");
+    if (!id) return false;
+    if (!publisherId) return this.sessions.delete(id);
+    const key = `${id}|${String(publisherId)}`;
+    this.purge(removedAt);
+    if (!this.sessions.has(key)) return false;
+    if (!this.tombstones.has(key) && this.tombstones.size >= this.maxSessions) return false;
+    this.sessions.delete(key);
+    this.tombstones.set(key, removedAt);
+    return true;
   }
 
   /** @param {number} [now] */
   purge(now = Date.now()) {
     let changed = false;
-    for (const [sessionId, session] of this.sessions.entries()) {
-      if (now - session.updatedAt > this.staleAfterMs) {
+    for (const [sessionId, entry] of this.sessions.entries()) {
+      if (now - entry.receivedAt > this.staleAfterMs) {
         this.sessions.delete(sessionId);
         changed = true;
       }
     }
+    for (const [sessionId, removedAt] of this.tombstones.entries()) {
+      if (now - removedAt > this.staleAfterMs) this.tombstones.delete(sessionId);
+    }
     return changed;
   }
 
@@ -49,7 +91,7 @@ export class SessionStore {
     this.purge(now);
     return {
       generatedAt: now,
-      sessions: sortSessions([...this.sessions.values()]),
+      sessions: sortSessions([...this.sessions.values()].map((entry) => entry.session)),
     };
   }
 }

package/src/client/broker-client.mjs

@@ -112,10 +112,31 @@ export async function requestBrokerShutdown(options = {}) {
 
 /** @param {SessionSnapshot} session @param {BrokerClientOptions} [options] */
 export async function publishSessionSnapshot(session, options = {}) {
-  await sendBrokerMessage(makeMessage("upsert", { session }), options);
+  const result = await sendBrokerMessage(makeMessage("upsert", { session }), {
+    ...options,
+    expectReply: true,
+  });
+  if (result?.ok !== true)
+    throw new Error(result?.error || "Activity strip broker rejected upsert.");
 }
 
-/** @param {string} sessionId @param {BrokerClientOptions} [options] */
-export async function removeSession(sessionId, options = {}) {
-  await sendBrokerMessage(makeMessage("remove", { sessionId }), options);
+/** @param {{ sessionId: string; publisherId: string }} session @param {BrokerClientOptions} [options] */
+export async function removeSession(session, options = {}) {
+  /** @type {Record<string, unknown>} */
+  let record = {};
+  let fallbackId = "";
+  if (session && typeof session === "object") {
+    record = session;
+  } else {
+    fallbackId = String(session ?? "");
+  }
+  const result = await sendBrokerMessage(
+    makeMessage("remove", {
+      sessionId: String(record.sessionId ?? fallbackId),
+      publisherId: String(record.publisherId ?? ""),
+    }),
+    { ...options, expectReply: true },
+  );
+  if (result?.ok !== true)
+    throw new Error(result?.error || "Activity strip broker rejected remove.");
 }