unsnooze 1.9.0 → 1.10.0

package/src/multiplexers/session-name.js

@@ -0,0 +1,28 @@
+// Wrapped sessions are created by name, and both tmux and zellij refuse a name
+// that is already live (tmux: "duplicate session: unsnooze"). Concurrent
+// `unsnooze <agent>` launches therefore need distinct names: the first holds
+// the base, later ones take the first free `<base>-N`.
+
+const MAX_PROBES = 64;
+
+export function resolveSessionName(base, isTaken) {
+  if (!isTaken(base)) return base;
+  for (let n = 2; n <= MAX_PROBES; n += 1) {
+    const candidate = `${base}-${n}`;
+    if (!isTaken(candidate)) return candidate;
+  }
+  // Improbable, but a name must still be returned; the pid is unique among live
+  // sessions even if a stale `<base>-<pid>` somehow lingers.
+  return `${base}-${process.pid}`;
+}
+
+// Raised by launchWrapped when the multiplexer binary could not be started
+// (spawnSync result.error). Distinct from a normal agent exit status so the
+// launcher can degrade to an unwatched CLI without double-running a healthy agent.
+export class SessionCreateError extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.name = 'SessionCreateError';
+    if (cause !== undefined) this.cause = cause;
+  }
+}

package/src/multiplexers/tmux.js

@@ -2,6 +2,8 @@ import { execFile as execFileCb, spawnSync } from 'node:child_process';
 import { constants as osConstants } from 'node:os';
 import { promisify } from 'node:util';
 
+import { resolveSessionName, SessionCreateError } from './session-name.js';
+
 const execFileAsync = promisify(execFileCb);
 
 function defaultSpawner(file, args, { sync = false, ...options } = {}) {
@@ -28,6 +30,8 @@ function wrappedSessionName(env) {
 // calls with a pause between them, or Ink treats Enter as bracketed paste.
 export const SUBMIT_DELAY_MS = 150;
 
+export { SessionCreateError };
+
 export function createTmux({ spawner = defaultSpawner, env = process.env } = {}) {
   const run = (...args) => spawner('tmux', args);
 
@@ -79,6 +83,17 @@ export function createTmux({ spawner = defaultSpawner, env = process.env } = {})
       }
     },
 
+    // Live session the pane currently lives in. Trust stdout, not the exit
+    // code (same tmux 3.7b blank-success pitfall as paneAlive).
+    async sessionForPane(pane) {
+      try {
+        const out = (await run('display-message', '-t', pane, '-p', '#{session_name}')).trim();
+        return out || null;
+      } catch {
+        return null;
+      }
+    },
+
     // Clients attached to the session that owns `pane`. Detached / missing
     // targets return [] so callers can feature-detect without try/catch.
     async clientTtys(pane) {
@@ -147,6 +162,33 @@ export function createTmux({ spawner = defaultSpawner, env = process.env } = {})
       }
     },
 
+    async listSessions() {
+      try {
+        const out = await run('list-sessions', '-F', '#{session_name}');
+        return out.split(/\r?\n/).map(line => line.trim()).filter(Boolean)
+          .map(name => ({ name, exited: false }));
+      } catch {
+        return [];
+      }
+    },
+
+    async listSessionPanes(sessionName) {
+      try {
+        const out = await run('list-panes', '-t', sessionName, '-F', '#{pane_id}');
+        return out.split(/\r?\n/).map(line => line.trim()).filter(Boolean);
+      } catch {
+        return [];
+      }
+    },
+
+    async closePane(pane) {
+      await run('kill-pane', '-t', pane);
+    },
+
+    async deleteSession(name) {
+      await run('kill-session', '-t', name);
+    },
+
     async newWindow(sessionName, cwd, launchSpec) {
       // Environment flags require tmux >= 3.0 for new-window and >= 3.2 for
       // new-session. Older tmux fails revival with an "unknown flag -e" error.
@@ -159,7 +201,9 @@ export function createTmux({ spawner = defaultSpawner, env = process.env } = {})
         pane = await run('new-window', '-t', `${sessionName}:`, '-c', cwd,
           '-P', '-F', '#{pane_id}', ...launch);
       }
