claude-term-tabs 0.0.0-bootstrap

package/dist/pause/ui.js

@@ -0,0 +1,149 @@
+import { spawn } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { writeOwnerOnly } from "../fsutil.js";
+import { createServer } from 'node:net';
+import { createInterface } from 'node:readline';
+import { tickPause, stragglerLines } from "./run.js";
+import { FINAL_STATES } from "./state.js";
+import { shellQuote } from "../shell.js";
+/** How often the straggler list refreshes. */
+export const POLL_MS = 3000;
+const CLEAR = '\x1b[2J\x1b[H';
+const SAFE_PATH = /^[A-Za-z0-9._\/-]+$/;
+const HEADER = 'ctt pause: Enter or double-click jumps to a session · ctrl-r re-sends the stop prompt · Esc stops waiting';
+/** fzf arguments for the live straggler list; `self` is the argv prefix that re-invokes ctt. */
+export function fzfArgs(port, self) {
+    const ctt = self.map(shellQuote).join(' ');
+    return [
+        '--listen', `127.0.0.1:${port}`,
+        '--delimiter', '\t', '--with-nth', '2..',
+        '--no-sort', '--layout', 'reverse', '--height', '50%',
+        '--prompt', 'waiting> ', '--header', HEADER,
+        '--bind', `enter:execute-silent(${ctt} _focus {1})`,
+        '--bind', `double-click:execute-silent(${ctt} _focus {1})`,
+        '--bind', `ctrl-r:execute-silent(${ctt} _send-stop {1})`
+    ];
+}
+/** The fzf reload action: it names only a ctt-chosen file, so no session data reaches fzf's action parser. */
+export function reloadAction(linesFile) {
+    if (!SAFE_PATH.test(linesFile))
+        throw new Error(`unsafe list file path: ${linesFile}`);
+    return `reload(cat ${shellQuote(linesFile)})`;
+}
+/** Environment for fzf with a fresh random FZF_API_KEY, which fzf then requires on every --listen request. */
+export function fzfEnv(base) {
+    return { ...base, FZF_API_KEY: randomBytes(32).toString('hex') };
+}
+/**
+ * Poll the pause every POLL_MS, showing stragglers until none remain (and nothing is still closing),
+ * the timeout passes, or the user closes the list. Returns the latest run.
+ */
+export async function runStragglerUi(run, deps, io, advance = tickPause) {
+    const deadline = deps.now() + io.timeoutMs;
+    let current = run;
+    const ui = io.hasFzf && io.isTty && process.env.CTT_NO_REAL_EXEC !== '1' ? await fzfUi(io, stragglerLines(current, deps.now())) : plainUi(io, deps);
+    try {
+        await ui.update(stragglerLines(current, deps.now()));
+        while (!ui.closed()) {
+            await io.sleep(POLL_MS);
+            if (ui.closed())
+                break;
+            try {
+                current = advance(current, deps);
+            }
+            catch (err) {
+                deps.warn(`claude-term-tabs: refresh failed, retrying: ${err.message}`);
+                continue;
+            }
+            const pending = current.tracked.some(t => !FINAL_STATES.has(t.state));
+            if (!pending || deps.now() >= deadline)
+                break;
+            await ui.update(stragglerLines(current, deps.now()));
+        }
+    }
+    finally {
+        await ui.finish();
+    }
+    return current;
+}
+function plainUi(io, deps) {
+    let last = '';
+    let shown = [];
+    const input = io.isTty && io.onPick !== undefined ? createInterface({ input: process.stdin }) : undefined;
+    input?.on('line', answer => {
+        const id = shown[Number(answer.trim()) - 1];
+        if (id !== undefined)
+            io.onPick?.(id);
+    });
+    return {
+        update: async (lines) => {
+            shown = lines.map(l => l.split('\t')[0]);
+            const body = lines.map((l, i) => `${String(i + 1).padStart(2)}) ${l.split('\t')[1]}`).join('\n');
+            if (io.isTty) {
+                io.write(`${CLEAR}Waiting for ${lines.length} sessions (${new Date(deps.now()).toLocaleTimeString()}). Type a number and Enter to jump.\n${body}`);
+            }
+            else if (body !== last) {
+                io.write(body);
+            }
+            last = body;
+        },
+        finish: async () => { input?.close(); },
+        closed: () => false
+    };
+}
+async function fzfUi(io, initial) {
+    const port = await freePort();
+    const dir = mkdtempSync(join(tmpdir(), 'claude-term-tabs-'));
+    const linesFile = join(dir, 'lines');
+    writeOwnerOnly(linesFile, initial.join('\n'));
+    const env = fzfEnv(process.env);
+    const child = spawn('fzf', fzfArgs(port, io.self), { stdio: ['pipe', 'ignore', 'inherit'], env });
+    let exited = false;
+    child.on('exit', () => { exited = true; });
+    child.on('error', () => { exited = true; });
+    child.stdin.end(initial.join('\n'));
+    const post = async (action) => {
+        if (exited)
+            return;
+        try {
+            const res = await fetch(`http://127.0.0.1:${port}`, { method: 'POST', headers: { 'x-api-key': env.FZF_API_KEY ?? '' }, body: action });
+            if (!res.ok)
+                process.stderr.write(`claude-term-tabs: the list refused an update (${res.status})\n`);
+        }
+        catch (err) {
+            if (!exited)
+                process.stderr.write(`claude-term-tabs: could not update the list: ${err.message}\n`);
+        }
+    };
+    return {
+        update: async (lines) => {
+            writeOwnerOnly(linesFile, lines.join('\n'));
+            await post(reloadAction(linesFile));
+        },
+        finish: async () => {
+            await post('abort');
+            if (!exited)
+                await new Promise(resolve => child.once('exit', () => resolve()));
+            rmSync(dir, { recursive: true, force: true });
+        },
+        closed: () => exited
+    };
+}
+function freePort() {
+    return new Promise((resolve, reject) => {
+        const server = createServer();
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            server.close(() => {
+                if (typeof address === 'object' && address !== null)
+                    resolve(address.port);
+                else
+                    reject(new Error('could not pick a port for fzf'));
+            });
+        });
+    });
+}

