@modelstatus/cli 0.1.46 → 0.1.48

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelstatus/cli",
-  "version": "0.1.46",
+  "version": "0.1.48",
   "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/tui/app.js

@@ -47,9 +47,22 @@ function useTermDims() {
   const [dims, setDims] = React.useState({ cols: (stdout && stdout.columns) || 80, rows: (stdout && stdout.rows) || 24 });
   React.useEffect(() => {
     if (!stdout) return undefined;
-    const on = () => setDims({ cols: stdout.columns || 80, rows: stdout.rows || 24 });
+    // Functional update that returns the SAME object when nothing changed, so a
+    // re-measure that finds identical dims doesn't trigger a needless re-render.
+    const on = () => setDims((prev) => {
+      const cols = stdout.columns || 80, rows = stdout.rows || 24;
+      return prev.cols === cols && prev.rows === rows ? prev : { cols, rows };
+    });
     stdout.on("resize", on);
-    return () => stdout.off("resize", on);
+    // Re-measure a few beats after mount. When the TUI REMOUNTS right after the
+    // game leaves the alternate screen, some terminals (notably Warp's block
+    // model) re-flow the viewport a moment LATER and report stdout.{columns,rows}
+    // stale at mount-time — so the first frame is too SHORT and Ink falls back to
+    // cursor-up diffing, which drifts/scrolls the window off the top (and Ctrl-L
+    // can't fix it because it redraws at the same wrong height). These one-shot
+    // re-reads pick up the settled size and snap the window back to full screen.
+    const timers = [60, 250, 600].map((ms) => setTimeout(on, ms));
+    return () => { stdout.off("resize", on); timers.forEach(clearTimeout); };
   }, [stdout]);
   const fw = Number(process.env.MM_TUI_WIDTH);
   const fh = Number(process.env.MM_TUI_HEIGHT);
@@ -256,12 +269,37 @@ export const appController = {
   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 */ }
     this._instance = render(h(Bootstrap, opts));
     return this._instance;
   },
 };
 
 export function runApp(opts) {
+  // Run the TUI in the ALTERNATE SCREEN BUFFER (a clean full-screen surface, like
+  // the game). Ink's default INLINE rendering drifts after the game's alt-screen
+  // round-trip in block-model terminals (Warp) — the window scrolls off the top
+  // and Ctrl-L can't recover it. Owning the alt screen ourselves makes every
+  // (re)mount paint a clean full screen, and leaving it on quit restores the
+  // host's scrollback. The in-TUI game keeps this alt screen (keepAlt) instead of
+  // toggling its own, so there's no unreliable nested-alt-screen handling.
+  const out = process.stdout;
+  const leaveAlt = () => {
+    if (!appController._inAlt) return;
+    try { out.write("\x1b[?1049l\x1b[?25h"); } catch { /* ignore */ }
+    appController._inAlt = false;
+  };
+  appController._leaveAlt = leaveAlt;
+  // Never strand the terminal in the alt buffer on a crash/signal.
+  process.once("exit", leaveAlt);
+  process.once("SIGINT", () => { leaveAlt(); process.exit(130); });
+  process.once("SIGTERM", () => { leaveAlt(); process.exit(143); });
+  try { out.write("\x1b[?1049h\x1b[2J\x1b[H"); } catch { /* ignore */ }
+  appController._inAlt = true;
+
   appController._opts = opts;
   const app = render(h(Bootstrap, opts));
   appController._instance = app;
@@ -276,6 +314,7 @@ export function runApp(opts) {
         if (appController._instance && appController._instance !== inst) {
           arm(appController._instance);
         } else {
+          leaveAlt(); // real quit → restore the host screen + scrollback
           resolve();
         }
       });

package/src/tui/game/launch.js

