claude-code-gnome-extension/lib/zellij.js

// Maps a session's working directory to the zellij tab it is running in.
//
// Knowing a session waits for you is only half the answer; the other half is
// where to look. When sessions live in zellij tabs, the tab name answers that
// better than a path does.
//
// `zellij action dump-layout` prints tab names with each pane's cwd but no pane
// ids, so ZELLIJ_PANE_ID from the hook cannot be used for the lookup and the
// match goes through the working directory instead. That is best-effort by
// nature: two sessions in one tab are indistinguishable, and a session whose
// cwd has moved since the pane opened will not match.

import Gio from 'gi://Gio';
import GLib from 'gi://GLib';

Gio._promisify(Gio.Subprocess.prototype, 'communicate_utf8_async');

// Layouts only change when tabs are rearranged, and opening the menu forces a
// refresh anyway -- so the background TTL is long enough that the periodic tick
// does not spawn a zellij process every time it runs.
const CACHE_TTL = 120; // seconds

// One subprocess per distinct zellij session named in the state directory.
// In real use that is one or two; the bound is there because the names come
// from files, and a directory full of them would fork a process per name.
const MAX_SESSIONS = 8;

export class ZellijTabs {
    constructor() {
        this._cache = new Map(); // zellij session -> { at, tabs: [{name, cwds}] }
        this._inFlight = new Map();
        this._available = null;
        this._cancellable = new Gio.Cancellable();
        this._children = new Set();
    }

    /** Tab name for a working directory, or null when unknown. */
    tabFor(zellijSession, cwd) {
        const entry = this._cache.get(zellijSession);
        if (!entry || !cwd)
            return null;
        // Longest matching prefix wins: a pane opened at the repo root must not
        // outrank one opened directly in the subdirectory the session runs in.
        let best = null;
        let bestLen = -1;
        for (const tab of entry.tabs) {
            for (const paneCwd of tab.cwds) {
                if (cwd !== paneCwd && !cwd.startsWith(`${paneCwd}/`))
                    continue;
                if (paneCwd.length > bestLen) {
                    bestLen = paneCwd.length;
                    best = tab.name;
                }
            }
        }
        return best;
    }

    /** Refresh the layout of every zellij session in use, at most once per TTL.
     *  `force` bypasses the TTL for the one moment it matters: the user just
     *  opened the menu and may have rearranged tabs since the last look. */
    async refresh(zellijSessions, force = false) {
        if (this._available === false)
            return;
        const now = GLib.get_monotonic_time() / 1e6;
        const work = [];
        for (const name of [...new Set(zellijSessions)].slice(0, MAX_SESSIONS)) {
            if (!name)
                continue;
            const entry = this._cache.get(name);
            if (!force && entry && now - entry.at < CACHE_TTL)
                continue;
            work.push(this._refreshOne(name, now));
        }
        await Promise.all(work);
    }

    async _refreshOne(name, now) {
        // Collapse concurrent refreshes of the same session; the menu opening
        // and the periodic tick can otherwise fire two subprocesses at once.
        if (this._inFlight.has(name))
            return this._inFlight.get(name);
        const promise = this._dumpLayout(name)
            .then(layout => {
                if (layout !== null)
                    this._available = true;
                // A failure is cached as an empty layout, not left uncached:
                // otherwise a zellij session that was renamed or killed while
                // its claude process lives on fails the TTL check every time
                // and forks a process on every tick, forever.
                this._cache.set(name, {
                    at: now,
                    tabs: layout === null ? [] : parseLayout(layout),
                });
            })
            .finally(() => this._inFlight.delete(name));
        this._inFlight.set(name, promise);
        return promise;
    }

    async _dumpLayout(session) {
        try {
            const proc = Gio.Subprocess.new(
                ['zellij', '--session', session, 'action', 'dump-layout'],
                Gio.SubprocessFlags.STDOUT_PIPE | Gio.SubprocessFlags.STDERR_SILENCE);
            this._children.add(proc);
            try {
                const [stdout] = await proc.communicate_utf8_async(null, this._cancellable);
                if (!proc.get_successful())
                    return null;
                return stdout ?? '';
            } finally {
                this._children.delete(proc);
            }
        } catch (e) {
            // zellij not installed, or not on the shell's PATH: stop trying.
            if (e.matches?.(GLib.SpawnError, GLib.SpawnError.NOENT))
                this._available = false;
            return null;
        }
    }

    /** Abandon any layout dump still running; the extension is going away. */
    destroy() {
        this._cancellable.cancel();
        // Cancelling only abandons the read; the child keeps running. A wedged
        // zellij server would otherwise outlive the extension being disabled.
        for (const proc of this._children)
            proc.force_exit();
        this._children.clear();
        this._cache.clear();
        this._inFlight.clear();
    }
}

/** Extract tab names and their pane working directories from a KDL layout.
 *
 *  Parsed with line matching rather than a KDL parser: the two constructs that
 *  matter are one line each, and a dependency-free extension cannot pull one in.
 */
export function parseLayout(text) {
    const tabs = [];
    // A layout-level `cwd "..."` is the base for panes that store a relative one.
    const baseMatch = text.match(/^\s*cwd\s+"([^"]*)"/m);
    const base = baseMatch ? baseMatch[1] : '';
    let current = null;
    for (const line of text.split('\n')) {
        const tabMatch = line.match(/^\s*tab\s.*?name="([^"]*)"/);
        if (tabMatch) {
            current = { name: tabMatch[1], cwds: [] };
            tabs.push(current);
            continue;
        }
        // A dump ends with new_tab_template and swap_tiled_layout blocks, whose
        // own `tab` lines carry no name. Their panes belong to no tab at all;
        // left attached to whatever came before, they make the last tab in the
        // dump answer for every unmatched directory -- confidently and wrongly.
        if (/^\s*(tab\s|tab\s*\{|new_tab_template|swap_tiled_layout|swap_floating_layout)/.test(line)) {
            current = null;
            continue;
        }
        if (!current)
            continue;
        const paneMatch = line.match(/^\s*pane\s.*?\bcwd="([^"]*)"/);
        if (paneMatch) {
            const cwd = paneMatch[1];
            // A relative pane cwd is meaningless without the layout-level one;
            // joining against "" yields a relative path that matches nothing.
            if (!cwd.startsWith('/') && !base)
                continue;
            const absolute = cwd.startsWith('/')
                ? cwd
                : GLib.build_filenamev([base, cwd]);
            if (!current.cwds.includes(absolute))
                current.cwds.push(absolute);
        }
    }
    return tabs;
}