package/dist/picker.js

@@ -0,0 +1,83 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { shellQuote } from "./shell.js";
+const SEP = ' · ';
+const FZF_CANCEL = new Set([1, 130]);
+/** Compact age: 5m, 3h, 2d. */
+export function formatAge(lastActive, now) {
+    const minutes = Math.max(0, Math.floor((now - lastActive) / 60_000));
+    if (minutes < 60)
+        return `${minutes}m`;
+    if (minutes < 24 * 60)
+        return `${Math.floor(minutes / 60)}h`;
+    return `${Math.floor(minutes / (24 * 60))}d`;
+}
+/** One picker line: `<sessionId>\t<fields joined by ' · '>`, with control characters flattened. */
+export function formatPickerLine(c, summary, now = Date.now()) {
+    const d = c.digest;
+    const fields = [
+        d.title ?? '(untitled)',
+        d.worktree !== undefined ? `${d.repo}/${d.worktree}` : d.repo,
+        d.branch,
+        formatAge(d.lastActive, now),
+        c.live ? c.status : 'closed',
+        c.pane !== undefined ? tabLabel(c) : undefined,
+        c.dirGone === true ? 'dir gone' : undefined,
+        summary
+    ].filter((f) => f !== undefined && f !== '').map(cleanField);
+    return `${d.sessionId}\t${fields.join(SEP)}`;
+}
+/** Session id from a selected picker line. */
+export function parsePickerSelection(line) {
+    return line.split('\t')[0].trim();
+}
+/** Let the user choose one candidate with fzf, or a numbered prompt without it. */
+export function pick(cands, summaries, exec, io) {
+    const now = Date.now();
+    const lines = cands.map(c => formatPickerLine(c, summaries.get(c.digest.sessionId), now));
+    const byId = new Map(cands.map(c => [c.digest.sessionId, c]));
+    if (io.hasFzf)
+        return byId.get(runFzf(lines, cands, exec) ?? '');
+    const menu = lines.map((l, i) => `${String(i + 1).padStart(2)}) ${l.split('\t')[1]}`).join('\n');
+    const answer = io.prompt(`${menu}\nPick a session (number, Enter to cancel): `).trim();
+    const n = Number(answer);
+    return Number.isInteger(n) && n >= 1 && n <= cands.length ? cands[n - 1] : undefined;
+}
+function runFzf(lines, cands, exec) {
+    const previewDir = mkdtempSync(join(tmpdir(), 'claude-term-tabs-'));
+    try {
+        for (const c of cands)
+            writeFileSync(join(previewDir, c.digest.sessionId), previewText(c.digest), { mode: 0o600 });
+        const r = exec('fzf', [
+            '--delimiter', '\t', '--with-nth', '2..', '--no-sort', '--height', '60%', '--reverse',
+            '--prompt', 'session> ',
+            '--preview', `cat ${shellQuote(previewDir)}/{1}`, '--preview-window', 'down,6,wrap'
+        ], lines.join('\n'));
+        if (FZF_CANCEL.has(r.status))
+            return undefined;
+        if (r.status !== 0)
+            throw new Error(`fzf failed (${r.status}): ${r.stderr.trim()}`);
+        return parsePickerSelection(r.stdout);
+    }
+    finally {
+        rmSync(previewDir, { recursive: true, force: true });
+    }
+}
+function previewText(d) {
+    return [
+        `repo:   ${d.repo}${d.worktree !== undefined ? ` (worktree ${d.worktree})` : ''}`,
+        `branch: ${d.branch ?? ''}`,
+        `cwd:    ${d.cwd}`,
+        `first:  ${d.firstPrompt ?? ''}`,
+        `last:   ${d.lastPrompt ?? ''}`,
+        d.note !== undefined ? `note:   ${d.note}` : ''
+    ].map(cleanField).join('\n');
+}
+function tabLabel(c) {
+    return `tab ${c.pane?.tabIndex ?? '?'}`;
+}
+/** Flatten control characters and escape sequences out of a display field. */
+export function cleanField(s) {
+    return s.replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)?/g, '').replace(/[\x00-\x1f\x7f-\x9f]+/g, ' ').replace(/ {2,}/g, ' ').trim();
+}