@@ -67,6 +67,7 @@ export async function playGameInTui({ dir, width, height, initialView = "scan",
         height: process.stdout.rows || height,
         level: 1,
         scanStore: handle,
+        inTui: true, // render in the TUI's alt screen; don't toggle a nested one
       });
     } finally {
       try { handle && handle.abort(); } catch { /* ignore */ }
@@ -80,8 +81,10 @@ export async function playGameInTui({ dir, width, height, initialView = "scan",
     // TUI comes back shifted down / not full-height until the next resize. Reset
     // the scroll region (\x1b[r), clear the screen, and home the cursor so the
     // remounted tree fills the whole terminal from the top (same as Ctrl-L).
-    try { process.stdout.write("\x1b[r\x1b[2J\x1b[3J\x1b[H"); } catch { /* ignore */ }
-    await new Promise((r) => setImmediate(r)); // let the reset flush before Ink mounts
+    // The game kept the TUI's alt screen intact (inTui → keepAlt), so we never
+    // left it — just let the game's restore() flush, then remount. remount() clears
+    // + homes inside the alt screen so the fresh tree paints a clean full screen.
+    await new Promise((r) => setImmediate(r));
     appController.remount({ initialView, fresh: false });
   } catch (e) {
     if (onError) onError(e); else throw e;

package/src/tui/game/loop.js

@@ -74,7 +74,7 @@ const fmtNum = (n) => (n == null ? "0" : Number(n).toLocaleString("en-US"));
  * @param {object} [o._inject]        test seams: { out, inp, proc, now, schedule, autoExitAfterMs }
  * @returns {Promise<{score:number, level:number, best:number, status:string}>}
  */
-export function runGame({ width, height, level = 1, scanStore = null, onExit, _inject = {} } = {}) {
+export function runGame({ width, height, level = 1, scanStore = null, onExit, inTui = false, _inject = {} } = {}) {
   return new Promise((resolve) => {
     const proc = _inject.proc || process;
     const out = _inject.out || proc.stdout || process.stdout;
@@ -89,7 +89,7 @@ export function runGame({ width, height, level = 1, scanStore = null, onExit, _i
     try { best = Number(loadConfig().dkHighScore) || 0; } catch { best = 0; }
 
     const dims = { width, height };
-    const term = new Term({ out, inp, proc, color: COLOR_ON });
+    const term = new Term({ out, inp, proc, color: COLOR_ON, keepAlt: inTui });
     const input = new InputState({ now });
 
     // Allocate the buffer for the WHOLE frame: HUD rows + board + key row, BOARD_W

package/src/tui/game/term.js

@@ -216,11 +216,17 @@ export class Term {
     inp = process.stdin,
     proc = process,
     color = COLOR_ON,
+    // When launched from inside the TUI (which now OWNS the alternate screen),
+    // don't toggle the alt buffer ourselves — render into the TUI's alt screen and
+    // leave it intact on exit so the remounted TUI stays on a clean full screen
+    // (toggling a nested alt screen is unreliable, esp. in Warp's block model).
+    keepAlt = false,
   } = {}) {
     this.out = out;
     this.inp = inp;
     this.proc = proc;
     this.color = color;
+    this.keepAlt = keepAlt;
     this.started = false;
     this.restored = false;
     this._wasRaw = false;
@@ -241,8 +247,9 @@ export class Term {
 
     // Enter alt screen + hide cursor ONCE (never per frame — that's the anti-
     // flicker invariant). Clear the alt buffer so a stale prior frame can't show
-    // through before the first diff paints.
-    this.write(ALT_ENTER + CURSOR_HIDE + CLEAR_SCREEN);
+    // through before the first diff paints. keepAlt → the TUI already owns the alt
+    // screen, so only hide-cursor + clear (don't re-enter / nest the alt buffer).
+    this.write((this.keepAlt ? "" : ALT_ENTER) + CURSOR_HIDE + CLEAR_SCREEN);
 
     // Raw mode so we get bytes immediately (no line buffering / no echo). Save
     // the prior state so restore() returns the terminal exactly as it was.
@@ -300,8 +307,10 @@ export class Term {
     this.restored = true;
 
     // Order matters: reset SGR + show cursor + leave alt LAST so the chrome
-    // lands back on the normal buffer with a visible cooked cursor.
-    try { this.write(SGR_RESET + CURSOR_SHOW + ALT_LEAVE); } catch {}
+    // lands back on the normal buffer with a visible cooked cursor. keepAlt → the
+    // TUI owns the alt screen and will remount into it, so only reset SGR (don't
+    // show the cursor or leave the alt buffer).
+    try { this.write(this.keepAlt ? SGR_RESET : SGR_RESET + CURSOR_SHOW + ALT_LEAVE); } catch {}
 
     const inp = this.inp;
     try {