@hellix-ai/cubes 0.1.5 → 0.2.1

package/README.md

@@ -14,6 +14,18 @@ cubes attach 7ff4                    # or name one: an id prefix, or part of its
 
 No install: `npx @hellix-ai/cubes attach <session>`. Later, `cubes upgrade` updates it in place.
 
+## The split view
+
+Run `cubes` on its own for everything at once: your sessions on the left, one of them open on the right.
+It runs inside its own tmux (install it with `brew install tmux` or `apt install tmux`; a tmux you already
+use is never touched), so close the terminal and run `cubes` again to land right back where you were.
+
+- **The list** is grouped like the web's Sessions page, with a session's spawned sessions nested under it
+  and a coloured dot for its state: working, idle, **needs you**, starting, ended.
+- **Above the session**, a header says which one it is: name · group · runner · state.
+- **Keys:** `⏎` (or a click) opens a session · `Ctrl-]` in a session jumps back to the list · `l` live only
+  · `m` mine only · `/` find · `←` `→` fold a session's children · `q` quits (sessions keep running).
+
 ## While attached
 
 Every key goes to the session, exactly as if Claude Code were running locally, except:
@@ -23,13 +35,18 @@ Every key goes to the session, exactly as if Claude Code were running locally, e
 | `Ctrl-]` | detach. The session keeps running. |
 | `Ctrl-V` | paste the image on your clipboard: it is uploaded to the session and its path typed in (macOS, and Linux with `wl-paste` or `xclip`). With no image on the clipboard, Ctrl-V goes through unchanged. |
 
+**Copying.** Drag over text in a session and it is copied the moment you let go - the session's tmux
+does the selecting (so there is no selection left for Cmd+C), and the CLI puts the text on your
+clipboard. Claude Code's own copy (the `c` on its login URL) lands there too. On Linux this needs
+`wl-copy`, `xclip` or `xsel`.
+
 **One keyboard per session.** Attaching takes the keyboard from any browser tab open on the same session
 (that tab becomes read-only, with a Take over button) and fits the session to your window. If someone
 takes it back, the terminal says so and goes read-only; detach and attach again to reclaim it.
 `cubes attach --view` watches without taking it.
 
 **Your tab shows the session.** The terminal tab is titled after the session, with its state in front,
-the way Claude Code does it locally: a spinner while it works, `✳` when idle, `✋` when it is waiting
+the way Claude Code does it locally (minus the animation): `●` while it works, `✳` when idle, `✋` when it is waiting
 for you. The moment it starts waiting, the terminal also gets a bell (most terminals mark the tab or
 bounce the dock) and a desktop notification with Claude's question (iTerm2, Ghostty, WezTerm, kitty and
 others). In Warp, the same events Warp's own Claude Code plugin sends drive its tab status and
@@ -37,8 +54,9 @@ notifications instead. Muted sessions stay quiet. Your own title comes back when
 `--no-status` turns all of it off.
 
 A stopped or hibernated session is resumed before attaching (`--no-resume` to refuse), with the
-spinning Cubes mark on screen until it is up. A dropped connection reconnects on its own and replays
-the screen.
+spinning Cubes mark on screen until it is up. If the connection drops, nothing reconnects behind your
+back: you are told why (the connection dropped, the session's machine stopped answering, too many
+viewers) and `r` reconnects when you choose to.
 
 Scrollback lives in the session's tmux: scroll with the mouse wheel or trackpad (tmux copy-mode), not
 your terminal's own scrollback.