package/dist/resume.js

@@ -0,0 +1,61 @@
+import { isResumableDir, resumeCommand } from "./history.js";
+import { shellQuote } from "./shell.js";
+/** Order recorded sessions by window then tab and decide, for each, whether to open it. */
+export function planResume(snap, liveIds, dirExists, config, opts) {
+    const ordered = [...snap.sessions].sort((a, b) => position(a.windowIndex) - position(b.windowIndex) || position(a.tabIndex) - position(b.tabIndex));
+    const windowsOpened = new Set();
+    return ordered.map(session => {
+        const base = resumeCommand(config, session.sessionId);
+        const command = opts.noPrompt ? base : `${base} ${shellQuote(config.resumePrompt)}`;
+        if (liveIds.has(session.sessionId))
+            return { session, action: 'skip-live', command, newWindow: false };
+        if (!isResumableDir(session.cwd, dirExists))
+            return { session, action: 'skip-dir-gone', command, newWindow: false };
+        const group = String(session.windowIndex ?? 'none');
+        const newWindow = !windowsOpened.has(group);
+        windowsOpened.add(group);
+        return { session, action: 'open', command, newWindow };
+    });
+}
+/** Carry out a resume plan. Returns 1 when there is no terminal to open tabs in, or a tab failed to open. */
+export function runResume(steps, adapter, opts, write) {
+    const shell = (s) => `cd ${shellQuote(s.session.cwd)} && ${s.command}`;
+    if (adapter === undefined && !opts.dryRun) {
+        write('No supported terminal to open tabs in; run these yourself:');
+        for (const s of steps.filter(x => x.action === 'open'))
+            write(`  ${shell(s)}`);
+        return 1;
+    }
+    let opened = 0;
+    let failed = false;
+    for (const s of steps) {
+        const name = `${s.session.title ?? s.session.sessionId} · ${s.session.repo}`;
+        if (s.action === 'skip-live') {
+            write(`  ${name} · already running`);
+            continue;
+        }
+        if (s.action === 'skip-dir-gone') {
+            write(`  ${name} · ${s.session.cwd} no longer exists, not resumed\n    ${shell(s)}`);
+            continue;
+        }
+        if (opts.dryRun) {
+            write(`  ${shell(s)}${s.newWindow ? '   (new window)' : ''}`);
+            continue;
+        }
+        try {
+            adapter?.openPane(s.session.cwd, s.command, { newWindow: s.newWindow });
+            opened++;
+            write(`→ ${name}`);
+        }
+        catch (err) {
+            failed = true;
+            write(`✗ ${name}: ${err.message}`);
+        }
+    }
+    if (!opts.dryRun)
+        write(`Resumed ${opened} of ${steps.length} sessions.`);
+    return failed ? 1 : 0;
+}
+function position(n) {
+    return n ?? Number.MAX_SAFE_INTEGER;
+}

