unsnooze 1.6.0 → 1.8.0

package/src/monitor.js

@@ -10,11 +10,11 @@
 
 import { readFileSync, unlinkSync } from 'node:fs';
 import { join } from 'node:path';
-import * as realTmux from './tmux.js';
+import { getMultiplexer } from './multiplexer.js';
 import {
   SCRAPE_INTERVAL_MS, PANE_SCAN_LINES, CAPTURE_LINES, EVENTS_DIR,
   EVENT_MARKER_TTL_MS, OVERLOAD_BACKOFF_S, OVERLOAD_JITTER,
-  FALLBACK_RESET_MS, RESET_MARGIN_MS, TMUX_SESSION_NAME,
+  FALLBACK_RESET_MS, RESET_MARGIN_MS, MUX_SESSION_NAME,
 } from './config.js';
 import { detectLimit, isBusy, overloadMatch } from './patterns.js';
 import { getAgent } from './agents/index.js';
@@ -24,18 +24,25 @@ import { parseResetTime, resetAtMs } from './time-parser.js';
 import { upsertSession, setStatus, readState } from './state.js';
 import { spawnResumerIfNeeded } from './spawn.js';
 import { makeLogger } from './logger.js';
+import { addressHash } from './lease.js';
 
 const log = makeLogger('monitor');
 
 const sleep = ms => new Promise(r => setTimeout(r, ms));
 
