@hellix-ai/cubes 0.1.4 → 0.2.0

package/dist/tui/listApp.js

@@ -0,0 +1,347 @@
+// The left pane of the split view: every session, grouped and nested, with its state, filterable,
+// and one keystroke (or click) from being open on the right.
+import { makeApi } from "../api.js";
+import { currentSession } from "../auth.js";
+import { age, listSessions, LIVE } from "../sessions.js";
+import { buildItems, statusOf, treePrefix } from "./model.js";
+import { ESC, fit, parseKeys, printable, strWidth } from "./term.js";
+import { fmtText, getSessionOption, selfCommand, setPaneOption, setSessionOption, SESSION, tmux } from "./tmux.js";
+const POLL_MS = 3000;
+const SELECTED_BG = 237;
+const ACCENT = 62;
+/** As many WHOLE key hints as fit, in order of how much they are needed - never one cut in half -
+ *  and the way out always last. */
+export function hints(width) {
+    const all = ["⏎ open", "l live", "m mine", "/ find", "^] back here", "←→ fold", "r refresh"];
+    const quit = "q quit";
+    let out = "";
+    for (const h of all) {
+        const next = out ? `${out}  ${h}` : h;
+        if (strWidth(`${next}  ${quit}`) > width)
+            break;
+        out = next;
+    }
+    return out ? `${out}  ${quit}` : quit;
+}
+export async function runList() {
+    const session = currentSession();
+    const api = makeApi(session);
+    const out = process.stdout;
+    const st = {
+        rows: [], loaded: false, error: null, filters: { live: false, mine: false, text: "" }, searching: false,
+        expanded: new Map(), selectedId: null, top: 0, current: getSessionOption("@cubes_current"), flash: null,
+    };
+    let items = [];
+    let flashTimer = null;
+    const restore = () => out.write(ESC.mouseOff + ESC.showCursor + ESC.altOff);
+    process.on("exit", restore);
+    for (const sig of ["SIGTERM", "SIGHUP"])
+        process.on(sig, () => process.exit(0));
+    if (process.stdin.isTTY)
+        process.stdin.setRawMode(true);
+    out.write(ESC.altOn + ESC.hideCursor + ESC.mouseOn);
+    const sessionItems = () => items.filter((i) => i.kind === "session");
+    const selIndex = () => items.findIndex((i) => i.kind === "session" && i.row.id === st.selectedId);
+    const rebuild = () => {
+        items = buildItems(st.rows, st.filters, st.expanded);
+        if (selIndex() < 0) {
+            const first = sessionItems()[0];
+            st.selectedId = first ? first.row.id : null;
+        }
+    };
+    const flash = (msg) => {
+        st.flash = msg;
+        if (flashTimer)
+            clearTimeout(flashTimer);
+        flashTimer = setTimeout(() => { st.flash = null; render(); }, 2500);
+        render();
+    };
+    // ── rendering ──────────────────────────────────────────────────────────────────────────────────
+    const chip = (label, on) => on ? `${ESC.bg(ACCENT)}${ESC.fg(255)} ${label} ${ESC.reset}` : `${ESC.dim} ${label} ${ESC.reset}`;
+    const sessionLine = (it, w, selected) => {
+        const r = it.row;
+        const s = statusOf(r);
+        const mark = r.id === st.current ? `${ESC.fg(ACCENT)}▌${ESC.reset}` : " ";
+        const tree = treePrefix(it);
+        const exp = it.children > 0 ? (it.expanded ? "▾" : "▸") : " ";
+        const right = w >= 34 ? (LIVE.has(r.status) ? s.label : age(r.ended_at ?? r.created_at)) : "";
+        const fixed = 1 + strWidth(tree) + 1 + 2; // mark, tree, expander, glyph + space
+        const titleW = Math.max(4, w - fixed - (right ? strWidth(right) + 1 : 0));
+        const title = fit(printable(r.title || "(untitled)"), titleW);
+        const bg = selected ? ESC.bg(SELECTED_BG) : "";
+        const body = `${bg}${ESC.dim}${tree}${ESC.reset}${bg}${exp}${ESC.fg(s.color)}${s.glyph}${ESC.reset}${bg} ` +
+            `${s.attention ? ESC.bold : ""}${title}${ESC.reset}${bg}${right ? ` ${ESC.fg(s.color)}${right}` : ""}`;
+        return `${mark}${body}${ESC.reset}`;
+    };
+    function render() {
+        const w = out.columns ?? 40;
+        const h = out.rows ?? 20;
+        const viewH = Math.max(1, h - 2);
+        const lines = [];
+        // Line 1: the filters, and the count they leave.
+        const search = st.searching || st.filters.text
+            ? ` ${ESC.fg(ACCENT)}/${ESC.reset}${printable(st.filters.text)}${st.searching ? `${ESC.inverse} ${ESC.reset}` : ""}`
+            : ` ${ESC.dim}/ find${ESC.reset}`;
+        lines.push(`${chip("live", st.filters.live)} ${chip("mine", st.filters.mine)}${search}`);
+        // The list, scrolled to keep the selection in view.
+        const sel = selIndex();
+        if (sel >= 0) {
+            if (sel < st.top)
+                st.top = sel;
+            if (sel >= st.top + viewH)
+                st.top = sel - viewH + 1;
+        }
+        st.top = Math.max(0, Math.min(st.top, Math.max(0, items.length - viewH)));
+        for (let i = 0; i < viewH; i++) {
+            const it = items[st.top + i];
+            if (!it) {
+                lines.push("");
+                continue;
+            }
+            if (it.kind === "section") {
+                const label = ` ${it.title} (${it.count}) `;
+                lines.push(`${ESC.dim}──${ESC.reset}${ESC.bold}${fit(printable(label), Math.min(w - 2, strWidth(label)))}${ESC.reset}` +
+                    `${ESC.dim}${"─".repeat(Math.max(0, w - 2 - strWidth(label)))}${ESC.reset}`);
+            }
+            else {
+                lines.push(sessionLine(it, w, it.row.id === st.selectedId));
+            }
+        }
+        if (!items.length) {
+            const msg = !st.loaded ? "loading sessions…" : st.error ? "" : "nothing matches - l / m / find narrow the list";
+            lines[2] = `  ${ESC.dim}${fit(msg, w - 2)}${ESC.reset}`;
+        }
+        // Last line: what went wrong, or what the keys do.
+        const foot = st.flash ?? (st.error ? `⚠ ${st.error}` : st.searching
+            ? "type to filter · ⏎ keep · esc clear"
+            : hints(w));
+        lines.push(`${st.error && !st.flash ? ESC.fg(203) : ESC.dim}${fit(foot, w)}${ESC.reset}`);
+        let frame = ESC.syncOn + ESC.home;
+        lines.forEach((l, i) => { frame += `${ESC.at(i + 1, 1)}\x1b[2K${l}`; });
+        out.write(frame + ESC.syncOff);
+        updateHeader();
+    }
+    let lastHeader = "";
+    function updateHeader() {
+        const live = st.rows.filter((r) => LIVE.has(r.status)).length;
+        const needs = st.rows.filter((r) => statusOf(r).attention).length;
+        const org = session.org ? ` · ${fmtText(printable(session.org))}` : "";
+        const h = `#[bold]Cubes#[nobold]${org} · ${live} live${needs ? ` · #[fg=colour214]${needs} need you#[default]` : ""}`;
+        if (h !== lastHeader) {
+            lastHeader = h;
+            setPaneOption("@cubes_header", h);
+        }
+    }
+    // ── actions ────────────────────────────────────────────────────────────────────────────────────
+    const move = (delta) => {
+        const list = sessionItems();
+        if (!list.length)
+            return;
+        const at = Math.max(0, list.findIndex((i) => i.row.id === st.selectedId));
+        const next = list[Math.max(0, Math.min(list.length - 1, at + delta))];
+        st.selectedId = next.row.id;
+    };
+    const open = (id) => {
+        const right = getSessionOption("@cubes_right");
+        if (!right) {
+            flash("the session pane is gone - run cubes again");
+            return;
+        }
+        const r = tmux(["respawn-pane", "-k", "-t", right, selfCommand(["_pane", id])]);
+        if (r.code !== 0) {
+            flash(`could not open it: ${r.err || r.code}`);
+            return;
+        }
+        tmux(["select-pane", "-t", right]);
+        st.current = id;
+        setSessionOption("@cubes_current", id);
+    };
+    const toggleFold = (id, open) => {
+        const it = sessionItems().find((i) => i.row.id === id);
+        if (!it || it.children === 0)
+            return false;
+        st.expanded.set(id, open ?? !it.expanded);
+        return true;
+    };
+    const goParent = () => {
+        const it = sessionItems().find((i) => i.row.id === st.selectedId);
+        if (it?.row.parent_session_id && items.some((i) => i.kind === "session" && i.row.id === it.row.parent_session_id)) {
+            st.selectedId = it.row.parent_session_id;
+        }
+    };
+    function onKey(k) {
+        if (st.searching) {
+            if (k.kind === "char")
+                st.filters.text += k.ch;
+            else if (k.kind === "backspace")
+                st.filters.text = [...st.filters.text].slice(0, -1).join("");
+            else if (k.kind === "enter" || k.kind === "down")
+                st.searching = false;
+            else if (k.kind === "escape" || k.kind === "ctrl-c") {
+                st.searching = false;
+                st.filters.text = "";
+            }
+            rebuild();
+            return;
+        }
+        const viewH = Math.max(1, (out.rows ?? 20) - 2);
+        switch (k.kind) {
+            case "up":
+                move(-1);
+                break;
+            case "down":
+                move(1);
+                break;
+            case "pgup":
+                move(-viewH);
+                break;
+            case "pgdn":
+                move(viewH);
+                break;
+            case "home":
+                move(-1e9);
+                break;
+            case "end":
+                move(1e9);
+                break;
+            case "enter":
+                if (st.selectedId)
+                    open(st.selectedId);
+                break;
+            case "tab":
+            case "ctrl-]": {
+                const right = getSessionOption("@cubes_right");
+                if (right)
+                    tmux(["select-pane", "-t", right]);
+                break;
+            }
+            case "right":
+                if (st.selectedId && !toggleFold(st.selectedId, true)) { /* a leaf: nothing to open */ }
+                break;
+            case "left":
+                if (!(st.selectedId && toggleFold(st.selectedId, false)))
+                    goParent();
+                break;
+            case "escape":
+                if (st.filters.text) {
+                    st.filters.text = "";
+                    rebuild();
+                }
+                break;
+            case "ctrl-l":
+                out.write(ESC.clear);
+                break;
+            case "mouse":
+                onMouse(k);
+                break;
+            case "char":
+                switch (k.ch) {
+                    case "j":
+                        move(1);
+                        break;
+                    case "k":
+                        move(-1);
+                        break;
+                    case "g":
+                        move(-1e9);
+                        break;
+                    case "G":
+                        move(1e9);
+                        break;
+                    case " ":
+                        if (st.selectedId)
+                            toggleFold(st.selectedId);
+                        break;
+                    case "l":
+                        st.filters.live = !st.filters.live;
+                        break;
+                    case "m":
+                        st.filters.mine = !st.filters.mine;
+                        break;
+                    case "/":
+                        st.searching = true;
+                        break;
+                    case "r":
+                        void refresh(true);
+                        break;
+                    case "d":
+                        tmux(["detach-client", "-s", SESSION]);
+                        break;
+                    case "q":
+                        tmux(["kill-session", "-t", SESSION]);
+                        break;
+                }
+                break;
+        }
+        rebuild();
+    }
+    function onMouse(k) {
+        if (k.release)
+            return;
+        if (k.button === 64) {
+            move(-3);
+            return;
+        } // wheel up
+        if (k.button === 65) {
+            move(3);
+            return;
+        } // wheel down
+        if (k.button !== 0)
+            return;
+        if (k.y === 1) { // the filter line
+            if (k.x <= 6)
+                st.filters.live = !st.filters.live;
+            else if (k.x <= 13)
+                st.filters.mine = !st.filters.mine;
+            else
+                st.searching = true;
+            return;
+        }
+        const it = items[st.top + k.y - 2];
+        if (!it || it.kind !== "session")
+            return;
+        // A click on the fold arrow folds; anywhere else on the row opens it.
+        const arrowCol = 1 + strWidth(treePrefix(it)) + 1;
+        if (it.children > 0 && k.x === arrowCol) {
+            st.selectedId = it.row.id;
+            toggleFold(it.row.id);
+            return;
+        }
+        st.selectedId = it.row.id;
+        open(it.row.id);
+    }
+    // ── data ───────────────────────────────────────────────────────────────────────────────────────
+    let inFlight = false;
+    async function refresh(announce = false) {
+        if (inFlight)
+            return;
+        inFlight = true;
+        try {
+            st.rows = await listSessions(api, { all: true });
+            st.loaded = true;
+            st.error = null;
+            if (announce)
+                flash(`${st.rows.length} sessions`);
+        }
+        catch (e) {
+            st.error = e.message;
+        }
+        finally {
+            inFlight = false;
+            // The pane on the right says which session it holds; it can change without us (a reconnect).
+            st.current = getSessionOption("@cubes_current");
+            rebuild();
+            render();
+        }
+    }
+    process.stdin.on("data", (b) => {
+        for (const k of parseKeys(b.toString("utf8")))
+            onKey(k);
+        render();
+    });
+    out.on("resize", render);
+    render();
+    await refresh();
+    setInterval(() => void refresh(), POLL_MS);
+    return new Promise(() => { });
+}