package/dist/score.js

@@ -0,0 +1,87 @@
+/** Minimum score for a local match to switch without asking. */
+export const MIN_WINNER_SCORE = 4;
+/** How far ahead of the runner-up a local winner must be. */
+export const WINNER_RATIO = 1.5;
+const MAX_RECENCY_BOOST = 0.5;
+const RECENCY_WINDOW_MS = 7 * 24 * 60 * 60 * 1000;
+const MIN_PREFIX_CHARS = 3;
+const PREFIX_STRENGTH = 0.5;
+const FILLER = new Set([
+    'a', 'about', 'an', 'and', 'claude', 'for', 'i', 'in', 'into', 'is', 'it', 'me', 'my', 'of', 'on',
+    'session', 'sessions', 'stuff', 'tab', 'that', 'the', 'thing', 'this', 'to', 'was', 'were',
+    'where', 'which', 'with', 'work', 'working'
+]);
+const TICKET = /^[a-z]+-\d+$/;
+const FIELD_WEIGHTS = {
+    title: 3,
+    repo: 3,
+    worktree: 2,
+    branch: 2,
+    lastPrompt: 2,
+    firstPrompt: 1
+};
+/** Lowercased query tokens with filler words removed; hyphenated words stay whole. */
+export function tokenize(query) {
+    return query.toLowerCase()
+        .split(/[^a-z0-9-]+/)
+        .map(t => t.replace(/^-+|-+$/g, ''))
+        .filter(t => t !== '' && !FILLER.has(t));
+}
+/** Candidates matching the query, highest score first. Rarer tokens count for more. */
+export function rankLocal(query, cands, now = Date.now()) {
+    const tokens = tokenize(query);
+    if (tokens.length === 0)
+        return [];
+    const words = cands.map(c => fieldWords(c.digest));
+    const hits = tokens.map(t => words.map(w => bestHit(t, w)));
+    const idf = hits.map(perCand => {
+        const df = perCand.filter(h => h > 0).length;
+        return df === 0 ? 0 : Math.log(1 + cands.length / df);
+    });
+    return cands
+        .map((cand, i) => {
+        const base = hits.reduce((sum, perCand, t) => sum + perCand[i] * idf[t], 0);
+        return { cand, score: base > 0 ? base + recencyBoost(cand.digest.lastActive, now) : 0 };
+    })
+        .filter(r => r.score > 0)
+        .sort((a, b) => b.score - a.score);
+}
+/** The top candidate when it is strong enough and well ahead of the runner-up. */
+export function clearWinner(ranked) {
+    const [top, next] = ranked;
+    if (top === undefined || top.score < MIN_WINNER_SCORE)
+        return undefined;
+    if (next !== undefined && top.score < next.score * WINNER_RATIO)
+        return undefined;
+    return top.cand;
+}
+function fieldWords(d) {
+    const entries = Object.keys(FIELD_WEIGHTS).map(f => [f, splitWords(d[f])]);
+    return new Map(entries);
+}
+function splitWords(text) {
+    if (text === undefined)
+        return [];
+    const whole = text.toLowerCase().split(/[^a-z0-9-]+/).filter(Boolean);
+    const parts = whole.flatMap(w => w.includes('-') ? w.split('-').filter(Boolean) : []);
+    return [...whole, ...parts];
+}
+function bestHit(token, words) {
+    let best = 0;
+    for (const [field, list] of words) {
+        const strength = matchStrength(token, list);
+        best = Math.max(best, strength * FIELD_WEIGHTS[field]);
+    }
+    return best;
+}
+function matchStrength(token, words) {
+    if (words.includes(token))
+        return 1;
+    if (TICKET.test(token) || token.length < MIN_PREFIX_CHARS)
+        return 0;
+    return words.some(w => w.startsWith(token)) ? PREFIX_STRENGTH : 0;
+}
+function recencyBoost(lastActive, now) {
+    const age = Math.max(0, now - lastActive);
+    return MAX_RECENCY_BOOST * Math.max(0, 1 - age / RECENCY_WINDOW_MS);
+}

