@martintrojer/murmur 0.2.0 → 0.2.2

package/dist/index.d.ts

@@ -412,6 +412,21 @@ declare function pidAlive(pid: number): boolean;
  * owns the pane, so this reads the same for a local and a remote pane -- a
  * reader cannot resolve a remote window id against its own tmux.
  *
+ * The session name is shortened to its last segment, and that is load-bearing
+ * rather than cosmetic. It is reached far more often than it looks: `agent_name`
+ * is set only by mu, `window_name` is null whenever tmux is auto-renaming (its
+ * default), and `pi_session` is null for the whole life of an unnamed session --
+ * pi's own auto-namer runs at CLOSE, so a live agent, which is exactly the one
+ * you are looking at, has no session name yet. So the common row for a
+ * hand-started pi fell through to here and printed `hacking/murmur`: a path,
+ * where a name belongs.
+ *
+ * The full session name is not lost. The picker's stream column shows it, and
+ * shows it precisely BECAUSE of this shortening: that column is blanked when it
+ * would repeat the name, so `hacking/murmur` in both cells collapsed to one
+ * path and a blank. Shortened, the row reads `murmur` + `hacking/murmur` -- the
+ * same width, carrying strictly more.
+ *
  * Falls back to the window id only when a node recorded no names at all, which
  * means a non-tmux harness.
  */
@@ -457,6 +472,36 @@ declare const ssh: Channel;
 declare function hasWarmSocket(target: string): boolean;
 
 declare const MAX_CONCURRENT_PEERS = 8;
+/**
+ * The optional half of a collect, as a bag rather than four positional
+ * arguments.
+ *
+ * `collect(store, ssh, now, undefined, mux)` was already the call site before
+ * the floor was added, and a fifth positional -- a bare number, next to another
+ * bare number -- is how `now` and `floorMs` get silently swapped.
+ */
+type CollectOptions = {
+    /** Bounds the whole run. Injectable so tests need not wait out real time. */
+    deadline?: Promise<void>;
+    /** The mux reconciliation asks which panes are alive. */
+    mux?: Mux;
+    /**
+     * Skip peers attempted within this many ms. Zero -- the default -- fetches
+     * every peer, which is what a deliberate `murmur collect` and the picker both
+     * want. Only the status bar, which repaints on a timer, passes a floor.
+     *
+     * Opt IN rather than opt out: a surface that forgets this argument keeps the
+     * old always-fetch behaviour, which is merely wasteful. The opposite default
+     * would mean a new surface silently serves stale data.
+     */
+    floorMs?: number;
+    /**
+     * Source of the floor's jitter, in [0, 1). Injected for the same reason `now`
+     * and `isAlive` are: a test pins both edges of the window by returning 0 and
+     * a value approaching 1, rather than sampling and hoping.
+     */
+    random?: () => number;
+};
 type CollectResult = {
     peer: string;
     ok: boolean;
@@ -486,7 +531,7 @@ type CollectResult = {
  * One round trip per peer, and never a second: the document is complete, so what
  * arrives either replaces the cache entirely or does not touch it.
  */
-declare function collect(store: Store, channel: Channel, now?: number, deadline?: Promise<void>): Promise<CollectResult[]>;
+declare function collect(store: Store, channel: Channel, now?: number, options?: CollectOptions): Promise<CollectResult[]>;
 
 declare function glance(store: Store, agent: PaneView, lines?: number): string | null;
 
@@ -554,8 +599,15 @@ declare function status(store: Store, identity: NodeIdentity, now?: number): Sta
  * display-popup, so one sleeping laptop would otherwise write ssh diagnostics
  * to stderr several times a minute, forever. `murmur collect`, which a human
  * runs deliberately, is the only place that prints.
+ *
+ * `floorMs` is how a caller says whether it is a TIMER or a PERSON. The status
+ * bar repaints on `status-interval` and passes COLLECT_FLOOR_MS, so fetch rate
+ * stops being tied to redraw rate. The picker passes nothing: pressing the key
+ * is a person asking now, and its `^r` reload comes back through here too --
+ * a refresh key that skipped the fetch would be a key that silently does
+ * nothing.
  */
-declare function statusWithCollect(store: Store, identity: NodeIdentity, now?: number, channel?: Channel): Promise<Status>;
+declare function statusWithCollect(store: Store, identity: NodeIdentity, now?: number, channel?: Channel, options?: CollectOptions): Promise<Status>;
 
 declare const MURMUR_VERSION: string;
 

package/dist/index.js

@@ -62,6 +62,10 @@ function runTmux(args) {
     return null;
   }
 }
+function chosenWindowName(name, autoRename) {
+  if (autoRename === "1") return null;
+  return name || null;
+}
 function exactSession(session) {
   return `=${session}`;
 }
@@ -81,16 +85,16 @@ var tmux = {
       "-t",
       pane,
       "-p",
-      "#{session_id}	#{window_id}	#{session_name}	#{window_name}"
+      "#{session_id}	#{window_id}	#{session_name}	#{window_name}	#{?automatic-rename,1,0}"
     ]);