package/dist/tui/model.js

@@ -0,0 +1,117 @@
+// What the split view's list shows: the sessions as a tree (a spawned session under the session that
+// spawned it), inside the same sections `cubes ls` and the web use, narrowed by the filters - all pure,
+// so the whole of it is testable without a terminal.
+import { LIVE, sectionize } from "../sessions.js";
+/** One status vocabulary for the list, the header and the tab: the server's lifecycle + activity. */
+export function statusOf(r) {
+    switch (r.status) {
+        case "running":
+            if (r.activity_status === "working")
+                return { glyph: "●", color: 75, label: "working", attention: false };
+            if (r.activity_status === "waiting")
+                return { glyph: "●", color: 214, label: "needs you", attention: true };
+            return { glyph: "●", color: 78, label: "idle", attention: false };
+        case "starting": return { glyph: "◌", color: 80, label: "starting", attention: false };
+        case "stranded": return { glyph: "○", color: 203, label: "stranded", attention: false };
+        case "cancelled": return { glyph: "○", color: 242, label: "ended", attention: false };
+        default: return { glyph: "○", color: 242, label: r.status, attention: false };
+    }
+}
+export function matches(r, f) {
+    if (f.live && !LIVE.has(r.status))
+        return false;
+    if (f.mine && r.created_by_me !== true)
+        return false;
+    const q = f.text.trim().toLowerCase();
+    if (q && !(r.title ?? "").toLowerCase().includes(q) && !r.id.toLowerCase().startsWith(q)
+        && !(r.group_name ?? "").toLowerCase().includes(q))
+        return false;
+    return true;
+}
+const startOf = (r) => r.started_at ?? r.ended_at ?? r.created_at ?? "";
+const order = (a, b) => {
+    const la = LIVE.has(a.row.status);
+    const lb = LIVE.has(b.row.status);
+    if (la !== lb)
+        return la ? -1 : 1;
+    return startOf(b.row).localeCompare(startOf(a.row));
+};
+/**
+ * Build the visible list.
+ *
+ * ⚠ A SPAWNED SESSION LIVES UNDER ITS PARENT, NOT IN ITS OWN GROUP. The tree is what says who started
+ * what; a child filed into a different section would lose its parent and read as a stray root. A
+ * child whose parent is not in the page (paged out, deleted) is shown as a root rather than hidden.
+ *
+ * ⚠ A FILTER KEEPS THE PATH TO A MATCH. A live child under an exited parent is still reachable with
+ * `live` on - the parent stays as the way to it, and it is drawn expanded so the match is visible.
+ *
+ * `expandedOverride` is what the person toggled; without one, a parent starts expanded when anything
+ * under it is live (the work in progress is the thing to see) and collapsed otherwise.
+ */
+export function buildItems(rows, f, expandedOverride) {
+    const byId = new Map(rows.map((r) => [r.id, { row: r, kids: [] }]));
+    const roots = [];
+    for (const n of byId.values()) {
+        const parent = n.row.parent_session_id ? byId.get(n.row.parent_session_id) : undefined;
+        if (parent && parent !== n)
+            parent.kids.push(n);
+        else
+            roots.push(n);
+    }
+    const keep = new Map(); // node matches, or something under it does
+    const anyLive = new Map();
+    const visit = (n) => {
+        n.kids.sort(order);
+        let k = matches(n.row, f);
+        let live = LIVE.has(n.row.status);
+        for (const c of n.kids) {
+            visit(c);
+            if (keep.get(c.row.id))
+                k = true;
+            if (anyLive.get(c.row.id))
+                live = true;
+        }
+        keep.set(n.row.id, k);
+        anyLive.set(n.row.id, live);
+    };
+    roots.forEach(visit);
+    const filtering = f.live || f.mine || f.text.trim() !== "";
+    const visibleRoots = roots.filter((n) => keep.get(n.row.id)).map((n) => n.row);
+    const items = [];
+    const sections = sectionize(visibleRoots);
+    const bare = sections.length === 1 && sections[0].title === "Ungrouped";
+    for (const sec of sections) {
+        const nodes = sec.rows.map((r) => byId.get(r.id));
+        if (!bare)
+            items.push({ kind: "section", title: sec.title, count: countVisible(nodes, keep) });
+        const walk = (n, depth, lasts) => {
+            const kids = n.kids.filter((c) => keep.get(c.row.id));
+            const kidMatch = filtering && kids.length > 0;
+            const expanded = expandedOverride.get(n.row.id) ?? (kidMatch || n.kids.some((c) => anyLive.get(c.row.id) === true));
+            items.push({ kind: "session", row: n.row, depth, lasts, children: kids.length, expanded: expanded && kids.length > 0 });
+            if (expanded)
+                kids.forEach((c, i) => walk(c, depth + 1, [...lasts, i === kids.length - 1]));
+        };
+        nodes.forEach((n) => walk(n, 0, []));
+    }
+    return items;
+}
+function countVisible(nodes, keep) {
+    let c = 0;
+    const go = (n) => { if (keep.get(n.row.id)) {
+        c++;
+        n.kids.forEach(go);
+    } };
+    nodes.forEach(go);
+    return c;
+}
+/** The tree guide in front of a child: `│ ` / blank per ancestor level, then `├─`/`└─`. */
+export function treePrefix(item) {
+    if (item.depth === 0)
+        return "";
+    let s = "";
+    for (let i = 0; i < item.lasts.length - 1; i++)
+        s += item.lasts[i] ? "  " : "│ ";
+    return s + (item.lasts[item.lasts.length - 1] ? "└─" : "├─");
+}

