@hellix-ai/cubes 0.1.2 → 0.1.4

package/README.md

@@ -7,7 +7,7 @@ Terminal.app, anything) with your own font, colors and keyboard shortcuts.
 npm install -g @hellix-ai/cubes      # needs Node.js 22.4+
 
 cubes login --host cubes.hellix.ai   # prints a code; approve it in the browser
-cubes ls                             # your sessions
+cubes ls                             # sessions, under a heading per group (--mine, --live)
 cubes attach                         # pick a running one
 cubes attach 7ff4                    # or name one: an id prefix, or part of its title
 ```
@@ -42,11 +42,15 @@ cubes login [--host URL] [--org ALIAS] [--no-browser]
 cubes logout
 cubes whoami
 cubes org [ALIAS]
-cubes ls [--all] [--json]
+cubes ls [--mine] [--live] [--all] [--json]
 cubes attach [SESSION] [--view] [--no-resume]
 cubes upgrade [--check]
 ```
 
+`cubes ls` lists sessions the way the web's Sessions page does: a section per package, then per group
+(A-Z), then Ungrouped, live ones first in each. `--mine` keeps the ones you started, `--live` the ones
+running now; they combine. `--all` adds sessions other sessions spawned; `--json` prints the rows.
+
 `--org ALIAS` works on any command. If you belong to several organizations, `cubes org` lists them and
 `cubes org <alias>` changes the default.
 

package/dist/cli.js

@@ -14,7 +14,7 @@ import { readClipboardImage } from "./clipboard.js";
 import { CubeSpinner } from "./cube.js";
 import { clearLogin, configPath, loadLogin, saveLogin } from "./config.js";
 import { parseArgs } from "./args.js";
-import { formatTable, isUuid, listSessions, LIVE, resolveSession, stateOf } from "./sessions.js";
+import { formatSections, isUuid, listSessions, LIVE, resolveSession, sectionize, stateOf } from "./sessions.js";
 import { upgrade } from "./upgrade.js";
 const PKG = createRequire(import.meta.url)("../package.json");
 const VERSION = PKG.version;
@@ -25,7 +25,8 @@ Usage:
   cubes logout                                            sign out and revoke this computer's login
   cubes whoami                                            who, where, and which org
   cubes org [ALIAS]                                       list your orgs, or switch the default
-  cubes ls [--all] [--json]                               list sessions (--all includes spawned ones)
+  cubes ls [--mine] [--live] [--all] [--json]             list sessions by group (--mine: you started them,
+                                                          --live: running now, --all: include spawned ones)
   cubes attach [SESSION] [--view] [--no-resume]           attach to a session
   cubes upgrade [--check]                                 install the newest cubes (--check only reports)
 
