@hellix-ai/cubes 0.1.4 → 0.2.0

package/dist/tui/term.js

@@ -0,0 +1,133 @@
+// The small amount of terminal the split view needs: how wide a string really is, how to cut one to a
+// column budget, and what the bytes a terminal sends for a key or a mouse click mean.
+/** Columns a code point occupies: 0 for combining marks and joiners, 2 for wide (CJK, emoji), else 1.
+ *  Not the whole of Unicode's East Asian Width table - the ranges that actually show up in session
+ *  titles and in our own glyphs. Getting this wrong shifts every column after the character. */
+export function cpWidth(cp) {
+    if (cp === 0)
+        return 0;
+    if (cp < 0x20 || (cp >= 0x7f && cp < 0xa0))
+        return 0;
+    if ((cp >= 0x300 && cp <= 0x36f) || cp === 0x200b || cp === 0x200c || cp === 0x200d ||
+        (cp >= 0xfe00 && cp <= 0xfe0f) || (cp >= 0x1f3fb && cp <= 0x1f3ff) || (cp >= 0xe0100 && cp <= 0xe01ef))
+        return 0;
+    if ((cp >= 0x1100 && cp <= 0x115f) || (cp >= 0x2e80 && cp <= 0xa4cf) || (cp >= 0xac00 && cp <= 0xd7a3) ||
+        (cp >= 0xf900 && cp <= 0xfaff) || (cp >= 0xfe30 && cp <= 0xfe4f) || (cp >= 0xff00 && cp <= 0xff60) ||
+        (cp >= 0xffe0 && cp <= 0xffe6) || (cp >= 0x1f300 && cp <= 0x1f64f) || (cp >= 0x1f900 && cp <= 0x1f9ff) ||
+        (cp >= 0x1f680 && cp <= 0x1f6ff) || (cp >= 0x2600 && cp <= 0x26ff && isEmojiPresentation(cp)) ||
+        cp === 0x270b || cp === 0x2705 || cp === 0x274c || (cp >= 0x20000 && cp <= 0x3fffd))
+        return 2;
+    return 1;
+}
+// The few symbols in U+2600-26FF that terminals draw two cells wide (emoji presentation by default).
+function isEmojiPresentation(cp) {
+    return [0x2614, 0x2615, 0x2648, 0x267f, 0x2693, 0x26a1, 0x26aa, 0x26ab, 0x26bd, 0x26be, 0x26c4, 0x26c5,
+        0x26ce, 0x26d4, 0x26ea, 0x26f2, 0x26f3, 0x26f5, 0x26fa, 0x26fd].includes(cp);
+}
+export function strWidth(s) {
+    let w = 0;
+    for (const ch of s)
+        w += cpWidth(ch.codePointAt(0));
+    return w;
+}
+/** Exactly `w` columns: cut with an ellipsis when too long, padded with spaces when short. */
+export function fit(s, w) {
+    if (w <= 0)
+        return "";
+    let out = "";
+    let used = 0;
+    const total = strWidth(s);
+    const budget = total > w ? w - 1 : w;
+    for (const ch of s) {
+        const cw = cpWidth(ch.codePointAt(0));
+        if (used + cw > budget)
+            break;
+        out += ch;
+        used += cw;
+    }
+    if (total > w) {
+        out += "…";
+        used += 1;
+    }
+    return out + " ".repeat(Math.max(0, w - used));
+}
+/** Nothing from the server may reach the screen as a control character. */
+export function printable(s) {
+    return s.replace(/[\x00-\x1f\x7f-\x9f]/g, " ");
+}
+const CSI_KEYS = {
+    A: "up", B: "down", C: "right", D: "left", H: "home", F: "end", Z: "backtab",
+};
+const TILDE_KEYS = {
+    "1": "home", "7": "home", "4": "end", "8": "end", "5": "pgup", "6": "pgdn",
+};
+/** Turn one read of raw input into keys. A lone ESC is the Escape key (tmux delivers a real escape
+ *  sequence in one read; the split view sets tmux's escape-time low so Escape is not held back). */
+export function parseKeys(input) {
+    const keys = [];
+    let i = 0;
+    while (i < input.length) {
+        const c = input[i];
+        if (c === "\x1b") {
+            const rest = input.slice(i);
+            const mouse = /^\x1b\[<(\d+);(\d+);(\d+)([Mm])/.exec(rest);
+            if (mouse) {
+                keys.push({ kind: "mouse", button: Number(mouse[1]), x: Number(mouse[2]), y: Number(mouse[3]), release: mouse[4] === "m" });
+                i += mouse[0].length;
+                continue;
+            }
+            const csi = /^\x1b[[O](\d*)(?:;\d+)*([A-Za-z~])/.exec(rest);
+            if (csi) {
+                const kind = csi[2] === "~" ? TILDE_KEYS[csi[1]] : CSI_KEYS[csi[2]];
+                if (kind)
+                    keys.push({ kind });
+                i += csi[0].length;
+                continue;
+            }
+            keys.push({ kind: "escape" });
+            i += 1;
+            continue;
+        }
+        i += 1;
+        if (c === "\r" || c === "\n")
+            keys.push({ kind: "enter" });
+        else if (c === "\t")
+            keys.push({ kind: "tab" });
+        else if (c === "\x7f" || c === "\b")
+            keys.push({ kind: "backspace" });
+        else if (c === "\x03")
+            keys.push({ kind: "ctrl-c" });
+        else if (c === "\x1d")
+            keys.push({ kind: "ctrl-]" });
+        else if (c === "\x0c")
+            keys.push({ kind: "ctrl-l" });
+        else if (c >= " ") {
+            // A surrogate pair is one character.
+            const cp = input.codePointAt(i - 1);
+            const ch = String.fromCodePoint(cp);
+            if (ch.length === 2)
+                i += 1;
+            keys.push({ kind: "char", ch });
+        }
+    }
+    return keys;
+}
+export const ESC = {
+    altOn: "\x1b[?1049h",
+    altOff: "\x1b[?1049l",
+    hideCursor: "\x1b[?25l",
+    showCursor: "\x1b[?25h",
+    mouseOn: "\x1b[?1000h\x1b[?1002h\x1b[?1006h",
+    mouseOff: "\x1b[?1000l\x1b[?1002l\x1b[?1006l",
+    syncOn: "\x1b[?2026h",
+    syncOff: "\x1b[?2026l",
+    home: "\x1b[H",
+    clear: "\x1b[2J",
+    reset: "\x1b[0m",
+    dim: "\x1b[2m",
+    bold: "\x1b[1m",
+    inverse: "\x1b[7m",
+    fg: (n) => `\x1b[38;5;${n}m`,
+    bg: (n) => `\x1b[48;5;${n}m`,
+    at: (row, col) => `\x1b[${row};${col}H`,
+};

package/dist/tui/tmux.js

@@ -0,0 +1,49 @@
+// The local tmux the split view runs in: its own socket, so it never touches a tmux the person uses,
+// and every call synchronous - these are a handful of tiny commands, never a stream.
+import { spawnSync } from "node:child_process";
+export const SOCKET = "cubes-tui";
+export const SESSION = "cubes";
+/** Run `tmux -L cubes-tui <args>`. `TMUX` is dropped from the child's env: inside someone's own tmux
+ *  it would make every command refuse ("sessions should be nested with care"). */
+export function tmux(args, opts = {}) {
+    const env = { ...process.env };
+    delete env.TMUX;
+    const r = spawnSync("tmux", ["-L", SOCKET, ...args], { encoding: "utf8", env, input: opts.input });
+    if (r.error)
+        return { code: 127, out: "", err: r.error.message };
+    return { code: r.status ?? 1, out: (r.stdout ?? "").trim(), err: (r.stderr ?? "").trim() };
+}
+/** tmux's version as a number (3.3a -> 3.3), or null when there is no tmux at all. */
+export function tmuxVersion() {
+    const r = spawnSync("tmux", ["-V"], { encoding: "utf8" });
+    if (r.error || r.status !== 0)
+        return null;
+    const m = /(\d+)\.(\d+)/.exec(r.stdout ?? "");
+    return m ? Number(`${m[1]}.${m[2]}`) : null;
+}
+/** Single-quote for the `sh -c` tmux runs a pane's command through. */
+export function shq(s) {
+    return `'${s.replace(/'/g, "'\\''")}'`;
+}
+/** A tmux FORMAT is parsed for `#{...}` and `#[...]`; a session's title must never be either. */
+export function fmtText(s) {
+    return s.replace(/#/g, "##");
+}
+/** The command line that runs this same CLI (same node, same script) with `args`. */
+export function selfCommand(args) {
+    return [process.execPath, process.argv[1] ?? "", ...args].map(shq).join(" ");
+}
+/** Set a pane option on THIS pane (the one the calling process runs in). Best-effort: a header that
+ *  failed to update must never take the pane down. */
+export function setPaneOption(name, value) {
+    const pane = process.env.TMUX_PANE;
+    if (!pane)
+        return;
+    tmux(["set-option", "-p", "-t", pane, name, value]);
+}
+export function setSessionOption(name, value) {
+    tmux(["set-option", "-t", SESSION, name, value]);
+}
+export function getSessionOption(name) {
+    return tmux(["show-options", "-v", "-q", "-t", SESSION, name]).out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hellix-ai/cubes",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "description": "Attach to your Cubes sessions from your own terminal (Warp, iTerm, Ghostty, anything).",
   "type": "module",
   "bin": {