package/dist/shell.js

@@ -0,0 +1,4 @@
+/** Quote `s` as one POSIX shell word. */
+export function shellQuote(s) {
+    return `'${s.replaceAll("'", "'\\''")}'`;
+}

package/dist/snapshot.js

@@ -0,0 +1,63 @@
+import { readdirSync, readFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { writeOwnerOnly } from "./fsutil.js";
+const SUFFIX = '.json';
+const NAME = /^\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}\.\d{3}Z\.json$/;
+/** Build a snapshot of live candidates; its id is the creation time with ':' as '-'. */
+export function snapshotFrom(cands, terminal, now) {
+    const createdAt = new Date(now).toISOString();
+    return {
+        id: createdAt.replaceAll(':', '-'),
+        createdAt,
+        sessions: cands.map(c => ({
+            sessionId: c.digest.sessionId,
+            cwd: c.digest.cwd,
+            title: c.digest.title,
+            repo: c.digest.repo,
+            branch: c.digest.branch,
+            windowIndex: c.pane?.windowIndex,
+            tabIndex: c.pane?.tabIndex,
+            terminal: c.pane !== undefined ? terminal : undefined,
+            handoffWritten: false
+        }))
+    };
+}
+/** Write (or overwrite) a snapshot owner-only; returns its path. */
+export function saveSnapshot(dir, snap) {
+    const path = join(dir, `${snap.id}${SUFFIX}`);
+    writeOwnerOnly(path, JSON.stringify(snap, null, 2));
+    return path;
+}
+/** Newest snapshot, or undefined when there is none. A corrupt newest file throws rather than falling back. */
+export function latestSnapshot(dir) {
+    const newest = snapshotFiles(dir).at(-1);
+    if (newest === undefined)
+        return undefined;
+    const path = join(dir, newest);
+    try {
+        return JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch (err) {
+        throw new Error(`snapshot ${path} is unreadable: ${err.message}`);
+    }
+}
+/** Delete snapshots created more than `maxAgeMs` before `now`; returns the deleted paths. */
+export function pruneSnapshots(dir, now, maxAgeMs) {
+    const cutoff = now - maxAgeMs;
+    const old = snapshotFiles(dir).filter(name => Date.parse(name.slice(0, -SUFFIX.length).replace(/T(\d{2})-(\d{2})-(\d{2})/, 'T$1:$2:$3')) < cutoff);
+    return old.map(name => {
+        const path = join(dir, name);
+        rmSync(path);
+        return path;
+    });
+}
+function snapshotFiles(dir) {
+    try {
+        return readdirSync(dir).filter(name => NAME.test(name)).sort();
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return [];
+        throw err;
+    }
+}

package/dist/terminals/adapter.js

@@ -0,0 +1,32 @@
+import { iterm2Adapter } from "./iterm2.js";
+import { weztermAdapter } from "./wezterm.js";
+const FACTORIES = {
+    iterm2: iterm2Adapter,
+    wezterm: weztermAdapter
+};
+/** The names `--terminal` accepts. */
+export const TERMINAL_NAMES = Object.freeze(Object.keys(FACTORIES));
+const BY_TERM_PROGRAM = {
+    'iTerm.app': 'iterm2',
+    WezTerm: 'wezterm'
+};
+/**
+ * Pick the adapter: explicit override, then TERM_PROGRAM, then whichever supported terminal is
+ * running. Returns undefined when none is available; throws on an unknown override.
+ */
+export function detectAdapter(env, exec, override) {
+    if (override !== undefined) {
+        const name = TERMINAL_NAMES.find(n => n === override);
+        if (name === undefined)
+            throw new Error(`unknown terminal "${override}" (supported: ${TERMINAL_NAMES.join(', ')})`);
+        return FACTORIES[name](exec);
+    }
+    const fromEnv = BY_TERM_PROGRAM[env.TERM_PROGRAM ?? ''];
+    if (fromEnv !== undefined)
+        return FACTORIES[fromEnv](exec);
+    if (exec('pgrep', ['-x', 'iTerm2']).status === 0)
+        return iterm2Adapter(exec);
+    if (exec('wezterm', ['cli', 'list', '--format', 'json']).status === 0)
+        return weztermAdapter(exec);
+    return undefined;
+}

package/dist/terminals/iterm2.js

@@ -0,0 +1,73 @@
+const LIST_SCRIPT = `function run () {
+  const app = Application('iTerm2')
+  const out = []
+  let shown = 0
+  for (const w of app.windows()) {
+    let wid, ids, ttys, names
+    try {
+      wid = String(w.id())
+      ids = w.tabs.sessions.id()
+      ttys = w.tabs.sessions.tty()
+      names = w.tabs.sessions.name()
+    } catch (e) {
+      continue
+    }
+    shown++
+    ids.forEach((tabIds, ti) => tabIds.forEach((id, si) => out.push({
+      id, tty: ttys[ti][si], title: names[ti][si], windowId: wid, windowIndex: shown, tabIndex: ti + 1
+    })))
+  }
+  return JSON.stringify(out)
+}`;
+const sessionScript = (onFound) => `function run (argv) {
+  const app = Application('iTerm2')
+  for (const w of app.windows()) {
+    let tabs
+    try { tabs = w.tabs() } catch (e) { continue }
+    for (const t of tabs) {
+      for (const s of t.sessions()) {
+        if (s.id() === argv[0]) {
+          ${onFound}
+          return 'ok'
+        }
+      }
+    }
+  }
+  throw new Error('session not found: ' + argv[0])
+}`;
+const FOCUS_SCRIPT = sessionScript('s.select(); t.select(); w.select(); app.activate()');
+const SEND_SCRIPT = sessionScript('s.write({ text: argv[1], newline: false }); delay(0.3); s.write({ text: "" })');
+const PASTE_START = '\x1b[200~';
+const PASTE_END = '\x1b[201~';
+const CLOSE_SCRIPT = sessionScript("s.write({ text: 'exit' })");
+const OPEN_SCRIPT = `function run (argv) {
+  const app = Application('iTerm2')
+  const quoted = "'" + argv[0].split("'").join("'\\\\''") + "'"
+  const fresh = argv[2] === 'new-window' || !app.currentWindow()
+  const session = fresh
+    ? app.createWindowWithDefaultProfile().currentSession()
+    : app.currentWindow().createTabWithDefaultProfile().currentSession()
+  session.write({ text: 'cd ' + quoted + ' && ' + argv[1] })
+  app.activate()
+  return session.id()
+}`;
+const AUTOMATION_HINT = 'iTerm2 refused automation. Allow your terminal to control iTerm2 in System Settings > Privacy & Security > Automation.';
+/** iTerm2 adapter driven by JXA through osascript. */
+export function iterm2Adapter(exec) {
+    const jxa = (script, args = []) => {
+        const r = exec('osascript', ['-l', 'JavaScript', '-e', script, ...args]);
+        if (r.status === 0)
+            return r.stdout;
+        if (r.stderr.includes('-1743'))
+            throw new Error(AUTOMATION_HINT);
+        throw new Error(`osascript failed (${r.status}): ${r.stderr.trim()}`);
+    };
+    return {
+        name: 'iterm2',
+        listPanes: () => JSON.parse(jxa(LIST_SCRIPT)),
+        focus: (pane) => { jxa(FOCUS_SCRIPT, [pane.id]); },
+        sendText: (pane, text) => { jxa(SEND_SCRIPT, [pane.id, `${PASTE_START}${text}${PASTE_END}`]); },
+        closePane: (pane) => { jxa(CLOSE_SCRIPT, [pane.id]); },
+        openPane: (cwd, command, opts) => jxa(OPEN_SCRIPT, [cwd, command, opts?.newWindow === true ? 'new-window' : 'tab']).trim()
+    };
+}

package/dist/terminals/wezterm.js

@@ -0,0 +1,34 @@
+/** WezTerm adapter driven by `wezterm cli`. */
+export function weztermAdapter(exec, shell = process.env.SHELL ?? '/bin/sh') {
+    const cli = (args) => {
+        const r = exec('wezterm', ['cli', ...args]);
+        if (r.status !== 0)
+            throw new Error(`wezterm cli ${args[0]} failed (${r.status}): ${r.stderr.trim()}`);
+        return r.stdout;
+    };
+    return {
+        name: 'wezterm',
+        listPanes: () => toPanes(JSON.parse(cli(['list', '--format', 'json']))),
+        focus: (pane) => { cli(['activate-pane', '--pane-id', pane.id]); },
+        sendText: (pane, text) => {
+            cli(['send-text', '--pane-id', pane.id, text]);
+            cli(['send-text', '--pane-id', pane.id, '--no-paste', '\r']);
+        },
+        closePane: (pane) => { cli(['kill-pane', '--pane-id', pane.id]); },
+        openPane: (cwd, command, opts) => {
+            return cli(['spawn', ...(opts?.newWindow === true ? ['--new-window'] : []), '--cwd', cwd, '--', shell, '-lc', `${command}; exec ${shell} -l`]).trim();
+        }
+    };
+}
+function toPanes(raw) {
+    const windows = [...new Set(raw.map(p => p.window_id))];
+    const tabsByWindow = new Map(windows.map(w => [w, [...new Set(raw.filter(p => p.window_id === w).map(p => p.tab_id))]]));
+    return raw.map(p => ({
+        id: String(p.pane_id),
+        tty: p.tty_name ?? '',
+        title: p.title,
+        windowId: String(p.window_id),
+        windowIndex: windows.indexOf(p.window_id) + 1,
+        tabIndex: (tabsByWindow.get(p.window_id) ?? []).indexOf(p.tab_id) + 1
+    }));
+}