@@ -160,16 +161,21 @@ async function cmdOrg(a) {
 }
 async function cmdLs(a) {
     const api = makeApi(currentSession({ org: str(a.flags, "org") }));
-    const rows = await listSessions(api, { all: a.flags.has("all") });
+    const mine = a.flags.has("mine");
+    const live = a.flags.has("live");
+    // Both narrow, and they compose: `--mine --live` is "my sessions that are running now".
+    const rows = (await listSessions(api, { all: a.flags.has("all") }))
+        .filter((r) => (!mine || r.created_by_me === true) && (!live || LIVE.has(r.status)));
     if (a.flags.has("json")) {
         process.stdout.write(JSON.stringify(rows, null, 2) + "\n");
         return;
     }
     if (!rows.length) {
-        process.stderr.write("No sessions.\n");
+        process.stderr.write(`No ${live ? "live " : ""}sessions${mine ? " of yours" : ""}.\n`);
         return;
     }
-    process.stdout.write(formatTable(rows, process.stdout.columns ?? 120) + "\n");
+    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. */

package/dist/sessions.js

@@ -64,20 +64,85 @@ function cut(s, w) {
         return "";
     return s.length <= w ? s : s.slice(0, w - 1) + "…";
 }
-export function formatTable(rows, width, now = Date.now()) {
-    const head = ["ID", "STATE", "AGE", "TITLE", "GROUP"];
-    const body = rows.map((s) => [
-        s.id.slice(0, 8),
-        stateOf(s),
-        age(s.last_attached_at ?? s.created_at, now),
-        s.title || "(untitled)",
-        s.group_name ?? "",
-    ]);
+/** Column layout shared by every table: widths come from ALL the rows, so the sections of one listing
+ *  line up with each other. */
+function layout(rows, width, now) {
+    const head = ["ID", "STATE", "AGE", "TITLE"];
+    const cells = (s) => [s.id.slice(0, 8), stateOf(s), age(s.last_attached_at ?? s.created_at, now), s.title || "(untitled)"];
+    const body = rows.map(cells);
     const w = (i) => Math.max(head[i].length, ...body.map((r) => r[i].length));
     const fixed = [w(0), w(1), w(2)];
-    const groupW = Math.min(w(4), 32);
-    const titleW = Math.max(10, Math.min(w(3), width - fixed.reduce((a, b) => a + b, 0) - groupW - 8));
-    const line = (r) => [r[0].padEnd(fixed[0]), r[1].padEnd(fixed[1]), r[2].padStart(fixed[2]),
-        cut(r[3], titleW).padEnd(titleW), cut(r[4], groupW)].join("  ").trimEnd();
-    return [line(head), ...body.map(line)].join("\n");
+    const titleW = Math.max(10, Math.min(w(3), width - fixed.reduce((a, b) => a + b, 0) - 6));
+    const line = (r) => [r[0].padEnd(fixed[0]), r[1].padEnd(fixed[1]), r[2].padStart(fixed[2]), cut(r[3], titleW)].join("  ").trimEnd();
+    return { header: line(head), row: (s) => line(cells(s)), width: fixed.reduce((a, b) => a + b, 0) + titleW + 6 };
+}
+export function formatTable(rows, width, now = Date.now()) {
+    const l = layout(rows, width, now);
+    return [l.header, ...rows.map(l.row)].join("\n");
+}
+/**
+ * The web Sessions page's sections (web SessionsPage.tsx groupSections), so a listing reads the same in
+ * both places: one per PACKAGE (most recently started first), then one per GROUP A-Z, then Ungrouped.
+ * Inside each, live sessions first, then the most recently started. Unlike the page, an empty group is
+ * not shown - there is nothing to do with an empty heading in a terminal.
+ */
+export function sectionize(rows) {
+    const startOf = (r) => (r ? r.started_at ?? r.ended_at ?? r.created_at ?? "" : "");
+    const order = (a, b) => {
+        const la = LIVE.has(a.status);
+        const lb = LIVE.has(b.status);
+        if (la !== lb)
+            return la ? -1 : 1;
+        return startOf(b).localeCompare(startOf(a));
+    };
+    const pkgs = new Map();
+    const groups = new Map();
+    const ungrouped = [];
+    for (const r of rows) {
+        if (r.package_id) {
+            const sec = pkgs.get(r.package_id) ?? { title: r.package_name || "Package", rows: [] };
+            sec.rows.push(r);
+            pkgs.set(r.package_id, sec);
+        }
+        else if (r.group_id && r.group_name) {
+            const sec = groups.get(r.group_id) ?? { title: r.group_name, rows: [] };
+            sec.rows.push(r);
+            groups.set(r.group_id, sec);
+        }
+        else {
+            ungrouped.push(r);
+        }
+    }
+    for (const sec of [...pkgs.values(), ...groups.values()])
+        sec.rows.sort(order);
+    const out = [
+        ...[...pkgs.values()].sort((a, b) => startOf(b.rows[0]).localeCompare(startOf(a.rows[0]))),
+        ...[...groups.values()].sort((a, b) => a.title.localeCompare(b.title)),
+    ];
+    if (ungrouped.length)
+        out.push({ title: "Ungrouped", rows: ungrouped.sort(order) });
+    return out;
+}
+/** The listing: one column header, then each section under a rule naming it and its count. A listing
+ *  that is ALL ungrouped (an org that does not use groups) gets no rule at all - it would only say so. */
+export function formatSections(sections, width, opts = {}) {
+    const all = sections.flatMap((s) => s.rows);
+    const l = layout(all, width, opts.now ?? Date.now());
+    const dim = (t) => (opts.color ? `\x1b[2m${t}\x1b[0m` : t);
+    const bold = (t) => (opts.color ? `\x1b[1m${t}\x1b[0m` : t);
+    const ruleW = Math.max(24, Math.min(width, l.width));
+    const out = [dim(l.header)];
+    const bare = sections.length === 1 && sections[0].title === "Ungrouped";
+    sections.forEach((sec, i) => {
+        if (!bare) {
+            const label = `${sec.title} (${sec.rows.length})`;
+            const fill = Math.max(2, ruleW - label.length - 4);
+            if (i > 0)
+                out.push("");
+            out.push(`${dim("──")} ${bold(sec.title)} ${dim(`(${sec.rows.length}) ${"─".repeat(fill)}`)}`);
+        }
+        for (const r of sec.rows)
+            out.push(l.row(r));
+    });
+    return out.join("\n");
 }

package/dist/upgrade.js

@@ -37,12 +37,19 @@ export function installerFor(scriptPath) {
         return "yarn";
     return "npm";
 }
+/**
+ * ⚠ FORCE A FRESH LOOK AT THE REGISTRY. npm keeps a local copy of a package's version list and trusts
+ * it for the registry's `max-age=300`, so within five minutes of any earlier install it does not know a
+ * release we just read from `/latest` exists: measured as `ETARGET No matching version found for
+ * @hellix-ai/cubes@0.1.3` four minutes after 0.1.3 was published. `--prefer-online` makes npm revalidate
+ * that copy; bun's `--no-cache` does the same for its manifest cache. pnpm and yarn revalidate already.
+ */
 export function installCommand(installer, spec) {
     switch (installer) {
         case "pnpm": return ["pnpm", "add", "-g", spec];
-        case "bun": return ["bun", "add", "-g", spec];
+        case "bun": return ["bun", "add", "-g", "--no-cache", spec];
         case "yarn": return ["yarn", "global", "add", spec];
-        default: return ["npm", "install", "-g", spec];
+        default: return ["npm", "install", "-g", "--prefer-online", spec];
     }
 }
 export async function latestVersion(pkg, fetchImpl = fetch) {

package/package.json

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