claude-term-tabs 0.0.0-bootstrap

package/dist/cli.js

@@ -0,0 +1,275 @@
+import { spawnSync } from 'node:child_process';
+import { closeSync, openSync, readSync } from 'node:fs';
+import { sep } from 'node:path';
+import { isatty } from 'node:tty';
+import { fileURLToPath } from 'node:url';
+import { parseFlags, SEARCH_FLAGS } from "./args.js";
+import { DigestCache } from "./cache.js";
+import { loadConfig } from "./config.js";
+import { realExec } from "./exec.js";
+import { dirExists as realDirExists, listClosedSessions, resumeCommand } from "./history.js";
+import { collectLiveSessions } from "./live.js";
+import { askHaiku, MAX_LLM_CANDIDATES } from "./llm.js";
+import { lineWriter } from "./output.js";
+import { defaultDirs } from "./paths.js";
+import { formatPickerLine, pick as realPick } from "./picker.js";
+import { clearWinner, rankLocal, tokenize } from "./score.js";
+import { detectAdapter } from "./terminals/adapter.js";
+import { runCommand } from "./commands.js";
+import { listPanesOrWarn } from "./discover.js";
+import { HELP } from "./help.js";
+export { runCommand };
+import { shellQuote } from "./shell.js";
+const EXIT_OK = 0;
+const EXIT_NONE = 1;
+const EXIT_ERROR = 2;
+/** Parse argv; throws on unknown flags. */
+export function parseArgs(argv) {
+    const { values, positionals } = parseFlags(argv, SEARCH_FLAGS, { positionals: true });
+    return {
+        query: positionals.join(' '),
+        list: values.list || values.json,
+        all: values.all,
+        json: values.json,
+        noLlm: values['no-llm'],
+        terminal: values.terminal,
+        help: values.help
+    };
+}
+/** Run the search and act on the result. Returns the process exit code. */
+export function run(opts, deps) {
+    if (opts.help) {
+        deps.stdout(HELP);
+        return EXIT_OK;
+    }
+    try {
+        const config = loadConfig(deps.dirs.config);
+        const adapter = deps.resolveAdapter(opts.terminal);
+        const panes = listPanesOrWarn(adapter, deps);
+        const pool = gatherCandidates(opts, deps, panes, config);
+        const ctx = { opts, deps, adapter, config, multiWindow: new Set(panes.map(p => p.windowIndex)).size > 1 };
+        return search(ctx, pool);
+    }
+    catch (err) {
+        deps.stderr(`claude-term-tabs: ${err.message}`);
+        return EXIT_ERROR;
+    }
+}
+function search(ctx, pool) {
+    const { opts, deps } = ctx;
+    if (tokenize(opts.query).length === 0)
+        return choose(ctx, byRecency(opts.all ? pool : pool.filter(c => c.live)), new Map());
+    const ranked = rankLocal(opts.query, pool, deps.now());
+    const winner = clearWinner(ranked);
+    if (winner !== undefined)
+        return confident(ctx, winner);
+    const local = ranked.map(r => r.cand);
+    if (opts.noLlm)
+        return choose(ctx, local, new Map());
+    const sent = dedupe([...local, ...byRecency(pool)]).slice(0, MAX_LLM_CANDIDATES);
+    const matches = askHaiku(opts.query, sent, deps.exec, deps.stderr);
+    if (matches === undefined) {
+        if (local.length > 0)
+            return choose(ctx, local, new Map());
+        deps.stdout('No local match, and Haiku was unavailable (see the warning above). Try different words or --all.');
+        return EXIT_NONE;
+    }
+    const byId = new Map(sent.map(c => [c.digest.sessionId, c]));
+    const found = matches.flatMap(m => byId.get(m.sessionId) ?? []);
+    const summaries = new Map(matches.map(m => [m.sessionId, m.summary]));
+    if (found.length === 1)
+        return confident(ctx, found[0], summaries.get(found[0].digest.sessionId));
+    return choose(ctx, found, summaries);
+}
+function choose(ctx, cands, summaries) {
+    const { opts, deps } = ctx;
+    if (cands.length === 0) {
+        deps.stdout(opts.all ? 'No matching sessions.' : 'No matching sessions. Try --all.');
+        return EXIT_NONE;
+    }
+    if (opts.list || !deps.isTty)
+        return printList(ctx, cands, summaries);
+    const chosen = deps.pick(cands, summaries);
+    return chosen === undefined ? EXIT_NONE : act(ctx, chosen, summaries.get(chosen.digest.sessionId));
+}
+function confident(ctx, c, summary) {
+    if (c.live)
+        return act(ctx, c, summary);
+    return choose(ctx, [c], new Map(summary !== undefined ? [[c.digest.sessionId, summary]] : []));
+}
+function act(ctx, c, summary) {
+    const { opts, deps, adapter } = ctx;
+    if (opts.list)
+        return printList(ctx, [c], new Map(summary !== undefined ? [[c.digest.sessionId, summary]] : []));
+    if (!c.live)
+        return resume(ctx, c);
+    if (adapter === undefined || c.pane === undefined) {
+        deps.stdout(`${describe(c, summary, deps.now())}`);
+        deps.stderr('claude-term-tabs: no supported terminal pane for this session, so not switching');
+        return EXIT_OK;
+    }
+    adapter.focus(c.pane);
+    deps.stdout(confirmation(c, ctx.multiWindow));
+    return EXIT_OK;
+}
+function resume(ctx, c) {
+    const { deps, adapter, config } = ctx;
+    const command = resumeCommand(config, c.digest.sessionId);
+    if (c.dirGone === true) {
+        deps.stdout(`${c.digest.cwd || '(unknown directory)'} no longer exists, and claude --resume only finds a session from the directory it ran in.\n  cd ${shellQuote(c.digest.cwd)} && ${command}`);
+        return EXIT_NONE;
+    }
+    if (adapter === undefined) {
+        deps.stdout(`cd ${shellQuote(c.digest.cwd)} && ${command}`);
+        return EXIT_OK;
+    }
+    adapter.openPane(c.digest.cwd, command);
+    deps.stdout(`→ resuming ${c.digest.title ?? c.digest.sessionId} · ${c.digest.repo} in a new tab`);
+    return EXIT_OK;
+}
+function printList(ctx, cands, summaries) {
+    const { opts, deps } = ctx;
+    const now = deps.now();
+    if (opts.json) {
+        deps.stdout(JSON.stringify(cands.map(c => toJson(c, summaries.get(c.digest.sessionId))), null, 2));
+    }
+    else {
+        deps.stdout(cands.map(c => describe(c, summaries.get(c.digest.sessionId), now)).join('\n'));
+    }
+    return EXIT_OK;
+}
+function describe(c, summary, now) {
+    const line = formatPickerLine(c, summary, now).split('\t')[1];
+    return c.pane === undefined && c.tty !== undefined ? `${line} · ${c.tty}` : line;
+}
+function confirmation(c, multiWindow) {
+    const where = [multiWindow ? `window ${c.pane?.windowIndex}` : undefined, `tab ${c.pane?.tabIndex}`].filter(Boolean).join(' · ');
+    return `→ ${c.digest.title ?? c.digest.sessionId} · ${c.digest.repo} · ${where}`;
+}
+function toJson(c, summary) {
+    const d = c.digest;
+    return {
+        sessionId: d.sessionId,
+        title: d.title,
+        repo: d.repo,
+        worktree: d.worktree,
+        branch: d.branch,
+        cwd: d.cwd,
+        live: c.live,
+        status: c.status,
+        lastActive: d.lastActive,
+        tty: c.tty,
+        window: c.pane?.windowIndex,
+        tab: c.pane?.tabIndex,
+        dirGone: c.dirGone,
+        summary
+    };
+}
+function gatherCandidates(opts, deps, panes, config) {
+    const cache = DigestCache.load(deps.dirs.cache, deps.stderr);
+    const paneByTty = new Map(panes.map(p => [p.tty, p]));
+    const live = collectLiveSessions({ sessionsDir: deps.dirs.sessions, projectsDir: deps.dirs.projects, exec: deps.exec, cache })
+        .map(c => ({ ...c, pane: c.tty !== undefined ? paneByTty.get(c.tty) : undefined }));
+    const closed = opts.all
+        ? listClosedSessions({ projectsDir: deps.dirs.projects, liveIds: new Set(live.map(c => c.digest.sessionId)), excludeDirs: config.excludeDirs, cache, dirExists: deps.dirExists })
+        : [];
+    if (opts.all)
+        cache.retainOnly(cache.touched());
+    try {
+        cache.save();
+    }
+    catch (err) {
+        deps.stderr(`claude-term-tabs: could not save cache: ${err.message}`);
+    }
+    return [...live, ...closed];
+}
+function byRecency(cands) {
+    return [...cands].sort((a, b) => b.digest.lastActive - a.digest.lastActive);
+}
+function dedupe(cands) {
+    const seen = new Set();
+    return cands.filter(c => !seen.has(c.digest.sessionId) && seen.add(c.digest.sessionId) !== undefined);
+}
+const realExecTty = (cmd, args, input) => {
+    if (process.env.CTT_NO_REAL_EXEC === '1')
+        return { status: 126, stdout: '', stderr: `${cmd}: blocked by CTT_NO_REAL_EXEC` };
+    const r = spawnSync(cmd, args, { encoding: 'utf8', input, stdio: ['pipe', 'pipe', 'inherit'] });
+    if (r.error)
+        return { status: 127, stdout: '', stderr: `${cmd}: ${r.error.message}` };
+    return { status: r.status ?? 1, stdout: r.stdout ?? '', stderr: '' };
+};
+function promptTty(question) {
+    process.stderr.write(question);
+    const fd = openSync('/dev/tty', 'r');
+    try {
+        const buf = Buffer.alloc(256);
+        const n = readSync(fd, buf, 0, buf.length, null);
+        return buf.subarray(0, n).toString('utf8').split('\n')[0];
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/**
+ * The real outside world. Building it runs nothing: whether fzf is installed is checked the first
+ * time something asks, so completion requests, which never need it, start no process.
+ */
+export function realDeps(exec = realExec) {
+    let fzf;
+    const deps = {
+        exec,
+        execTty: realExecTty,
+        dirs: defaultDirs,
+        stdout: lineWriter(1),
+        stderr: lineWriter(2),
+        prompt: promptTty,
+        now: Date.now,
+        // isatty, not process.stdout.isTTY: touching process.stdout makes a piped fd 1 non-blocking.
+        isTty: isatty(1),
+        get hasFzf() {
+            fzf ??= exec('sh', ['-c', 'command -v fzf']).status === 0;
+            return fzf;
+        },
+        dirExists: realDirExists,
+        resolveAdapter: override => detectAdapter(process.env, exec, override),
+        pick: (cands, summaries) => realPick(cands, summaries, realExecTty, { hasFzf: deps.hasFzf, prompt: promptTty }),
+        isAlive: pid => {
+            try {
+                process.kill(pid, 0);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        sleep: ms => new Promise(resolve => setTimeout(resolve, ms)),
+        self: [process.execPath, process.argv[1]],
+        completionProgram: completionProgram(process.argv[1], import.meta.url),
+        shell: process.env.SHELL
+    };
+    return deps;
+}
+/**
+ * What a completion script should run. An installed package (built, so it runs from dist/) is called by name from
+ * PATH, because the path it ran from may not last (npx cleans its cache; a version manager keeps one prefix per Node). A clone runs from src/ and keeps
+ * its own path, so it works without being on PATH.
+ */
+export function completionProgram(argv1, moduleUrl) {
+    return fileURLToPath(moduleUrl).endsWith(`${sep}dist${sep}cli.js`) ? 'claude-term-tabs' : argv1;
+}
+/** Entry point used by bin/claude-term-tabs. */
+export async function main(argv) {
+    const deps = realDeps();
+    const sub = await runCommand(argv, deps);
+    if (sub !== undefined)
+        return sub;
+    let opts;
+    try {
+        opts = parseArgs(argv);
+    }
+    catch (err) {
+        process.stderr.write(`claude-term-tabs: ${err.message}\n${HELP}\n`);
+        return EXIT_ERROR;
+    }
+    return run(opts, deps);
+}

package/dist/commands.js

@@ -0,0 +1,150 @@
+import { readFileSync, statSync } from 'node:fs';
+import { basename } from 'node:path';
+import { COMMANDS, completionScript, isCommand, isShell, PAUSE_FLAGS, parseFlags, RESUME_FLAGS, SHELLS } from "./args.js";
+import { answerCompletion, COMPLETE_FLAG } from "./complete.js";
+import { loadConfig } from "./config.js";
+import { HELP } from "./help.js";
+import { liveWithPanes } from "./discover.js";
+import { inFrontOf } from "./foreground.js";
+import { transcriptFor } from "./live.js";
+import { pauseSummary, sendStop, startPause } from "./pause/run.js";
+import { runStragglerUi } from "./pause/ui.js";
+import { planResume, runResume } from "./resume.js";
+import { latestSnapshot } from "./snapshot.js";
+const EXIT_OK = 0;
+const EXIT_NONE = 1;
+const EXIT_USAGE = 2;
+/** Run a subcommand when argv[0] names one; undefined means "not a subcommand, search instead". */
+export async function runCommand(argv, deps) {
+    const [name, ...rest] = argv;
+    if (isCommand(name) && asksHelp(rest))
+        return showHelp(deps);
+    try {
+        switch (name) {
+            case 'pause': return await pause(rest, deps);
+            case 'resume': return resume(rest, deps);
+            case 'completion': return completion(rest, deps);
+            case COMPLETE_FLAG: return answerCompletion(rest, deps);
+            case '_focus': return focus(rest, deps);
+            case '_send-stop': return sendStopCommand(rest, deps);
+            default: return undefined;
+        }
+    }
+    catch (err) {
+        deps.stderr(`claude-term-tabs: ${err.message}`);
+        return EXIT_USAGE;
+    }
+}
+async function pause(argv, deps) {
+    const { values } = parseFlags(argv, PAUSE_FLAGS);
+    const config = loadConfig(deps.dirs.config);
+    const timeoutMinutes = values.timeout !== undefined ? positive(values.timeout, '--timeout') : config.pauseTimeoutMinutes;
+    const adapter = deps.resolveAdapter();
+    const pdeps = {
+        now: deps.now,
+        adapter,
+        collect: () => liveWithPanes(deps, adapter),
+        isAlive: deps.isAlive,
+        transcriptOf: c => transcriptFor(deps.dirs.projects, c.digest.cwd, c.digest.sessionId),
+        sizeOf: p => statSync(p).size,
+        snapshotDir: deps.dirs.snapshots,
+        config,
+        warn: deps.stderr,
+        onSnapshot: path => { snapshotPath = path; },
+        inFront: c => frontOf(deps, c)
+    };
+    let snapshotPath = '';
+    const run = startPause(pdeps, { autoClose: values['auto-close'] });
+    deps.stdout(`Recorded ${run.tracked.length} sessions in ${snapshotPath}; sent the stop prompt. Waiting up to ${timeoutMinutes} min.`);
+    const end = await runStragglerUi(run, pdeps, {
+        hasFzf: deps.hasFzf,
+        isTty: deps.isTty,
+        timeoutMs: timeoutMinutes * 60_000,
+        self: deps.self,
+        write: deps.stdout,
+        sleep: deps.sleep,
+        onPick: id => { focus([id], deps); }
+    });
+    const summary = pauseSummary(end);
+    deps.stdout(summary.text);
+    return summary.exitCode;
+}
+function resume(argv, deps) {
+    const { values } = parseFlags(argv, RESUME_FLAGS);
+    const config = loadConfig(deps.dirs.config);
+    const snap = values.snapshot !== undefined ? readSnapshot(values.snapshot) : latestSnapshot(deps.dirs.snapshots);
+    if (snap === undefined) {
+        deps.stdout('No snapshot found. Run ctt pause first.');
+        return EXIT_NONE;
+    }
+    const adapter = deps.resolveAdapter();
+    const liveIds = new Set(liveWithPanes(deps, adapter).map(c => c.digest.sessionId));
+    const steps = planResume(snap, liveIds, deps.dirExists, config, { noPrompt: values['no-prompt'] });
+    deps.stdout(`Snapshot ${snap.createdAt}: ${steps.length} sessions`);
+    return runResume(steps, adapter, { dryRun: values['dry-run'] }, deps.stdout);
+}
+function showHelp(deps) {
+    deps.stdout(HELP);
+    return EXIT_OK;
+}
+function asksHelp(argv) {
+    const end = argv.indexOf('--');
+    return (end === -1 ? argv : argv.slice(0, end)).some(a => a === '-h' || a === '--help');
+}
+/** `ctt completion [bash|zsh]` prints the script; without a shell, $SHELL decides when it is bash or zsh. */
+function completion(argv, deps) {
+    const { positionals } = parseFlags(argv, COMMANDS.completion.flags, { positionals: true });
+    if (positionals.length > 1)
+        throw new Error(`Unexpected argument '${positionals[1]}'`);
+    const shell = positionals[0] ?? basename(deps.shell ?? '');
+    if (!isShell(shell)) {
+        const where = positionals[0] === undefined ? ' in $SHELL' : '';
+        throw new Error(`unknown shell "${shell}"${where} (supported: ${SHELLS.join(', ')}); run ${SHELLS.map(s => `ctt completion ${s}`).join(' or ')}`);
+    }
+    deps.stdout(completionScript(shell, deps.completionProgram ?? deps.self[1] ?? 'ctt'));
+    return EXIT_OK;
+}
+function focus(argv, deps) {
+    const id = requireId(argv);
+    const adapter = deps.resolveAdapter();
+    const c = liveWithPanes(deps, adapter).find(x => x.digest.sessionId === id);
+    if (c?.pane === undefined || adapter === undefined) {
+        deps.stderr(`claude-term-tabs: no reachable pane for session ${id}`);
+        return EXIT_NONE;
+    }
+    adapter.focus(c.pane);
+    return EXIT_OK;
+}
+function sendStopCommand(argv, deps) {
+    const id = requireId(argv);
+    const adapter = deps.resolveAdapter();
+    const c = liveWithPanes(deps, adapter).find(x => x.digest.sessionId === id);
+    if (c === undefined) {
+        deps.stderr(`claude-term-tabs: session ${id} is not running`);
+        return EXIT_NONE;
+    }
+    return sendStop(c, adapter, loadConfig(deps.dirs.config).stopPrompt, deps.stderr, x => frontOf(deps, x)) ? EXIT_OK : EXIT_NONE;
+}
+function frontOf(deps, c) {
+    return c.tty !== undefined ? inFrontOf(deps.exec, c.tty) : 'other';
+}
+function requireId(argv) {
+    const { positionals } = parseFlags(argv, {}, { positionals: true });
+    if (positionals.length !== 1)
+        throw new Error('expected exactly one session id');
+    return positionals[0];
+}
+function readSnapshot(path) {
+    try {
+        return JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch (err) {
+        throw new Error(`cannot read snapshot ${path}: ${err.message}`);
+    }
+}
+function positive(raw, flag) {
+    const n = Number(raw);
+    if (!Number.isFinite(n) || n <= 0)
+        throw new Error(`${flag} must be a positive number of minutes`);
+    return n;
+}

package/dist/complete.js

@@ -0,0 +1,18 @@
+import { COMPLETE_FLAG, completions, isShell, SHELLS } from "./args.js";
+export { COMPLETE_FLAG };
+/**
+ * Answer a completion script's `ctt --complete <shell> <words>` (`argv` is what follows the flag).
+ * bin/claude-term-tabs calls this before loading the rest of ctt, so a Tab press stays fast. Returns the
+ * exit code.
+ */
+export function answerCompletion(argv, out) {
+    const [shell, ...words] = argv;
+    if (!isShell(shell)) {
+        out.stderr(`claude-term-tabs: ${COMPLETE_FLAG} needs ${SHELLS.join(' or ')}, then the words to complete`);
+        return 2;
+    }
+    const offered = completions(shell, words);
+    if (offered.length > 0)
+        out.stdout(offered.join('\n'));
+    return 0;
+}

package/dist/config.js

@@ -0,0 +1,76 @@
+import { readFileSync, realpathSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { isAbsolute, join, resolve } from 'node:path';
+/** Prompt typed into every session by `ctt pause`. */
+export const DEFAULT_STOP_PROMPT = "Pausing for a machine restart. Stop at the nearest safe point: start nothing new, and do not push, merge, apply, post or transition anything that was not already mid-flight. Leave no file half-edited; do not commit unless that was already the plan. Background jobs, Monitors, /loop wakeups and subagents will die with the restart.\n\nThen reply with a message headed HANDOFF (under 20 lines):\n- Goal: what this session is for (ticket/PR refs)\n- Done: what is finished, with PR numbers, commits, ticket states\n- In flight: branch, worktree path, uncommitted changes, anything half-done\n- Lost on restart: background watches/monitors/loops/agents and how to restart them\n- Next step: the exact next action\n- Open questions: anything you need from me\n\nThen stop and wait.\n";
+/** Prompt passed to every session reopened by `ctt resume`. */
+export const DEFAULT_RESUME_PROMPT = "Resumed after a machine restart. Find your most recent HANDOFF message above and pick up from its \"Next step\". Before acting, re-check live state, since anything may have moved while we were down: git branch and status (and worktree path if any), PR and CI status, and Jira status for any ticket involved. Restart any background watches, monitors or loops the handoff lists. Then give me a 3-line status and continue. If there is no HANDOFF message, summarize where we left off and ask before doing anything.\n";
+const DEFAULT_PAUSE_TIMEOUT_MINUTES = 10;
+/** Load config; a missing file gives defaults, anything unreadable or invalid throws. */
+export function loadConfig(path) {
+    let raw;
+    try {
+        raw = readFileSync(path, 'utf8');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return withDefaults({});
+        throw new Error(`cannot read config ${path}: ${err.message}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`invalid config ${path}: ${err.message}`);
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+        throw new Error(`invalid config ${path}: not an object`);
+    return withDefaults(validate(parsed, path));
+}
+function validate(o, path) {
+    const bad = (key, want) => new Error(`invalid config ${path}: ${key} must be ${want}`);
+    if (o.resumeCommand !== undefined && typeof o.resumeCommand !== 'string')
+        throw bad('resumeCommand', 'a string');
+    for (const key of ['stopPrompt', 'resumePrompt']) {
+        if (o[key] !== undefined && (typeof o[key] !== 'string' || o[key] === ''))
+            throw bad(key, 'a non-empty string');
+    }
+    const t = o.pauseTimeoutMinutes;
+    if (t !== undefined && (typeof t !== 'number' || !Number.isFinite(t) || t <= 0))
+        throw bad('pauseTimeoutMinutes', 'a positive number');
+    const x = o.excludeDirs;
+    let excludeDirs;
+    if (x !== undefined) {
+        if (!Array.isArray(x) || !x.every(d => typeof d === 'string'))
+            throw bad('excludeDirs', 'a list of directories');
+        const dirs = x.map(expandDir);
+        if (dirs.some(d => d === undefined))
+            throw bad('excludeDirs', 'absolute paths or paths starting with ~/');
+        // Claude Code records the physical cwd, so a dir reached through a symlink (macOS /tmp) also matches by its real path.
+        excludeDirs = [...new Set(dirs.flatMap(d => [d, realpathOr(d)]))];
+    }
+    return { ...o, ...(excludeDirs !== undefined && { excludeDirs }) };
+}
+/** `~/x` → `$HOME/x`, resolved (normalized, no trailing slash); undefined when not absolute. */
+function expandDir(d) {
+    const p = d === '~' || d.startsWith('~/') ? join(homedir(), d.slice(1)) : d;
+    return isAbsolute(p) ? resolve(p) : undefined;
+}
+function realpathOr(d) {
+    try {
+        return realpathSync(d);
+    }
+    catch {
+        return d;
+    }
+}
+function withDefaults(c) {
+    return {
+        resumeCommand: c.resumeCommand,
+        stopPrompt: c.stopPrompt ?? DEFAULT_STOP_PROMPT,
+        resumePrompt: c.resumePrompt ?? DEFAULT_RESUME_PROMPT,
+        pauseTimeoutMinutes: c.pauseTimeoutMinutes ?? DEFAULT_PAUSE_TIMEOUT_MINUTES,
+        excludeDirs: c.excludeDirs ?? []
+    };
+}

package/dist/discover.js

@@ -0,0 +1,29 @@
+import { DigestCache } from "./cache.js";
+import { collectLiveSessions } from "./live.js";
+/** Live sessions with their panes attached; a pane listing failure warns and attaches none. */
+export function liveWithPanes(deps, adapter) {
+    const cache = DigestCache.load(deps.dirs.cache, deps.stderr);
+    const panes = listPanesOrWarn(adapter, deps);
+    const byTty = new Map(panes.map(p => [p.tty, p]));
+    const live = collectLiveSessions({ sessionsDir: deps.dirs.sessions, projectsDir: deps.dirs.projects, exec: deps.exec, cache })
+        .map(c => ({ ...c, pane: c.tty !== undefined ? byTty.get(c.tty) : undefined }));
+    try {
+        cache.save();
+    }
+    catch (err) {
+        deps.stderr(`claude-term-tabs: could not save cache: ${err.message}`);
+    }
+    return live;
+}
+/** Panes from the adapter, or none (with a warning) when listing fails. */
+export function listPanesOrWarn(adapter, deps) {
+    if (adapter === undefined)
+        return [];
+    try {
+        return adapter.listPanes();
+    }
+    catch (err) {
+        deps.stderr(`claude-term-tabs: ${err.message}`);
+        return [];
+    }
+}

package/dist/exec.js

@@ -0,0 +1,13 @@
+import { spawnSync } from 'node:child_process';
+const MAX_BUFFER = 64 * 1024 * 1024;
+/** Real Exec backed by spawnSync. Spawn failure returns status 127, a timeout 124, CTT_NO_REAL_EXEC=1 blocks with 126. */
+export const realExec = (cmd, args, input, opts) => {
+    if (process.env.CTT_NO_REAL_EXEC === '1')
+        return { status: 126, stdout: '', stderr: `${cmd}: blocked by CTT_NO_REAL_EXEC` };
+    const r = spawnSync(cmd, args, { encoding: 'utf8', input, maxBuffer: MAX_BUFFER, timeout: opts?.timeoutMs });
+    if (r.error?.code === 'ETIMEDOUT')
+        return { status: 124, stdout: '', stderr: `${cmd}: timed out` };
+    if (r.error)
+        return { status: 127, stdout: '', stderr: `${cmd}: ${r.error.message}` };
+    return { status: r.status ?? 1, stdout: r.stdout ?? '', stderr: r.stderr ?? '' };
+};

package/dist/foreground.js

@@ -0,0 +1,19 @@
+import { basename } from 'node:path';
+const SHELLS = new Set(['zsh', 'bash', 'fish', 'sh', 'dash', 'ksh', 'tcsh', 'csh']);
+/** Classify `ps -t <tty> -o pgid=,tpgid=,comm=` output by the foreground process group. */
+export function foregroundKind(psOutput) {
+    const front = psOutput.split('\n').flatMap(line => {
+        const m = /^\s*(\d+)\s+(\d+)\s+(.+?)\s*$/.exec(line);
+        return m !== null && m[1] === m[2] ? [basename(m[3]).replace(/^-/, '')] : [];
+    });
+    if (front.includes('claude'))
+        return 'claude';
+    if (front.length > 0 && front.every(c => SHELLS.has(c)))
+        return 'shell';
+    return 'other';
+}
+/** What is in front of `tty` right now; any failure reads as 'other', which blocks typing. */
+export function inFrontOf(exec, tty) {
+    const r = exec('ps', ['-t', tty.replace(/^\/dev\//, ''), '-o', 'pgid=,tpgid=,comm=']);
+    return r.status === 0 ? foregroundKind(r.stdout) : 'other';
+}

package/dist/fsutil.js

@@ -0,0 +1,18 @@
+import { randomBytes } from 'node:crypto';
+import { chmodSync, closeSync, constants, mkdirSync, openSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+/** Atomically write `text` to `file` as 0600, creating or tightening its directory to 0700. */
+export function writeOwnerOnly(file, text) {
+    const dir = dirname(file);
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    chmodSync(dir, 0o700);
+    const tmp = `${file}.${randomBytes(8).toString('hex')}.tmp`;
+    const fd = openSync(tmp, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+    try {
+        writeFileSync(fd, text);
+    }
+    finally {
+        closeSync(fd);
+    }
+    renameSync(tmp, file);
+}