package/dist/tui/paneApp.js

@@ -0,0 +1,156 @@
+// The right pane of the split view: the session itself, under a header (tmux's pane border) that says
+// which one it is - name, group, runner, state - and stays current while you work in it.
+//
+// The list replaces this process (`respawn-pane -k`) to open another session, so it only ever holds
+// one. When an attach ends it SAYS so and waits: there is no automatic reconnect, by decision ("never
+// keep retrying to reattach a session") - `r` reconnects when the person chooses to.
+import { makeApi } from "../api.js";
+import { attach } from "../attach.js";
+import { currentSession } from "../auth.js";
+import { readClipboardImage } from "../clipboard.js";
+import { CubeSpinner, cubeSize } from "../cube.js";
+import { ensureRunning } from "../resume.js";
+import { statusOf } from "./model.js";
+import { ESC, fit, parseKeys, printable, strWidth } from "./term.js";
+import { fmtText, getSessionOption, setPaneOption, setSessionOption, tmux } from "./tmux.js";
+const out = process.stdout;
+const focusList = () => {
+    const left = getSessionOption("@cubes_left");
+    if (left)
+        tmux(["select-pane", "-t", left]);
+};
+/** The header: `● Title · Group · runner · state`, as a tmux format (styles via #[...]). */
+export function headerFor(r, override) {
+    const s = override ?? statusOf({ status: r.status ?? "running", activity_status: r.activity_status ?? null });
+    const parts = [
+        `#[fg=colour${s.color}]${s.glyph}#[default] #[bold]${fmtText(printable(r.title || r.id.slice(0, 8)))}#[nobold]`,
+        fmtText(printable(r.group_name || r.package_name || "no group")),
+        fmtText(printable(r.runner_name || "-")),
+        `#[fg=colour${s.color}]${s.label}#[default]`,
+    ];
+    return parts.join(" #[fg=colour240]·#[default] ");
+}
+function setHeader(r, override) {
+    setPaneOption("@cubes_header", headerFor(r, override));
+    const s = override ?? statusOf({ status: r.status ?? "running", activity_status: r.activity_status ?? null });
+    setSessionOption("@cubes_tab", `${s.glyph} ${printable(r.title || "Cubes session")}`);
+}
+/** Read keys until one is accepted. Raw mode on for as long as we wait. */
+function waitKey(accept) {
+    return new Promise((resolve) => {
+        if (process.stdin.isTTY)
+            process.stdin.setRawMode(true);
+        const onData = (b) => {
+            for (const k of parseKeys(b.toString("utf8"))) {
+                if (!accept(k))
+                    continue;
+                process.stdin.off("data", onData);
+                process.stdin.pause();
+                resolve(k);
+                return;
+            }
+        };
+        process.stdin.on("data", onData);
+        process.stdin.resume();
+    });
+}
+/** A few centred lines, nothing else on screen. */
+function message(lines) {
+    const w = out.columns ?? 80;
+    const h = out.rows ?? 24;
+    const top = Math.max(0, Math.floor((h - lines.length) / 2));
+    let s = ESC.hideCursor + ESC.home + ESC.clear;
+    lines.forEach((l, i) => {
+        const t = fit(l.text, Math.min(w - 2, strWidth(l.text)));
+        const col = Math.max(1, Math.floor((w - strWidth(t)) / 2) + 1);
+        s += `${ESC.at(top + i + 1, col)}${l.style ?? ""}${t}${ESC.reset}`;
+    });
+    out.write(s);
+}
+/** Where to put the cube so it sits in the middle of this pane. */
+function cubePlacement() {
+    const w = out.columns ?? 80;
+    const h = out.rows ?? 24;
+    const size = cubeSize(w, h);
+    if (!size)
+        return { indent: 2, top: 0 };
+    return { indent: Math.max(2, Math.floor((w - size.w) / 2)), top: Math.max(0, Math.floor((h - size.h - 2) / 2)) };
+}
+async function welcome() {
+    setSessionOption("@cubes_current", "");
+    setSessionOption("@cubes_tab", "Cubes");
+    setPaneOption("@cubes_header", "#[bold]Cubes#[nobold] #[fg=colour240]·#[default] pick a session on the left");
+    let spin = null;
+    const draw = () => {
+        spin?.stop();
+        const { indent, top } = cubePlacement();
+        out.write(ESC.hideCursor + ESC.home + ESC.clear + "\n".repeat(top));
+        spin = new CubeSpinner(out, "Pick a session on the left", process.env, indent);
+    };
+    draw();
+    out.on("resize", draw);
+    for (;;) {
+        await waitKey((k) => k.kind === "ctrl-]" || k.kind === "escape" || k.kind === "tab");
+        focusList();
+    }
+}
+const OUTCOME_WORDS = {
+    ended: { head: "Session ended", key: "resume it", color: 242 },
+    disconnected: { head: "Disconnected", key: "reconnect", color: 214 },
+    refused: { head: "The server refused the attach", key: "try again", color: 203 },
+    detached: { head: "Detached", key: "attach again", color: 242 },
+};
+async function sessionPane(id) {
+    const api = makeApi(currentSession());
+    setSessionOption("@cubes_current", id);
+    let row = { id, title: null, status: "running", created_at: "" };
+    setHeader(row, { glyph: "◌", color: 80, label: "connecting" });
+    for (;;) {
+        let result;
+        try {
+            row = await api.get(`/sessions/${encodeURIComponent(id)}`);
+            setHeader(row);
+            const { indent, top } = cubePlacement();
+            out.write(ESC.home + ESC.clear + "\n".repeat(top));
+            row = await ensureRunning(api, row, true, out, indent);
+            setHeader(row);
+            result = await attach({
+                api,
+                host: currentSession().host,
+                openWs: (url, protocols) => new WebSocket(url, protocols),
+                stdin: process.stdin,
+                stdout: out,
+                stderr: out,
+                readClipboardImage: () => readClipboardImage(),
+            }, row, {
+                onDetachKey: focusList,
+                status: { onRow: (r) => { row = { ...row, ...r }; setHeader(row); } },
+            });
+        }
+        catch (e) {
+            result = { code: 1, message: e.message, outcome: "disconnected" };
+        }
+        const words = OUTCOME_WORDS[result.outcome];
+        setHeader(row, { glyph: "○", color: words.color, label: words.head.toLowerCase() });
+        message([
+            { text: words.head, style: ESC.bold + ESC.fg(words.color) },
+            { text: result.message, style: ESC.dim },
+            { text: "" },
+            { text: `r  ${words.key}     ^]  back to the list` },
+        ]);
+        // Wait for the person: `r` goes round again, ^] / Esc / Tab hand focus back to the list.
+        for (;;) {
+            const k = await waitKey((k) => (k.kind === "char" && (k.ch === "r" || k.ch === "R")) || k.kind === "enter"
+                || k.kind === "ctrl-]" || k.kind === "escape" || k.kind === "tab");
+            if (k.kind === "char" || k.kind === "enter")
+                break;
+            focusList();
+        }
+    }
+}
+export async function runPane(id) {
+    for (const sig of ["SIGTERM", "SIGHUP"])
+        process.on(sig, () => process.exit(0));
+    process.on("exit", () => out.write(ESC.showCursor));
+    return id ? sessionPane(id) : welcome();
+}