-    const [session, window, sessionName, windowName] = fields?.split("	") ?? [];
+    const [session, window, sessionName, windowName, autoRename] = fields?.split("	") ?? [];
     if (!session || !window) return null;
     return {
       session: asSessionId(session),
       window: asWindowId(window),
       pane,
       session_name: sessionName || null,
-      window_name: windowName || null
+      window_name: chosenWindowName(windowName, autoRename)
     };
   },
   // Which of this host's PANES still exist. The only liveness question tmux is
@@ -181,8 +185,12 @@ function pidAlive(pid) {
 }
 
 // src/agents.ts
+function sessionLeaf(session) {
+  const leaf = session.split("/").filter(Boolean).at(-1);
+  return leaf ?? session;
+}
 function agentLabel(agent) {
-  const name = agent.agent_name ?? agent.pi_session ?? agent.window_name ?? agent.session_name;
+  const name = agent.agent_name ?? agent.pi_session ?? agent.window_name ?? (agent.session_name === null ? null : sessionLeaf(agent.session_name));
   return terminalText(name ?? agent.window);
 }
 function agentLocation(agent) {
@@ -576,6 +584,7 @@ function viewSort(views) {
 // src/collector.ts
 var MAX_CONCURRENT_PEERS = 8;
 var COLLECT_DEADLINE_MS = 4e3;
+var COLLECT_JITTER_MS = 2e4;
 async function mapSettled(items, limit, task, deadline) {
   const results = new Array(items.length);
   let cursor = 0;
@@ -597,6 +606,14 @@ async function mapSettled(items, limit, task, deadline) {
   await (stop ? Promise.race([pool, stop]) : pool);
   return results;
 }
+function duePeers(peers, now, floorMs, random) {
+  if (floorMs <= 0) return [...peers];
+  return peers.filter((peer) => {
+    if (peer.last_attempt_at === null) return true;
+    const jitter = (random() - 0.5) * COLLECT_JITTER_MS;
+    return now - peer.last_attempt_at >= floorMs + jitter;
+  });
+}
 function isUnreachable(message) {
   return /Host is down|No route to host|Connection refused|Connection timed out|Connection closed|Operation timed out|Network is unreachable|Name or service not known|Could not resolve hostname|timed out after/i.test(
     message
@@ -611,11 +628,12 @@ function stripInvocation(message) {
 function normalizeFailure(message) {
   return stripInvocation(message).replace(/\s+/g, " ").trim();
 }
-async function collect(store, channel, now = Date.now(), deadline) {
+async function collect(store, channel, now = Date.now(), options = {}) {
+  const { deadline, mux = tmux, floorMs = 0, random = Math.random } = options;
   const results = [];
   let timer;
   try {
-    const peers = store.peers();
+    const peers = duePeers(store.peers(), now, floorMs, random);
     const bounded = deadline ?? new Promise((resolve) => {
       timer = setTimeout(resolve, COLLECT_DEADLINE_MS);
       timer.unref?.();
@@ -658,7 +676,7 @@ async function collect(store, channel, now = Date.now(), deadline) {
     clearTimeout(timer);
   }
   try {
-    store.reconcileLocal({ panes: tmux.livePanes(), now });
+    store.reconcileLocal({ panes: mux.livePanes(), now });
   } catch {
   }
   return results;
@@ -783,9 +801,9 @@ function status(store, identity, now = Date.now()) {
     }))
   };
 }
-async function statusWithCollect(store, identity, now = Date.now(), channel = ssh) {
+async function statusWithCollect(store, identity, now = Date.now(), channel = ssh, options = {}) {
   try {
-    await collect(store, channel, now);
+    await collect(store, channel, now, options);
   } catch {
   }
   return status(store, identity, now);