herdr-remote 0.2.13 → 0.2.14

package/dist/tui.mjs

@@ -4064,7 +4064,7 @@ function About({ ctx }) {
         children: updateLabel
       }
     ) }),
-    /* @__PURE__ */ jsx10(Row, { label: t("about.version"), children: /* @__PURE__ */ jsx10(Text9, { color: theme.muted, children: "0.2.13" }) }),
+    /* @__PURE__ */ jsx10(Row, { label: t("about.version"), children: /* @__PURE__ */ jsx10(Text9, { color: theme.muted, children: "0.2.14" }) }),
     /* @__PURE__ */ jsx10(Row, { label: t("about.configPath"), children: /* @__PURE__ */ jsx10(Text9, { color: theme.muted, children: (0, import_config.configPath)() }) }),
     /* @__PURE__ */ jsx10(Row, { label: t("about.statePath"), children: /* @__PURE__ */ jsx10(Text9, { color: theme.muted, children: (0, import_config.stateDir)() }) }),
     /* @__PURE__ */ jsx10(Box9, { marginTop: 1, children: /* @__PURE__ */ jsx10(Text9, { color: theme.muted, children: t("about.docs") }) }),

package/herdr-plugin.toml

@@ -1,6 +1,6 @@
 id = "herdr.remote.web"
 name = "Herdr Remote Web"
