@modelstatus/cli 0.1.52 → 0.1.54

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelstatus/cli",
-  "version": "0.1.52",
+  "version": "0.1.54",
   "description": "Track which AI models you use, where, and never get surprised by a retirement. Free offline model-health for any repo (mm status), browser sign-in for cloud inventory + alerts.",
   "keywords": [
     "llm",

package/src/index.js

@@ -2,6 +2,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { spawnSync } from "node:child_process";
 import { resolveAuth, loadConfig, saveConfig, clearAuth, configFilePath } from "./config.js";
 import { createClient } from "./api.js";
 import { collectFrom, availability, ALL_SOURCE_IDS, getSource } from "./sources/index.js";
@@ -12,7 +13,7 @@ import {
 import { redactValue } from "./redact.js";
 import { assignProjects, buildUsages } from "./upload.js";
 import { loginViaBrowser } from "./auth.js";
-import { maybeCheckForUpdate } from "./updater.js";
+import { maybeCheckForUpdate, forceUpdate } from "./updater.js";
 import { track, maybeAnalyticsNotice } from "./telemetry.js";
 import { BUILD_VERSION } from "./version.js";
 
@@ -691,7 +692,8 @@ Usage:
   mm sources               List detection sources and whether each can run here
   mm integrations          Manage live integrations (list | enable <id> | disable <id> | env <id> <tag>)
   mm clear                 Delete all tracked usages from your inventory (--all also wipes projects/rules; --yes to skip the prompt)
-  mm upgrade               Open Stripe checkout and poll until Pro is active
+  mm update                Update to the latest version now and relaunch (or add --update to any command)
+  mm upgrade               Open Stripe checkout and poll until Pro is active (the paid plan, not the binary)
   mm play [dir]            Play Donkey Kong while a background scan walks the dir (just for fun)
   mm tui                   Force-launch the TUI (logs you in first if needed)
 
@@ -705,7 +707,7 @@ Scan sources (--sources; default = filesystem + enabled integrations; "all" for
   Secret sources shell out to your already-authenticated CLIs, run read-only,
   and only ever upload model ids — secret VALUES never leave your machine.
 
-Flags: --api <url> · --key <key> · --project <id|name> · --yes · --json · --ci · --dry-run
+Flags: --update · --api <url> · --key <key> · --project <id|name> · --yes · --json · --ci · --dry-run
        --sources <list> · --region <r> · --namespace <ns> · --kube-context <c> · --db <dsn> · --sql-table <t>
        --vercel-project <p> · --vercel-team <t> · --gh-repo <owner/name> · --supabase-ref <ref>
 
@@ -721,13 +723,38 @@ async function maybePrintUpdate(promise) {
       // be unsafe. Point the user at a one-line reinstall to a user-owned dir.
       process.stderr.write(`\n✦ mm ${r.to} is available (you're on ${r.from}). Auto-update can't write ${process.execPath} — reinstall:\n  curl -fsSL https://llmstatus.ai/install.sh | bash\n`);
     } else {
-      process.stderr.write(`\n✓ Updated mm ${r.from} → ${r.to} — your next run uses the new version.\n`);
+      process.stderr.write(`\n✓ Updated mm ${r.from} → ${r.to} — your next run uses it (or run \`mm update\` to relaunch on it now).\n`);
     }
   } catch {
     /* swallow */
   }
 }
 
+/**
+ * `mm update` (command) or `--update` (flag on any command): apply the in-place
+ * self-update NOW and RE-EXEC the fresh binary, so a single run lands on the new
+ * version — no opening the app twice. `rerunArgs` is what the new binary should
+ * run (the same invocation minus the update trigger). Re-execs + exits on a real
+ * update; otherwise prints status and returns (caller continues normally).
+ */
+async function applyUpdate(rerunArgs) {
+  const r = await forceUpdate();
+  if (r.status === "updated") {
+    process.stderr.write(`✓ Updated mm ${r.from} → ${r.to}. Relaunching…\n`);
+    const child = spawnSync(process.execPath, rerunArgs, {
+      stdio: "inherit",
+      env: { ...process.env, MM_JUST_UPDATED: r.to },
+    });
+    process.exit(child.status ?? 0);
+  }
+  if (r.status === "latest") process.stderr.write(`✓ Already on the latest mm (${r.version}).\n`);
+  else if (r.status === "manual")
+    process.stderr.write(`✦ mm ${r.to} is available (you're on ${r.from}), but auto-update can't write ${process.execPath}. Reinstall:\n  curl -fsSL https://llmstatus.ai/install.sh | bash\n`);
+  else if (r.status === "npm") process.stderr.write(`This is an npm-managed install. Update with:\n  npm update -g @modelstatus/cli\n`);
+  else if (r.status === "unsupported") process.stderr.write(`Self-update isn't supported for this build. Reinstall:\n  curl -fsSL https://llmstatus.ai/install.sh | bash\n`);
+  else if (r.status === "error") process.stderr.write(`! Update check failed: ${r.message}\n`);
+}
+
 async function main() {
   const { positional, flags } = parseArgs(process.argv.slice(2));
   const cmd = positional[0];
@@ -750,6 +777,20 @@ async function main() {
   maybeAnalyticsNotice();
   track("cli_command", { command: cmd || "tui" });
 
+  // Explicit self-update: `mm update` (command) or `--update` (flag on any
+  // command). Apply the update in place and RE-EXEC the fresh binary so this one
+  // run lands on the latest — no opening the app twice. `mm update` with nothing
+  // else then opens the TUI on the new version.
+  if (cmd === "update" || flags.update) {
+    const rerun = process.argv.slice(2).filter((a) => a !== "update" && a !== "--update");
+    await applyUpdate(rerun); // re-execs + exits when it actually updates
+    if (cmd === "update") {
+      await launchTui(positional[1], flags);
+      return;
+    }
+    // A bare `--update` on another command falls through to run that command.
+  }
+
   // Kick off the background self-update check — runs in parallel with the
   // user's command, capped at 1/24h, only for shell-installed binaries.
   const updatePromise = maybeCheckForUpdate(flags);

package/src/tui/app.js

@@ -305,14 +305,21 @@ export const appController = {
     try { this._instance && this._instance.unmount(); } catch { /* already gone */ }
     this._instance = null;
   },
-  /** Mount a fresh Ink tree, merging the base opts with `next` (e.g. a tab). */
+  /** Mount a fresh Ink tree, merging the base opts with `next` (e.g. a tab).
+   * Only called after the in-TUI game (launch.js). */
   remount(next = {}) {
     const opts = { ...(this._opts || {}), ...next };
     this._opts = opts;
-    // We're still in the alt screen (entered by runApp; the game kept it). Clear +
-    // home so the fresh Ink tree paints the whole screen from the top with no
-    // leftover game frame and no inline-cursor drift.
-    try { process.stdout.write("\x1b[2J\x1b[H"); } catch { /* ignore */ }
+    // RECYCLE the alt screen: leave (?1049l) then re-enter (?1049h) + clear + home.
+    // We're still in the alt screen the game kept, but block-model terminals (Warp)
+    // drop their clean full-screen presentation during the game round-trip and the
+    // host's block header bleeds back over the top rows. A plain clear can't undo
+    // that. Leaving + re-entering reproduces the EXACT main→alt transition that
+    // runApp does on first launch (which renders perfectly), so Warp re-enters
+    // full-screen mode and the window paints flush from the top again. The two
+    // sequences are written together with no render between them, so there's no
+    // visible flash of the host screen.
+    try { process.stdout.write("\x1b[?1049l\x1b[?1049h\x1b[2J\x1b[H"); } catch { /* ignore */ }
     this._instance = render(h(Bootstrap, opts));
     return this._instance;
   },

package/src/updater.js

@@ -133,6 +133,41 @@ async function downloadAndReplace(version, key, expectedSha) {
  * "0.1.8 → v0.1.9" which looks like a typo. */
 function dispVer(v) { return String(v).replace(/^v/, ""); }
 
+/**
+ * Force an update RIGHT NOW for an explicit `mm update` / `--update` — ignores
+ * the 30s throttle AND MM_NO_AUTO_UPDATE (the user asked for it). Swaps the
+ * binary in place but never re-execs (the caller does, so this one run can land
+ * on the new version without opening the app twice). Never throws; returns:
+ *   { status: "updated", from, to }   binary swapped — caller should re-exec
+ *   { status: "latest", version }     already the newest
+ *   { status: "manual", from, to }    newer exists but the dir isn't writable
+ *   { status: "npm" }                 npm-managed install (use npm update -g)
+ *   { status: "unsupported" }         not a shell binary / unknown platform
+ *   { status: "error", message }      the check or download failed
+ */
+export async function forceUpdate() {
+  try {
+    if (!IS_SHELL_INSTALL) return { status: "npm" };
+    const key = platformKey();
+    if (!key) return { status: "unsupported" };
+
+    const manifest = await fetchJson(`${CDN}/cli/${CHANNEL_PATH}/version.json`);
+    writeCache({ ...(readCache() || {}), last_check: Date.now(), latest_known: manifest.version });
+    if (!manifest.version) return { status: "error", message: "manifest has no version" };
+    if (compareVer(manifest.version, BUILD_VERSION) <= 0) return { status: "latest", version: dispVer(BUILD_VERSION) };
+
+    const expectedSha = manifest.sha256?.[key];
+    if (!expectedSha) return { status: "error", message: `no sha256 for ${key}` };
+    if (!dirWritable(path.dirname(process.execPath))) {
+      return { status: "manual", from: dispVer(BUILD_VERSION), to: dispVer(manifest.version) };
+    }
+    await downloadAndReplace(manifest.version, key, expectedSha);
+    return { status: "updated", from: dispVer(BUILD_VERSION), to: dispVer(manifest.version) };
+  } catch (e) {
+    return { status: "error", message: e?.message ?? String(e) };
+  }
+}
+
 /** Returns { from, to } if an update was completed, else null. Never throws. */
 export async function maybeCheckForUpdate(flags = {}) {
   try {