@hellix-ai/cubes 0.1.0 → 0.1.1

package/dist/cli.js

@@ -14,7 +14,9 @@ import { readClipboardImage } from "./clipboard.js";
 import { clearLogin, configPath, loadLogin, saveLogin } from "./config.js";
 import { parseArgs } from "./args.js";
 import { formatTable, isUuid, listSessions, LIVE, resolveSession, stateOf } from "./sessions.js";
-const VERSION = createRequire(import.meta.url)("../package.json").version;
+import { upgrade } from "./upgrade.js";
+const PKG = createRequire(import.meta.url)("../package.json");
+const VERSION = PKG.version;
 const HELP = `cubes ${VERSION} - attach to your Cubes sessions from your own terminal
 
 Usage:
@@ -24,6 +26,7 @@ Usage:
   cubes org [ALIAS]                                       list your orgs, or switch the default
   cubes ls [--all] [--json]                               list sessions (--all includes spawned ones)
   cubes attach [SESSION] [--view] [--no-resume]           attach to a session
+  cubes upgrade [--check]                                 install the newest cubes (--check only reports)
 
 SESSION is an id, the start of one (4+ characters), or part of its title. Left out, you pick from
 the running sessions. A stopped or hibernated session is resumed first unless --no-resume.
@@ -281,10 +284,26 @@ async function main(argv) {
             return 0;
         case "attach":
         case "a": return cmdAttach(a);
+        case "upgrade":
+        case "update":
+            return upgrade({
+                pkg: PKG.name, current: VERSION, scriptPath: process.argv[1] ?? "",
+                log: (line) => process.stderr.write(`${line}\n`),
+            }, { check: a.flags.has("check") });
         default: throw new CliError(`unknown command "${a.cmd}" - see \`cubes help\``);
     }
 }
-main(process.argv.slice(2)).then((code) => process.exit(code), (e) => {
+/** Exit only once everything written has reached its destination. A write to a PIPE is asynchronous
+ *  in Node, so a bare process.exit() after `cubes ls --json | jq` cut the JSON off mid-string. An empty
+ *  write's callback fires after every write queued before it. */
+function exitAfterFlush(code) {
+    let pending = 2;
+    const done = () => { if (--pending === 0)
+        process.exit(code); };
+    process.stdout.write("", done);
+    process.stderr.write("", done);
+}
+main(process.argv.slice(2)).then((code) => exitAfterFlush(code), (e) => {
     process.stderr.write(`cubes: ${e instanceof Error ? e.message : String(e)}\n`);
-    process.exit(e instanceof CliError ? e.exitCode : 1);
+    exitAfterFlush(e instanceof CliError ? e.exitCode : 1);
 });

package/dist/sessions.js

@@ -65,19 +65,19 @@ function cut(s, w) {
     return s.length <= w ? s : s.slice(0, w - 1) + "…";
 }
 export function formatTable(rows, width, now = Date.now()) {
-    const head = ["ID", "STATE", "AGE", "TITLE", "REPO"];
+    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.repo_full_name ?? "",
+        s.group_name ?? "",
     ]);
     const w = (i) => Math.max(head[i].length, ...body.map((r) => r[i].length));
     const fixed = [w(0), w(1), w(2)];
-    const repoW = Math.min(w(4), 32);
-    const titleW = Math.max(10, Math.min(w(3), width - fixed.reduce((a, b) => a + b, 0) - repoW - 8));
+    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], repoW)].join("  ").trimEnd();
+        cut(r[3], titleW).padEnd(titleW), cut(r[4], groupW)].join("  ").trimEnd();
     return [line(head), ...body.map(line)].join("\n");
 }

package/dist/upgrade.js