-      return { pane: pane.trim(), paneOwner: sessionName };
+      // tmux pane ids are server-global; paneOwner is only meaningful for
+      // zellij. Tracking the session lives on muxSession, not paneOwner.
+      return { pane: pane.trim(), paneOwner: null };
     },
 
     launchWrapped(launchSpec) {
@@ -167,9 +211,26 @@ export function createTmux({ spawner = defaultSpawner, env = process.env } = {})
       // tmux in the foreground also gives Ctrl-C to the active pane directly.
       // Its -e environment flags require tmux >= 3.2; older versions fail
       // revival with an "unknown flag -e" error.
-      const args = ['new-session', '-s', wrappedSessionName(env),
+      const name = resolveSessionName(wrappedSessionName(env), candidate => {
+        try {
+          return spawner('tmux', ['has-session', '-t', candidate],
+            { sync: true, stdio: 'ignore', env }).status === 0;
+        } catch {
+          return false;
+        }
+      });
+      // Session name is discovered live via sessionForPane at record-write
+      // time — do NOT inject UNSNOOZE_SESSION_NAME (would leak into daemons
+      // spawned from the agent via {...process.env}).
+      const args = ['new-session', '-s', name,
         ...envArgs(launchSpec.env), launchSpec.file, ...(launchSpec.args || [])];
       const result = spawner('tmux', args, { sync: true, stdio: 'inherit', env });
+      if (result?.error) {
+        throw new SessionCreateError(
+          `failed to start tmux session "${name}": ${result.error.message}`,
+          result.error,
+        );
+      }
       return exitStatus(result);
     },
 

package/src/multiplexers/zellij.js

@@ -3,6 +3,8 @@ import { constants as osConstants } from 'node:os';
 import { basename } from 'node:path';
 import { promisify } from 'node:util';
 
+import { resolveSessionName, SessionCreateError } from './session-name.js';
+
 const execFileAsync = promisify(execFileCb);
 
 function defaultSpawner(file, args, { sync = false, ...options } = {}) {
@@ -48,20 +50,54 @@ function wrappedLayout(launchSpec) {
   return `layout { pane command=${kdlString(argv[0])} close_on_exit=true { args ${argv.slice(1).map(kdlString).join(' ')} } }`;
 }
 
+// Parse `zellij list-sessions -s` rows: strip ANSI, keep leading name token,
+// detect an "(EXITED …)" suffix. Rows that fail to parse are dropped.
+function parseSessionRows(stdout) {
+  return String(stdout)
+    // eslint-disable-next-line no-control-regex
+    .replace(/\u001b\[[0-9;]*m/g, '')
+    .split(/\r?\n/)
+    .map(line => line.trim())
+    .filter(Boolean)
+    .map(line => {
+      const name = line.split(/\s+/)[0];
+      if (!name) return null;
+      return { name, exited: /\(EXITED/i.test(line) };
+    })
+    .filter(Boolean);
+}
+
 export const SUBMIT_DELAY_MS = 150;
 
+export { SessionCreateError };
+
 export function createZellij({ spawner = defaultSpawner, env = process.env } = {}) {
   const childEnv = () => scrubZellijEnv(env);
   const run = (args, options = {}) => spawner('zellij', args, { env: childEnv(), ...options });
 
+  // Sync counterpart of sessionExists, for the sync launchWrapped path. Rows can
+  // carry ANSI colour and an "(EXITED …)" suffix, so only the leading name token
+  // is compared. Probe failure → empty set: assume free and let zellij arbitrate.
+  const liveSessionNames = () => {
+    try {
+      const result = spawner('zellij', ['list-sessions', '-s'],
+        { sync: true, encoding: 'utf8', env: childEnv() });
+      const stdout = typeof result === 'string' ? result : (result?.stdout ?? '');
+      return new Set(parseSessionRows(stdout).map(row => row.name));
+    } catch {
+      return new Set();
+    }
+  };
+
   const build = owner => {
     const owned = (...args) => {
       if (!owner) throw new Error('unsnooze: zellij pane operation requires a session owner');
       return run(['-s', owner, ...args]);
     };
 
-    const paneEntries = async () => {
-      const stdout = await owned('action', 'list-panes', '-a', '-j');
+    const paneEntries = async (session = owner) => {
+      if (!session) throw new Error('unsnooze: zellij pane operation requires a session owner');
+      const stdout = await run(['-s', session, 'action', 'list-panes', '-a', '-j']);
       const parsed = JSON.parse(stdout);
       return Array.isArray(parsed) ? parsed : [];
     };
@@ -127,6 +163,12 @@ export function createZellij({ spawner = defaultSpawner, env = process.env } = {
         }
       },
 
+      // Pane ids are per-session; the bound owner is the session name. Fall
+      // back to the ambient ZELLIJ_SESSION_NAME when unbound.
+      async sessionForPane(_pane) {
+        return owner || env.ZELLIJ_SESSION_NAME || null;
+      },
+
       async paneCurrentCommand(pane) {
         try {
           const id = Number(pane);
@@ -144,21 +186,75 @@ export function createZellij({ spawner = defaultSpawner, env = process.env } = {
       async sessionExists(name) {
         try {
           const stdout = await run(['list-sessions', '-s']);
-          return stdout.split(/\r?\n/).some(line => line.trim() === name);
+          return parseSessionRows(stdout).some(row => row.name === name);
         } catch {
           return false;
         }
       },
 
+      async listSessions() {
+        try {
+          const stdout = await run(['list-sessions', '-s']);
+          return parseSessionRows(stdout);
+        } catch {
+          return [];
+        }
+      },
+
+      async listSessionPanes(sessionName) {
+        try {
+          const entries = await paneEntries(sessionName);
+          return entries
+            .filter(entry => entry.is_plugin === false && entry.exited === false)
+            .map(entry => String(entry.id));
+        } catch {
+          return [];
+        }
+      },
+
+      async closePane(pane) {
+        if (!owner) throw new Error('unsnooze: zellij pane operation requires a session owner');
+        await owned('action', 'close-pane', '-p', `terminal_${pane}`);
+      },
+
+      async deleteSession(name) {
+        await run(['delete-session', name]);
+      },
+
       async newWindow(sessionName, cwd, launchSpec) {
+        let created = false;
+        let preexisting = [];
         if (!(await backend.sessionExists(sessionName))) {
+          // attach -b -c uses the default layout, which leaves a shell pane
+          // that never exits. Snapshot its ids so we can close them after the
+          // agent pane is added (closing the last pane would kill the session).
           await run(['attach', '-b', '-c', sessionName]);
+          created = true;
+          try {
+            preexisting = (await paneEntries(sessionName))
+              .filter(entry => entry.is_plugin === false)
+              .map(entry => entry.id);
+          } catch {
+            preexisting = [];
+          }
         }
+        // --close-on-exit matches launchWrapped's close_on_exit=true and tmux
+        // (pane dies with its command) so exited revivals don't keep the session.
         const stdout = await run([
-          '-s', sessionName, 'run', '--cwd', cwd, '--', ...launchArgv(launchSpec),
+          '-s', sessionName, 'run', '--close-on-exit', '--cwd', cwd, '--',
+          ...launchArgv(launchSpec),
         ]);
         const match = stdout.trim().match(/^terminal_(\d+)$/);
         if (!match) throw new Error(`unsnooze: unexpected zellij pane id: ${stdout.trim()}`);
+        if (created && preexisting.length) {
+          for (const id of preexisting) {
+            try {
+              await run(['-s', sessionName, 'action', 'close-pane', '-p', `terminal_${id}`]);
+            } catch {
+              // Best-effort: a missing default pane is fine.
+            }
+          }
+        }
         return { pane: match[1], paneOwner: sessionName };
       },
 
@@ -166,11 +262,21 @@ export function createZellij({ spawner = defaultSpawner, env = process.env } = {
         // The layout contains exactly one auto-closing pane, avoiding the
         // lingering default shell created by attach -b. The foreground client
         // owns the terminal, so Ctrl-C reaches zellij and its active pane.
+        const live = liveSessionNames();
+        const name = resolveSessionName(wrappedSessionName(env), c => live.has(c));
+        // Session name is discovered live via sessionForPane at record-write
+        // time — do NOT inject UNSNOOZE_SESSION_NAME into the layout env.
         const result = spawner('zellij', [
-          '--session', wrappedSessionName(env), '--layout-string', wrappedLayout(launchSpec),
+          '--session', name, '--layout-string', wrappedLayout(launchSpec),
         ], {
           sync: true, stdio: 'inherit', env: childEnv(),
         });
+        if (result?.error) {
+          throw new SessionCreateError(
+            `failed to start zellij session "${name}": ${result.error.message}`,
+            result.error,
+          );
+        }
         return exitStatus(result);
       },
 

package/src/reap.js

@@ -0,0 +1,187 @@
+// Explicit process/session cleanup (`unsnooze sessions` / `unsnooze reap`).
+// Never auto-kills a live agent pane unless the user opts in via reapResumed.
+
+import { MUX_SESSION_NAME, RESUME_SESSION_NAME } from './config.js';
+import { getMultiplexer } from './multiplexer.js';
+import { readState, setStatus, updateState } from './state.js';
+import { getConfig } from './settings.js';
+import { makeLogger } from './logger.js';
+
+const log = makeLogger('reap');
+
+// How a user reaches a revived session. Shared by status, toast, and `sessions`.
+export function attachHint(muxName, sessionName) {
+  if (!sessionName) return null;
+  if (muxName === 'zellij') return `zellij attach ${sessionName}`;
+  return `tmux attach -t ${sessionName}`;
+}
+
+// A session name is unsnooze-owned if it is the interactive base, a collision
+// suffix (`unsnooze-2`…), the dedicated resume session, or a pid fallback.
+export function isUnsnoozeSessionName(name, base = MUX_SESSION_NAME) {
+  if (!name || typeof name !== 'string') return false;
+  if (name === base) return true;
+  if (name === RESUME_SESSION_NAME) return true;
+  if (name === `${base}-resumed`) return true;
+  // base-N / base-<pid>
+  if (name.startsWith(`${base}-`) && /^[0-9]+$/.test(name.slice(base.length + 1))) return true;
+  return false;
+}
+
+export async function listOwnedSessions({ muxName = null } = {}) {
+  const names = muxName ? [muxName] : ['tmux', 'zellij'];
+  const out = [];
+  for (const name of names) {
+    let mux;
+    try { mux = getMultiplexer(name); } catch { continue; }
+    if (!mux.available?.()) continue;
+    if (typeof mux.listSessions !== 'function') continue;
+    let sessions = [];
+    try { sessions = await mux.listSessions(); } catch { continue; }
+    for (const row of sessions) {
+      if (!isUnsnoozeSessionName(row.name)) continue;
+      let panes = [];
+      try {
+        const bound = mux.bind ? mux.bind(row.name) : mux;
+        panes = typeof bound.listSessionPanes === 'function'
+          ? await bound.listSessionPanes(row.name)
+          : [];
+      } catch { panes = []; }
+      // Match records that live in this session.
+      const records = Object.values(readState().sessions).filter(s =>
+        (s.muxSession === row.name || s.paneOwner === row.name)
+        && (!s.mux || s.mux === name));
+      out.push({
+        mux: name,
+        name: row.name,
+        exited: !!row.exited,
+        panes,
+        records: records.map(r => ({
+          key: r.key,
+          status: r.status,
+          agent: r.agent,
+          cwd: r.cwd,
+          pane: r.pane,
+        })),
+        attach: attachHint(name, row.name),
+      });
+    }
+  }
+  return out;
+}
+
+// Close panes for terminal records and remove empty/exited unsnooze sessions.
+// dryRun (default true) only reports what would happen.
+export async function reap({
+  dryRun = true,
+  yes = false,
+  resolveMux = rec => getMultiplexer(rec.mux, { owner: rec.paneOwner }),
+} = {}) {
+  // --yes flips dry-run off; plain default stays dry-run.
+  if (yes) dryRun = false;
+  const actions = [];
+  const state = readState();
+  const terminal = Object.values(state.sessions).filter(s =>
+    ['resumed', 'failed', 'cancelled'].includes(s.status) && s.pane);
+
+  for (const rec of terminal) {
+    let alive = false;
+    try {
+      const mux = resolveMux(rec);
+      alive = await mux.paneAlive(rec.pane);
+    } catch { alive = false; }
+    if (!alive) {
+      actions.push({ kind: 'drop-record', key: rec.key, reason: 'pane already dead' });
+      if (!dryRun) {
+        updateState(s => { delete s.sessions[rec.key]; return s; });
+      }
+      continue;
+    }
+    actions.push({
+      kind: 'close-pane',
+      key: rec.key,
+      mux: rec.mux,
+      pane: rec.pane,
+      paneOwner: rec.paneOwner,
+      session: rec.muxSession,
+    });
+    if (!dryRun) {
+      try {
+        const mux = resolveMux(rec);
+        if (typeof mux.closePane === 'function') await mux.closePane(rec.pane);
+        setStatus(rec.key, rec.status, { pane: null });
+        updateState(s => { delete s.sessions[rec.key]; return s; });
+      } catch (err) {
+        actions.push({ kind: 'error', key: rec.key, message: err.message });
+      }
+    }
+  }
+
+  // Empty / EXITED unsnooze-owned sessions.
+  for (const name of ['tmux', 'zellij']) {
+    let mux;
+    try { mux = getMultiplexer(name); } catch { continue; }
+    if (!mux.available?.() || typeof mux.listSessions !== 'function') continue;
+    let sessions = [];
+    try { sessions = await mux.listSessions(); } catch { continue; }
+    for (const row of sessions) {
+      if (!isUnsnoozeSessionName(row.name)) continue;
+      const bound = mux.bind ? mux.bind(row.name) : mux;
+      let panes = [];
+      try {
+        panes = typeof bound.listSessionPanes === 'function'
+          ? await bound.listSessionPanes(row.name)
+          : [];
+      } catch { panes = []; }
+      const empty = panes.length === 0;
+      const exited = !!row.exited;
+      // tmux auto-destroys empty sessions; only act when empty (or EXITED for zellij).
+      if (!empty && !exited) continue;
+      actions.push({
+        kind: 'delete-session',
+        mux: name,
+        name: row.name,
+        reason: exited ? 'exited' : 'empty',
+      });
+      if (!dryRun && typeof bound.deleteSession === 'function') {
+        try { await bound.deleteSession(row.name); }
+        catch (err) {
+          actions.push({ kind: 'error', name: row.name, message: err.message });
+        }
+      }
+    }
+  }
+
+  return { dryRun, actions };
+}
+
+// Optional auto-reap of long-idle `resumed` panes when reapResumed is on.
+export async function autoReapIfEnabled({
+  resolveMux = rec => getMultiplexer(rec.mux, { owner: rec.paneOwner }),
+  now = Date.now(),
+} = {}) {
+  if (!getConfig('reapResumed')) return 0;
+  const idleAfter = getConfig('reapIdleAfter');
+  let closed = 0;
+  for (const rec of Object.values(readState().sessions)) {
+    if (rec.status !== 'resumed' || !rec.pane) continue;
+    const ts = rec.lastAttemptAt || rec.detectedAt || 0;
+    if (ts > now - idleAfter) continue;
+    try {
+      const mux = resolveMux(rec);
+      if (!(await mux.paneAlive(rec.pane))) {
+        updateState(s => { delete s.sessions[rec.key]; return s; });
+        continue;
+      }
+      if (typeof mux.closePane === 'function') {
+        await mux.closePane(rec.pane);
+        closed += 1;
+        log(`${rec.key}: auto-reaped idle resumed pane ${rec.pane}`);
+      }
+      updateState(s => { delete s.sessions[rec.key]; return s; });
+    } catch (err) {
+      log(`${rec.key}: auto-reap failed: ${err.message}`);
+    }
+  }
+  return closed;
+}