@@ -46,6 +64,7 @@ your terminal's own scrollback.
 ## Commands
 
 ```
+cubes                                  # the split view
 cubes login [--host URL] [--org ALIAS] [--no-browser]
 cubes logout
 cubes whoami

package/dist/attach.js

@@ -22,10 +22,16 @@ const WS_CLOSE_BACKPRESSURE = 4001;
 const WS_CLOSE_FULL = 4002;
 const WS_CLOSE_PARKED = 4004;
 const WS_CLOSE_UNAUTHORIZED = 4403;
-/** Drops that mean "the session is fine, the socket is not": re-mint a ticket and re-attach; the
- *  server replays its scrollback ring. 1001/1012/1013 are a server going away or restarting. */
-const TRANSIENT = new Set([WS_CLOSE_BACKPRESSURE, 1001, 1005, 1006, 1011, 1012, 1013]);
-const DEFAULT_BACKOFF = [300, 600, 1200, 2400, 5000, 5000, 5000, 5000];
+/** Why a connection that was not a session ending went away, in words a person can act on. */
+export function dropReason(code, reason = "") {
+    if (code === WS_CLOSE_PARKED)
+        return "this session's machine stopped answering";
+    if (code === WS_CLOSE_FULL)
+        return "this session already has the most viewers it allows - close another view, then reconnect";
+    if (code === WS_CLOSE_BACKPRESSURE)
+        return "the connection fell too far behind the session and was dropped";
+    return `the connection dropped (${code}${reason ? ` ${reason}` : ""})`;
+}
 /** Everything an attached session may have switched on in YOUR terminal (mouse reporting, bracketed
  *  paste, focus events, app cursor keys, kitty/modifyOtherKeys keyboard modes, a hidden cursor, a
  *  scroll region) - switched back off on the way out, so detaching never leaves Warp/iTerm in a
@@ -35,13 +41,11 @@ export const RESTORE_TERMINAL = "\x1b[0m\x1b[?25h\x1b[0 q\x1b[r" +
     "\x1b[?2004l\x1b[?1004l\x1b[?1l\x1b>\x1b[<u\x1b[>4;0m";
 const ENTER_ALT = "\x1b[?1049h\x1b[H\x1b[2J";
 const LEAVE_ALT = "\x1b[?1049l";
-const CLEAR = "\x1b[H\x1b[2J";
 export function wsUrlFor(host, id) {
     return `${host.replace(/^http/i, "ws")}/api/sessions/${encodeURIComponent(id)}/tty`;
 }
 export function attach(deps, session, opts = {}) {
     const { api, stdin, stdout, stderr } = deps;
-    const backoff = opts.backoffMs ?? DEFAULT_BACKOFF;
     const filter = new InputFilter({ pasteImage: !opts.view });
     const enc = new TextEncoder();
     return new Promise((resolve) => {
@@ -54,19 +58,29 @@ export function attach(deps, session, opts = {}) {
         let yielded = false;
         let entered = false;
         let done = false;
-        let attempts = 0;
-        let timer = null;
         // Keystrokes that must wait their turn: until the server says who holds the keyboard, and while
         // an image paste is uploading (so what is typed after Ctrl-V lands after the path, not before).
         let pending = [];
         let pasting = false;
         // Our own sequences (title, bell, notifications) wait here until the session's stream is between
         // escape sequences - see termstatus.ts. A fresh filter per connection: a replay starts clean.
-        let stream = new StreamFilter();
+        // ⚠ ONLY THE KEYBOARD COPIES. The session's output reaches every viewer, so a `c` pressed in a
+        // browser tab on the same session would otherwise overwrite THIS person's clipboard too. The web
+        // terminal draws the same line (Terminal.tsx, its OSC 52 handler).
+        const onClipboard = deps.clipboard ? (text) => {
+            if (role !== "writer")
+                return;
+            void deps.clipboard.write(text).then((ok) => {
+                if (!ok || done)
+                    return;
+                status?.flash(`✓ Copied ${[...text].length} characters`);
+                opts.onCopied?.(text);
+            });
+        } : undefined;
+        let stream = new StreamFilter(onClipboard);
         let injections = [];
         let status = null;
         let pollTimer = null;
-        let spinTimer = null;
         const inject = (seq) => {
             if (stream.safe)
                 stdout.write(seq);
@@ -86,18 +100,20 @@ export function attach(deps, session, opts = {}) {
             stdout.write(TITLE_PUSH);
             status = new TermStatus({ status: "running", ...session }, inject, cfg.env);
             status.update({ status: "running", ...session });
+            cfg.onRow?.({ status: "running", ...session });
             let inFlight = false;
             pollTimer = setInterval(() => {
                 if (inFlight || done)
                     return;
                 inFlight = true;
                 api.get(`/sessions/${encodeURIComponent(session.id)}`)
-                    .then((row) => { if (!done)
-                    status?.update(row); })
+                    .then((row) => { if (!done) {
+                    status?.update(row);
+                    cfg.onRow?.(row);
+                } })
                     .catch(() => { })
                     .finally(() => { inFlight = false; });
             }, cfg.pollMs ?? 3000);
-            spinTimer = setInterval(() => { status?.tick(); flushInjections(); }, cfg.spinMs ?? 250);
         };
         const note = (msg) => {
             stderr.write(entered ? `\r\n\x1b[2m[cubes] ${msg}\x1b[0m\r\n` : `[cubes] ${msg}\n`);
@@ -111,16 +127,12 @@ export function attach(deps, session, opts = {}) {
             stdout.write(ENTER_ALT);
             startStatus();
         };
-        const finish = (code, message) => {
+        const finish = (code, message, outcome) => {
             if (done)
                 return;
             done = true;
-            if (timer)
-                clearTimeout(timer);
             if (pollTimer)
                 clearInterval(pollTimer);
-            if (spinTimer)
-                clearInterval(spinTimer);
             stdin.off("data", onData);
             stdout.off("resize", onResize);
             const sock = ws;
@@ -139,7 +151,7 @@ export function attach(deps, session, opts = {}) {
                     stdin.setRawMode?.(false);
             }
             stdin.pause();
-            resolve({ code, message });
+            resolve({ code, message, outcome });
         };
         const sendRaw = (b) => {
             if (ws && ws.readyState === OPEN)
@@ -206,7 +218,11 @@ export function attach(deps, session, opts = {}) {
         function onData(chunk) {
             for (const a of filter.feed(chunk)) {
                 if (a.kind === "detach") {
-                    finish(0, "detached");
+                    if (opts.onDetachKey) {
+                        opts.onDetachKey();
+                        continue;
+                    }
+                    finish(0, "detached", "detached");
                     return;
                 }
                 if (a.kind === "paste-image") {
@@ -219,44 +235,20 @@ export function attach(deps, session, opts = {}) {
             }
         }
         function onResize() { sendResize(); }
-        const retry = (ms) => {
-            if (done)
-                return;
-            timer = setTimeout(() => { timer = null; void connect(); }, ms);
-        };
         const onClose = (code, reason) => {
             ws = null;
             role = null;
             if (done)
                 return;
             if (code === 1000) {
-                finish(0, reason ? `session ended (${reason})` : "session ended");
+                finish(0, reason ? `session ended (${reason})` : "session ended", "ended");
                 return;
             }
             if (code === WS_CLOSE_UNAUTHORIZED) {
-                finish(1, "the server refused the attach - your sign-in or org membership may have changed");
+                finish(1, "the server refused the attach - your sign-in or org membership may have changed", "refused");
                 return;
             }
-            if (code === WS_CLOSE_PARKED) {
-                note("this session's terminal is parked (its machine stopped answering). Waiting for it to come back - Ctrl-] to give up.");
-                retry(opts.parkedRetryMs ?? 15_000);
-                return;
-            }
-            if (code === WS_CLOSE_FULL) {
-                note("this session already has the most viewers it allows - waiting for one to leave. Ctrl-] to give up.");
-                retry(opts.fullRetryMs ?? 5_000);
-                return;
-            }
-            if (TRANSIENT.has(code) && attempts < backoff.length) {
-                const ms = backoff[attempts];
-                attempts += 1;
-                note(`connection dropped (${code}) - reconnecting (${attempts}/${backoff.length})…`);
-                retry(ms);
-                return;
-            }
-            finish(1, TRANSIENT.has(code)
-                ? "lost the connection to the session and could not get it back"
-                : `the session closed the connection (${code}${reason ? ` ${reason}` : ""})`);
+            finish(1, dropReason(code, reason), "disconnected");
         };
         const connect = async () => {
             if (done)
@@ -269,22 +261,15 @@ export function attach(deps, session, opts = {}) {
                 if (done)
                     return;
                 if (e instanceof ApiError && e.status === 409) {
-                    finish(1, "the session is not running any more");
+                    finish(1, "the session is not running any more", "ended");
                     return;
                 }
                 if (e instanceof ApiError && e.status < 500) {
-                    finish(1, e.message);
-                    return;
-                }
-                // The server itself is restarting or unreachable: same ladder as a dropped socket.
-                if (attempts < backoff.length) {
-                    const ms = backoff[attempts];
-                    attempts += 1;
-                    note(`${e.message} - retrying (${attempts}/${backoff.length})…`);
-                    retry(ms);
+                    finish(1, e.message, "refused");
                     return;
                 }
-                finish(1, e.message);
+                // The server is restarting or unreachable: a disconnect like any other, the caller offers it.
+                finish(1, e.message, "disconnected");
                 return;
             }
             if (done)
@@ -292,16 +277,13 @@ export function attach(deps, session, opts = {}) {
             const sock = deps.openWs(wsUrlFor(deps.host, session.id), [TTY_SUBPROTOCOL, ticket]);
             sock.binaryType = "arraybuffer";
             ws = sock;
-            stream = new StreamFilter();
+            stream = new StreamFilter(onClipboard);
             askedTakeover = false;
             takeoverPending = false;
             sock.onopen = () => {
                 if (ws !== sock)
                     return;
-                if (!entered)
-                    enter();
-                else
-                    stdout.write(CLEAR); // the server replays its ring; paint it on a clean screen
+                enter();
                 sendResize();
             };
             sock.onmessage = (ev) => {
@@ -317,9 +299,6 @@ export function attach(deps, session, opts = {}) {
                         return;
                     }
                     if (msg.type === "role") {
-                        // A role is what proves the attach stuck (the viewer-cap refusal arrives AFTER open),
-                        // so this - not onopen - is where the reconnect ladder resets.
-                        attempts = 0;
                         const prev = role;
                         role = msg.writer ? "writer" : "mirror";
                         if (role === "mirror" && prev === "writer") {
@@ -357,10 +336,10 @@ export function attach(deps, session, opts = {}) {
         stdout.on("resize", onResize);
         stdin.resume();
         if (opts.signal?.aborted) {
-            finish(0, "detached");
+            finish(0, "detached", "detached");
             return;
         }
-        opts.signal?.addEventListener("abort", () => finish(0, "detached"), { once: true });
+        opts.signal?.addEventListener("abort", () => finish(0, "detached", "detached"), { once: true });
         void connect();
     });
 }

package/dist/cli.js

@@ -7,11 +7,15 @@
 import { spawn } from "node:child_process";
 import { createRequire } from "node:module";
 import { createInterface } from "node:readline/promises";
-import { makeApi, ApiError } from "./api.js";
+import { makeApi } from "./api.js";
 import { attach, RESTORE_TERMINAL } from "./attach.js";
 import { CliError, currentSession, discover, loginFromTokens, normalizeHost, orgsOf, pollDevice, revoke, startDevice, whoOf, } from "./auth.js";
-import { readClipboardImage } from "./clipboard.js";
+import { clipboardWriter, readClipboardImage, writeClipboard } from "./clipboard.js";
 import { CubeSpinner } from "./cube.js";
+import { ensureRunning } from "./resume.js";
+import { launchTui } from "./tui/launch.js";
+import { runList } from "./tui/listApp.js";
+import { runPane } from "./tui/paneApp.js";
 import { clearLogin, configPath, loadLogin, saveLogin } from "./config.js";
 import { parseArgs } from "./args.js";
 import { formatSections, isUuid, listSessions, LIVE, resolveSession, sectionize, stateOf } from "./sessions.js";
@@ -21,6 +25,8 @@ const VERSION = PKG.version;
 const HELP = `cubes ${VERSION} - attach to your Cubes sessions from your own terminal
 
 Usage:
+  cubes                                                   the split view: your sessions on the left, one open
+                                                          on the right (needs tmux)
   cubes login [--host URL] [--org ALIAS] [--no-browser]   sign in with a code you approve in the browser
   cubes logout                                            sign out and revoke this computer's login
   cubes whoami                                            who, where, and which org
@@ -38,10 +44,18 @@ While attached, every key goes to the session except:
   Ctrl-]   detach (the session keeps running)
   Ctrl-V   paste the image on your clipboard (uploaded, then its path is typed in)
 
+To copy, drag over text: it is on your clipboard the moment you let go (the session's tmux does the
+selecting). Claude Code's own copy, like the c on its login URL, lands there too.
+
+If the connection drops, nothing reconnects on its own: you are told why, and r reconnects.
+
+In the split view: ⏎ or a click opens a session, Ctrl-] in a session jumps back to the list, l / m
+show only live / your sessions, / finds, ←→ fold a session's children, q quits (sessions keep running).
+
 Attaching takes the keyboard from any browser tab on the same session (it becomes read-only) and
 fits the session to this window. --view watches without taking it.
 