@@ -0,0 +1,105 @@
+// `cubes upgrade`: ask npm for the newest release and reinstall with whatever installed this copy.
+//
+// The install command has to match how the CLI got onto the machine: `npm install -g` over a pnpm or
+// bun global install leaves the old copy first on PATH, and an npx run is a throwaway cache entry
+// that `npx @hellix-ai/cubes@latest` already refreshes. The path of the running script says which.
+import { spawn } from "node:child_process";
+import { CliError } from "./auth.js";
+export const REGISTRY = "https://registry.npmjs.org";
+/** -1 / 0 / 1 for plain x.y.z versions. A prerelease sorts below its release (0.2.0-rc < 0.2.0). */
+export function compareVersions(a, b) {
+    const parse = (v) => {
+        const [core = "", pre] = v.trim().replace(/^v/, "").split("-", 2);
+        return { nums: core.split(".").map((n) => Number.parseInt(n, 10) || 0), pre };
+    };
+    const x = parse(a);
+    const y = parse(b);
+    for (let i = 0; i < 3; i++) {
+        const d = (x.nums[i] ?? 0) - (y.nums[i] ?? 0);
+        if (d)
+            return d > 0 ? 1 : -1;
+    }
+    if (x.pre && !y.pre)
+        return -1;
+    if (!x.pre && y.pre)
+        return 1;
+    return 0;
+}
+export function installerFor(scriptPath) {
+    const p = scriptPath.replace(/\\/g, "/");
+    if (p.includes("/_npx/"))
+        return "npx";
+    if (p.includes("/.bun/"))
+        return "bun";
+    if (/\/pnpm\/|\/\.pnpm\//.test(p))
+        return "pnpm";
+    if (/\/yarn\/global\//.test(p))
+        return "yarn";
+    return "npm";
+}
+export function installCommand(installer, spec) {
+    switch (installer) {
+        case "pnpm": return ["pnpm", "add", "-g", spec];
+        case "bun": return ["bun", "add", "-g", spec];
+        case "yarn": return ["yarn", "global", "add", spec];
+        default: return ["npm", "install", "-g", spec];
+    }
+}
+export async function latestVersion(pkg, fetchImpl = fetch) {
+    let res;
+    try {
+        res = await fetchImpl(`${REGISTRY}/${pkg.replace("/", "%2f")}/latest`, { signal: AbortSignal.timeout(10_000) });
+    }
+    catch (e) {
+        throw new CliError(`cannot reach the npm registry: ${e.message}`);
+    }
+    if (!res.ok)
+        throw new CliError(`the npm registry answered HTTP ${res.status} for ${pkg}`);
+    const body = (await res.json());
+    if (typeof body.version !== "string")
+        throw new CliError("the npm registry did not say what the latest version is");
+    return body.version;
+}
+function runInherited(argv) {
+    return new Promise((resolve) => {
+        // shell on Windows only, where the package managers are .cmd shims spawn cannot start directly.
+        const child = spawn(argv[0], argv.slice(1), { stdio: "inherit", shell: process.platform === "win32" });
+        child.on("error", () => resolve(127));
+        child.on("exit", (code) => resolve(code ?? 1));
+    });
+}
+/** Returns the process exit code. `check` only reports. */
+export async function upgrade(d, opts = {}) {
+    const latest = await latestVersion(d.pkg, d.fetchImpl);
+    const cmp = compareVersions(d.current, latest);
+    if (cmp === 0) {
+        d.log(`cubes ${d.current} is the latest version.`);
+        return 0;
+    }
+    if (cmp > 0) {
+        d.log(`cubes ${d.current} is newer than the latest published (${latest}); nothing to do.`);
+        return 0;
+    }
+    const installer = installerFor(d.scriptPath);
+    const spec = `${d.pkg}@${latest}`;
+    if (installer === "npx") {
+        d.log(`cubes ${latest} is available (this is ${d.current}). You are running it through npx, so ask for the new one:`);
+        d.log(`  npx ${d.pkg}@latest <command>`);
+        return 0;
+    }
+    const argv = installCommand(installer, spec);
+    if (opts.check) {
+        d.log(`cubes ${latest} is available (you have ${d.current}). Run \`cubes upgrade\`, or: ${argv.join(" ")}`);
+        return 0;
+    }
+    d.log(`Upgrading cubes ${d.current} -> ${latest}: ${argv.join(" ")}`);
+    const code = await (d.run ?? runInherited)(argv);
+    if (code === 127)
+        throw new CliError(`could not run \`${argv[0]}\` - upgrade by hand: ${argv.join(" ")}`);
+    if (code !== 0) {
+        throw new CliError(`the upgrade failed (exit ${code}). If it was a permissions error, your global ${argv[0]} ` +
+            `directory is not writable by you - run it with the rights it needs: ${argv.join(" ")}`);
+    }
+    d.log(`cubes is now ${latest}.`);
+    return 0;
+}

package/package.json

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