@modelstatus/cli 0.1.1 → 0.1.26

package/src/tui/views/whatsnew.js

@@ -1,12 +1,28 @@
+/* What's New view — registry change feed, alert notifications, and code drift.
+ * Three sub-tabs (Registry / Alerts / Drift) switched with ←/→. Renders body-only;
+ * the shell (app.js) owns the window chrome, status bar (fed by reportStatus) and
+ * keybar. Data loading + drift logic + key handlers are unchanged from the
+ * original; only the render is restyled to the LLM Status design system. */
 import React from "react";
 import { Box, Text, useInput } from "ink";
-import { h, useAsync, cell, clampCursor } from "../ui.js";
+import {
+  h, C, GLYPH, SubTabs, ListRow, StateLine, cellE, clampCursor, SPINNER, useTick, useAsync,
+} from "../ui.js";
 import { collectFrom } from "../../sources/index.js";
 import { loadConfig, setConfigValue } from "../../config.js";
 
 const TABS = ["Registry", "Alerts", "Drift"];
 
-export function WhatsNewView({ client, dir, ui, active }) {
+export const meta = {
+  keys: [
+    { k: "←→", label: "section" },
+    { k: "↑↓", label: "scroll" },
+    { k: "m", label: "mark seen" },
+    { k: "r", label: "drift" },
+  ],
+};
+
+export function WhatsNewView({ client, dir, ui, active, width = 78, height = 14 }) {
   const [tab, setTab] = React.useState(0);
   const [cursor, setCursor] = React.useState(0);
   const lastSeen = loadConfig().lastEventsSeenAt || null;
@@ -23,6 +39,11 @@ export function WhatsNewView({ client, dir, ui, active }) {
   }, []);
   const notif = useAsync(async () => (await client.listNotifications({})).data || [], []);
   const [drift, setDrift] = React.useState(null);
+  // Gate the spinner tick on actual loading — not tab focus — so an idle
+  // What's New tab doesn't re-render ~12×/sec forever.
+  const tick = useTick(80, active && (reg.loading || notif.loading || (drift && drift.loading)));
+  const spin = SPINNER[tick % SPINNER.length];
+  const ROWS = Math.max(3, height - 4); // subtabs + blank + footer overhead
 
   async function runDrift() {
     setDrift({ loading: true });
@@ -90,88 +111,109 @@ export function WhatsNewView({ client, dir, ui, active }) {
     { isActive: active },
   );
 
-  const tabBar = h(
-    Box,
-    {},
-    ...TABS.map((t, i) =>
-      h(Text, { key: t, color: i === tab ? "black" : "gray", backgroundColor: i === tab ? "cyan" : undefined }, ` ${t} `),
-    ),
-    h(Text, { color: "gray" }, "  (←/→ switch)"),
-  );
+  // Push per-tab context up to the shell status bar.
+  React.useEffect(() => {
+    let context;
+    if (tab === 0) context = `${reg.data?.events.length || 0} changes`;
+    else if (tab === 1) context = `${(notif.data || []).length} alerts`;
+    else context = drift && !drift.loading && !drift.error ? `+${drift.added.length} / -${drift.gone.length}` : "drift";
+    ui?.reportStatus?.({ context });
+  }, [tab, reg.data, notif.data, drift, ui]);
 
-  let body, footer;
+  let body;
   if (tab === 0) {
-    footer = "←/→ tab · ↑↓ scroll · m mark seen";
-    if (reg.loading) body = h(Text, { color: "gray" }, "Loading registry changes…");
-    else if (reg.error) body = h(Text, { color: "red" }, reg.error);
+    if (reg.loading) body = h(StateLine, { kind: "loading", spin, text: "loading registry changes…" });
+    else if (reg.error) body = h(StateLine, { kind: "error", text: reg.error });
     else {
       const events = reg.data.events;
-      if (!events.length) body = h(Text, { color: "gray" }, "No registry changes recorded yet.");
+      if (!events.length) body = h(Text, { color: C.FG_DIM }, "  No registry changes recorded yet.");
       else {
         const start = clampCursor(cursor, events.length);
         body = h(
           Box,
           { flexDirection: "column" },
-          ...events.slice(start, start + 12).map((e) => {
+          ...events.slice(start, start + ROWS).map((e) => {
             const name = e.model_id ? reg.data.models.get(e.model_id) : reg.data.provs.get(e.provider_id);
             const isNew = lastSeen && e.published_at && e.published_at > lastSeen;
-            return h(
-              Text,
-              { key: e.id, color: isNew ? "yellow" : "white" },
-              `${isNew ? "• " : "  "}${cell(e.event_type, 18)} ${cell(name || "—", 26)} ${String(e.published_at || "").slice(0, 10)}`,
-            );
+            const cells = [
+              { text: `${isNew ? GLYPH.bullet : GLYPH.custom} `, color: isNew ? C.ACCENT : C.FG_FAINT },
+              { text: cellE(e.event_type, 18), color: C.FG },
+              { text: " ", color: C.FG },
+              { text: cellE(name || "—", 26), color: isNew ? C.FG : C.FG_DIM },
+              { text: " ", color: C.FG },
+              { text: String(e.published_at || "").slice(0, 10).padEnd(10), color: C.FG_DIM },
+            ];
+            return h(ListRow, { key: e.id, active: false, cells, width });
           }),
         );
       }
     }
   } else if (tab === 1) {
-    footer = "←/→ tab · ↑↓ move · o mark read";
     const list = notif.data || [];
-    if (notif.loading) body = h(Text, { color: "gray" }, "Loading alerts…");
-    else if (!list.length) body = h(Text, { color: "gray" }, "No alerts yet. Configure rules in the Alerts view.");
-    else
+    if (notif.loading) body = h(StateLine, { kind: "loading", spin, text: "loading alerts…" });
+    else if (notif.error) body = h(StateLine, { kind: "error", text: notif.error });
+    else if (!list.length) body = h(Text, { color: C.FG_DIM }, "  No alerts yet. Configure rules in the Alerts view.");
+    else {
+      const cur = clampCursor(cursor, list.length);
       body = h(
         Box,
         { flexDirection: "column" },
-        ...list.slice(0, 12).map((n, i) =>
-          h(
-            Text,
-            { key: n.id, inverse: i === clampCursor(cursor, list.length), color: n.unread ? "white" : "gray" },
-            `${n.unread ? "●" : "○"} ${cell(n.title, 40)} ${String(n.when || "").slice(0, 10)}`,
-          ),
-        ),
+        ...list.slice(0, ROWS).map((n, i) => {
+          const cells = [
+            { text: `${n.unread ? GLYPH.bullet : GLYPH.custom} `, color: n.unread ? C.ACCENT : C.FG_FAINT },
+            { text: cellE(n.title, 40), color: n.unread ? C.FG : C.FG_DIM },
+            { text: " ", color: C.FG },
+            { text: String(n.when || "").slice(0, 10).padEnd(10), color: C.FG_DIM },
+          ];
+          return h(ListRow, { key: n.id, active: i === cur, cells, width });
+        }),
       );
+    }
   } else {
-    footer = "←/→ tab · r scan for drift · ↑↓ move · a archive (gone)";
-    if (!drift) body = h(Text, { color: "gray" }, `Press r to scan ${dir} and compare against tracked usages.`);
-    else if (drift.loading) body = h(Text, { color: "gray" }, "Scanning for drift…");
-    else if (drift.error) body = h(Text, { color: "red" }, drift.error);
+    if (!drift) body = h(Text, { color: C.FG_DIM }, `  Press r to scan ${dir} and compare against tracked usages.`);
+    else if (drift.loading) body = h(StateLine, { kind: "loading", spin, text: "scanning for drift…" });
+    else if (drift.error) body = h(StateLine, { kind: "error", text: drift.error });
     else {
       const gone = drift.gone || [];
+      const curGone = clampCursor(cursor, gone.length);
       body = h(
         Box,
         { flexDirection: "column" },
         h(
           Text,
           {},
-          h(Text, { color: "green" }, `${drift.added.length} new in code`),
-          h(Text, { color: "gray" }, `  ·  ${drift.present} still present  ·  `),
-          h(Text, { color: "red" }, `${gone.length} gone from code`),
+          h(Text, { color: "#16a34a" }, `${drift.added.length} new in code`),
+          h(Text, { color: C.FG_DIM }, `  ·  ${drift.present} still present  ·  `),
+          h(Text, { color: "#dc2626" }, `${gone.length} gone from code`),
         ),
         h(Text, {}, ""),
-        ...drift.added.slice(0, 5).map((c, i) =>
-          h(Text, { key: "a" + i, color: "green" }, `  + ${cell(c.display || c.model_string, 24)} ${c.location_label}`),
-        ),
-        ...gone.slice(0, 7).map((u, i) =>
-          h(
-            Text,
-            { key: "g" + i, inverse: i === clampCursor(cursor, gone.length), color: "red" },
-            `  - ${cell(u.model_display || u.custom_model_name || "?", 24)} ${u.source_path || "—"}`,
-          ),
-        ),
+        ...drift.added.slice(0, 5).map((c, i) => {
+          const cells = [
+            { text: "+ ", color: "#16a34a" },
+            { text: cellE(c.display || c.model_string, 24), color: "#16a34a" },
+            { text: " ", color: C.FG },
+            { text: cellE(c.location_label || "—", width - 28), color: C.FG_DIM },
+          ];
+          return h(ListRow, { key: "a" + i, active: false, cells, width });
+        }),
+        ...gone.slice(0, 7).map((u, i) => {
+          const cells = [
+            { text: "- ", color: "#dc2626" },
+            { text: cellE(u.model_display || u.custom_model_name || "?", 24), color: "#dc2626" },
+            { text: " ", color: C.FG },
+            { text: cellE(u.source_path || "—", width - 28), color: C.FG_DIM },
+          ];
+          return h(ListRow, { key: "g" + i, active: i === curGone, cells, width });
+        }),
       );
     }
   }
 
-  return h(Box, { flexDirection: "column" }, tabBar, h(Text, {}, ""), body, h(Text, {}, ""), h(Text, { color: "gray" }, footer));
+  return h(
+    Box,
+    { flexDirection: "column" },
+    h(SubTabs, { idx: tab, tabs: TABS }),
+    h(Text, {}, ""),
+    body,
+  );
 }

package/src/updater.js

@@ -0,0 +1,170 @@
+/* Background self-updater for the shell-installed binary.
+ *
+ * Design (see also docs.llmstatus.ai/install):
+ *   - Only runs when IS_SHELL_INSTALL is true (Bun-compiled binary). npm-managed
+ *     installs defer to `npm update -g @modelstatus/cli`.
+ *   - Capped at one check per 24 h (cache file at ~/.config/llmstatus/updater.json).
+ *   - Opt-out via MM_NO_AUTO_UPDATE=1, or any --json/--ci invocation.
+ *   - All errors are swallowed silently. The user's command must NEVER break
+ *     because the updater hiccupped.
+ *   - Verifies the downloaded binary's sha256 against `cli/latest/version.json`
+ *     before atomically renaming over process.execPath.
+ *   - Notification (one stderr line) prints after the user's command finishes —
+ *     same-run doesn't re-exec, so any in-flight state stays sane.
+ */
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { BUILD_VERSION, IS_SHELL_INSTALL, UPDATE_CHANNEL } from "./version.js";
+
+// Per-channel manifest path on the CDN. Stable lives at /cli/latest/ for
+// backwards-compat with the original layout; experimental at /cli/experimental/.
+const CHANNEL_PATH = UPDATE_CHANNEL === "experimental" ? "experimental" : "latest";
+
+const CDN = (process.env.MM_CDN || "https://cdn.llmstatus.ai").replace(/\/$/, "");
+const CACHE_FILE = path.join(os.homedir(), ".config", "llmstatus", "updater.json");
+// Throttle update checks to once per 30 s. Effectively "every run" for normal
+// use, but protects against tight loops (`for i; do mm status; done`) hammering
+// the CDN. version.json itself is 520 bytes and cached at the CF edge, so the
+// network cost is trivial — this throttle is purely about local CPU/IO.
+// Override with MM_UPDATE_INTERVAL_MS for testing.
+const CHECK_INTERVAL_MS = Number(process.env.MM_UPDATE_INTERVAL_MS) || 30 * 1000;
+
+/** Tolerant of v-prefixes; splits on dots & dashes (handles 0.1.2-rc1). */
+function parseVer(s) {
+  return String(s).replace(/^v/, "").split(/[.-]/).map((p) => /^\d+$/.test(p) ? Number(p) : p);
+}
+/** -1 / 0 / +1  (a < b / a == b / a > b). */
+function compareVer(a, b) {
+  const av = parseVer(a);
+  const bv = parseVer(b);
+  for (let i = 0; i < Math.max(av.length, bv.length); i++) {
+    const ap = av[i] ?? 0;
+    const bp = bv[i] ?? 0;
+    if (ap < bp) return -1;
+    if (ap > bp) return 1;
+  }
+  return 0;
+}
+
+function readCache() {
+  try {
+    return JSON.parse(fs.readFileSync(CACHE_FILE, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function writeCache(obj) {
+  try {
+    fs.mkdirSync(path.dirname(CACHE_FILE), { recursive: true, mode: 0o700 });
+    fs.writeFileSync(CACHE_FILE, JSON.stringify(obj));
+  } catch {
+    /* best effort */
+  }
+}
+
+/** Matches the keys in version.json sha256 map + the binary filename suffix. */
+function platformKey() {
+  const osKey =
+    process.platform === "darwin" ? "darwin" :
+    process.platform === "linux" ? "linux" :
+    process.platform === "win32" ? "windows" :
+    null;
+  if (!osKey) return null;
+  const archKey =
+    process.arch === "arm64" ? "arm64" :
+    process.arch === "x64" ? "x64" :
+    null;
+  if (!archKey) return null;
+  return `${osKey}-${archKey}`;
+}
+
+async function fetchJson(url) {
+  const res = await fetch(url, { cache: "no-store" });
+  if (!res.ok) throw new Error(`GET ${url} -> ${res.status}`);
+  return res.json();
+}
+
+/** True if we can create/rename files in `dir` (needed for an atomic swap). */
+function dirWritable(dir) {
+  try {
+    fs.accessSync(dir, fs.constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Replace the executable via the atomic tmp+rename pattern ONLY (a new inode).
+ * We must NOT writeFileSync over the live executable's inode: truncating +
+ * rewriting a running, memory-mapped Mach-O can make macOS SIGKILL the running
+ * process mid-write ("killed: 9"). Requires a writable parent dir; callers
+ * pre-check dirWritable() and never reach here otherwise. Throws on failure
+ * (the outer catch swallows it — better no update than a half-written binary). */
+function replaceBinary(exe, buf) {
+  const tmp = path.join(path.dirname(exe), `.${path.basename(exe)}.new.${process.pid}`);
+  try {
+    fs.writeFileSync(tmp, buf, { mode: 0o755 });
+    fs.renameSync(tmp, exe);
+  } catch (e) {
+    try { fs.unlinkSync(tmp); } catch { /* tmp may not exist */ }
+    throw e;
+  }
+}
+
+async function downloadAndReplace(version, key, expectedSha) {
+  const exe = process.execPath;
+  const ext = process.platform === "win32" ? ".exe" : "";
+  const url = `${CDN}/cli/${version}/modelstatus-cli-${key}${ext}`;
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`GET ${url} -> ${res.status}`);
+  const buf = Buffer.from(await res.arrayBuffer());
+  const actualSha = crypto.createHash("sha256").update(buf).digest("hex");
+  if (actualSha !== expectedSha) {
+    throw new Error(`sha256 mismatch: expected ${expectedSha.slice(0, 12)}…, got ${actualSha.slice(0, 12)}…`);
+  }
+  replaceBinary(exe, buf);
+}
+
+/** Strip an optional leading "v" for display. The manifest writes "v0.1.8" but
+ * BUILD_VERSION is baked in as "0.1.8" — without this the notification reads
+ * "0.1.8 → v0.1.9" which looks like a typo. */
+function dispVer(v) { return String(v).replace(/^v/, ""); }
+
+/** Returns { from, to } if an update was completed, else null. Never throws. */
+export async function maybeCheckForUpdate(flags = {}) {
+  try {
+    if (!IS_SHELL_INSTALL) return null;
+    if (process.env.MM_NO_AUTO_UPDATE) return null;
+    if (flags.json || flags.ci) return null;
+
+    const cache = readCache() || {};
+    if (cache.last_check && Date.now() - cache.last_check < CHECK_INTERVAL_MS) return null;
+
+    const key = platformKey();
+    if (!key) return null;
+
+    const manifest = await fetchJson(`${CDN}/cli/${CHANNEL_PATH}/version.json`);
+    // Always update the cache so we don't re-check for 24 h.
+    writeCache({ ...cache, last_check: Date.now(), latest_known: manifest.version });
+
+    if (!manifest.version || compareVer(manifest.version, BUILD_VERSION) <= 0) return null;
+    const expectedSha = manifest.sha256?.[key];
+    if (!expectedSha) return null;
+
+    // Only self-update when we can atomically swap the binary (writable parent
+    // dir). For root-owned dirs like /usr/local/bin we can't — and overwriting
+    // the live binary in place is unsafe — so signal a manual reinstall instead
+    // of downloading + corrupting the running process.
+    if (!dirWritable(path.dirname(process.execPath))) {
+      return { manual: true, from: dispVer(BUILD_VERSION), to: dispVer(manifest.version) };
+    }
+
+    await downloadAndReplace(manifest.version, key, expectedSha);
+    return { from: dispVer(BUILD_VERSION), to: dispVer(manifest.version) };
+  } catch {
+    return null;
+  }
+}

package/src/version.js

@@ -0,0 +1,32 @@
+/* Single source of truth for the CLI's version + install method.
+ *
+ * - In a Bun-compiled binary: `bun build --define __BUILD_VERSION__='"X.Y.Z"' --define __IS_SHELL_INSTALL__=true`
+ *   replaces the identifiers at compile time. BUILD_VERSION is the literal,
+ *   IS_SHELL_INSTALL is true (so the auto-updater runs).
+ * - In the npm-published JS: the identifiers stay undefined, so we read the
+ *   version from package.json at runtime and IS_SHELL_INSTALL defaults to false
+ *   (npm owns updates for that install path).
+ */
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+function readPkgVersion() {
+  try {
+    const pkgPath = fileURLToPath(new URL("../package.json", import.meta.url));
+    return JSON.parse(readFileSync(pkgPath, "utf8")).version;
+  } catch {
+    return null;
+  }
+}
+
+// eslint-disable-next-line no-undef
+export const BUILD_VERSION = typeof __BUILD_VERSION__ !== "undefined" ? __BUILD_VERSION__ : (readPkgVersion() ?? "unknown");
+
+// eslint-disable-next-line no-undef
+export const IS_SHELL_INSTALL = typeof __IS_SHELL_INSTALL__ !== "undefined" ? __IS_SHELL_INSTALL__ : false;
+
+// Release channel — "stable" or "experimental". Baked at compile time so a
+// channel is sticky to the binary; switching channels means re-installing.
+// (npm-installed JS is always treated as stable.)
+// eslint-disable-next-line no-undef
+export const UPDATE_CHANNEL = typeof __UPDATE_CHANNEL__ !== "undefined" ? __UPDATE_CHANNEL__ : "stable";