-The tab is titled after the session, with its state: a spinner while it works, ✳ when idle, ✋ when it
+The tab is titled after the session, with its state: ● while it works, ✳ when idle, ✋ when it
 is waiting for you - and a bell plus a desktop notification the moment it starts waiting (in Warp, its
 own agent status instead). --no-status turns all of that off.
 
@@ -182,46 +196,6 @@ async function cmdLs(a) {
     const color = !!process.stdout.isTTY && !process.env.NO_COLOR;
     process.stdout.write(formatSections(sectionize(rows), process.stdout.columns ?? 120, { color }) + "\n");
 }
-const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-/** Bring a stopped/hibernated session back and wait until its terminal can be attached. */
-async function ensureRunning(api, row, resume) {
-    const id = encodeURIComponent(row.id);
-    let s = row;
-    if (s.status === "running")
-        return s;
-    if (!LIVE.has(s.status) && !resume)
-        throw new CliError(`that session is ${s.status}; leave out --no-resume to bring it back`);
-    const name = `"${s.title ?? s.id.slice(0, 8)}"`;
-    // The same cube the session's own screen spins while Claude boots, so the wait reads as one thing.
-    const spin = new CubeSpinner(process.stderr, `${LIVE.has(s.status) ? "Starting" : "Resuming"} ${name}`);
-    try {
-        if (!LIVE.has(s.status)) {
-            try {
-                await api.post(`/sessions/${id}/resume`);
-            }
-            catch (e) {
-                if (!(e instanceof ApiError && e.status === 409 && /already running/.test(e.message)))
-                    throw e;
-            }
-        }
-        const deadline = Date.now() + 5 * 60_000;
-        while (Date.now() < deadline) {
-            s = await api.get(`/sessions/${id}`);
-            if (s.status === "running")
-                return s;
-            if (!LIVE.has(s.status))
-                throw new CliError(`the session stopped while starting (${s.status})`);
-            if (s.provision_note) {
-                spin.update(`${s.provision_note}${s.provision_total ? ` (${s.provision_done ?? 0}/${s.provision_total})` : ""}`);
-            }
-            await sleep(1000);
-        }
-        throw new CliError("the session is taking too long to start - check it in the browser");
-    }
-    finally {
-        spin.stop();
-    }
-}
 async function cmdAttach(a) {
     const s = currentSession({ org: str(a.flags, "org") });
     const api = makeApi(s);
@@ -243,9 +217,7 @@ async function cmdAttach(a) {
     }
     if (!isTTY())
         throw new CliError("attach needs an interactive terminal");
-    row = await ensureRunning(api, row, !a.flags.has("no-resume"));
     const view = a.flags.has("view");
-    process.stderr.write(`Attaching to "${row.title ?? row.id}" (${row.id.slice(0, 8)})${view ? ", read-only" : ""}. Ctrl-] detaches.\n`);
     const ac = new AbortController();
     for (const sig of ["SIGTERM", "SIGHUP"])
         process.on(sig, () => ac.abort());
@@ -259,17 +231,51 @@ async function cmdAttach(a) {
         process.stderr.write(`cubes: ${e.message}\n`);
         process.exit(1);
     });
