unsnooze 1.16.1 → 1.16.3

package/CHANGELOG.md

@@ -1,5 +1,47 @@
 # Changelog
 
+## 1.16.3 — 2026-08-22
+
+- **A dashboard left open overnight no longer runs the machine out of memory.**
+  ([#16](https://github.com/saaranshM/unsnooze/issues/16)) `unsnooze status` in
+  a spare pane is exactly what it is for, and after nine or ten hours it was
+  dying on *"FATAL ERROR: Ineffective mark-compacts near heap limit — JavaScript
+  heap out of memory"*. The dashboard itself was innocent: React's development
+  build files a `performance.measure()` entry for every render, commit and
+  `setState` — the performance track it publishes for devtools — and Node
+  buffers user-timing entries forever with nothing to drain them. The status tab
+  repaints about three times a second (a one-second data tick plus the
+  450ms logo animation), each repaint left roughly 40 entries behind, and a
+  night of that walks into Node's 2GB heap ceiling. Measured at ~12kB retained
+  per render, surviving a forced garbage collection. The dashboard now drains
+  that buffer while it is mounted; heap use went from climbing without limit to
+  flat. Nothing else in unsnooze records user timing, and no other command
+  renders long enough to have been affected.
+
+- **Every release now creates its GitHub release automatically.** They were
+  written by hand afterwards, so 1.16.2 shipped to npm and to the website while
+  the repository's Releases tab still showed 1.16.1. The publish workflow now
+  creates the release from that version's CHANGELOG section, and waits for the
+  npm registry to actually serve the new version before rebuilding the website —
+  `npm publish` returns before the registry does, which is why 1.16.2's own
+  changelog entry was briefly invisible on unsnooze.dev.
+
+## 1.16.2 — 2026-08-22
+
+- **A herdr revival now opens a tab in your project's workspace, not a new
+  workspace of its own.** ([#15](https://github.com/saaranshM/unsnooze/issues/15))
+  `newWindow` means "one more terminal for this work" — a window in tmux, a tab
+  in Zellij — and it was mapped to `herdr workspace create`. But a herdr
+  workspace is the *project*: it is per repo, the way a tmux session is. So
+  every reset left another top-level workspace for the same repo, and a week of
+  them was a sidebar full of duplicates. unsnooze now asks herdr which
+  workspace is already open on that directory and adds a tab there, creating a
+  workspace only when there is genuinely none — a session it just started, or a
+  directory herdr has nothing open on. A tab rather than a split, because a
+  revived agent draws a full-screen TUI and halving the pane you are looking at
+  would leave two terminals too narrow to use; neither takes focus away from
+  what you are doing.
+
 ## 1.16.1 — 2026-08-16
 
 - **`unsnooze status` no longer offers an attach command for headless sessions.**

package/README.md

@@ -751,7 +751,7 @@ explicitly with `unsnooze config set multiplexer tmux`, `zellij`, or `herdr`.
 
 #### herdr specifics
 
-herdr differs from tmux and Zellij in three ways that are visible in use:
+herdr differs from tmux and Zellij in four ways that are visible in use:
 
 - **unsnooze never restarts a stopped herdr session.** herdr restores saved
   agent panes when a session restarts (`resume_agents_on_restore` is on by
@@ -761,10 +761,17 @@ herdr differs from tmux and Zellij in three ways that are visible in use:
   reusing the name. If you restart a stopped session yourself and herdr brings
   the agent back, unsnooze may still open a fresh pane for it; that case is not
   yet detected.
+- **A revived session opens a tab, not a workspace.** A herdr workspace is the
+  project — per repo, the way a tmux *session* is — while a tab is what tmux
+  calls a window. So a revival opens a new tab in whichever workspace herdr
+  already has open on that directory, and only creates a workspace when there
+  is none. (A tab rather than a split: a revived agent draws a full-screen TUI,
+  and halving the pane you are looking at would leave two terminals too narrow
+  to use. Neither steals focus.)
 - **Multi-line resume messages are carried, not typed.** herdr starts a pane
   command by typing it into the pane's shell, where a newline would submit half
   a command and a tab would be a completion request. Any such argument is passed
-  through the workspace environment instead and referenced by the typed line, so
+  through the new tab's environment instead and referenced by the typed line, so
   a multi-paragraph `resumeMessage` reaches the agent as one argument, byte for
   byte. (A NUL byte is still refused — an environment value cannot hold one.)
 - **A custom `HERDR_SOCKET_PATH` that does not match the session being

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unsnooze",
-  "version": "1.16.1",
+  "version": "1.16.3",
   "description": "Automatically resume Claude Code, Codex CLI, Grok, Qwen Code, Kimi CLI, OpenCode, and Antigravity sessions when 5-hour or weekly usage limits reset—on macOS, Linux and Windows, with or without a terminal multiplexer.",
   "keywords": [
     "claude",

package/src/dashboard/run.js

@@ -62,6 +62,41 @@ export function installMouseCleanup(stdout = process.stdout) {
   };
 }
 
+// React's development build records a `performance.measure()` entry for every
+// render, commit and setState — the React Performance Track it publishes for
+// devtools. Node buffers user-timing entries and nothing ever drains that
+// buffer, so on a long-lived dashboard it IS the leak: the status tab repaints
+// roughly three times a second (a 1s data tick plus the 450ms logo animation),
+// each repaint leaves ~40 entries behind, and an overnight `unsnooze status`
+// walked into Node's 2GB heap ceiling and aborted (#16). Measured at ~12 kB
+// retained per render, surviving a forced GC.
+//
+// The entries cannot be capped (Node caps resource timing, not user timing) and
+// switching React to its production build would mean setting NODE_ENV for the
+// whole CLI before anything imports React. Draining is the narrow fix: nothing
+// in unsnooze reads user timing, and the sweep lives exactly as long as the
+// render does.
+export const TIMING_SWEEP_MS = 5_000;
+
+export function sweepReactTiming(perf = globalThis.performance) {
+  try {
+    perf?.clearMeasures?.();
+    perf?.clearMarks?.();
+  } catch { /* a runtime with no user timing has nothing to leak */ }
+}
+
+// Returns the stop function. The timer is unref'd: draining a buffer is never
+// a reason to hold the process open.
+export function startTimingSweep({ intervalMs = TIMING_SWEEP_MS, perf } = {}) {
+  sweepReactTiming(perf);
+  const timer = setInterval(() => sweepReactTiming(perf), intervalMs);
+  timer.unref?.();
+  return () => {
+    clearInterval(timer);
+    sweepReactTiming(perf);
+  };
+}
+
 export function shouldUseDashboard({
   force = null,
   json = false,
@@ -87,13 +122,18 @@ export async function runDashboard({ tab = 'status' } = {}) {
   }
 
   installMouseCleanup(process.stdout);
-  const instance = render(h(App, { initialTab: tab, mouseEnabled: getConfig('mouse') !== false }), {
-    exitOnCtrlC: true,
-    // Full-screen: separate buffer like vim / htop / less — original scrollback restored on quit
-    alternateScreen: true,
-  });
+  const stopTimingSweep = startTimingSweep();
+  try {
+    const instance = render(h(App, { initialTab: tab, mouseEnabled: getConfig('mouse') !== false }), {
+      exitOnCtrlC: true,
+      // Full-screen: separate buffer like vim / htop / less — original scrollback restored on quit
+      alternateScreen: true,
+    });
 
-  await instance.waitUntilExit();
+    await instance.waitUntilExit();
+  } finally {
+    stopTimingSweep();
+  }
   // Belt and braces: normal quit also clears modes (provider already did).
   process.stdout.write(MOUSE_DISABLE_ALL);
   return 0;

package/src/multiplexers/herdr.js

@@ -2,7 +2,7 @@
 // remains alive with its shell prompt. The resumer must therefore verify
 // agent ownership before injecting, and revival can reuse a surviving pane
 // only when Task 3 wires that path deliberately.
-// Launch env is delivered via workspace create --env. Keep this narrow because
+// Launch env is delivered via tab/workspace create --env. Keep this narrow because
 // pane run types argv into the pane shell, but preserve the two Claude config
 // roots: desktop/isolated Claude sessions cannot be resumed without them.
 
@@ -276,6 +276,66 @@ export function createHerdr({ spawner = defaultSpawner, env = process.env } = {}
       return syncOutput(result);
     };
 
+    const listPaneRows = async session => {
+      const result = parseResult(await inSession(session, 'pane', 'list'));
+      return Array.isArray(result?.panes) ? result.panes : [];
+    };
+
+    const samePath = (a, b) => {
+      if (typeof a !== 'string' || typeof b !== 'string' || !a || !b) return false;
+      const trim = value => (value.length > 1 ? value.replace(/\/+$/, '') : value);
+      return trim(a) === trim(b);
+    };
+
+    // The workspace herdr already has open on this project, if any.
+    //
+    // A herdr workspace is the project, not the window: it is where a repo
+    // lives, the way a tmux SESSION is, and creating one per revival left a
+    // user with N top-level workspaces for one repo (#15). herdr reports no cwd
+    // on a workspace, so the project is read off its panes instead — `pane
+    // list` walks workspaces in order, so the first match is the oldest
+    // workspace on this path, which is the user's own rather than one of ours.
+    const workspaceOnProject = async (session, cwd) => {
+      try {
+        const match = (await listPaneRows(session)).find(pane =>
+          samePath(pane?.cwd, cwd) || samePath(pane?.foreground_cwd, cwd));
+        return match?.workspace_id ? String(match.workspace_id) : null;
+      } catch {
+        return null;
+      }
+    };
+
+    const rootPaneId = (created, what) => {
+      const pane = created?.root_pane?.pane_id;
+      if (!pane) throw new Error(`unsnooze: unexpected herdr ${what} shape: no root_pane`);
+      return String(pane);
+    };
+
+    // One more full-size terminal for `cwd`, in the workspace that project
+    // already occupies. A TAB, not a pane split: `newWindow` means the same
+    // thing on every backend — a tmux window, a zellij tab — and a revived
+    // agent draws a full-screen TUI, so halving the pane the user is looking at
+    // would leave two terminals too narrow to use. Only when herdr has no
+    // workspace on this project (a session we just started has none at all)
+    // does a new workspace get created.
+    const openTerminal = async (session, cwd, envArgs) => {
+      const workspace = await workspaceOnProject(session, cwd);
+      if (workspace) {
+        try {
+          return rootPaneId(parseResult(await inSession(
+            session, 'tab', 'create', '--workspace', workspace,
+            '--cwd', cwd, '--label', 'unsnooze', ...envArgs,
+          )), 'tab');
+        } catch {
+          // The workspace can close between the listing and the create. A
+          // revival into a fresh workspace still revives; failing does not.
+        }
+      }
+      return rootPaneId(parseResult(await inSession(
+        session, 'workspace', 'create', '--cwd', cwd, '--label', 'unsnooze', ...envArgs,
+      )), 'workspace');
+    };
+
     const backend = {
       name: 'herdr',
       owner,
@@ -477,9 +537,8 @@ export function createHerdr({ spawner = defaultSpawner, env = process.env } = {}
 
       async listSessionPanes(sessionName) {
         try {
-          const result = parseResult(await inSession(sessionName, 'pane', 'list'));
-          const panes = Array.isArray(result?.panes) ? result.panes : [];
-          return panes.map(entry => String(entry.pane_id)).filter(Boolean);
+          return (await listPaneRows(sessionName))
+            .map(entry => String(entry.pane_id)).filter(Boolean);
         } catch {
           return [];
         }
@@ -515,14 +574,11 @@ export function createHerdr({ spawner = defaultSpawner, env = process.env } = {}
         }
         // Build the command first: an argument that cannot be typed (a
         // multi-line resume message) travels as environment instead, and that
-        // environment has to be on the workspace before the pane exists.
+        // environment has to be on the tab before its pane exists.
         const { line, env: argEnv } = shellCommand(launchSpec.file, launchSpec.args || []);
-        const workspace = parseResult(await inSession(
-          target, 'workspace', 'create', '--cwd', cwd, '--label', 'unsnooze',
-          ...envFlags({ ...launchSpec?.env, ...argEnv }),
-        ));
-        const pane = workspace?.root_pane?.pane_id;
-        if (!pane) throw new Error('unsnooze: unexpected herdr workspace shape: no root_pane');
+        const pane = await openTerminal(
+          target, cwd, envFlags({ ...launchSpec?.env, ...argEnv }),
+        );
         // One argument, already quoted: `pane run` joins its operands with
         // spaces and types them into the pane's shell, so the quoting has to be
         // ours. It also submits the line itself (PaneSendInput carries