-version = "0.2.13"
+version = "0.2.14"
 min_herdr_version = "0.9.1"
 description = "Browser access to Herdr workspaces via local or self-hosted relay"
 platforms = ["linux", "macos"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "herdr-remote",
-  "version": "0.2.13",
+  "version": "0.2.14",
   "description": "Browser access to Herdr workspaces: plugin, host connector, and configuration TUI",
   "license": "MIT",
   "repository": {

package/src/agent-status.js

@@ -51,9 +51,23 @@ function emptyCounts() {
  *
  * Sorted by how much each status wants attention, so the capped list keeps the
  * agents worth naming rather than the first ones Herdr happened to report.
+ * `focusedPaneId` and `focusedAgent` also track the live pane selection,
+ * including shells and panes Herdr has not added to its agent summary.
  */
 function summarizeAgents(snapshot) {
   const entries = Array.isArray(snapshot?.agents) ? snapshot.agents : [];
+  const focusedPaneId = typeof snapshot?.focused_pane_id === 'string' ? snapshot.focused_pane_id : null;
+  const focusedPane = focusedPaneId && Array.isArray(snapshot?.panes)
+    ? snapshot.panes.find((pane) => pane?.pane_id === focusedPaneId)
+    : null;
+  const focusedAgentEntry = focusedPaneId
+    ? entries.find((entry) => entry?.pane_id === focusedPaneId)
+    : null;
+  const focusedAgent = typeof focusedPane?.agent === 'string'
+    ? focusedPane.agent
+    : typeof focusedAgentEntry?.agent === 'string'
+      ? focusedAgentEntry.agent
+      : null;
   const counts = emptyCounts();
   const ranked = [];
 
@@ -74,6 +88,8 @@ function summarizeAgents(snapshot) {
   ranked.sort((left, right) => AGENT_STATUSES.indexOf(left.status) - AGENT_STATUSES.indexOf(right.status));
 
   return {
+    focusedPaneId,
+    focusedAgent,
     counts,
     // Total rather than a sum the browser has to compute, and the one number a
     // collapsed chip can show on its own.
@@ -85,6 +101,7 @@ function summarizeAgents(snapshot) {
 /** Whether two summaries say the same thing, so an unchanged one is not sent. */
 function sameSummary(left, right) {
   if (!left || !right) return left === right;
+  if (left.focusedPaneId !== right.focusedPaneId || left.focusedAgent !== right.focusedAgent) return false;
   if (left.total !== right.total) return false;
   for (const status of AGENT_STATUSES) {
     if ((left.counts?.[status] || 0) !== (right.counts?.[status] || 0)) return false;
@@ -102,7 +119,7 @@ function sameSummary(left, right) {
 
 /** The summary of a workstation with nothing to report, or nothing to ask. */
 function emptySummary() {
-  return { counts: emptyCounts(), total: 0, agents: [] };
+  return { focusedPaneId: null, focusedAgent: null, counts: emptyCounts(), total: 0, agents: [] };
 }
 
 module.exports = {

package/src/herdr-api.js

@@ -22,9 +22,8 @@
  * `herdr` CLI connects per command for the same reason, and so does this.
  *
  * Subscriptions are the exception Herdr does keep open — `events.subscribe`
- * holds the connection — but they are no use here: the event that tracks agent
- * state is scoped to a single `pane_id`, and the whole-session pane events stay
- * silent through minutes of continuous agent work. The caller polls.
+ * holds the connection. Focus and agent-detection events let the caller refresh
+ * the focused pane immediately, with a slow poll retained as a fallback.
  *
  * Nothing here may affect a terminal session. Herdr's server is an ordinary
  * process that can be restarted under a running herdr-remote, and when it is,
@@ -39,6 +38,10 @@ const REQUEST_TIMEOUT_MS = 10_000;
 /** An answer this long is not an answer. Guards a socket that never newlines. */
 const MAX_RESPONSE_BYTES = 8 * 1024 * 1024;
 
+/** A subscription that disappears should recover without keeping a dead socket busy. */
+const SUBSCRIBE_RETRY_BASE_MS = 1_000;
+const SUBSCRIBE_RETRY_MAX_MS = 10_000;
+
 let requestCounter = 0;
 
 /**
@@ -117,7 +120,125 @@ function requestHerdr(socketPath, method, params = {}, options = {}) {
   });
 }
 
+/**
+ * Subscribe to Herdr's event stream and reconnect if its local server restarts.
+ *
+ * The initial response is an acknowledgement (`result.type` is
+ * `subscription_started`); later lines are envelopes with `event` and `data`.
+ * They share a socket, but are separate NDJSON messages. A subscription never
+ * starts or writes to a terminal, so an unavailable socket is only a reason to
+ * retry this side channel.
+ */
+function subscribeHerdr(socketPath, subscriptions, onEvent, options = {}) {
+  const {
+    connect = net.connect,
+    retryBaseMs = SUBSCRIBE_RETRY_BASE_MS,
+    retryMaxMs = SUBSCRIBE_RETRY_MAX_MS,
+  } = options;
+  let socket = null;
+  let reconnectTimer = null;
+  let handshakeTimer = null;
+  let retryCount = 0;
+  let closed = false;
+
+  const scheduleReconnect = () => {
+    if (closed || reconnectTimer) return;
+    const delay = Math.min(retryBaseMs * (2 ** retryCount), retryMaxMs);
+    retryCount += 1;
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = null;
+      open();
+    }, delay);
+    if (typeof reconnectTimer.unref === 'function') reconnectTimer.unref();
+  };
+
+  const open = () => {
+    if (closed) return;
+    let current;
+    try {
+      current = connect(socketPath);
+    } catch {
+      scheduleReconnect();
+      return;
+    }
+    socket = current;
+    let buffer = '';
+    let requestId = null;
+    let acknowledged = false;
+    const clearHandshake = () => {
+      if (handshakeTimer) clearTimeout(handshakeTimer);
+      handshakeTimer = null;
+    };
+
+    current.setEncoding('utf8');
+    current.on('connect', () => {
+      requestCounter += 1;
+      requestId = `herdr-remote:subscription:${requestCounter}`;
+      current.write(`${JSON.stringify({
+        id: requestId,
+        method: 'events.subscribe',
+        params: { subscriptions },
+      })}\n`);
+      handshakeTimer = setTimeout(() => current.destroy(), REQUEST_TIMEOUT_MS);
+      if (typeof handshakeTimer.unref === 'function') handshakeTimer.unref();
+    });
+    current.on('data', (chunk) => {
+      buffer += chunk;
+      if (Buffer.byteLength(buffer, 'utf8') > MAX_RESPONSE_BYTES) {
+        current.destroy();
+        return;
+      }
+      let newline;
+      while ((newline = buffer.indexOf('\n')) !== -1) {
+        const line = buffer.slice(0, newline);
+        buffer = buffer.slice(newline + 1);
+        if (!line) continue;
+        let message;
+        try {
+          message = JSON.parse(line);
+        } catch {
+          current.destroy();
+          return;
+        }
+        if (message?.id === requestId) {
+          clearHandshake();
+          if (message.error) {
+            current.destroy();
+            return;
+          }
+          acknowledged = true;
+          retryCount = 0;
+        } else if (acknowledged && typeof message?.event === 'string' && message.data && typeof message.data === 'object') {
+          try { onEvent(message); } catch {}
+        }
+      }
+    });
+    current.on('error', () => {});
+    current.on('close', () => {
+      clearHandshake();
+      if (socket === current) socket = null;
+      scheduleReconnect();
+    });
+  };
+
+  open();
+  return {
+    close() {
+      if (closed) return;
+      closed = true;
+      if (reconnectTimer) clearTimeout(reconnectTimer);
+      if (handshakeTimer) clearTimeout(handshakeTimer);
+      reconnectTimer = null;
+      handshakeTimer = null;
+      const active = socket;
+      socket = null;
+      if (active) active.destroy();
+    },
+  };
+}
+
 module.exports = {
   REQUEST_TIMEOUT_MS,
   requestHerdr,
+  subscribeHerdr,
 };

package/src/host-connector.js

@@ -26,13 +26,20 @@ const {
   PROTOCOL_VERSION,
 } = require('herdr-remote-relay/protocol');
 const { resolveHostPalette } = require('./terminal-palette');
-const { requestHerdr } = require('./herdr-api');
+const { requestHerdr, subscribeHerdr } = require('./herdr-api');
 const { sameSummary, summarizeAgents } = require('./agent-status');
 const { EXIT_REPLACED, EXIT_AUTH_FAILED } = require('./exit-codes');
 const { savePastedFile, cleanPastedDir } = require('./pasted-files');
 
 /** How often the agent summary is re-read while a browser is watching. */
 const AGENT_STATUS_POLL_MS = 5_000;
+const AGENT_STATUS_EVENT_DEBOUNCE_MS = 150;
+const AGENT_STATUS_SUBSCRIPTIONS = [
+  { type: 'pane.focused' },
+  { type: 'tab.focused' },
+  { type: 'workspace.focused' },
+  { type: 'pane.agent_detected' },
+];
 
 function randomId(prefix) {
   return `${prefix}-${crypto.randomBytes(9).toString('base64url')}`;
@@ -113,7 +120,10 @@ class HostConnector {
     this.PtySession = options.PtySession || PtySession;
     /** The side channel that answers "does anything need me?"; see startAgentStatus. */
     this.requestHerdr = options.requestHerdr || requestHerdr;
+    this.subscribeHerdr = options.subscribeHerdr || subscribeHerdr;
     this.agentStatusTimer = null;
+    this.agentStatusDebounceTimer = null;
+    this.agentStatusSubscription = null;
     this.agentStatusPending = false;
     this.lastAgentSummary = null;
     this.fastFailures = 0;
@@ -591,22 +601,49 @@ class HostConnector {
    * PTYs survive it — so every failure here is a retry, never anything a
    * terminal session notices.
    *
-   * Polled, and one connection per poll: Herdr answers a socket request and
-   * hangs up, and its only long-lived connection — a subscription — carries no
-   * event that tracks agent state without naming a pane. See `herdr-api.js`.
+   * A long-lived subscription provides fast refreshes on pane and workspace
+   * focus changes; the five-second poll still repairs missed events and a
+   * restarted Herdr server. Both paths only read the side-channel snapshot.
    */
   startAgentStatus() {
     if (this.agentStatusTimer || this.stopping) return;
     this.agentStatusTimer = setInterval(() => this.readAgentStatus(), AGENT_STATUS_POLL_MS);
     if (typeof this.agentStatusTimer.unref === 'function') this.agentStatusTimer.unref();
+    try {
+      this.agentStatusSubscription = this.subscribeHerdr(
+        this.socketPath,
+        AGENT_STATUS_SUBSCRIPTIONS,
+        () => this.scheduleAgentStatusRead(),
+      );
+    } catch {
+      // A missing or restarting Herdr server leaves the regular poll in place.
+    }
     this.readAgentStatus();
   }
 
+  scheduleAgentStatusRead() {
+    if (!this.agentStatusTimer) return;
+    if (this.agentStatusDebounceTimer) clearTimeout(this.agentStatusDebounceTimer);
+    this.agentStatusDebounceTimer = setTimeout(() => {
+      this.agentStatusDebounceTimer = null;
+      this.readAgentStatus();
+    }, AGENT_STATUS_EVENT_DEBOUNCE_MS);
+    if (typeof this.agentStatusDebounceTimer.unref === 'function') this.agentStatusDebounceTimer.unref();
+  }
+
   stopAgentStatus() {
     if (this.agentStatusTimer) {
       clearInterval(this.agentStatusTimer);
       this.agentStatusTimer = null;
     }
+    if (this.agentStatusDebounceTimer) {
+      clearTimeout(this.agentStatusDebounceTimer);
+      this.agentStatusDebounceTimer = null;
+    }
+    if (this.agentStatusSubscription) {
+      this.agentStatusSubscription.close();
+      this.agentStatusSubscription = null;
+    }
     this.lastAgentSummary = null;
   }