-    const result = await attach({
-        api,
-        host: s.host,
-        openWs: (url, protocols) => new WebSocket(url, protocols),
-        stdin: process.stdin,
-        stdout: process.stdout,
-        stderr: process.stderr,
-        readClipboardImage: () => readClipboardImage(),
-    }, row, { view, signal: ac.signal, status: a.flags.has("no-status") ? false : undefined });
-    process.stderr.write(`[cubes] ${result.message}\n`);
-    return result.code;
+    // ⚠ ONE ATTACH PER DECISION. A drop is reported, not retried ("never keep retrying to reattach a
+    // session"): the person reads why and presses r to go again, or anything else to leave.
+    for (;;) {
+        row = await ensureRunning(api, row, !a.flags.has("no-resume"));
+        process.stderr.write(`Attaching to "${row.title ?? row.id}" (${row.id.slice(0, 8)})${view ? ", read-only" : ""}. Ctrl-] detaches.\n`);
+        const result = await attach({
+            api,
+            host: s.host,
+            openWs: (url, protocols) => new WebSocket(url, protocols),
+            stdin: process.stdin,
+            stdout: process.stdout,
+            stderr: process.stderr,
+            readClipboardImage: () => readClipboardImage(),
+            clipboard: copier(),
+        }, row, { view, signal: ac.signal, status: a.flags.has("no-status") ? false : undefined });
+        if (result.outcome !== "disconnected" || ac.signal.aborted) {
+            process.stderr.write(`[cubes] ${result.message}\n`);
+            return result.code;
+        }
+        process.stderr.write(`[cubes] disconnected: ${result.message}\n`);
+        if (!(await keyIs("Press r to reconnect, any other key to quit. ", ["r", "R", "\r"])))
+            return result.code;
+        row = await api.get(`/sessions/${encodeURIComponent(row.id)}`);
+    }
+}
+/** What the session copies goes to this machine's clipboard, when it has a way to write one. */
+export function copier() {
+    const cmd = clipboardWriter();
+    return cmd ? { write: (text) => writeClipboard(cmd, text) } : null;
+}
+/** One keystroke, raw: true when it is one of `yes`. */
+function keyIs(prompt, yes) {
+    if (!process.stdin.isTTY)
+        return Promise.resolve(false);
+    process.stderr.write(prompt);
+    return new Promise((resolve) => {
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.once("data", (b) => {
+            process.stdin.setRawMode(false);
+            process.stdin.pause();
+            process.stderr.write("\n");
+            resolve(yes.includes(b.toString("utf8")));
+        });
+    });
 }
 async function main(argv) {
     if (typeof WebSocket === "undefined") {
@@ -280,6 +286,9 @@ async function main(argv) {
         process.stdout.write(`${VERSION}\n`);
         return 0;
     }
+    // No command at all, in a terminal: the split view. Piped or scripted, still the help.
+    if (!a.cmd && !a.flags.has("help") && isTTY())
+        return launchTui({ org: str(a.flags, "org") });
     if (!a.cmd || a.cmd === "help" || a.flags.has("help")) {
         process.stdout.write(HELP);
         return a.cmd || a.flags.has("help") ? 0 : 1;
@@ -304,6 +313,9 @@ async function main(argv) {
             return 0;
         case "attach":
         case "a": return cmdAttach(a);
+        // The split view's two panes (src/tui), started by tmux - not for typing by hand.
+        case "_list": return runList();
+        case "_pane": return runPane(a.pos[0]);
         case "upgrade":
         case "update":
             return upgrade({

package/dist/clipboard.js

@@ -3,7 +3,7 @@
 // macOS: AppleScript coerces whatever the pasteboard holds (a screenshot, an image copied from a
 // browser) to PNG and writes it to a temp file. Linux: wl-paste on Wayland, xclip on X11. Anything
 // else, or no image there, is null - and the caller then sends Ctrl-V through untouched.
-import { execFile } from "node:child_process";
+import { execFile, spawn, spawnSync } from "node:child_process";
 import { mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -65,3 +65,34 @@ export async function readClipboardImage(platform = process.platform, env = proc
         return linux(env);
     return null;
 }
+// ── WRITING: what the session copies (OSC 52) lands on THIS machine's clipboard ─────────────────────
+/** The command that writes the clipboard here, or null when there is none to use. */
+export function clipboardWriter(platform = process.platform, env = process.env) {
+    const has = (cmd) => spawnSync("sh", ["-c", `command -v ${cmd}`], { stdio: "ignore" }).status === 0;
+    if (platform === "darwin")
+        return ["pbcopy"];
+    if (platform === "win32")
+        return ["clip"];
+    if (platform === "linux") {
+        if (env.WAYLAND_DISPLAY && has("wl-copy"))
+            return ["wl-copy"];
+        if (env.DISPLAY && has("xclip"))
+            return ["xclip", "-selection", "clipboard", "-in"];
+        if (env.DISPLAY && has("xsel"))
+            return ["xsel", "--clipboard", "--input"];
+    }
+    return null;
+}
+export function writeClipboard(cmd, text) {
+    return new Promise((resolve) => {
+        try {
+            const child = spawn(cmd[0], cmd.slice(1), { stdio: ["pipe", "ignore", "ignore"] });
+            child.on("error", () => resolve(false));
+            child.on("exit", (code) => resolve(code === 0));
+            child.stdin.end(text);
+        }
+        catch {
+            resolve(false);
+        }
+    });
+}

package/dist/cube.js

@@ -100,6 +100,7 @@ export function renderRow(levels, color) {
  */
 export class CubeSpinner {
     out;
+    indent;
     timer = null;
     frame = 0;
     drawn = 0;
@@ -110,8 +111,10 @@ export class CubeSpinner {
     // A Ctrl-C mid-wait: Node's default SIGINT exit runs no "exit" listeners, so it would leave the
     // cube on screen and the cursor hidden. Clean up, then exit the way the default would have.
     onSigint = () => { this.stop(); process.exit(130); };
-    constructor(out, caption, env = process.env) {
+    /** `indent`: columns to the left of the cube (the split view centres it in its pane). */
+    constructor(out, caption, env = process.env, indent = 2) {
         this.out = out;
+        this.indent = indent;
         this.caption = caption;
         this.size = out.isTTY && env.TERM !== "dumb" ? cubeSize(out.columns ?? 80, out.rows ?? 24) : null;
         this.color = !env.NO_COLOR;
@@ -155,10 +158,11 @@ export class CubeSpinner {
         // A caption that wraps would add a row this redraw does not know to move back over.
         const room = Math.max(10, (this.out.columns ?? 80) - 6);
         const text = this.caption.length > room ? this.caption.slice(0, room - 1) + "…" : this.caption;
-        const pad = " ".repeat(Math.max(0, Math.floor((w - text.length - 3) / 2) + 2));
+        const pad = " ".repeat(Math.max(0, Math.floor((w - text.length - 3) / 2) + this.indent));
         let s = this.drawn ? `\x1b[${this.drawn}A` : "";
+        const lead = " ".repeat(this.indent);
         for (const r of rows)
-            s += `\r  ${renderRow(r, this.color)}\x1b[K\n`;
+            s += `\r${lead}${renderRow(r, this.color)}\x1b[K\n`;
         const cap = `${text}${dots}`;
         s += `\r\x1b[K\n\r${pad}${this.color ? CAPTION + cap + "\x1b[0m" : cap}\x1b[K\n`;
         this.out.write(s);

package/dist/resume.js

@@ -0,0 +1,47 @@
+// Bringing a stopped or hibernated session back, and waiting until its terminal can be attached -
+// shared by `cubes attach` and the split view's session pane.
+import { ApiError } from "./api.js";
+import { CliError } from "./auth.js";
+import { CubeSpinner } from "./cube.js";
+import { LIVE } from "./sessions.js";
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** Bring a stopped/hibernated session back and wait until its terminal can be attached. `out` is
+ *  where the cube spins meanwhile; `indent` centres it (the split view's pane). */
+export async function ensureRunning(api, row, resume, out = process.stderr, indent = 2) {
+    const id = encodeURIComponent(row.id);
+    let s = row;
+    if (s.status === "running")
+        return s;
+    if (!LIVE.has(s.status) && !resume)
+        throw new CliError(`that session is ${s.status}; leave out --no-resume to bring it back`);
+    const name = `"${s.title ?? s.id.slice(0, 8)}"`;
+    // The same cube the session's own screen spins while Claude boots, so the wait reads as one thing.
+    const spin = new CubeSpinner(out, `${LIVE.has(s.status) ? "Starting" : "Resuming"} ${name}`, process.env, indent);
+    try {
+        if (!LIVE.has(s.status)) {
+            try {
+                await api.post(`/sessions/${id}/resume`);
+            }
+            catch (e) {
+                if (!(e instanceof ApiError && e.status === 409 && /already running/.test(e.message)))
+                    throw e;
+            }
+        }
+        const deadline = Date.now() + 5 * 60_000;
+        while (Date.now() < deadline) {
+            s = await api.get(`/sessions/${id}`);
+            if (s.status === "running")
+                return s;
+            if (!LIVE.has(s.status))
+                throw new CliError(`the session stopped while starting (${s.status})`);
+            if (s.provision_note) {
+                spin.update(`${s.provision_note}${s.provision_total ? ` (${s.provision_done ?? 0}/${s.provision_total})` : ""}`);
+            }
+            await sleep(1000);
+        }
+        throw new CliError("the session is taking too long to start - check it in the browser");
+    }
+    finally {
+        spin.stop();
+    }
+}

package/dist/sessions.js

@@ -5,12 +5,23 @@ export const LIVE = new Set(["starting", "running"]);
 export function attachable(s) {
     return s.origin !== "ide" && s.exec_mode !== "headless";
 }
+/** The server pages at 200 (live sessions first), so a big org needs several pages. Capped, because
+ *  this runs every few seconds in the split view and the oldest ended sessions are the least useful. */
+const PAGE = 200;
+const MAX_PAGES = 5;
 export async function listSessions(api, opts = {}) {
-    const q = new URLSearchParams({ limit: "200" });
-    if (opts.all)
-        q.set("scope", "all");
-    const page = await api.get(`/sessions?${q}`);
-    return (page.sessions ?? []).filter(attachable);
+    const out = [];
+    for (let page = 0; page < MAX_PAGES; page++) {
+        const q = new URLSearchParams({ limit: String(PAGE), offset: String(page * PAGE) });
+        if (opts.all)
+            q.set("scope", "all");
+        const res = await api.get(`/sessions?${q}`);
+        const got = res.sessions ?? [];
+        out.push(...got);
+        if (got.length < PAGE || (typeof res.total === "number" && out.length >= res.total))
+            break;
+    }
+    return out.filter(attachable);
 }
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 export function isUuid(s) {