-export function createMonitor({ pane, cwd, agent = getAgent('claude'), tmux = realTmux, scrapeInterval = SCRAPE_INTERVAL_MS }) {
+export function createMonitor({
+  muxName = 'tmux', paneOwner = null, pane, leaseId = null, cwd,
+  agent = getAgent('claude'), mux = getMultiplexer(muxName, { owner: paneOwner }),
+  scrapeInterval = SCRAPE_INTERVAL_MS, notifier = notify,
+}) {
+  const notifyCtx = { mux: muxName, pane, paneOwner };
   let trackedKey = null;      // state key of the record we created
   let overloadAttempt = 0;
+  let terminalNotified = false;   // one notification per terminal-error appearance
   let running = true;
 
   function markerPath() {
-    return join(EVENTS_DIR, `${pane.replace(/[^%\w]/g, '_')}.json`);
+    return join(EVENTS_DIR, `${addressHash({ mux: muxName, paneOwner, pane })}.json`);
   }
 
   function consumeMarker() {
@@ -56,16 +63,19 @@ export function createMonitor({ pane, cwd, agent = getAgent('claude'), tmux = re
     });
     const sessionId = agent.latestSessionId(cwd, detectedAt);
     const state = upsertSession({
-      sessionId, cwd, pane, agent: agent.id, tmuxSession: TMUX_SESSION_NAME,
+      sessionId, cwd, pane, mux: muxName, paneOwner, leaseId,
+      agent: agent.id, muxSession: MUX_SESSION_NAME,
       status: 'stopped', limitType, detectedVia: via, detectedAt,
       resetAt: at, resetSource: source,
       attempts: 0, lastAttemptAt: null, lastError: null,
     });
     trackedKey = sessionId
-      || Object.values(state.sessions).find(s => s.pane === pane && s.status === 'stopped')?.key
+      || Object.values(state.sessions).find(s => s.mux === muxName
+        && s.paneOwner === paneOwner && s.pane === pane
+        && ['stopped', 'resuming', 'resumed'].includes(s.status))?.key
       || null;
     log(`pane ${pane}: limit recorded (${limitType}, via ${via}), resets ${new Date(at).toISOString()}`);
-    notify(`${agent.name} hit a usage limit`, `${cwd} — auto-resume at ${new Date(at).toLocaleTimeString()}`);
+    notifier(`${agent.name} hit a usage limit`, `${cwd} — auto-resume at ${new Date(at).toLocaleTimeString()}`, { context: notifyCtx });
     spawnResumerIfNeeded();
   }
 
@@ -77,10 +87,10 @@ export function createMonitor({ pane, cwd, agent = getAgent('claude'), tmux = re
     }
     const key = steps > 0 ? 'Down' : 'Up';
     for (let i = 0; i < Math.abs(steps); i++) {
-      await tmux.sendKey(pane, key);
+      await mux.sendKey(pane, key);
       await sleep(120);
     }
-    await tmux.sendKey(pane, 'Enter');
+    await mux.sendKey(pane, 'Enter');
     log(`pane ${pane}: selected "Stop and wait for limit to reset" (${steps} steps)`);
     await sleep(1000);
     // After selection the TUI prints the limit banner — next scrape records it.
@@ -100,16 +110,16 @@ export function createMonitor({ pane, cwd, agent = getAgent('claude'), tmux = re
     log(`pane ${pane}: overload — retry ${overloadAttempt}/${OVERLOAD_BACKOFF_S.length} in ${Math.round(wait / 1000)}s`);
     await sleep(wait);
     if (!running) return;
-    const text = await tmux.capturePane(pane, CAPTURE_LINES).catch(() => null);
+    const text = await mux.capturePane(pane, CAPTURE_LINES).catch(() => null);
     if (text === null) return;
     if (isBusy(text, agent.patterns.busyPatterns)) { log(`pane ${pane}: busy after overload wait — skip inject`); return; }
     if (!overloadMatch(text, agent.patterns.overloadPatterns)) { overloadAttempt = 0; return; }   // recovered on its own
-    await tmux.sendText(pane, 'Continue where you left off. The previous attempt failed with a transient API error.');
+    await mux.sendText(pane, 'Continue where you left off. The previous attempt failed with a transient API error.');
     log(`pane ${pane}: overload retry message sent`);
   }
 
   async function tick() {
-    if (!(await tmux.paneAlive(pane))) {
+    if (!(await mux.paneAlive(pane))) {
       log(`pane ${pane}: gone — monitor exiting (record persists for resumer)`);
       running = false;
       return;
@@ -118,7 +128,7 @@ export function createMonitor({ pane, cwd, agent = getAgent('claude'), tmux = re
     const marker = consumeMarker();
     let text;
     try {
-      text = await tmux.capturePane(pane, CAPTURE_LINES);
+      text = await mux.capturePane(pane, CAPTURE_LINES);
     } catch {
       return;   // transient capture failure
     }
@@ -126,8 +136,8 @@ export function createMonitor({ pane, cwd, agent = getAgent('claude'), tmux = re
     // Interactive menu takes priority — it blocks the session until answered.
     // Checked against the VISIBLE screen only: a menu in scrollback history
     // was already answered, and re-driving it would inject stray keys.
-    const visible = tmux.capturePaneVisible
-      ? await tmux.capturePaneVisible(pane).catch(() => '')
+    const visible = mux.capturePaneVisible
+      ? await mux.capturePaneVisible(pane).catch(() => '')
       : text;
     if (agent.menu && agent.menu.isPrompt(visible, PANE_SCAN_LINES)) {
       if (!getConfig('menuAutoAnswer')) {
@@ -156,16 +166,34 @@ export function createMonitor({ pane, cwd, agent = getAgent('claude'), tmux = re
       return;
     }
 
+    // Non-resetting terminal errors (credits exhausted, membership expired,
+    // discontinued tiers): notify once per appearance, never touch the ledger —
+    // there is no reset to wait for. Re-arms when the error clears.
+    const term = overloadMatch(text, agent.patterns.terminalPatterns || []);
+    if (term) {
+      if (!terminalNotified) {
+        terminalNotified = true;
+        notifier(`${agent.name} needs attention ⚠️`, `${cwd} — ${term.line}`, { context: notifyCtx });
+        log(`pane ${pane}: terminal error (no auto-resume): ${term.line}`);
+      }
+    } else {
+      terminalNotified = false;
+    }
+
     // No banner. If we were tracking a stopped record and claude is active
     // again, someone resumed it (user or resumer) — mark it.
     if (trackedKey) {
       const state = readState();
       const rec = state.sessions[trackedKey];
       if (rec && rec.status === 'stopped') {
-        setStatus(trackedKey, 'resumed', { lastAttemptAt: Date.now() });
+        setStatus(trackedKey, 'resumed', { lastAttemptAt: Date.now(), bannerCleared: true });
         log(`pane ${pane}: banner cleared, ${trackedKey} marked resumed`);
+        trackedKey = null;
       }
-      if (rec && rec.status !== 'stopped') trackedKey = null;
+      if (rec && rec.status === 'resumed') {
+        setStatus(trackedKey, 'resumed', { bannerCleared: true });
+        trackedKey = null;
+      } else if (rec && rec.status !== 'stopped') trackedKey = null;
     }
 
     // Overload marker (banner-less path).
@@ -191,9 +219,9 @@ export function createMonitor({ pane, cwd, agent = getAgent('claude'), tmux = re
   };
 }
 
-export async function runMonitor(pane, agentId) {
+export async function runMonitor(muxName, paneOwner, pane, agentId, leaseId) {
   const cwd = process.env.UNSNOOZE_CWD || process.cwd();
-  const monitor = createMonitor({ pane, cwd, agent: getAgent(agentId) });
+  const monitor = createMonitor({ muxName, paneOwner: paneOwner || null, pane, leaseId, cwd, agent: getAgent(agentId) });
   await monitor.run();
   return 0;
 }

package/src/multiplexer.js

@@ -0,0 +1,58 @@
+import tmux from './multiplexers/tmux.js';
+import zellij from './multiplexers/zellij.js';
+import { getConfig } from './settings.js';
+
+const NAMES = ['tmux', 'zellij'];
+
+export function createMultiplexerFactory({
+  backends = { tmux, zellij },
+  getSetting = () => getConfig('multiplexer'),
+  env = process.env,
+} = {}) {
+  const cache = new Map();
+
+  const prototypeFor = name => {
+    if (!NAMES.includes(name) || !backends[name]) {
+      throw new Error(`unsnooze: unknown multiplexer "${name}"`);
+    }
+    if (!cache.has(name)) cache.set(name, backends[name]);
+    return cache.get(name);
+  };
+
+  const isAvailable = name => {
+    try { return prototypeFor(name).available(); } catch { return false; }
+  };
+
+  const resolveName = explicit => {
+    if (explicit && explicit !== 'auto') return explicit;
+
+    let configured = 'auto';
+    try { configured = getSetting() || 'auto'; } catch { /* pre-setting compatibility */ }
+    if (configured !== 'auto') return configured;
+
+    if (env.ZELLIJ) return 'zellij';
+    if (env.TMUX) return 'tmux';
+
+    const tmuxInstalled = isAvailable('tmux');
+    const zellijInstalled = isAvailable('zellij');
+    if (tmuxInstalled !== zellijInstalled) return tmuxInstalled ? 'tmux' : 'zellij';
+    return 'tmux';
+  };
+
+  const getMultiplexer = (name, { owner = null } = {}) => {
+    const prototype = prototypeFor(resolveName(name));
+    return prototype.bind ? prototype.bind(owner) : prototype;
+  };
+
+  return {
+    getMultiplexer,
+    available: name => prototypeFor(name).available(),
+    inside: name => prototypeFor(name).inside(),
+  };
+}
+
+const factory = createMultiplexerFactory();
+
+export const getMultiplexer = (...args) => factory.getMultiplexer(...args);
+export const available = (...args) => factory.available(...args);
+export const inside = (...args) => factory.inside(...args);

package/src/multiplexers/tmux.js

@@ -0,0 +1,200 @@
+import { execFile as execFileCb, spawnSync } from 'node:child_process';
+import { constants as osConstants } from 'node:os';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFileCb);
+
+function defaultSpawner(file, args, { sync = false, ...options } = {}) {
+  if (sync) return spawnSync(file, args, options);
+  return execFileAsync(file, args, options).then(({ stdout }) => stdout);
+}
+
+function envArgs(env = {}) {
+  return Object.entries(env)
+    .filter(([, value]) => value !== undefined)
+    .flatMap(([key, value]) => ['-e', `${key}=${value}`]);
+}
+
+function exitStatus(result) {
+  if (result.status !== null && result.status !== undefined) return result.status;
+  return result.signal ? 128 + (osConstants.signals[result.signal] || 0) : 1;
+}
+
+function wrappedSessionName(env) {
+  return env.UNSNOOZE_SESSION_NAME || env.UNSNOOZE_TMUX_SESSION || 'unsnooze';
+}
+
+// Submit delay: text and the submitting Enter must be TWO separate send-keys
+// calls with a pause between them, or Ink treats Enter as bracketed paste.
+export const SUBMIT_DELAY_MS = 150;
+
+export function createTmux({ spawner = defaultSpawner, env = process.env } = {}) {
+  const run = (...args) => spawner('tmux', args);
+
+  const backend = {
+    name: 'tmux',
+    SUBMIT_DELAY_MS,
+
+    available() {
+      try {
+        return spawner('tmux', ['-V'], { sync: true, stdio: 'ignore' }).status === 0;
+      } catch {
+        return false;
+      }
+    },
+
+    inside() { return !!env.TMUX; },
+    currentPaneId() {
+      if (env.UNSNOOZE_MUX === 'tmux' && env.UNSNOOZE_PANE) return env.UNSNOOZE_PANE;
+      return env.TMUX_PANE || null;
+    },
+
+    async capturePane(pane, lines = 200) {
+      return run('capture-pane', '-t', pane, '-p', '-S', `-${lines}`);
+    },
+
+    async capturePaneVisible(pane) {
+      return run('capture-pane', '-t', pane, '-p');
+    },
+
+    async sendText(pane, text) {
+      await run('send-keys', '-t', pane, '-l', text);
+      await new Promise(resolve => setTimeout(resolve, SUBMIT_DELAY_MS));
+      await run('send-keys', '-t', pane, 'Enter');
+    },
+
+    async sendKey(pane, key) {
+      await run('send-keys', '-t', pane, key);
+    },
+
+    async paneAlive(pane) {
+      try {
+        // tmux 3.7b prints a blank line and exits 0 for a nonexistent target,
+        // so the exit code alone is not evidence — the output must echo the
+        // pane id back.
+        const out = await run('display-message', '-t', pane, '-p', '#{pane_id}');
+        return out.trim() === pane;
+      } catch {
+        return false;
+      }
+    },
+
+    // Clients attached to the session that owns `pane`. Detached / missing
+    // targets return [] so callers can feature-detect without try/catch.
+    async clientTtys(pane) {
+      try {
+        const out = await run('list-clients', '-t', pane, '-F', '#{client_tty}\t#{client_termname}');
+        return out.split('\n')
+          .map(line => line.trimEnd())
+          .filter(Boolean)
+          .map(line => {
+            const [tty, termname = ''] = line.split('\t');
+            return { tty, termname };
+          })
+          .filter(entry => entry.tty);
+      } catch {
+        return [];
+      }
+    },
+
+    async paneTty(pane) {
+      try {
+        const out = (await run('display-message', '-t', pane, '-p', '#{pane_tty}')).trim();
+        return out || null;
+      } catch {
+        return null;
+      }
+    },
+
+    // Global session env from `show-environment -g`. `-REMOVED` markers are
+    // skipped; only keys listed in `names` are returned. Errors → {}.
+    async globalEnv(names = []) {
+      if (!names.length) return {};
+      try {
+        const out = await run('show-environment', '-g');
+        const wanted = new Set(names);
+        const result = {};
+        for (const line of out.split('\n')) {
+          const trimmed = line.trimEnd();
+          // tmux prints "NAME=value" or "NAME -REMOVED"
+          if (!trimmed || trimmed.endsWith(' -REMOVED')) continue;
+          const eq = trimmed.indexOf('=');
+          if (eq <= 0) continue;
+          const key = trimmed.slice(0, eq);
+          if (!wanted.has(key)) continue;
+          result[key] = trimmed.slice(eq + 1);
+        }
+        return result;
+      } catch {
+        return {};
+      }
+    },
+
+    async paneCurrentCommand(pane) {
+      try {
+        return (await run('display-message', '-t', pane, '-p', '#{pane_current_command}')).trim();
+      } catch {
+        return null;
+      }
+    },
+
+    async sessionExists(name) {
+      try {
+        await run('has-session', '-t', name);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+
+    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.
+      const launch = [...envArgs(launchSpec.env), launchSpec.file, ...(launchSpec.args || [])];
+      let pane;
+      if (!(await backend.sessionExists(sessionName))) {
+        pane = await run('new-session', '-d', '-s', sessionName, '-c', cwd,
+          '-P', '-F', '#{pane_id}', ...launch);
+      } else {
+        pane = await run('new-window', '-t', `${sessionName}:`, '-c', cwd,
+          '-P', '-F', '#{pane_id}', ...launch);
+      }
+      return { pane: pane.trim(), paneOwner: sessionName };
+    },
+
+    launchWrapped(launchSpec) {
+      // A foreground, single-pane session disappears with the agent. Keeping
+      // 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),
+        ...envArgs(launchSpec.env), launchSpec.file, ...(launchSpec.args || [])];
+      const result = spawner('tmux', args, { sync: true, stdio: 'inherit', env });
+      return exitStatus(result);
+    },
+
+    // tmux pane ids are server-global, so owner binding is intentionally inert.
+    bind() { return backend; },
+  };
+
+  return backend;
+}
+
+const tmux = createTmux();
+
+export const available = (...args) => tmux.available(...args);
+export const tmuxAvailable = available;
+export const inside = (...args) => tmux.inside(...args);
+export const insideTmux = inside;
+export const currentPaneId = (...args) => tmux.currentPaneId(...args);
+export const capturePane = (...args) => tmux.capturePane(...args);
+export const capturePaneVisible = (...args) => tmux.capturePaneVisible(...args);
+export const sendText = (...args) => tmux.sendText(...args);
+export const sendKey = (...args) => tmux.sendKey(...args);
+export const paneAlive = (...args) => tmux.paneAlive(...args);
+export const paneCurrentCommand = (...args) => tmux.paneCurrentCommand(...args);
+export const sessionExists = (...args) => tmux.sessionExists(...args);
+export const newWindow = (...args) => tmux.newWindow(...args);
+export const launchWrapped = (...args) => tmux.launchWrapped(...args);
+
+export default tmux;

package/src/multiplexers/zellij.js

@@ -0,0 +1,193 @@
+import { execFile as execFileCb, spawnSync } from 'node:child_process';
+import { constants as osConstants } from 'node:os';
+import { basename } from 'node:path';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFileCb);
+
+function defaultSpawner(file, args, { sync = false, ...options } = {}) {
+  if (sync) return spawnSync(file, args, options);
+  return execFileAsync(file, args, options).then(({ stdout }) => stdout);
+}
+
+function scrubZellijEnv(env) {
+  return Object.fromEntries(Object.entries(env).filter(([key]) => !key.startsWith('ZELLIJ')));
+}
+
+function launchArgv({ file, args = [], env = {} }) {
+  const assignments = Object.entries(env)
+    .filter(([, value]) => value !== undefined)
+    .map(([key, value]) => `${key}=${value}`);
+  return ['/usr/bin/env', ...assignments, file, ...args];
+}
+
+function exitStatus(result) {
+  if (result.status !== null && result.status !== undefined) return result.status;
+  return result.signal ? 128 + (osConstants.signals[result.signal] || 0) : 1;
+}
+
+function wrappedSessionName(env) {
+  return env.UNSNOOZE_SESSION_NAME || env.UNSNOOZE_TMUX_SESSION || 'unsnooze';
+}
+
+function rawKeyBytes(key) {
+  const known = {
+    Escape: [27], Enter: [13], Tab: [9], Backspace: [127],
+    Down: [27, 91, 66], Up: [27, 91, 65],
+    Right: [27, 91, 67], Left: [27, 91, 68],
+  };
+  return known[key] || [...Buffer.from(key)];
+}
+
+function kdlString(value) {
+  return JSON.stringify(String(value));
+}
+
+function wrappedLayout(launchSpec) {
+  const argv = launchArgv(launchSpec);
+  return `layout { pane command=${kdlString(argv[0])} close_on_exit=true { args ${argv.slice(1).map(kdlString).join(' ')} } }`;
+}
+
+export const SUBMIT_DELAY_MS = 150;
+
+export function createZellij({ spawner = defaultSpawner, env = process.env } = {}) {
+  const childEnv = () => scrubZellijEnv(env);
+  const run = (args, options = {}) => spawner('zellij', args, { env: childEnv(), ...options });
+
+  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 parsed = JSON.parse(stdout);
+      return Array.isArray(parsed) ? parsed : [];
+    };
+
+    const backend = {
+      name: 'zellij',
+      owner,
+      SUBMIT_DELAY_MS,
+
+      available() {
+        try {
+          return spawner('zellij', ['--version'], { sync: true, stdio: 'ignore', env: childEnv() }).status === 0;
+        } catch {
+          return false;
+        }
+      },
+
+      inside() { return !!env.ZELLIJ; },
+      currentPaneId() {
+        if (env.UNSNOOZE_MUX === 'zellij' && env.UNSNOOZE_PANE) return env.UNSNOOZE_PANE;
+        return env.ZELLIJ_PANE_ID || null;
+      },
+
+      // v1 limitation: dump-screen is viewport-only, so `lines` is ignored;
+      // unlike tmux, a banner/menu that scrolls away between polls is missed.
+      // `dump-screen --full` may provide a future scrollback-capable option.
+      async capturePane(pane, _lines = 200) {
+        return owned('action', 'dump-screen', '--pane-id', String(pane));
+      },
+
+      async capturePaneVisible(pane) {
+        return owned('action', 'dump-screen', '--pane-id', String(pane));
+      },
+
+      async sendText(pane, text) {
+        await owned('action', 'write-chars', '--pane-id', String(pane), text);
+        await new Promise(resolve => setTimeout(resolve, SUBMIT_DELAY_MS));
+        await owned('action', 'write', '--pane-id', String(pane), '13');
+      },
+
+      async sendKey(pane, key) {
+        if (key === 'Down' || key === 'Up') {
+          try {
+            await owned('action', 'send-keys', '--pane-id', String(pane), key);
+            return;
+          } catch {
+            // Older/changed zellij key grammars still have a raw-byte path.
+          }
+        } else if (key === 'Enter') {
+          await owned('action', 'write', '--pane-id', String(pane), '13');
+          return;
+        }
+        await owned('action', 'write', '--pane-id', String(pane), ...rawKeyBytes(key).map(String));
+      },
+
+      async paneAlive(pane) {
+        try {
+          const id = Number(pane);
+          return (await paneEntries()).some(entry =>
+            entry.id === id && entry.is_plugin === false && entry.exited === false);
+        } catch {
+          return false;
+        }
+      },
+
+      async paneCurrentCommand(pane) {
+        try {
+          const id = Number(pane);
+          const entry = (await paneEntries()).find(candidate =>
+            candidate.id === id && candidate.is_plugin === false && candidate.exited === false);
+          // zellij's pane_command includes arguments (e.g. "node -e …",
+          // "claude --resume <id>"), so take the executable token before basename.
+          if (!entry?.pane_command) return null;
+          return basename(entry.pane_command.trim().split(/\s+/)[0]);
+        } catch {
+          return null;
+        }
+      },
+
+      async sessionExists(name) {
+        try {
+          const stdout = await run(['list-sessions', '-s']);
+          return stdout.split(/\r?\n/).some(line => line.trim() === name);
+        } catch {
+          return false;
+        }
+      },
+
+      async newWindow(sessionName, cwd, launchSpec) {
+        if (!(await backend.sessionExists(sessionName))) {
+          await run(['attach', '-b', '-c', sessionName]);
+        }
+        const stdout = await run([
+          '-s', sessionName, 'run', '--cwd', cwd, '--', ...launchArgv(launchSpec),
+        ]);
+        const match = stdout.trim().match(/^terminal_(\d+)$/);
+        if (!match) throw new Error(`unsnooze: unexpected zellij pane id: ${stdout.trim()}`);
+        return { pane: match[1], paneOwner: sessionName };
+      },
+
+      launchWrapped(launchSpec) {
+        // 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 result = spawner('zellij', [
+          '--session', wrappedSessionName(env), '--layout-string', wrappedLayout(launchSpec),
+        ], {
+          sync: true, stdio: 'inherit', env: childEnv(),
+        });
+        return exitStatus(result);
+      },
+
+      bind(nextOwner) { return build(nextOwner); },
+    };
+
+    return backend;
+  };
+
+  return build(null);
+}
+
+const zellij = createZellij();
+
+export const available = (...args) => zellij.available(...args);
+export const inside = (...args) => zellij.inside(...args);
+export const currentPaneId = (...args) => zellij.currentPaneId(...args);
+export const launchWrapped = (...args) => zellij.launchWrapped(...args);
+
+export default zellij;