@mutmutco/installer-launcher 1.0.1 → 1.1.0

package/dist/launcher.js

@@ -296,6 +296,11 @@ function parseProductConfig(text) {
   } catch {
     throw new Error("product config host must be an http(s) URL");
   }
+  const dl = field(record, "dl").replace(/\/+$/, "");
+  if (dl) {
+    if (!/^https:\/\//u.test(dl)) throw new Error("product config dl must be an https URL");
+    config.dl = dl;
+  }
   return config;
 }
 function field(record, key) {
@@ -672,9 +677,10 @@ async function installAcquisition(dir, candidate, version, acquisition, options)
 
 // src/index.ts
 import { spawn as spawn2, spawnSync as spawnSync3 } from "node:child_process";
-import { existsSync as existsSync7, readFileSync as readFileSync7, statSync, mkdtempSync as mkdtempSync2, unlinkSync as unlinkSync2, rmdirSync, mkdirSync as mkdirSync6, renameSync as renameSync4, rmSync as rmSync5 } from "node:fs";
+import { existsSync as existsSync8, readFileSync as readFileSync8, statSync, mkdtempSync as mkdtempSync2, unlinkSync as unlinkSync2, rmdirSync, mkdirSync as mkdirSync6, renameSync as renameSync5, rmSync as rmSync6, writeFileSync as writeFileSync8 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { dirname as dirname3, join as join6, resolve as resolve2 } from "node:path";
+import { dirname as dirname4, join as join7, resolve as resolve2 } from "node:path";
+import { isSea } from "node:sea";
 import { fileURLToPath, pathToFileURL as pathToFileURL2 } from "node:url";
 
 // ../face/src/face.ts
@@ -685,6 +691,7 @@ var PRODUCTS = Object.freeze({
   "mm-strategy": Object.freeze({
     name: "MM Strategy",
     installWarm: "Welcome. Let's get you ready.",
+    checkWarm: "Here's where things stand.",
     accent: "38;2;249;115;22",
     warm: "Welcome back. Checking for updates...",
     doctor: "mm-strategy doctor"
@@ -692,6 +699,7 @@ var PRODUCTS = Object.freeze({
   "mmi-hub": Object.freeze({
     name: "mmi-hub",
     installWarm: "Welcome. Let's get you ready.",
+    checkWarm: "Here's where things stand.",
     accent: "38;2;125;211;252",
     warm: "Welcome back. Checking for updates...",
     doctor: "mmi doctor"
@@ -699,6 +707,7 @@ var PRODUCTS = Object.freeze({
   "jerv-hub": Object.freeze({
     name: "jerv-hub",
     installWarm: "Welcome. Let's get you ready.",
+    checkWarm: "Here's where things stand.",
     accent: "38;2;248;113;113",
     warm: "Welcome back. Checking for updates...",
     doctor: "jerv doctor"
@@ -706,6 +715,7 @@ var PRODUCTS = Object.freeze({
   jervcode: Object.freeze({
     name: "JervCode",
     installWarm: "Welcome. Let's get you ready.",
+    checkWarm: "Here's where things stand.",
     accent: "38;2;192;132;252",
     warm: "Welcome back. Checking for updates...",
     doctor: "jervcode doctor"
@@ -821,7 +831,7 @@ function createFace({ product, color = false, columns, env = process.env, operat
   const welcome = () => continuesFace || nested ? [] : [
     `${paint(identity.accent, GLYPH.diamond)}  ${paint(identity.accent, identity.name)} \u2014 Mutatis Mutandis`,
     bar(),
-    `${bar()}  ${operation === "install" ? identity.installWarm : identity.warm}`,
+    `${bar()}  ${operation === "install" ? identity.installWarm : operation === "check" ? identity.checkWarm : identity.warm}`,
     bar()
   ];
   const continues = (phase, kind = "ok") => {
@@ -851,7 +861,11 @@ function createFace({ product, color = false, columns, env = process.env, operat
     const content = Math.min(width - 6, Math.max(...body.map(visibleWidth)));
     const rule = paint(identity.accent, GLYPH.rule.repeat(content + 4));
     const frame = (left, right) => `${paint(identity.accent, left)}${rule}${paint(identity.accent, right)}`;
-    const bodyRow = (line) => line.startsWith(GLYPH.check) ? `${paint(identity.accent, GLYPH.check)}${line.slice(1)}` : line;
+    const headGlyph = { [GLYPH.check]: identity.accent, [GLYPH.cross]: identity.accent, [GLYPH.dot]: PALETTE.muted };
+    const bodyRow = (line) => {
+      const sgr = headGlyph[line.charAt(0)];
+      return sgr ? `${paint(sgr, line.charAt(0))}${line.slice(1)}` : line;
+    };
     return [
       frame(GLYPH.boxTop, GLYPH.boxTopEnd),
       ...body.map((line) => `${paint(identity.accent, GLYPH.bar)}  ${bodyRow(line)}${" ".repeat(Math.max(0, content - visibleWidth(line)))}  ${paint(identity.accent, GLYPH.bar)}`),
@@ -877,6 +891,9 @@ function createFace({ product, color = false, columns, env = process.env, operat
 // ../face/src/shell.ts
 var RELAY_INDENT = " ".repeat(TITLE_COLUMN - 1);
 
+// ../face/src/rows.ts
+var plainText = (text) => String(text).replaceAll("\u2192", "->").replaceAll("\xB7", "-").replaceAll("\u2014", "-").replaceAll("\u2026", "...");
+
 // ../face/src/spinner.ts
 import { appendFileSync as appendFileSync2, writeSync as writeSync2 } from "node:fs";
 import { Worker } from "node:worker_threads";
@@ -1109,22 +1126,44 @@ function validateInstallerProduct(value) {
   if (doctor !== identity.doctor) return fail("doctor");
   if (!Array.isArray(input.surfaces) || input.surfaces.length === 0) return fail("surfaces");
   const ids = /* @__PURE__ */ new Set();
-  const surfaces = input.surfaces.map((raw) => {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw)) return fail("surface");
-    const source = raw;
-    const id = text(source.id, "surface.id");
+  const surfaces = input.surfaces.map((raw2) => {
+    if (!raw2 || typeof raw2 !== "object" || Array.isArray(raw2)) return fail("surface");
+    const source2 = raw2;
+    const id = text(source2.id, "surface.id");
     if (ids.has(id)) return fail("duplicate surface.id");
     ids.add(id);
     const surface = { id };
     for (const field2 of ["npm", "bin", "kind", "activation"]) {
-      if (source[field2] !== void 0) surface[field2] = text(source[field2], `surface.${field2}`);
+      if (source2[field2] !== void 0) surface[field2] = text(source2[field2], `surface.${field2}`);
     }
     if (Boolean(surface.npm) !== Boolean(surface.bin)) return fail("surface npm/bin pair");
     if (surface.kind !== void 0 && !["agent-home", "payload"].includes(surface.kind)) return fail("surface.kind");
     if (!surface.npm && !surface.kind) return fail("surface implementation");
     return surface;
   });
-  return { product, gate, doctor, surfaces };
+  if (input.launcher === void 0) return { product, gate, doctor, surfaces };
+  const raw = input.launcher;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return fail("launcher");
+  const source = raw;
+  const https = (value2, field2) => {
+    const url = text(value2, field2).replace(/\/+$/u, "");
+    let parsed;
+    try {
+      parsed = new URL(url);
+    } catch {
+      return fail(field2);
+    }
+    return parsed.protocol === "https:" && !parsed.username && !parsed.password ? url : fail(field2);
+  };
+  const launcher = {
+    product: text(source.product, "launcher.product"),
+    bin: text(source.bin, "launcher.bin"),
+    key: text(source.key, "launcher.key"),
+    host: https(source.host, "launcher.host")
+  };
+  if (source.dl !== void 0) launcher.dl = https(source.dl, "launcher.dl");
+  if (Buffer.from(launcher.key, "base64").length !== 32) return fail("launcher.key");
+  return { product, gate, doctor, surfaces, launcher };
 }
 var PHASES = {
   preflight: ["Checking prerequisites", "Checked prerequisites"],
@@ -1149,6 +1188,23 @@ var UPDATE_CHECK_PHASES = /* @__PURE__ */ new Set([
   "sign-in",
   "check"
 ]);
+var SURFACE_WORDS = Object.freeze({
+  updated: "updated",
+  current: "already current",
+  failed: "failed",
+  skipped: "skipped",
+  retry: "retrying",
+  pending: "pending",
+  kept: "kept",
+  /** Read-only report states. */
+  behind: "update available",
+  ahead: "ahead of the release",
+  staged: "next launch",
+  unknown: "unknown",
+  missing: "not installed"
+});
+var AUTO_UPDATE = "auto-update";
+var LAUNCHER_SURFACE = "launcher";
 function createInstallerRun(value, options = {}) {
   const declaration = validateInstallerProduct(value);
   const env = options.env ?? process.env;
@@ -1276,11 +1332,11 @@ function createInstallerRun(value, options = {}) {
     },
     surface(facts) {
       if (finished) throw new Error("installer run already finished");
-      const surface = declaration.surfaces.find((surface2) => surface2.id === facts.id);
+      const surface = declaration.surfaces.find((surface2) => surface2.id === facts.id) ?? (facts.id === LAUNCHER_SURFACE ? { id: LAUNCHER_SURFACE } : void 0);
       if (!surface) throw new Error("installer run: undeclared surface");
       start();
       const versions = facts.to ? facts.from && facts.from !== facts.to ? ` ${facts.from} ${tty ? "\u2192" : "->"} ${facts.to}` : ` ${facts.to}` : "";
-      const status = { updated: options.dryRun ? "would update" : "updated", current: "already current", failed: "failed", skipped: "skipped", retry: "retrying", pending: "pending", kept: "kept" }[facts.state];
+      const status = facts.state === "updated" && options.dryRun ? "would update" : SURFACE_WORDS[facts.state];
       if (!status) throw new Error("installer run: unknown surface state");
       const separator = tty ? "\xB7" : "-";
       const activation = facts.state === "updated" && surface.activation ? ` ${separator} ${surface.activation}` : "";
@@ -1388,8 +1444,9 @@ function createInstallerRun(value, options = {}) {
       if (options.quiet && facts.updated === 0 && facts.failed === 0 && !facts.operationFailed) return;
       const changed = !facts.version ? "No release target is available." : facts.dryRun ? `Would update ${facts.updated} of ${facts.total} surfaces to ${facts.version}.` : facts.installed ? `Installed ${facts.version} across ${facts.total} surfaces.` : `Updated ${facts.updated} of ${facts.total} surfaces to ${facts.version}.`;
       const ready = facts.failed === 0 && !facts.dryRun && !facts.deferred && !facts.operationFailed && Boolean(facts.version);
+      const deferred = Boolean(facts.deferred) && facts.failed === 0 && !facts.operationFailed;
       const body = [
-        `${ready ? GLYPH.check : facts.dryRun ? GLYPH.dot : GLYPH.cross}  ${face.identity.name}${ready ? " is ready." : facts.dryRun ? " preview complete." : facts.deferred ? " update deferred." : " is not ready yet."}`,
+        `${ready ? GLYPH.check : facts.dryRun || deferred ? GLYPH.dot : GLYPH.cross}  ${face.identity.name}${ready ? " is ready." : facts.dryRun ? " preview complete." : deferred ? ` ${operation === "install" ? "install" : "update"} deferred.` : " is not ready yet."}`,
         changed,
         ...facts.failed ? [`Failed ${facts.failed} of ${facts.total} surfaces.`] : [],
         ...facts.detail ? [facts.detail] : [],
@@ -1412,6 +1469,89 @@ function createInstallerRun(value, options = {}) {
   return run2;
 }
 
+// ../face/src/screens.ts
+function screenLane(render = {}, stream = "stdout") {
+  const env = render.env ?? process.env;
+  const out = stream === "stdout" ? process.stdout : process.stderr;
+  const tty = render.tty ?? Boolean(out.isTTY);
+  const color = tty && render.color !== false && env.NO_COLOR === void 0 && env.TERM !== "dumb";
+  return { tty, color, columns: render.columns ?? out.columns, env };
+}
+var faceFor = (product, lane, operation) => createFace({ product, color: lane.color, columns: lane.columns, env: { ...lane.env, MM_OUTER_CONSOLE: void 0, MM_FACE_CONTINUES: void 0, MM_PROGRESS_FD: void 0, MM_PROGRESS_FILE: void 0 }, operation });
+function renderNotice(product, notice, render) {
+  const lane = screenLane(render, notice.state === "fail" ? "stderr" : "stdout");
+  const face = faceFor(product, lane);
+  const width = face.width - 3;
+  const [first, ...rest] = wrapWords(plain(notice.message, lane), width);
+  if (!lane.tty) {
+    return [`${notice.state === "fail" ? "Error: " : ""}${[first, ...rest].join(" ")}`, ...notice.next ? [`Next: ${notice.next}`] : []];
+  }
+  const glyph = notice.state === "fail" ? face.paint(face.identity.accent, GLYPH.cross) : notice.state === "note" ? face.paint(PALETTE.muted, GLYPH.dot) : face.paint(face.identity.accent, GLYPH.check);
+  return [
+    `${glyph}  ${first}`,
+    ...rest.map((line) => `   ${line}`),
+    ...notice.next ? [`   ${face.paint(PALETTE.muted, "Next:")}  ${notice.next}`] : []
+  ];
+}
+function renderReport(product, report, render) {
+  const lane = screenLane(render);
+  const face = faceFor(product, lane, "check");
+  const { verdict } = report;
+  const headline = `${face.identity.name} ${verdict.headline}`;
+  if (!lane.tty) {
+    return [
+      `${face.identity.name} - Mutatis Mutandis`,
+      face.identity.checkWarm,
+      ...report.rows.map((row) => `${row.mark === "fail" ? "Failed: " : ""}${plainText(rowTitle(row))}`),
+      ...report.rows.flatMap((row) => row.note ? [`  ${plainText(row.note)}`] : []),
+      `${verdict.state === "fail" ? "Error: " : ""}${plainText(headline)}`,
+      ...(verdict.facts ?? []).map(plainText),
+      `Next: ${verdict.next}`
+    ];
+  }
+  const glyph = verdict.state === "fail" ? GLYPH.cross : verdict.state === "note" ? GLYPH.dot : GLYPH.check;
+  const facts = verdict.facts?.length ? verdict.facts : [verdict.state === "ok" ? "Everything checked passed." : "See the rows above."];
+  return [
+    ...face.welcome(),
+    // A report row IS an update row: glyph, subject, state (#7071). Two layouts for one fact — a
+    // mark mid-row after a subject column here, a leading glyph in `update` — is the drift itself.
+    ...report.rows.flatMap((row) => [face.step(rowTitle(row), null, row.mark ?? "note"), ...row.note ? [face.relay(row.note)] : []]),
+    ...report.rows.length ? [face.paint(PALETTE.muted, GLYPH.bar)] : [],
+    ...face.receipt([`${glyph}  ${headline}`, ...facts, `Next:  ${verdict.next}`], { ready: verdict.state === "ok" }),
+    face.signOff()
+  ].filter((line) => line !== "");
+}
+function renderUsage(product, usage2, render) {
+  const lane = screenLane(render);
+  const face = faceFor(product, lane);
+  const all = [...usage2.commands, ...usage2.options ?? []];
+  const column = Math.min(Math.max(...all.map((entry2) => entry2.usage.length)), 34);
+  const table = (entries) => entries.flatMap((entry2) => {
+    const [first, ...rest] = wrapWords(plain(entry2.text, lane), Math.max(20, face.width - column - 6));
+    const head = entry2.usage.length > column ? [`  ${entry2.usage}`, `  ${" ".repeat(column)}  ${first}`] : [`  ${entry2.usage.padEnd(column)}  ${first}`];
+    return [...head, ...rest.map((line) => `  ${" ".repeat(column)}  ${line}`)];
+  });
+  return [
+    `${face.paint(face.identity.accent, usage2.bin)} ${usage2.version} ${lane.tty ? "\xB7" : "-"} ${plain(usage2.summary, lane)}`,
+    "",
+    `Usage:  ${usage2.bin} <command> [options]`,
+    "",
+    "Commands:",
+    ...table(usage2.commands),
+    ...usage2.options?.length ? ["", "Options:", ...table(usage2.options)] : []
+  ];
+}
+function renderVersion(bin, version, launcher) {
+  return `${bin} ${version}${launcher ? ` (launcher ${launcher})` : ""}`;
+}
+function printScreen(lines, stream = "stdout") {
+  const out = stream === "stdout" ? process.stdout : process.stderr;
+  out.write(lines.map((line) => `${line}
+`).join(""));
+}
+var plain = (text, lane) => lane.tty ? String(text) : plainText(stripColor(String(text)));
+var rowTitle = (row) => `${row.surface}${row.aspect ? ` ${row.aspect}` : ""}${row.instance ? ` \xB7 ${row.instance}` : ""} ${row.state}`;
+
 // src/autoupdate.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
 import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync6, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "node:fs";
@@ -1442,19 +1582,33 @@ function scheduleName(config) {
 function scheduleLabel(config) {
   return `${config.binName}-autoupdate`.replace(/[^A-Za-z0-9_-]+/g, "-");
 }
+var HIDDEN_SCRIPT = "autoupdate-hidden.vbs";
+function hiddenVbs(command2) {
+  const line = command2.map((arg) => `""${arg.replaceAll('"', '""')}""`).join(" ");
+  return `' Generated by \`autoupdate on\`: wscript //B runs this with no window, so the hourly update
+' never flashes a console. The exit code is the update's, for Task Scheduler's last result.
+Dim shell, code
+Set shell = CreateObject("WScript.Shell")
+code = shell.Run("${line}", 0, True)
+WScript.Quit code
+`;
+}
 function quoteWindows(arg) {
   return /[\s"&|<>^%]/.test(arg) ? `"${arg.replace(/"/g, '\\"')}"` : arg;
 }
 function enableSchedule(config, command2, options = {}) {
   const platform = schedulePlatform(options.platform);
-  if (!platform) throw new Error(`autoupdate is not supported on ${options.platform ?? process.platform}.`);
+  if (!platform) throw new Error(`Auto-update is not supported on ${options.platform ?? process.platform}.`);
   const exec = options.exec ?? defaultExec;
   const home = homeOf(options);
   if (platform === "win32") {
-    const taskLine = command2.map(quoteWindows).join(" ");
-    const result2 = exec("schtasks", ["/Create", "/TN", scheduleName(config), "/TR", taskLine, "/SC", "HOURLY", "/IT", "/F"]);
+    const stateDir = options.stateDir ?? defaultProductDir(config.product);
+    mkdirSync5(stateDir, { recursive: true });
+    const script = join5(stateDir, HIDDEN_SCRIPT);
+    writeFileSync6(script, hiddenVbs(command2));
+    const result2 = exec("schtasks", ["/Create", "/TN", scheduleName(config), "/TR", `wscript.exe //B //Nologo ${quoteWindows(script)}`, "/SC", "HOURLY", "/IT", "/F"]);
     if (result2.code !== 0) {
-      throw new Error(`could not turn autoupdate on: ${firstLine(result2.stdout || result2.stderr) || `exit ${result2.code}`}`);
+      throw new Error(`Could not turn auto-update on: ${firstLine(result2.stdout || result2.stderr) || `exit ${result2.code}`}`);
     }
     return;
   }
@@ -1467,7 +1621,7 @@ function enableSchedule(config, command2, options = {}) {
     exec("launchctl", ["bootout", `gui/${process.getuid?.() ?? 501}/${label2}`]);
     const result2 = exec("launchctl", ["bootstrap", `gui/${process.getuid?.() ?? 501}`, plist]);
     if (result2.code !== 0) {
-      throw new Error(`could not turn autoupdate on: ${firstLine(result2.stderr || result2.stdout) || `exit ${result2.code}`}`);
+      throw new Error(`Could not turn auto-update on: ${firstLine(result2.stderr || result2.stdout) || `exit ${result2.code}`}`);
     }
     return;
   }
@@ -1478,23 +1632,24 @@ function enableSchedule(config, command2, options = {}) {
   writeFileSync6(join5(dir, `${label}.timer`), linuxTimer(label));
   const reload = exec("systemctl", ["--user", "daemon-reload"]);
   if (reload.code !== 0) {
-    throw new Error(`could not turn autoupdate on: ${firstLine(reload.stderr || reload.stdout) || `exit ${reload.code}`}`);
+    throw new Error(`Could not turn auto-update on: ${firstLine(reload.stderr || reload.stdout) || `exit ${reload.code}`}`);
   }
   const result = exec("systemctl", ["--user", "enable", "--now", `${label}.timer`]);
   if (result.code !== 0) {
-    throw new Error(`could not turn autoupdate on: ${firstLine(result.stderr || result.stdout) || `exit ${result.code}`}`);
+    throw new Error(`Could not turn auto-update on: ${firstLine(result.stderr || result.stdout) || `exit ${result.code}`}`);
   }
 }
 function disableSchedule(config, options = {}) {
   const platform = schedulePlatform(options.platform);
-  if (!platform) throw new Error(`autoupdate is not supported on ${options.platform ?? process.platform}.`);
+  if (!platform) throw new Error(`Auto-update is not supported on ${options.platform ?? process.platform}.`);
   const exec = options.exec ?? defaultExec;
   const home = homeOf(options);
   if (platform === "win32") {
     const result = exec("schtasks", ["/Delete", "/TN", scheduleName(config), "/F"]);
     if (result.code !== 0 && !/cannot find|does not exist/i.test(`${result.stdout} ${result.stderr}`)) {
-      throw new Error(`could not turn autoupdate off: ${firstLine(result.stdout || result.stderr) || `exit ${result.code}`}`);
+      throw new Error(`Could not turn auto-update off: ${firstLine(result.stdout || result.stderr) || `exit ${result.code}`}`);
     }
+    rmSync4(join5(options.stateDir ?? defaultProductDir(config.product), HIDDEN_SCRIPT), { force: true });
     return;
   }
   if (platform === "darwin") {
@@ -1587,6 +1742,161 @@ function firstLine(text) {
   return String(text).split(/\r?\n/).map((line) => line.trim()).filter(Boolean)[0] ?? "";
 }
 
+// src/refresh.ts
+import { execFile } from "node:child_process";
+import { chmodSync, existsSync as existsSync7, lstatSync, readdirSync, readFileSync as readFileSync7, renameSync as renameSync4, rmSync as rmSync5, writeFileSync as writeFileSync7 } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname as dirname3, join as join6 } from "node:path";
+var LAUNCHER_RECORD_FILE = "launcher.json";
+var RECORD_TIMEOUT_MS = 1e4;
+function platformKey(platform, arch) {
+  if (platform === "win32") return arch === "x64" || arch === "arm64" ? `win-${arch}` : null;
+  return platform === "darwin" && arch === "arm64" ? "darwin-arm64" : null;
+}
+function verifierFor(target) {
+  return { product: target.product, host: target.host, loginKind: "github", publicKey: target.key, binName: target.bin };
+}
+async function fetchRecord(target, options) {
+  let json;
+  try {
+    const response = await (options.fetch ?? fetch)(
+      `${target.host.replace(/\/+$/u, "")}/release/launcher`,
+      { signal: AbortSignal.timeout(options.timeoutMs ?? RECORD_TIMEOUT_MS) }
+    );
+    if (!response.ok) return null;
+    json = await response.json();
+  } catch {
+    return null;
+  }
+  let record;
+  try {
+    record = parseManifest(json);
+  } catch {
+    return null;
+  }
+  if (!verifyManifest(record, record.signature, verifierFor(target))) return "bad-signature";
+  return { version: record.version, files: record.files };
+}
+async function readLauncherRecord(target, options = {}) {
+  const record = await fetchRecord(target, options);
+  return record === "bad-signature" ? null : record;
+}
+function compareVersions(a, b) {
+  const split = (v) => {
+    const [core, pre = ""] = v.split("-", 2);
+    return { nums: core.split(".").map((n) => Number.parseInt(n, 10) || 0), pre };
+  };
+  const x = split(a);
+  const y = split(b);
+  for (let i = 0; i < 3; i++) if ((x.nums[i] ?? 0) !== (y.nums[i] ?? 0)) return (x.nums[i] ?? 0) > (y.nums[i] ?? 0) ? 1 : -1;
+  if (x.pre === y.pre) return 0;
+  if (!x.pre) return 1;
+  if (!y.pre) return -1;
+  return x.pre > y.pre ? 1 : -1;
+}
+function recordedPath(productDir) {
+  try {
+    const saved = JSON.parse(readFileSync7(join6(productDir, LAUNCHER_RECORD_FILE), "utf8"));
+    return typeof saved.path === "string" && saved.path ? saved.path : null;
+  } catch {
+    return null;
+  }
+}
+function installedPath(target, productDir, platform) {
+  return platform === "win32" ? join6(productDir, "bin", `${target.bin}.exe`) : join6(homedir(), ".local", "bin", target.bin);
+}
+function parseLauncherVersion(stdout, bin) {
+  const text = String(stdout).trim();
+  if (!text.startsWith(`${bin} `)) return null;
+  return text.match(/launcher (\d+\.\d+\.\d+[^\s)]*)/u)?.[1] ?? null;
+}
+function runVersion(path, bin) {
+  return new Promise((resolve3) => {
+    execFile(path, ["--version"], { timeout: 3e4, windowsHide: true, encoding: "utf8" }, (error, stdout) => {
+      resolve3(error ? null : parseLauncherVersion(stdout, bin));
+    });
+  });
+}
+function removeStale(file) {
+  const prefix = `${basename(file)}.old-`;
+  let names;
+  try {
+    names = readdirSync(dirname3(file));
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    if (!name.startsWith(prefix)) continue;
+    try {
+      rmSync5(join6(dirname3(file), name), { force: true });
+    } catch {
+    }
+  }
+}
+async function refreshLauncher(target, options = {}) {
+  const started = Date.now();
+  const platform = options.platform ?? process.platform;
+  const key = platformKey(platform, options.arch ?? process.arch);
+  if (!key) return null;
+  const productDir = options.productDir ?? defaultProductDir(target.product);
+  const recorded = recordedPath(productDir);
+  const file = options.path ?? (recorded && existsSync7(recorded) ? recorded : installedPath(target, productDir, platform));
+  if (!existsSync7(file) || lstatSync(file).isSymbolicLink()) return null;
+  if (!options.dryRun) removeStale(file);
+  const from = await (options.readVersion ?? ((path) => runVersion(path, target.bin)))(file);
+  if (!from) return null;
+  const arm = (verdict, to, detail) => ({ surface: "launcher", from, to, verdict, detail, durationMs: Date.now() - started });
+  const record = await fetchRecord(target, options);
+  if (record === "bad-signature") return arm("fail", from, "The launcher record failed its signature check.");
+  const entry2 = record?.files.find((candidate) => candidate.path === key);
+  if (!record || !entry2) return arm("skip", from, "No launcher update is offered yet.");
+  if (compareVersions(record.version, from) <= 0) return arm("ok", from, "");
+  if (options.dryRun) return arm("ok", record.version, "");
+  let unlock;
+  if (!options.lockHeld) {
+    try {
+      unlock = lockInstallation(productDir);
+    } catch {
+      return arm("defer", from, "Another install is running; the launcher updates next time.");
+    }
+  }
+  const next = `${file}.new-${process.pid}`;
+  let moved;
+  try {
+    let bytes;
+    try {
+      const response = await (options.fetch ?? fetch)(
+        `${(target.dl ?? target.host).replace(/\/+$/u, "")}/dl/${target.product}/${key}`,
+        { signal: AbortSignal.timeout(3e5) }
+      );
+      if (!response.ok) return arm("defer", from, "The launcher download did not complete; it retries next time.");
+      bytes = await readDownload(response, void 0, entry2.size);
+    } catch {
+      return arm("defer", from, "The launcher download did not complete; it retries next time.");
+    }
+    if (!verifyFileBytes(entry2, bytes)) return arm("fail", from, "The downloaded launcher failed its checksum.");
+    try {
+      writeFileSync7(next, bytes, { mode: 493 });
+      if (platform !== "win32") chmodSync(next, 493);
+      if (platform === "win32") {
+        moved = `${file}.old-${process.pid}-${Date.now()}`;
+        renameSync4(file, moved);
+      }
+      renameSync4(next, file);
+    } catch {
+      try {
+        if (moved && !existsSync7(file)) renameSync4(moved, file);
+      } catch {
+      }
+      rmSync5(next, { force: true });
+      return arm("fail", from, "The launcher could not be replaced.");
+    }
+    return arm("ok", record.version, "");
+  } finally {
+    unlock?.();
+  }
+}
+
 // src/login-github.ts
 import { spawn } from "node:child_process";
 var realSleep = (ms) => new Promise((resolve3) => setTimeout(resolve3, ms));
@@ -1822,7 +2132,7 @@ function page(title, body) {
 }
 
 // src/index.ts
-var LAUNCHER_VERSION = true ? "1.0.1" : readVersionFromPackage();
+var LAUNCHER_VERSION = true ? "1.1.0" : readVersionFromPackage();
 function defaultPrint(message) {
   process.stdout.write(`${message}
 `);
@@ -1831,79 +2141,192 @@ function defaultPrintErr(message) {
   process.stderr.write(`${message}
 `);
 }
+var LAUNCHER_VERBS = /* @__PURE__ */ new Set(["install", "update", "status", "doctor", "login", "logout", "autoupdate"]);
+var VALUE_FLAGS = /* @__PURE__ */ new Set(["--config", "--dir"]);
+var SWITCHES = {
+  "--json": "json",
+  "--no-color": "noColor",
+  "--dry-run": "dryRun",
+  "--help": "help",
+  "-h": "help",
+  "--version": "version",
+  "-v": "version"
+};
+function parseArgv(argv2) {
+  const parsed = { flags: {}, args: [], rest: [] };
+  const flag = (i2) => {
+    const arg = argv2[i2];
+    if (VALUE_FLAGS.has(arg)) {
+      const value = argv2[i2 + 1];
+      if (value === void 0 || value.startsWith("-")) {
+        parsed.unknownFlag ??= arg;
+        return i2 + 1;
+      }
+      parsed.flags[arg === "--config" ? "config" : "dir"] = value;
+      return i2 + 2;
+    }
+    const name = SWITCHES[arg];
+    if (!name) return -1;
+    parsed.flags[name] = true;
+    return i2 + 1;
+  };
+  const skip = (i2) => {
+    const next = flag(i2);
+    if (next >= 0) return next;
+    parsed.unknownFlag ??= argv2[i2];
+    return i2 + 1;
+  };
+  let i = 0;
+  while (i < argv2.length && argv2[i].startsWith("-")) {
+    if (argv2[i] === "--run") {
+      parsed.run = { file: argv2[i + 1], args: argv2.slice(i + 2) };
+      return parsed;
+    }
+    i = skip(i);
+  }
+  parsed.command = argv2[i];
+  if (parsed.command === void 0) return parsed;
+  if (!LAUNCHER_VERBS.has(parsed.command)) {
+    parsed.rest = argv2.slice(i + 1);
+    return parsed;
+  }
+  for (i += 1; i < argv2.length; ) {
+    if (argv2[i].startsWith("-")) i = skip(i);
+    else parsed.args.push(argv2[i++]);
+  }
+  return parsed;
+}
+var NO_PRODUCT = "mmi-hub";
+function sentence(message) {
+  const text = message.trim().replace(/\s+—\s+/gu, ". ");
+  if (!text) return "Something went wrong.";
+  return `${text[0].toUpperCase()}${text.slice(1)}${/[.!?]$/u.test(text) ? "" : "."}`;
+}
+function screensFor(product, bin, render, options) {
+  const show = (lines, stream = "stdout") => {
+    const sink = stream === "stderr" ? options.printErr : options.print;
+    if (sink) for (const line of lines) sink(line);
+    else printScreen(lines, stream);
+  };
+  return {
+    product,
+    bin,
+    render,
+    show,
+    notice: (state, message, next) => show(renderNotice(product, { state, message, ...next ? { next } : {} }, render)),
+    refuse: (message, next, code = 1) => {
+      show(renderNotice(product, { state: "fail", message, ...next ? { next } : {} }, render), "stderr");
+      return code;
+    }
+  };
+}
 async function run(rawOptions = {}) {
   const print = rawOptions.print ?? defaultPrint;
   const printErr = rawOptions.printErr ?? defaultPrintErr;
-  const argv2 = rawOptions.argv ?? process.argv.slice(2);
-  const runAt = argv2.indexOf("--run");
-  if (runAt >= 0) return runFile(argv2[runAt + 1], argv2.slice(runAt + 2), printErr);
+  const parsed = parseArgv(rawOptions.argv ?? process.argv.slice(2));
+  if (parsed.run) return runFile(parsed.run.file, parsed.run.args, printErr);
+  const render = {
+    ...rawOptions.tty === void 0 ? {} : { tty: rawOptions.tty },
+    ...parsed.flags.noColor ? { color: false } : {}
+  };
   let config;
   try {
-    config = loadProductConfig({ configPath: rawOptions.configPath ?? flagValue(argv2, "--config") });
+    config = loadProductConfig({ configPath: rawOptions.configPath ?? parsed.flags.config });
   } catch (error) {
-    print(`cannot start: ${error.message}`);
-    return 2;
-  }
-  const dir = resolveProductDir(config.product, rawOptions.dir ?? flagValue(argv2, "--dir"));
-  const positional = argv2.filter((arg) => !arg.startsWith("-"));
-  if (argv2.includes("--version") || argv2.includes("-v")) {
-    print(`${config.binName} launcher ${LAUNCHER_VERSION}`);
+    return screensFor(NO_PRODUCT, "", { ...render, color: false }, rawOptions).refuse(`The launcher cannot start: ${sentence(error.message)}`, void 0, 2);
+  }
+  const dir = resolveProductDir(config.product, rawOptions.dir ?? parsed.flags.dir);
+  const ui = screensFor(faceProduct(config), config.binName, render, rawOptions);
+  if ((parsed.command === "install" || parsed.command === "update") && !parsed.flags.version) recordSelf(dir);
+  if (parsed.unknownFlag) return ui.refuse(`Unknown option: ${parsed.unknownFlag}.`, `${ui.bin} --help`, 2);
+  if (parsed.flags.version) {
+    print(renderVersion(ui.bin, readState(dir)?.version ?? "not installed", LAUNCHER_VERSION));
     return 0;
   }
-  if (argv2.includes("--help") || argv2.includes("-h") || positional.length === 0) {
-    printUsage(config, print);
-    return positional.length === 0 ? 2 : 0;
+  const command2 = parsed.command;
+  if (parsed.flags.help || command2 === void 0) {
+    ui.show(usage(config, dir, render));
+    return parsed.flags.help ? 0 : 2;
   }
-  const command2 = positional[0];
+  const mutating = ["install", "login", "logout"].includes(command2) || command2 === "update" && !parsed.flags.dryRun || command2 === "autoupdate" && ["on", "off"].includes(parsed.args[0] ?? "");
   let unlock;
   try {
-    unlock = lockInstallation(dir);
-    await recoverAcquisition(dir, async (command3, cwd, env) => {
-      const result = (rawOptions.runEntry ?? defaultRunEntry)(command3, cwd, env);
-      return result.ok && (result.code === void 0 || result.code === 0);
-    }, payloadEnv(dir) ?? process.env);
+    if (mutating) {
+      unlock = lockInstallation(dir);
+      await recoverAcquisition(dir, async (command3, cwd, env) => {
+        const result = (rawOptions.runEntry ?? defaultRunEntry)(command3, cwd, env);
+        return result.ok && (result.code === void 0 || result.code === 0);
+      }, payloadEnv(dir) ?? process.env);
+    }
     switch (command2) {
       case "login":
-        unlock();
-        await doLogin(config, dir, rawOptions, print);
+        unlock?.();
+        await doLogin(config, dir, rawOptions, (line) => ui.notice("note", line));
+        ui.notice("ok", `Signed in to ${identityFor(ui.product).name}.`, `${ui.bin} install`);
         return 0;
       case "logout":
         wipeProductDir(dir);
-        print(`signed out of ${config.product} and removed the downloaded payload.`);
+        ui.notice("ok", `Signed out of ${identityFor(ui.product).name} and removed the downloaded payload.`, `${ui.bin} login`);
         return 0;
       case "install":
-        return await doInstall(config, dir, rawOptions, print);
+        return await doInstall(config, dir, rawOptions, print, parsed.flags);
       case "update":
-        return await doUpdate(config, dir, rawOptions, print);
+        return await doUpdate(config, dir, rawOptions, print, parsed.flags);
+      case "status":
+        return await doStatus(config, dir, rawOptions, ui, print, Boolean(parsed.flags.json));
       case "doctor":
-        return doDoctor(config, dir, rawOptions, print, unlock);
+        return doDoctor(config, dir, rawOptions, ui);
       case "autoupdate":
-        return doAutoupdate(config, rawOptions, positional.slice(1), print);
+        return doAutoupdate(config, dir, rawOptions, parsed.args, ui);
       default:
-        return doForward(config, dir, rawOptions, command2, argv2, print, unlock);
+        return doForward(config, dir, rawOptions, command2, parsed.rest, ui, () => unlock?.());
     }
   } catch (error) {
-    if (error instanceof NeedsLoginError) {
-      print("you are signed out \u2014 run login first.");
-      return 3;
+    if (error instanceof NeedsLoginError) return ui.refuse("You are signed out.", `${ui.bin} login`, 3);
+    const message = error.message;
+    if (/another installer is running|lock recovery is already pending/u.test(message)) {
+      return ui.refuse("Another install or update is running.", `${ui.bin} status`);
     }
-    print(`failed: ${error.message}`);
-    return 1;
+    return ui.refuse(sentence(message), `${ui.bin} ${command2}`);
   } finally {
     unlock?.();
   }
 }
-function flagValue(argv2, flag) {
-  const index = argv2.indexOf(flag);
-  if (index < 0) return void 0;
-  const value = argv2[index + 1];
-  return value && !value.startsWith("-") ? value : void 0;
+function recordSelf(dir) {
+  if (!isSea()) return;
+  try {
+    mkdirSync6(dir, { recursive: true });
+    writeFileSync8(join7(dir, LAUNCHER_RECORD_FILE), `${JSON.stringify({ path: process.execPath, version: LAUNCHER_VERSION })}
+`);
+  } catch {
+  }
 }
-function printUsage(config, print) {
-  print(`${config.binName} launcher ${LAUNCHER_VERSION} \u2014 sign in and install ${config.product}.`);
-  print("usage: launcher <login|logout|install|update|doctor|autoupdate on|off|status> [--config <path>] [--dir <path>]");
-  print("       launcher --run <file> [args\u2026]   (run a payload file with the embedded runtime)");
-  print("       launcher <verb> [args\u2026]         (forwarded to the payload when it declares run + verbs)");
+function launcherTarget(config) {
+  return { product: config.product, bin: config.binName, key: config.publicKey, host: config.host, ...config.dl ? { dl: config.dl } : {} };
+}
+function usage(config, dir, render) {
+  const name = config.product;
+  return renderUsage(faceProduct(config), {
+    bin: config.binName,
+    version: `${readState(dir)?.version ?? "not installed"} (launcher ${LAUNCHER_VERSION})`,
+    summary: `Sign in, install and update ${name}.`,
+    commands: [
+      { usage: "install", text: `Sign in and install ${name}.` },
+      { usage: "update [--dry-run]", text: `Update ${name} and this launcher.` },
+      { usage: "status", text: `Show versions, sign-in and ${AUTO_UPDATE}.` },
+      { usage: "doctor", text: `Check this machine, then run the ${name} doctor.` },
+      { usage: "login", text: "Sign in." },
+      { usage: "logout", text: "Sign out and remove the downloaded payload." },
+      { usage: "autoupdate on|off|status", text: `Turn hourly ${AUTO_UPDATE} on or off, or show it.` },
+      { usage: "<verb> ...", text: `Passed to ${name} when it declares it.` }
+    ],
+    options: [
+      { usage: "--json", text: "Print status as JSON." },
+      { usage: "--no-color", text: "Print without colour." },
+      { usage: "--config <path>", text: "Use this product config." },
+      { usage: "--dir <path>", text: "Use this folder for sign-in and downloads." }
+    ]
+  }, render);
 }
 async function runFile(file, args, printErr) {
   if (!file) {
@@ -1911,7 +2334,7 @@ async function runFile(file, args, printErr) {
     return 1;
   }
   const abs = resolve2(process.cwd(), file);
-  if (!existsSync7(abs)) {
+  if (!existsSync8(abs)) {
     printErr(`cannot run ${file}: no such file.`);
     return 1;
   }
@@ -1967,15 +2390,14 @@ async function ensureFreshToken(config, dir, fetchImpl = fetch) {
   });
   return refreshed.accessToken;
 }
-async function doLogin(config, dir, options, print, installer) {
+async function doLogin(config, dir, options, prompt, installer) {
   const fetchImpl = options.fetchImpl ?? fetch;
   const open = options.open ?? openBrowser;
   if (config.loginKind === "github") {
     const tokens = await loginGithub(config, {
       fetchImpl,
       open,
-      print,
-      ...installer ? { onDeviceCode: (prompt) => installer.signIn(prompt) } : {}
+      onDeviceCode: (grant) => installer ? installer.signIn(grant) : prompt(`To sign in, open ${grant.url} and enter the code ${grant.code}.`)
     });
     writeTokens(dir, {
       accessToken: tokens.accessToken,
@@ -1983,7 +2405,12 @@ async function doLogin(config, dir, options, print, installer) {
       expiresAt: Date.now() + tokens.expiresIn * 1e3
     });
   } else {
-    const tokens = await loginGoogle({ host: config.host, open, fetchImpl });
+    const tokens = await loginGoogle({
+      host: config.host,
+      open,
+      fetchImpl,
+      print: (line) => installer ? installer.relay(line) : prompt(line)
+    });
     writeTokens(dir, {
       accessToken: tokens.accessToken,
       refreshToken: tokens.refreshToken,
@@ -1991,20 +2418,19 @@ async function doLogin(config, dir, options, print, installer) {
       clientId: tokens.clientId
     });
   }
-  if (!installer) print(`signed in to ${config.product}.`);
 }
-async function fetchAccessTokenOrLogin(config, dir, options, print, installer) {
+async function fetchAccessTokenOrLogin(config, dir, options, installer) {
   const fetchImpl = options.fetchImpl ?? fetch;
   const fresh = await ensureFreshToken(config, dir, fetchImpl);
   if (fresh) return fresh;
-  await doLogin(config, dir, options, print, installer);
+  await doLogin(config, dir, options, (line) => installer.relay(line), installer);
   const after = readTokens(dir);
   if (!after) throw new Error("sign-in did not produce a token");
   return after.accessToken;
 }
 function readPayloadArgv(dir, key) {
   try {
-    const parsed = JSON.parse(readFileSync7(join6(payloadDir(dir), "payload.json"), "utf8"));
+    const parsed = JSON.parse(readFileSync8(join7(payloadDir(dir), "payload.json"), "utf8"));
     const entry2 = parsed[key];
     if (typeof entry2 === "string") {
       const parts = entry2.trim().split(/\s+/).filter(Boolean);
@@ -2026,7 +2452,7 @@ function readPayloadRun(dir) {
 }
 function readPayloadVerbs(dir) {
   try {
-    const parsed = JSON.parse(readFileSync7(join6(payloadDir(dir), "payload.json"), "utf8"));
+    const parsed = JSON.parse(readFileSync8(join7(payloadDir(dir), "payload.json"), "utf8"));
     const verbs = parsed.verbs;
     if (verbs === "*") return "*";
     if (Array.isArray(verbs) && verbs.every((v) => typeof v === "string" && v.trim().length > 0)) {
@@ -2043,7 +2469,7 @@ function resolveEntry(entry2) {
 function needsShell(command2) {
   if (process.platform !== "win32") return false;
   if (/\.(cmd|bat)$/i.test(command2)) return true;
-  return !existsSync7(command2);
+  return !existsSync8(command2);
 }
 function quoteForShell(arg) {
   return /[\s"&|<>^%]/.test(arg) ? `"${arg.replace(/"/g, '\\"')}"` : arg;
@@ -2109,8 +2535,16 @@ function faceProduct(config) {
 function formatMb(bytes) {
   return (bytes / 1048576).toFixed(1).replace(/\.0$/, "");
 }
-async function installOrUpdate(config, dir, options, print, update) {
+async function installOrUpdate(config, dir, options, print, update, flags2) {
+  let launcherFailed = false;
+  const code = await installOrUpdateRun(config, dir, options, print, update, flags2, () => {
+    launcherFailed = true;
+  });
+  return launcherFailed ? Math.max(code, 1) : code;
+}
+async function installOrUpdateRun(config, dir, options, print, update, flags2, markLauncherFailed) {
   const product = faceProduct(config);
+  const dryRun = update && Boolean(flags2.dryRun);
   const installer = createInstallerRun({
     product,
     gate: config.host,
@@ -2120,17 +2554,55 @@ async function installOrUpdate(config, dir, options, print, update) {
     operation: update ? "update" : "install",
     tty: options.tty,
     animate: !options.print && Boolean(process.stderr.isTTY),
+    dryRun,
+    ...flags2.noColor ? { color: false } : {},
     ...options.print ? { write: (text) => print(text.replace(/\n$/, "")) } : {}
   });
   const fetchImpl = options.fetchImpl ?? fetch;
   let version = readState(dir)?.version ?? "unknown";
   installer.start();
   try {
+    const refresh = options.refresh ?? (isSea() ? refreshLauncher : void 0);
+    const arm = refresh ? await refresh(launcherTarget(config), {
+      lockHeld: true,
+      path: process.execPath,
+      dryRun,
+      productDir: dir,
+      fetch: fetchImpl,
+      readVersion: async () => LAUNCHER_VERSION
+    }) : null;
+    if (arm) {
+      installer.surface({
+        id: LAUNCHER_SURFACE,
+        from: arm.from,
+        to: arm.to,
+        state: armState(arm),
+        ...arm.durationMs === void 0 ? {} : { seconds: arm.durationMs / 1e3 },
+        ...arm.verdict !== "ok" && arm.detail ? { detail: arm.detail } : {}
+      });
+      if (arm.verdict === "fail") {
+        const finish = installer.finish;
+        installer.finish = (facts) => finish({
+          ...facts,
+          operationFailed: true,
+          detail: facts.detail ?? "The launcher could not update itself.",
+          retry: facts.retry ?? `${config.binName} update`
+        });
+        markLauncherFailed();
+      }
+    }
     const current = readState(dir);
-    const payloadPresent = existsSync7(payloadDir(dir));
+    const payloadPresent = existsSync8(payloadDir(dir));
     let started = Date.now();
     installer.phase("resolve", { state: "running" });
     const pointer = await fetchReleaseVersion(config, fetchImpl);
+    if (dryRun) {
+      installer.phase("resolve", { seconds: (Date.now() - started) / 1e3 });
+      const installed = payloadPresent ? current?.version : void 0;
+      if (pointer) installer.surface({ id: config.product, from: installed, to: pointer, state: installed === pointer ? "current" : "updated" });
+      installer.finish({ ...pointer ? { version: pointer } : {}, total: 1, updated: pointer && installed !== pointer ? 1 : 0, failed: 0, dryRun: true });
+      return 0;
+    }
     if (pointer && current?.version === pointer && payloadPresent) {
       version = pointer;
       installer.phase("resolve", { seconds: (Date.now() - started) / 1e3 });
@@ -2147,14 +2619,14 @@ async function installOrUpdate(config, dir, options, print, update) {
     }
     installer.phase("sign-in", { state: "running" });
     started = Date.now();
-    const accessToken = await fetchAccessTokenOrLogin(config, dir, options, print, installer);
+    const accessToken = await fetchAccessTokenOrLogin(config, dir, options, installer);
     installer.phase("sign-in", { seconds: (Date.now() - started) / 1e3 });
     installer.phase("resolve", { state: "running" });
     started = Date.now();
     const manifest = await fetchVerifiedManifest(config, accessToken, fetchImpl);
     version = manifest.version;
     installer.phase("resolve", { seconds: (Date.now() - started) / 1e3 });
-    const unchanged = current?.version === version && existsSync7(payloadDir(dir));
+    const unchanged = current?.version === version && existsSync8(payloadDir(dir));
     if (unchanged && current.acquired) {
       installer.surface({ id: config.product, from: version, to: version, state: "current" });
       return await finishLastMile(config, dir, options, installer, version, true, acquisitionRepairCommand(dir, version));
@@ -2164,14 +2636,14 @@ async function installOrUpdate(config, dir, options, print, update) {
       started = Date.now();
       const cached = reusableCandidate(dir, manifest);
       const candidate = cached ?? randomUUID4();
-      const candidateDir = join6(dir, "candidates", candidate);
+      const candidateDir = join7(dir, "candidates", candidate);
       const onProgress = ({ done, total }) => installer.phase("download", {
         state: "running",
         measure: total ? `${Math.floor(done / total * 100)}% \xB7 ${formatMb(done)} of ${formatMb(total)} MB` : `${formatMb(done)} MB`,
         ...total ? { runningTitle: `Downloading ${config.product} ${version} (${formatMb(total)} MB)` } : {}
       });
       if (!cached) await downloadAndUnpack(config, candidateDir, manifest, accessToken, { fetchImpl, onProgress, cacheDir: dir });
-      const acquisition = existsSync7(join6(candidateDir, "payload", "payload.json")) ? readAcquisition(join6(candidateDir, "payload")) : null;
+      const acquisition = existsSync8(join7(candidateDir, "payload", "payload.json")) ? readAcquisition(join7(candidateDir, "payload")) : null;
       if (acquisition) {
         rememberCandidate(dir, candidate, manifest);
         installer.phase("download", { seconds: (Date.now() - started) / 1e3 });
@@ -2194,10 +2666,10 @@ async function installOrUpdate(config, dir, options, print, update) {
         installer.finish(outcome ?? { version, total: 1, updated: 1, failed: 0, installed: true });
         return 0;
       }
-      const target = join6(dir, "payload");
+      const target = join7(dir, "payload");
       mkdirSync6(dir, { recursive: true });
-      rmSync5(target, { recursive: true, force: true });
-      renameSync4(join6(candidateDir, "payload"), target);
+      rmSync6(target, { recursive: true, force: true });
+      renameSync5(join7(candidateDir, "payload"), target);
       writeState(dir, { version, updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
       installer.phase("download", { seconds: (Date.now() - started) / 1e3 });
     }
@@ -2223,11 +2695,11 @@ async function installOrUpdate(config, dir, options, print, update) {
     installer.stop();
   }
 }
-function doInstall(config, dir, options, print) {
-  return installOrUpdate(config, dir, options, print, false);
+function doInstall(config, dir, options, print, flags2) {
+  return installOrUpdate(config, dir, options, print, false, flags2);
 }
-function doUpdate(config, dir, options, print) {
-  return installOrUpdate(config, dir, options, print, true);
+function doUpdate(config, dir, options, print, flags2) {
+  return installOrUpdate(config, dir, options, print, true, flags2);
 }
 function payloadEnv(dir) {
   const stored = readTokens(dir);
@@ -2239,8 +2711,8 @@ function payloadFileAsCommand(entry2, payload) {
   const first = entry2[0];
   if (!first || first === "$self") return null;
   if (first.includes("/") || first.includes("\\")) return null;
-  const candidate = join6(payload, first);
-  if (!existsSync7(candidate)) return null;
+  const candidate = join7(payload, first);
+  if (!existsSync8(candidate)) return null;
   if (NEVER_A_PROGRAM.test(first)) return first;
   if (process.platform === "win32") return null;
   try {
@@ -2259,7 +2731,7 @@ async function finishLastMile(config, dir, options, installer, version, unchange
       updated: unchanged ? 0 : 1,
       failed: 0,
       installed: true,
-      detail: `next step: run ${join6(payload, config.binName)} to start ${config.product}.`
+      detail: `next step: run ${join7(payload, config.binName)} to start ${config.product}.`
     });
     return 0;
   }
@@ -2305,9 +2777,9 @@ async function runInstallEntry(entry2, cwd, env, installer, tokens = null) {
   const [command2, ...args] = entry2;
   const shell = needsShell(command2);
   const progress = !(process.platform === "win32" && shell);
-  const outcomeDir = mkdtempSync2(join6(tmpdir4(), "mm-installer-outcome-"));
-  const outcomeFile = join6(outcomeDir, "outcome.json");
-  const progressFile = join6(outcomeDir, "progress.jsonl");
+  const outcomeDir = mkdtempSync2(join7(tmpdir4(), "mm-installer-outcome-"));
+  const outcomeFile = join7(outcomeDir, "outcome.json");
+  const progressFile = join7(outcomeDir, "progress.jsonl");
   const childEnv = { ...env, MM_INSTALLER_OUTCOME_FILE: outcomeFile };
   delete childEnv.MM_FACE_TRANSCRIPT;
   delete childEnv.MM_PROGRESS_FILE;
@@ -2357,8 +2829,8 @@ async function runInstallEntry(entry2, cwd, env, installer, tokens = null) {
       const pollProgress = () => {
         if (progressError) return;
         try {
-          if (!existsSync7(progressFile)) return;
-          const bytes = readFileSync7(progressFile);
+          if (!existsSync8(progressFile)) return;
+          const bytes = readFileSync8(progressFile);
           receive(progressDecoder.write(bytes.subarray(progressOffset)));
           progressOffset = bytes.length;
         } catch {
@@ -2391,109 +2863,146 @@ async function runInstallEntry(entry2, cwd, env, installer, tokens = null) {
       return { ...result, ok: false, code: result.code || 1, error: "installer outcome: invalid child result" };
     }
   } finally {
-    if (existsSync7(progressFile)) unlinkSync2(progressFile);
-    if (existsSync7(outcomeFile)) unlinkSync2(outcomeFile);
+    if (existsSync8(progressFile)) unlinkSync2(progressFile);
+    if (existsSync8(outcomeFile)) unlinkSync2(outcomeFile);
     rmdirSync(outcomeDir);
   }
 }
-function doForward(config, dir, options, command2, argv2, print, unlock) {
-  if (command2 && existsSync7(command2)) {
-    print(`${command2} is a file, not a command \u2014 did you mean \`--run ${command2}\`?`);
-    return 2;
+function armState(arm) {
+  if (arm.verdict === "fail") return "failed";
+  if (arm.verdict === "defer") return "retry";
+  if (arm.verdict === "skip") return "kept";
+  return arm.from === arm.to ? "current" : "updated";
+}
+function doForward(config, dir, options, command2, rest, ui, unlock) {
+  if (existsSync8(command2)) {
+    return ui.refuse(`${command2} is a file, not a command.`, `${ui.bin} --run ${command2}`, 2);
   }
   const acquired = readState(dir)?.acquired;
   const target = acquired ? [acquired.node, acquired.entry] : readPayloadRun(dir);
   const verbs = readPayloadVerbs(dir);
-  const declared = verbs === "*" || Array.isArray(verbs) && command2 !== void 0 && verbs.includes(command2);
-  if (!target || !declared) {
-    print(`unknown command: ${command2}`);
-    printUsage(config, print);
-    return 2;
-  }
-  const forwarded = [...resolveEntry(target), ...argv2];
+  const declared = verbs === "*" || Array.isArray(verbs) && verbs.includes(command2);
+  if (!target || !declared) return ui.refuse(`Unknown command: ${command2}.`, `${ui.bin} --help`, 2);
+  const forwarded = [...resolveEntry(target), command2, ...rest];
   const cwd = payloadDir(dir);
   const inherited = payloadEnv(dir);
   const env = acquired ? runtimeEnvironment(acquired.node, inherited ?? process.env) : inherited;
   unlock();
   const result = (options.runEntry ?? defaultRunEntry)(forwarded, cwd, env);
   if (!result.ok && result.code === void 0) {
-    print(`failed: ${result.error ?? `could not run ${forwarded[0]}`}`);
-    return 1;
+    return ui.refuse(`Could not start ${config.product}: ${sentence(result.error ?? `could not run ${forwarded[0]}`)}`, `${ui.bin} doctor`);
   }
   return result.code ?? 0;
 }
-function doAutoupdate(config, options, args, print) {
+function doAutoupdate(config, dir, options, args, ui) {
   const mode = args[0] ?? "status";
-  const scheduleOptions = options.autoupdate ?? {};
+  const scheduleOptions = { stateDir: dir, ...options.autoupdate };
   const command2 = options.autoupdate?.command ?? [process.execPath, "update"];
-  if (mode === "on") {
-    try {
-      enableSchedule(config, command2, scheduleOptions);
-    } catch (error) {
-      print(error.message);
-      return 1;
-    }
-    const state2 = querySchedule(config, scheduleOptions);
-    print(`auto-update: on (${state2.cadence ?? "hourly"})`);
-    return 0;
-  }
-  if (mode === "off") {
+  const name = identityFor(ui.product).name;
+  if (mode === "on" || mode === "off") {
     try {
-      disableSchedule(config, scheduleOptions);
+      if (mode === "on") enableSchedule(config, command2, scheduleOptions);
+      else disableSchedule(config, scheduleOptions);
     } catch (error) {
-      print(error.message);
-      return 1;
+      return ui.refuse(sentence(error.message), `${ui.bin} doctor`);
     }
-    print("auto-update: off");
+    if (mode === "on") ui.notice("ok", `Auto-update is on. ${name} checks for updates every hour.`, `${ui.bin} autoupdate status`);
+    else ui.notice("ok", "Auto-update is off.", `${ui.bin} autoupdate on`);
     return 0;
   }
-  if (mode !== "status") {
-    print(`unknown autoupdate mode: ${mode} \u2014 use on, off or status.`);
-    return 1;
-  }
+  if (mode !== "status") return ui.refuse(`Unknown autoupdate mode: ${mode}.`, `${ui.bin} autoupdate status`, 2);
   const state = querySchedule(config, scheduleOptions);
-  if (!state.supported) {
-    print("auto-update: unsupported on this platform");
-    return 1;
-  }
-  print(`auto-update: ${state.enabled ? `on (${state.cadence ?? "hourly"})` : "off"}`);
-  if (state.lastRun) print(`last run:    ${state.lastRun}`);
+  if (!state.supported) return ui.refuse("Auto-update is not supported on this platform.", `${ui.bin} update`);
+  if (state.enabled) ui.notice("ok", `Auto-update is on and runs every hour.${state.lastRun ? ` Last run: ${state.lastRun}.` : ""}`);
+  else ui.notice("note", "Auto-update is off.", `${ui.bin} autoupdate on`);
   return 0;
 }
-function doDoctor(config, dir, options, print, unlock) {
-  doLauncherDoctor(config, dir, options, print);
+function localFacts(config, dir, options) {
+  const state = readState(dir);
+  const tokens = readTokens(dir);
+  const expired = Boolean(tokens && tokens.expiresAt <= Date.now());
+  return {
+    installed: state && existsSync8(payloadDir(dir)) ? state.version : null,
+    // An expired access token with a refresh token renews on the next use; it is still signed in.
+    signedIn: Boolean(tokens && (!expired || tokens.refreshToken)),
+    expired,
+    schedule: querySchedule(config, { stateDir: dir, ...options.autoupdate })
+  };
+}
+function signInRow(local) {
+  if (local.signedIn) return { surface: "sign-in", state: local.expired ? "signed in \xB7 renews on next use" : "signed in", mark: "ok" };
+  return { surface: "sign-in", state: local.expired ? "expired" : "signed out", mark: "fail" };
+}
+function autoUpdateRow({ supported, enabled, cadence, lastRun }) {
+  if (!supported) return { surface: AUTO_UPDATE, state: "unsupported on this platform", mark: "note" };
+  if (!enabled) return { surface: AUTO_UPDATE, state: "off", mark: "note" };
+  return { surface: AUTO_UPDATE, state: `on \xB7 ${cadence ?? "hourly"}`, mark: "ok", ...lastRun ? { note: `Last run: ${lastRun}` } : {} };
+}
+function verdictFor(ui, local, updateAvailable, ready) {
+  if (!local.installed) return { state: "fail", headline: "is not installed.", next: `${ui.bin} install` };
+  if (!local.signedIn) return { state: "fail", headline: "is signed out.", next: `${ui.bin} login` };
+  if (updateAvailable) return { state: "note", headline: "has an update available.", next: `${ui.bin} update` };
+  return { state: "ok", headline: "is ready.", next: ready };
+}
+function within(fetchImpl, ms) {
+  return ((input, init) => fetchImpl(input, { ...init, signal: AbortSignal.timeout(ms) }));
+}
+var STATUS_PROBE_MS = 3e3;
+async function doStatus(config, dir, options, ui, print, json) {
+  const fetchImpl = within(options.fetchImpl ?? fetch, STATUS_PROBE_MS);
+  const local = localFacts(config, dir, options);
+  const [release, record] = await Promise.all([
+    fetchReleaseVersion(config, fetchImpl),
+    readLauncherRecord(launcherTarget(config), { fetch: fetchImpl, timeoutMs: STATUS_PROBE_MS })
+  ]);
+  const launcherNewer = record !== null && compareVersions(record.version, LAUNCHER_VERSION) > 0;
+  const releaseOrder = local.installed && release ? compareVersions(release, local.installed) : null;
+  const verdict = verdictFor(ui, local, launcherNewer || (releaseOrder ?? 0) > 0, `${ui.bin} doctor`);
+  if (json) {
+    print(JSON.stringify({
+      product: config.product,
+      launcher: { version: LAUNCHER_VERSION, available: launcherNewer ? record.version : null },
+      installed: local.installed,
+      release,
+      signIn: local.signedIn ? local.expired ? "renews" : "signed-in" : local.expired ? "expired" : "signed-out",
+      autoupdate: { supported: local.schedule.supported, enabled: local.schedule.enabled, lastRun: local.schedule.lastRun ?? null },
+      verdict: verdict.state,
+      next: verdict.next
+    }, null, 2));
+    return verdict.state === "fail" ? 1 : 0;
+  }
+  const launcherRow = record === null ? { surface: "launcher", state: `${LAUNCHER_VERSION} \xB7 ${SURFACE_WORDS.unknown}`, mark: "note" } : launcherNewer ? { surface: "launcher", state: `${LAUNCHER_VERSION} \u2192 ${record.version} \xB7 ${SURFACE_WORDS.behind}`, mark: "note" } : { surface: "launcher", state: `${LAUNCHER_VERSION} \xB7 ${SURFACE_WORDS.current}`, mark: "ok" };
+  const productRow = !local.installed ? { surface: config.product, state: SURFACE_WORDS.missing, mark: "fail" } : releaseOrder === null ? { surface: config.product, state: `${local.installed} \xB7 ${SURFACE_WORDS.unknown}`, mark: "note" } : releaseOrder > 0 ? { surface: config.product, state: `${local.installed} \u2192 ${release} \xB7 ${SURFACE_WORDS.behind}`, mark: "note" } : releaseOrder < 0 ? { surface: config.product, state: `${local.installed} \xB7 ${SURFACE_WORDS.ahead}`, mark: "note" } : { surface: config.product, state: `${local.installed} \xB7 ${SURFACE_WORDS.current}`, mark: "ok" };
+  ui.show(renderReport(ui.product, {
+    rows: [launcherRow, productRow, signInRow(local), autoUpdateRow(local.schedule)],
+    verdict: { ...verdict, facts: [release ? `The release is ${release}.` : "The release version could not be read."] }
+  }, ui.render));
+  return verdict.state === "fail" ? 1 : 0;
+}
+function doDoctor(config, dir, options, ui) {
+  const local = localFacts(config, dir, options);
+  const verdict = verdictFor(ui, local, false, `${ui.bin} status`);
+  ui.show(renderReport(ui.product, {
+    rows: [
+      { surface: "launcher", state: LAUNCHER_VERSION, mark: "ok" },
+      local.installed ? { surface: config.product, state: local.installed, mark: "ok" } : { surface: config.product, state: SURFACE_WORDS.missing, mark: "fail" },
+      signInRow(local),
+      autoUpdateRow(local.schedule)
+    ],
+    // Paths belong in the receipt, never a row.
+    verdict: { ...verdict, facts: [`Folder: ${dir}`, `Release host: ${config.host}`] }
+  }, ui.render));
+  const own = verdict.state === "fail" ? 1 : 0;
   const acquired = readState(dir)?.acquired;
   const target = acquired ? [acquired.node, acquired.entry] : readPayloadRun(dir);
   const verbs = readPayloadVerbs(dir);
   const chains = target !== null && (verbs === "*" || Array.isArray(verbs) && verbs.includes("doctor"));
-  if (!chains) return 0;
+  if (!chains) return own;
   const cwd = payloadDir(dir);
   const inherited = payloadEnv(dir);
   const env = acquired ? runtimeEnvironment(acquired.node, inherited ?? process.env) : inherited;
-  unlock();
   const result = (options.runEntry ?? defaultRunEntry)([...resolveEntry(target), "doctor"], cwd, env);
-  return result.code ?? (result.ok ? 0 : 1);
-}
-function doLauncherDoctor(config, dir, options, print) {
-  const tokens = readTokens(dir);
-  const state = readState(dir);
-  const payloadPresent = existsSync7(payloadDir(dir));
-  print(`product:  ${config.product}`);
-  print(`host:     ${config.host}`);
-  print(`login:    ${config.loginKind}`);
-  print(`dir:      ${dir}`);
-  if (tokens) {
-    const remaining = Math.max(0, Math.round((tokens.expiresAt - Date.now()) / 1e3));
-    print(`token:    present (expires in ${remaining}s)`);
-  } else {
-    print("token:    none \u2014 run login first.");
-  }
-  print(`payload:  ${state ? state.version : "none"}${payloadPresent ? "" : " (not downloaded)"}`);
-  print(`paths:    tokens ${join6(dir, "tokens.json")}, state ${join6(dir, "state.json")}, payload ${payloadDir(dir)}`);
-  const schedule = querySchedule(config, options.autoupdate ?? {});
-  print(
-    `auto-update: ${!schedule.supported ? "unsupported on this platform" : schedule.enabled ? `on (${schedule.cadence ?? "hourly"})` : "off"}`
-  );
+  return (result.code ?? (result.ok ? 0 : 1)) || own;
 }
 var invokedAsMain = typeof process.argv[1] === "string" && (() => {
   try {
@@ -2512,8 +3021,7 @@ if (invokedAsMain) {
       process.exitCode = code;
     },
     (error) => {
-      process.stderr.write(`failed: ${error.message}
-`);
+      printScreen(renderNotice(NO_PRODUCT, { state: "fail", message: sentence(error.message) }, { color: false }), "stderr");
       process.exitCode = 1;
     }
   );
@@ -2523,6 +3031,7 @@ export {
   defaultRunEntry,
   ensureFreshToken,
   formatMb,
+  parseArgv,
   readPayloadEntry,
   readPayloadRun,
   readPayloadVerbs,