@modelstatus/cli 0.1.86 → 0.1.88

package/src/tui/app.js

@@ -371,9 +371,20 @@ export function App({ apiBase, apiKey, dir, initialView, onSignedIn, fresh }) {
 }
 
 /** Top-level TUI entry — always renders App; auth unlocks tabs in-place. */
-function Bootstrap(props) {
+export function Bootstrap(props) {
   const [apiKey, setApiKey] = React.useState(props.apiKey);
-  return h(App, { ...props, apiKey, onSignedIn: (k) => { track("signed_in"); setApiKey(k); } });
+  return h(App, {
+    ...props,
+    apiKey,
+    onSignedIn: (k) => {
+      track("signed_in");
+      // Keep the module-level controller in sync: a game round-trip remounts
+      // from _opts (captured at runApp time), and a stale null apiKey there
+      // would silently sign the session back out after the game.
+      if (appController._opts) appController._opts = { ...appController._opts, apiKey: k };
+      setApiKey(k);
+    },
+  });
 }
 
 // Module-level controller so a view (the Scan tab) can UNMOUNT the whole Ink
@@ -383,6 +394,22 @@ function Bootstrap(props) {
 export const appController = {
   _instance: null,
   _opts: null,
+  // A game handoff is in flight: the coming unmount is NOT a real quit. Set by
+  // launch.js BEFORE unmount(); cleared by remount() (or endHandoff() when the
+  // game fails to come back). runApp's exit waiter checks it to decide whether
+  // to keep the alt screen + promise alive or treat the unmount as a quit.
+  _handoff: false,
+  _handoffWaiter: null, // runApp's deferred quit-or-rearm check (see runApp)
+  /** Mark the next unmount as a game handoff (a remount will follow). */
+  beginHandoff() { this._handoff = true; },
+  /** End a handoff — normally via remount(); called directly (without a
+   * remount) when the game errored, so runApp treats the unmount as a quit. */
+  endHandoff() {
+    this._handoff = false;
+    const w = this._handoffWaiter;
+    this._handoffWaiter = null;
+    if (w) w();
+  },
   /** Tear down the current Ink tree (releases raw mode + stdin listeners). */
   unmount() {
     try { this._instance && this._instance.unmount(); } catch { /* already gone */ }
@@ -398,6 +425,10 @@ export const appController = {
     // right before this, so by now the terminal reports its stable full height.
     try { process.stdout.write("\x1b[2J\x1b[H"); } catch { /* ignore */ }
     this._instance = render(h(Bootstrap, opts));
+    // launch.js re-entered the alt screen right before remounting — record it so
+    // the final quit's leaveAlt() actually restores the host screen + scrollback.
+    this._inAlt = true;
+    this.endHandoff(); // flush runApp's waiter → it re-arms on the new instance
     return this._instance;
   },
 };
@@ -427,20 +458,31 @@ export function runApp(opts) {
   appController._opts = opts;
   const app = render(h(Bootstrap, opts));
   appController._instance = app;
-  // waitUntilExit resolves when the CURRENT instance unmounts. A Scan-tab game
-  // launch unmounts + remounts, which would resolve this early; so we re-arm on
-  // each remount and only resolve when an instance exits WITHOUT a pending
-  // remount (i.e. a real quit). The `_exiting` flag is set by a clean exit().
+  // waitUntilExit resolves when the CURRENT instance unmounts — including the
+  // deliberate unmount at the start of a game handoff (launch.js), which nulls
+  // _instance and resolves this promise BEFORE the remount happens. So a game
+  // launch must not read as a quit: launch.js sets appController._handoff before
+  // unmounting, and while it's set we park the decision in _handoffWaiter.
+  // remount()/endHandoff() flush the waiter — a remount re-arms on the new
+  // instance; a failed handoff (no remount) falls through to the real-quit path.
   return new Promise((resolve) => {
     const arm = (inst) => {
       inst.waitUntilExit().then(() => {
-        // If a remount happened (a new instance is live and differs), keep waiting.
-        if (appController._instance && appController._instance !== inst) {
-          arm(appController._instance);
-        } else {
-          leaveAlt(); // real quit → restore the host screen + scrollback
-          resolve();
-        }
+        const settle = () => {
+          if (appController._handoff) {
+            // Game round-trip in flight — decide after remount()/endHandoff().
+            appController._handoffWaiter = settle;
+            return;
+          }
+          // If a remount happened (a new instance is live and differs), keep waiting.
+          if (appController._instance && appController._instance !== inst) {
+            arm(appController._instance);
+          } else {
+            leaveAlt(); // real quit → restore the host screen + scrollback
+            resolve();
+          }
+        };
+        settle();
       });
     };
     arm(app);

package/src/tui/game/launch.js

@@ -26,13 +26,15 @@ export async function playGameInTui({ dir, width, height, initialView = "scan",
   if (launching) return;
   launching = true;
   track("game_opened", { game: "donkey_kong", scan_phase: scanPhase });
+  let appController = null; // hoisted so the catch below can end a dangling handoff
   try {
-    const [{ runGame }, { startScanProcess }, { appController }, { writeDiskScan, loadRegistry }] = await Promise.all([
+    const [{ runGame }, { startScanProcess }, app, { writeDiskScan, loadRegistry }] = await Promise.all([
       import("./loop.js"),
       import("../../sources/scan-process.js"),
       import("../app.js"),
       import("../scan-stream.js"),
     ]);
+    appController = app.appController;
 
     // (1) Start a TRUE background scan SUBPROCESS over `dir`. It survives the Ink
     // unmount (separate OS process). Pre-fetch + cache the registry so the worker
@@ -56,6 +58,11 @@ export async function playGameInTui({ dir, width, height, initialView = "scan",
     } catch { handle = null; }
 
     // (2) Unmount the Ink tree (releases raw mode + stdin). Let teardown settle.
+    // beginHandoff FIRST: unmount() resolves ink's exit promise synchronously,
+    // and without the flag runApp's exit waiter would read this as a real quit —
+    // dropping the alt screen mid-game and resolving runApp early (main() then
+    // races the game for stdout). See appController/runApp in ../app.js.
+    appController.beginHandoff();
     appController.unmount();
     await new Promise((r) => setImmediate(r));
 
@@ -90,8 +97,13 @@ export async function playGameInTui({ dir, width, height, initialView = "scan",
     // useTermDims — we no longer poll for it).
     try { process.stdout.write("\x1b[?1049l\x1b[?1049h\x1b[2J\x1b[H"); } catch { /* ignore */ }
     await new Promise((r) => setImmediate(r));
-    appController.remount({ initialView, fresh: false });
+    appController.remount({ initialView, fresh: false }); // remount ends the handoff
   } catch (e) {
+    // The handoff died without a remount (e.g. the game threw). End it so
+    // runApp's parked waiter treats the earlier unmount as a real quit and
+    // restores the host screen instead of waiting forever. No-op when the
+    // error happened before beginHandoff (tree still mounted → toast shows).
+    if (appController) appController.endHandoff();
     if (onError) onError(e); else throw e;
   } finally {
     launching = false;

package/src/tui/signin.js

@@ -12,6 +12,19 @@ import { h } from "./ui.js";
 
 const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 
+// One in-flight device-auth session per apiBase, held OUTSIDE the component.
+// SignIn is remounted on every signed-out Account-tab visit (and after a game
+// round-trip); without this, each mount minted a NEW device code and popped
+// ANOTHER browser tab — and an approval made in the browser after the user
+// switched tabs landed on a code nobody was polling. A remount now resumes the
+// pending session (same code, same URL, no extra tab) and picks the approval up.
+// Sessions clear on approval/denial/expiry/start-failure (and g re-mints one).
+// apiBase -> { device_code, user_code, verification_url, interval, deadline, opened }
+const authSessions = new Map();
+
+/** Test hook: forget all pending device-auth sessions. */
+export function _resetAuthSessions() { authSessions.clear(); }
+
 export function SignIn({ apiBase, onSuccess, onSkip }) {
   const { exit } = useApp();
   const [phase, setPhase] = React.useState("starting"); // starting | polling | error
@@ -35,19 +48,38 @@ export function SignIn({ apiBase, onSuccess, onSkip }) {
 
     const start = async () => {
       try {
-        const s = await client.authStart({ client_name: "mm CLI" });
+        // Resume the session a previous mount left in flight (tab switch, game
+        // round-trip) — same code, same browser tab, and an approval made while
+        // we weren't looking gets picked up on the first poll. Mint a fresh one
+        // only when none is pending or the old one passed its deadline.
+        let s = authSessions.get(apiBase);
+        if (!s || Date.now() > s.deadline) {
+          const fresh = await client.authStart({ client_name: "mm CLI" });
+          s = {
+            device_code: fresh.device_code,
+            user_code: fresh.user_code,
+            verification_url: fresh.verification_url,
+            interval: Math.max(1, fresh.interval || 3) * 1000,
+            deadline: Date.now() + (fresh.expires_in || 600) * 1000,
+            opened: false,
+          };
+          // Cache even if this mount was cancelled mid-start — the code is
+          // already minted, so let the next visit resume it instead of orphaning it.
+          authSessions.set(apiBase, s);
+        }
         if (cancelled) return;
         setCode(s.user_code);
         setUrl(s.verification_url);
         setPhase("polling");
-        openUrl(s.verification_url); // best-effort, no error if it fails
-
-        const interval = Math.max(1, s.interval || 3) * 1000;
-        const deadline = Date.now() + (s.expires_in || 600) * 1000;
+        if (!s.opened) {
+          s.opened = true;
+          openUrl(s.verification_url); // best-effort, ONCE per session (o re-opens)
+        }
 
         const poll = async () => {
           if (cancelled) return;
-          if (Date.now() > deadline) {
+          if (Date.now() > s.deadline) {
+            authSessions.delete(apiBase);
             setError("The login request expired.");
             setPhase("error");
             return;
@@ -60,6 +92,7 @@ export function SignIn({ apiBase, onSuccess, onSkip }) {
           }
           if (cancelled) return;
           if (res?.status === "approved") {
+            authSessions.delete(apiBase);
             const cfg = loadConfig();
             cfg.apiKey = res.api_key;
             cfg.apiBase = apiBase;
@@ -68,20 +101,23 @@ export function SignIn({ apiBase, onSuccess, onSkip }) {
             return;
           }
           if (res?.status === "denied") {
+            authSessions.delete(apiBase);
             setError("Authorization was denied.");
             setPhase("error");
             return;
           }
           if (res?.status === "expired") {
+            authSessions.delete(apiBase);
             setError("The login request expired. Press q and run mm login again.");
             setPhase("error");
             return;
           }
-          pollTimer = setTimeout(poll, interval);
+          pollTimer = setTimeout(poll, s.interval);
         };
         poll();
       } catch (e) {
         if (cancelled) return;
+        authSessions.delete(apiBase); // a failed start isn't resumable
         setError(e?.message || String(e));
         setPhase("error");
       }

package/src/tui/views/account.js

@@ -28,6 +28,18 @@ export function AccountView({ client, me, refreshMe, apiBase, ui, active }) {
 
   React.useEffect(() => ui?.reportStatus?.({ context: `plan: ${me?.plan ?? "…"}` }), [me, ui]);
 
+  // The upgrade poll below is a self-rescheduling setTimeout chain — without
+  // cleanup it outlives the view (keeps hitting /me every 4s for up to 10min,
+  // sets state on an unmounted component, and holds the event loop open AFTER
+  // quit, hanging the user's shell). Cancel it the moment the view unmounts.
+  const pollTimerRef = React.useRef(null);
+  const mountedRef = React.useRef(true);
+  React.useEffect(() => () => {
+    mountedRef.current = false;
+    if (pollTimerRef.current) clearTimeout(pollTimerRef.current);
+    pollTimerRef.current = null;
+  }, []);
+
   async function upgrade() {
     // Without a loaded account a checkout would just fire at an unreachable
     // endpoint and die with a raw fetch error — say what to do instead.
@@ -40,9 +52,11 @@ export function AccountView({ client, me, refreshMe, apiBase, ui, active }) {
       setStatus("Complete checkout in your browser… (polling /me)");
       const deadline = Date.now() + 10 * 60 * 1000;
       const tick = async () => {
+        if (!mountedRef.current) return;
         if (Date.now() > deadline) return setStatus("Timed out — press u to retry.");
         try {
           const m = await client.me();
+          if (!mountedRef.current) return;
           if (m?.account?.plan && m.account.plan !== "free") {
             setStatus(null);
             ui.showToast(`upgraded to ${m.account.plan}!`);
@@ -52,9 +66,12 @@ export function AccountView({ client, me, refreshMe, apiBase, ui, active }) {
         } catch {
           /* keep polling */
         }
-        setTimeout(tick, 4000);
+        if (!mountedRef.current) return;
+        pollTimerRef.current = setTimeout(tick, 4000);
       };
-      setTimeout(tick, 4000);
+      // A second u press replaces (not stacks) any poll chain already running.
+      if (pollTimerRef.current) clearTimeout(pollTimerRef.current);
+      pollTimerRef.current = setTimeout(tick, 4000);
     } catch (e) {
       setStatus(e.status === 503 ? "Billing isn't configured on this server." : `checkout failed: ${e.message} — press u to retry.`);
     }

package/src/tui/views/alerts.js

@@ -125,11 +125,20 @@ export function AlertsView({ client, ui, active, width = 78, height = 14 }) {
             .patchRule(cur.id, { delivery: DELIVERY[(DELIVERY.indexOf(cur.delivery) + 1) % 3] })
             .then(() => rules.reload())
             .catch((e) => ui.showToast(e.message, "red"));
-        if (input === "d")
-          return client.deleteRule(cur.id).then(() => {
-            ui.showToast("rule deleted");
-            rules.reload();
-          }).catch((e) => ui.showToast(e.message, "red"));
+        if (input === "d") {
+          // One stray keypress shouldn't silently delete a rule — confirm with a
+          // single y, same pattern as InventoryView's d (inventory.js).
+          return ui.askPrompt(`Delete ${ruleLabel(cur)}? type y`, {
+            onSubmit: (v) => {
+              if (String(v || "").trim().toLowerCase() !== "y") return ui.showToast("delete cancelled");
+              client.deleteRule(cur.id).then(() => {
+                ui.showToast("rule deleted");
+                setCursor((c) => clampCursor(c, ruleList.length - 1));
+                rules.reload();
+              }).catch((e) => ui.showToast(e.message, "red"));
+            },
+          });
+        }
       } else {
         if (input === "n") return addChannel();
         if (input === "t" && cur) return testChannel(cur);
@@ -150,14 +159,18 @@ export function AlertsView({ client, ui, active, width = 78, height = 14 }) {
     if (!ruleList.length) {
       body = h(EmptyCard, { title: "No alert rules yet", lines: ["Stay ahead of your model timeline — a heads-up 90, 30, 7, and 1 day before anything you use is deprecated or retired.", "Press n to set the sensible default (your models · in-app + email · those lead times)."], width });
     } else {
+      // Window the list around the cursor (same as whatsnew.js) — a fixed
+      // slice(0, ROWS) lets the selection walk below the visible page and
+      // space/c/d act on a row the user can't see.
       const curIdx = clampCursor(cursor, ruleList.length);
+      const start = Math.max(0, Math.min(curIdx - ROWS + 1, ruleList.length - ROWS));
       const fixed = 2 + 26 + 1 + 10 + 1; // glyph + name + gap + delivery + gap
       const rest = Math.max(8, width - 1 - fixed);
       body = h(
         Box,
         { flexDirection: "column" },
-        ...ruleList.slice(0, ROWS).map((r, i) => {
-          const isCur = i === curIdx;
+        ...ruleList.slice(start, start + ROWS).map((r, i) => {
+          const isCur = start + i === curIdx;
           const enabled = !!r.enabled;
           const leads = r.leadTimes || r.lead_times || [];
           const chanText = [(r.channels || []).join(","), leads.length ? leads.join("/") + "d" : ""].filter(Boolean).join(" · ");
@@ -182,13 +195,15 @@ export function AlertsView({ client, ui, active, width = 78, height = 14 }) {
         h(Text, { color: "#d97706" }, "  Slack/Discord/SMS/webhook channels need Pro — press 7 → u to upgrade."),
       );
     } else {
+      // Windowed around the cursor like the rules list above.
       const curIdx = clampCursor(cursor, chanList.length);
+      const start = Math.max(0, Math.min(curIdx - ROWS + 1, chanList.length - ROWS));
       const rest = Math.max(8, width - 1 - 10); // after the 10-wide kind pill
       body = h(
         Box,
         { flexDirection: "column" },
-        ...chanList.slice(0, ROWS).map((c, i) => {
-          const isCur = i === curIdx;
+        ...chanList.slice(start, start + ROWS).map((c, i) => {
+          const isCur = start + i === curIdx;
           const cells = [
             { text: cell(c.kind, 10), color: KIND_COLOR[c.kind] || C.FG_DIM, bold: true },
             { text: cellE(c.label || c.value, rest), color: C.FG },

package/src/tui/views/inventory.js

@@ -24,6 +24,7 @@ export const meta = {
     { k: "g", label: "refresh" },
     { k: "r", label: "rescan" },
     { k: "n", label: "new" },
+    { k: "p", label: "llm prompt" },
     { k: "e", label: "env" },
     { k: "t", label: "tag" },
     { k: "c", label: "critical" },
@@ -100,6 +101,61 @@ export function InventoryView({ client, ui, dir = ".", active, width = 78, heigh
     ui?.reportStatus?.({ counts, context: query ? `${filtered.length} of ${usages.length}` : `${usages.length} tracked` });
   }, [usages, ui, query, filtered.length, q.error, q.loading]);
 
+  /** p: build the LLM fix prompt for every dying usage in the CURRENT view
+   * (the / filter scopes it — search "prod", press p, get a prod-only prompt)
+   * and put it on the clipboard (file fallback). Inventory rows can point at
+   * code on other machines, which is exactly why the prompt exists: paste it
+   * into the agent that lives WITH that code. Registry lookup is best-effort
+   * (cached snapshot) to turn replacement slugs into real API ids; without a
+   * cache the slug is still an unambiguous instruction for an agent. */
+  async function makeLlmPrompt() {
+    const dying = filtered.filter((u) => u.health && u.health !== "ok" && u.health !== "custom");
+    if (!dying.length) return ui.showToast(query ? "no matching usages need fixing" : "all current — nothing to fix", "#16a34a");
+    try {
+      const [{ terminalReplacement }, { buildFixPrompt }, { deliverText }, { computeHealth }] = await Promise.all([
+        import("../../fix.js"), import("../../fix-prompt.js"), import("../../clipboard.js"), import("../../registry/local.js"),
+      ]);
+      const today = new Date();
+      let bySlug = new Map();
+      try {
+        const { getRegistry } = await import("../../registry/fetch.js");
+        const snap = await getRegistry({ offline: true, cacheFile: process.env.LLMSTATUS_REGISTRY_CACHE || undefined });
+        bySlug = new Map((snap.models || []).map((m) => [m.slug, m]));
+      } catch { /* no cached registry — replacement slugs still name the target */ }
+      const isCurrent = (m) => computeHealth(m, 90, today) === "ok";
+      const byModel = new Map(); // one section per model, refs merged across projects
+      for (const u of dying) {
+        const key = u.model_display || u.custom_model_name || u.canonical_id || "?";
+        const e = byModel.get(key) || {
+          slug: u.canonical_id || key,
+          display: u.model_display || key,
+          health: u.health,
+          retires_date: u.retires_date ? String(u.retires_date).slice(0, 10) : null,
+          replacement: u.replacement_slug
+            ? terminalReplacement(u.replacement_slug, (slug) => bySlug.get(slug) ?? null, isCurrent)
+            : null,
+          refs: [],
+        };
+        e.refs.push({
+          file: u.source_path || u.location_label || "(added manually — find its usages)",
+          line: u.source_line,
+          matched: u.custom_model_name || u.canonical_id,
+          repo: u.source_repo || undefined,
+        });
+        byModel.set(key, e);
+      }
+      const text = buildFixPrompt([...byModel.values()], { date: today });
+      if (!text) return ui.showToast("no locatable references to hand off", "#d97706");
+      const nRefs = [...byModel.values()].reduce((n, f) => n + f.refs.length, 0);
+      const res = deliverText(text);
+      if (res.method === "clipboard") ui.showToast(`${GLYPH.check} LLM fix prompt copied (${byModel.size} model${byModel.size === 1 ? "" : "s"} · ${nRefs} refs) — paste into your AI agent`);
+      else if (res.method === "file") ui.showToast(`${GLYPH.check} no clipboard tool — prompt saved to ${res.path}`);
+      else ui.showToast("couldn't copy or save the prompt", "#dc2626");
+    } catch (e) {
+      ui.showToast(e.message, "red");
+    }
+  }
+
   async function patch(u, body, label) {
     try {
       await client.patchUsage(u.id, body);
@@ -128,6 +184,7 @@ export function InventoryView({ client, ui, dir = ".", active, width = 78, heigh
       if (input === "g") return q.reload();
       if (input === "r") return ui.switchTo("scan");
       if (input === "n") return ui.switchTo("add");
+      if (input === "p") return makeLlmPrompt();
       if (input === "t") {
         const untagged = usages.filter(isUntagged);
         if (!untagged.length) return ui.showToast("nothing untagged");

package/src/tui/views/local.js

@@ -29,6 +29,7 @@ export const meta = {
     { k: "↑↓", label: "nav" },
     { k: "↵", label: "refs" },
     { k: "f", label: "fix all" },
+    { k: "p", label: "llm prompt" },
     { k: "u", label: "push → Inv" },
     { k: "g", label: "rescan" },
     { k: "/", label: "search" },
@@ -134,6 +135,39 @@ export function LocalView({ client, me, dir, ui, width = 78, height = 14, active
     });
   }
 
+  /** p (while idle): build the LLM fix prompt for EVERY dying model found here
+   * and put it on the clipboard (file fallback) — for the refs `mm fix` can't
+   * safely touch (pinned ids, config indirection) hand the whole job to the
+   * user's AI coding agent instead. Same builder as `mm prompt`. */
+  function makeLlmPrompt() {
+    const dying = items.filter((it) => it.model && it.health !== "ok" && it.health !== "custom");
+    if (!dying.length) return ui?.showToast?.("all current — nothing to fix", "#16a34a");
+    Promise.all([import("../../fix.js"), import("../../fix-prompt.js"), import("../../clipboard.js")]).then(
+      ([{ terminalReplacement }, { buildFixPrompt }, { deliverText }]) => {
+        const bySlug = new Map((scan.snapshot?.models || []).map((m) => [m.slug, m]));
+        const today = new Date();
+        const isCurrent = (m) => computeHealth(m, 90, today) === "ok";
+        const findings = dying.map((it) => ({
+          slug: it.model.slug,
+          display: it.model.display,
+          health: it.health,
+          retires_date: it.model.retires_date,
+          replacement: it.model.replacement_slug
+            ? terminalReplacement(it.model.replacement_slug, (slug) => bySlug.get(slug) ?? null, isCurrent)
+            : null,
+          refs: distinctRefs(it.refs).map((r) => ({ file: r.source_path || r.location_label, line: r.source_line, matched: r.model_string })),
+        }));
+        const text = buildFixPrompt(findings, { date: today });
+        if (!text) return ui?.showToast?.("no file references to hand off", "#d97706");
+        const nRefs = findings.reduce((n, f) => n + f.refs.length, 0);
+        const res = deliverText(text);
+        if (res.method === "clipboard") ui?.showToast?.(`${GLYPH.check} LLM fix prompt copied (${dying.length} model${dying.length === 1 ? "" : "s"} · ${nRefs} refs) — paste into your AI agent`);
+        else if (res.method === "file") ui?.showToast?.(`${GLYPH.check} no clipboard tool — prompt saved to ${res.path}`);
+        else ui?.showToast?.("couldn't copy or save the prompt", "#dc2626");
+      },
+    );
+  }
+
   const tick = useTick(80, running || pushing);
   const spin = SPINNER[tick % SPINNER.length];
   const search = useSearch();
@@ -281,7 +315,9 @@ export function LocalView({ client, me, dir, ui, width = 78, height = 14, active
       if (key.upArrow || input === "k") return nav.up();
       if (input === "e") return excludeRef(drefs[0]); // exclude the highlighted model's location (editable)
       if (input === "f") return fixRefs(cur?.refs || [], `all ${cur?.count ?? 0} references`);
-      if (input === "p" && running) return scan.togglePause();
+      // p is overloaded by state: pausing only means anything mid-scan, and the
+      // prompt is only trustworthy once the scan is done — no key collision.
+      if (input === "p") return running ? scan.togglePause() : makeLlmPrompt();
       if (input === "g") { justReloadedRef.current = true; return scan.reload(); }
       if (input === "u" && !pushing) return pushToInventory();
     },