@mutmutco/installer-launcher 0.1.2 → 0.1.4

package/dist/launcher.js

@@ -1,13 +1,319 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { spawnSync } from "node:child_process";
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
-import { dirname as dirname2, join as join3, resolve } from "node:path";
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { existsSync as existsSync4, readFileSync as readFileSync4, statSync } from "node:fs";
+import { dirname as dirname2, join as join4, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL as pathToFileURL2 } from "node:url";
 
+// node_modules/@mutmutco/installer-face/dist/index.js
+var PRODUCTS = Object.freeze({
+  "mm-strategy": Object.freeze({
+    name: "MM Strategy",
+    accent: "38;2;249;115;22",
+    warm: "Welcome. Let's set up MM Strategy \u2014 about a minute."
+  }),
+  "mmi-hub": Object.freeze({
+    name: "mmi-hub",
+    accent: "38;2;125;211;252",
+    warm: "Welcome back. Checking your surfaces\u2026"
+  }),
+  "jerv-hub": Object.freeze({
+    name: "jerv-hub",
+    accent: "38;2;248;113;113",
+    warm: "Welcome back. Checking your surfaces\u2026"
+  }),
+  jervcode: Object.freeze({
+    name: "JervCode",
+    accent: "38;2;192;132;252",
+    warm: "Welcome back. Keeping JervCode current\u2026"
+  })
+});
+function identityFor(product) {
+  const identity = PRODUCTS[product];
+  if (!identity) {
+    throw new Error(`unknown product ${JSON.stringify(product)} \u2014 add it to installer/face/src/products.ts rather than composing a greeting locally (known: ${Object.keys(PRODUCTS).join(", ")})`);
+  }
+  return identity;
+}
+var GLYPH = Object.freeze({
+  diamond: "\u25C6",
+  hollow: "\u25C7",
+  bar: "\u2502",
+  check: "\u2714",
+  cross: "\u2716",
+  dot: "\u25CF",
+  boxTop: "\u256D",
+  boxTopEnd: "\u256E",
+  boxBottom: "\u2570",
+  boxBottomEnd: "\u256F",
+  rule: "\u2500"
+});
+var PALETTE = Object.freeze({
+  green: "38;2;31;209;138",
+  ink: "38;2;237;237;237",
+  muted: "38;2;150;150;150",
+  line: "38;2;42;42;42"
+});
+var TITLE_COLUMN = 6;
+var ANSI = /\u001b\[[0-9;]*m/g;
+function visibleWidth(text) {
+  return [...String(text).replace(ANSI, "")].length;
+}
+function faceWidth(columns) {
+  const raw = Number(columns);
+  return Math.max(40, Math.min(100, Number.isFinite(raw) && raw > 0 ? raw : 100));
+}
+function wrapWords(text, width) {
+  const limit = Math.max(8, Math.floor(width));
+  const lines = [];
+  let line = "";
+  for (const word of String(text).split(/\s+/u).filter(Boolean)) {
+    let token = word;
+    while (visibleWidth(token) > limit) {
+      if (line) {
+        lines.push(line);
+        line = "";
+      }
+      lines.push([...token].slice(0, limit).join(""));
+      token = [...token].slice(limit).join("");
+    }
+    if (!line) line = token;
+    else if (visibleWidth(line) + 1 + visibleWidth(token) <= limit) line += ` ${token}`;
+    else {
+      lines.push(line);
+      line = token;
+    }
+  }
+  if (line) lines.push(line);
+  return lines.length ? lines : [""];
+}
+function createFace({ product, color = false, columns }) {
+  const identity = identityFor(product);
+  const width = faceWidth(columns);
+  const paint = (sgr, text) => color ? `\x1B[${sgr}m${text}\x1B[0m` : String(text);
+  const bar = () => paint(PALETTE.muted, GLYPH.bar);
+  const indent = " ".repeat(TITLE_COLUMN - 1);
+  const welcome = () => [
+    `${paint(identity.accent, GLYPH.diamond)}  ${paint(identity.accent, identity.name)} \u2014 Mutatis Mutandis`,
+    bar(),
+    `${bar()}  ${identity.warm}`,
+    bar()
+  ];
+  const step = (title, seconds = null, kind = "ok") => {
+    const glyph = kind === "fail" ? paint(identity.accent, GLYPH.cross) : kind === "note" ? paint(PALETTE.muted, GLYPH.hollow) : paint(PALETTE.green, GLYPH.check);
+    const time = seconds === null || seconds === void 0 ? "" : paint(PALETTE.muted, `${Math.max(0, Math.round(seconds))}s`);
+    const column = Math.min(44, Math.max(0, width - 8));
+    const reserved = time ? 6 : 0;
+    const [first, ...rest] = wrapWords(title, width - TITLE_COLUMN - reserved);
+    const head = `${bar()}  ${glyph}  ${first}`;
+    const pad = Math.max(1, column - visibleWidth(head));
+    return [time ? `${head}${" ".repeat(pad)}${time}` : head, ...rest.map((line) => `${bar()}${indent}${line}`)].join("\n");
+  };
+  const relay = (text) => String(text).split("\n").map((line) => line.trim() === "" ? bar() : `${bar()}${indent}${line}`).join("\n");
+  const receipt = (lines) => {
+    const body = (Array.isArray(lines) ? lines : String(lines).split("\n")).flatMap((raw) => {
+      const line = String(raw);
+      if (visibleWidth(line) <= width - 6) return [line];
+      const lead = /^\s*/u.exec(line)?.[0] ?? "";
+      return wrapWords(line, width - 6 - lead.length).map((part) => `${lead}${part}`);
+    });
+    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(PALETTE.green, GLYPH.check)}${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)}`),
+      frame(GLYPH.boxBottom, GLYPH.boxBottomEnd)
+    ];
+  };
+  const signOff = () => `${paint(identity.accent, GLYPH.diamond)}  ${paint(identity.accent, `${identity.name} \xB7 Mutatis Mutandis`)}`;
+  const refusal = (message) => `${bar()}  ${paint(identity.accent, GLYPH.cross)}  ${message}`;
+  return { identity, width, welcome, step, relay, receipt, signOff, refusal, paint };
+}
+var RELAY_INDENT = " ".repeat(TITLE_COLUMN - 1);
+var FRAMES = ["\u25D2", "\u25D0", "\u25D3", "\u25D1"];
+var SPINNER_FRAMES = Object.freeze([...FRAMES]);
+var ALLOWED = new Set(Object.values(GLYPH));
+
+// src/autoupdate.ts
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+function schedulePlatform(override) {
+  const platform = override ?? process.platform;
+  if (platform === "win32" || platform === "darwin" || platform === "linux") return platform;
+  return null;
+}
+function defaultExec(command, args) {
+  const result = spawnSync(command, args, { encoding: "utf8", windowsHide: true });
+  if (result.error) return { code: 1, stdout: "", stderr: result.error.message };
+  return {
+    code: typeof result.status === "number" ? result.status : 1,
+    stdout: String(result.stdout ?? ""),
+    stderr: String(result.stderr ?? "")
+  };
+}
+function homeOf(options) {
+  if (options.homeDir) return options.homeDir;
+  if (process.platform === "win32") return process.env.USERPROFILE ?? tmpdir();
+  return process.env.HOME ?? tmpdir();
+}
+function scheduleName(config) {
+  return `${config.binName} autoupdate`;
+}
+function scheduleLabel(config) {
+  return `${config.binName}-autoupdate`.replace(/[^A-Za-z0-9_-]+/g, "-");
+}
+function quoteWindows(arg) {
+  return /[\s"&|<>^%]/.test(arg) ? `"${arg.replace(/"/g, '\\"')}"` : arg;
+}
+function enableSchedule(config, command, options = {}) {
+  const platform = schedulePlatform(options.platform);
+  if (!platform) throw new Error(`autoupdate is not supported on ${options.platform ?? process.platform}.`);
+  const exec = options.exec ?? defaultExec;
+  const home = homeOf(options);
+  if (platform === "win32") {
+    const taskLine = command.map(quoteWindows).join(" ");
+    const result2 = exec("schtasks", ["/Create", "/TN", scheduleName(config), "/TR", taskLine, "/SC", "HOURLY", "/IT", "/F"]);
+    if (result2.code !== 0) {
+      throw new Error(`could not turn autoupdate on: ${firstLine(result2.stdout || result2.stderr) || `exit ${result2.code}`}`);
+    }
+    return;
+  }
+  if (platform === "darwin") {
+    const label2 = scheduleLabel(config);
+    const dir2 = join(home, "Library", "LaunchAgents");
+    mkdirSync(dir2, { recursive: true });
+    const plist = join(dir2, `${label2}.plist`);
+    writeFileSync(plist, darwinPlist(label2, command));
+    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}`}`);
+    }
+    return;
+  }
+  const label = scheduleLabel(config);
+  const dir = join(home, ".config", "systemd", "user");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${label}.service`), linuxService(command));
+  writeFileSync(join(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}`}`);
+  }
+  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}`}`);
+  }
+}
+function disableSchedule(config, options = {}) {
+  const platform = schedulePlatform(options.platform);
+  if (!platform) throw new Error(`autoupdate 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}`}`);
+    }
+    return;
+  }
+  if (platform === "darwin") {
+    const label2 = scheduleLabel(config);
+    exec("launchctl", ["bootout", `gui/${process.getuid?.() ?? 501}/${label2}`]);
+    rmSync(join(home, "Library", "LaunchAgents", `${label2}.plist`), { force: true });
+    return;
+  }
+  const label = scheduleLabel(config);
+  const dir = join(home, ".config", "systemd", "user");
+  exec("systemctl", ["--user", "disable", "--now", `${label}.timer`]);
+  rmSync(join(dir, `${label}.service`), { force: true });
+  rmSync(join(dir, `${label}.timer`), { force: true });
+}
+function querySchedule(config, options = {}) {
+  const platform = schedulePlatform(options.platform);
+  if (!platform) return { supported: false, enabled: false };
+  const exec = options.exec ?? defaultExec;
+  const home = homeOf(options);
+  if (platform === "win32") {
+    const result = exec("schtasks", ["/Query", "/TN", scheduleName(config), "/FO", "LIST", "/V"]);
+    if (result.code !== 0) return { supported: true, enabled: false };
+    const lastRun = valueOf(result.stdout, "Last Run Time:");
+    const nextRun = valueOf(result.stdout, "Next Run Time:");
+    const state2 = { supported: true, enabled: true, cadence: "hourly" };
+    if (lastRun && !/disabled|never|not run/i.test(lastRun)) state2.lastRun = lastRun;
+    else if (nextRun && !/disabled|never/i.test(nextRun)) state2.lastRun = `next run ${nextRun}`;
+    return state2;
+  }
+  if (platform === "darwin") {
+    const plist = join(home, "Library", "LaunchAgents", `${scheduleLabel(config)}.plist`);
+    if (!existsSync(plist)) return { supported: true, enabled: false };
+    return { supported: true, enabled: true, cadence: "hourly" };
+  }
+  const timer = join(home, ".config", "systemd", "user", `${scheduleLabel(config)}.timer`);
+  if (!existsSync(timer)) return { supported: true, enabled: false };
+  const state = { supported: true, enabled: true, cadence: "hourly" };
+  const shown = exec("systemctl", ["--user", "show", `${scheduleLabel(config)}.service`, "-p", "ExecMainStartTimestamp", "--value"]);
+  const stamp = (shown.stdout ?? "").trim();
+  if (shown.code === 0 && stamp && stamp !== "n/a") state.lastRun = stamp;
+  return state;
+}
+function darwinPlist(label, command) {
+  const args = command.map((arg) => `        <string>${xmlEscape(arg)}</string>`).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <key>Label</key>
+    <string>${xmlEscape(label)}</string>
+    <key>ProgramArguments</key>
+    <array>
+${args}
+    </array>
+    <key>StartInterval</key>
+    <integer>3600</integer>
+  </dict>
+</plist>
+`;
+}
+function linuxService(command) {
+  const line = command.map((arg) => /[\s"\\]/.test(arg) ? `"${arg.replace(/(["\\])/g, "\\$1")}"` : arg).join(" ");
+  return `[Unit]
+Description=${"Hourly update check"}
+[Service]
+Type=oneshot
+ExecStart=${line}
+`;
+}
+function linuxTimer(label) {
+  return `[Unit]
+Description=Hourly update check for ${label}
+[Timer]
+OnCalendar=hourly
+Persistent=true
+[Install]
+WantedBy=timers.target
+`;
+}
+function xmlEscape(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function valueOf(output, key) {
+  const line = output.split(/\r?\n/).find((candidate) => candidate.trimStart().startsWith(key));
+  if (!line) return null;
+  const value = line.slice(line.indexOf(key) + key.length).trim();
+  return value ? value : null;
+}
+function firstLine(text) {
+  return String(text).split(/\r?\n/).map((line) => line.trim()).filter(Boolean)[0] ?? "";
+}
+
 // src/config.ts
-import { readFileSync } from "node:fs";
+import { readFileSync as readFileSync2 } from "node:fs";
 import { getAsset } from "node:sea";
 
 // src/module-url.ts
@@ -29,10 +335,10 @@ function loadProductConfig(options = {}) {
   const explicit = options.configPath ?? process.env.LAUNCHER_CONFIG;
   const devFallback = new URL("../config/product.template.json", moduleUrl());
   if (explicit) {
-    return parseProductConfig(readFileSync(explicit, "utf8"));
+    return parseProductConfig(readFileSync2(explicit, "utf8"));
   }
   try {
-    return parseProductConfig(readFileSync(devFallback, "utf8"));
+    return parseProductConfig(readFileSync2(devFallback, "utf8"));
   } catch {
   }
   try {
@@ -321,9 +627,9 @@ function page(title, body) {
 
 // src/payload.ts
 import { createHash as createHash2, createPublicKey, verify } from "node:crypto";
-import { mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
+import { mkdirSync as mkdirSync2, renameSync, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import { dirname, join as join2 } from "node:path";
 
 // src/canonical.ts
 function canonicalJson(value) {
@@ -463,56 +769,56 @@ async function fetchFileBytes(config, accessToken, path, fetchImpl) {
 }
 async function downloadAndUnpack(config, dir, manifest, accessToken, options = {}) {
   const fetchImpl = options.fetchImpl ?? fetch;
-  const staging = join(tmpdir(), `launcher-${config.product}-${Date.now()}-${Math.floor(Math.random() * 1e6)}`);
-  mkdirSync(staging, { recursive: true });
+  const staging = join2(tmpdir2(), `launcher-${config.product}-${Date.now()}-${Math.floor(Math.random() * 1e6)}`);
+  mkdirSync2(staging, { recursive: true });
   try {
     for (const entry of manifest.files) {
       const bytes = await fetchFileBytes(config, accessToken, entry.path, fetchImpl);
       if (!verifyFileBytes(entry, bytes)) {
         throw new Error(`file ${entry.path} failed its checksum \u2014 refusing to install anything.`);
       }
-      const dest = join(staging, entry.path);
-      mkdirSync(dirname(dest), { recursive: true });
-      writeFileSync(dest, bytes);
+      const dest = join2(staging, entry.path);
+      mkdirSync2(dirname(dest), { recursive: true });
+      writeFileSync2(dest, bytes);
     }
-    const target = join(dir, "payload");
-    mkdirSync(dir, { recursive: true });
-    rmSync(target, { force: true, recursive: true });
+    const target = join2(dir, "payload");
+    mkdirSync2(dir, { recursive: true });
+    rmSync2(target, { force: true, recursive: true });
     renameSync(staging, target);
   } catch (error) {
-    rmSync(staging, { force: true, recursive: true });
+    rmSync2(staging, { force: true, recursive: true });
     throw error;
   }
   return manifest.version;
 }
 
 // src/store.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { tmpdir as tmpdir2 } from "node:os";
-import { join as join2 } from "node:path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { tmpdir as tmpdir3 } from "node:os";
+import { join as join3 } from "node:path";
 function defaultProductDir(product) {
   if (process.platform === "win32") {
-    const base = process.env.LOCALAPPDATA ?? join2(tmpdir2(), "launcher-fallback");
-    return join2(base, product);
+    const base = process.env.LOCALAPPDATA ?? join3(tmpdir3(), "launcher-fallback");
+    return join3(base, product);
   }
-  const home = process.env.HOME ?? tmpdir2();
-  return join2(home, `.${product}`);
+  const home = process.env.HOME ?? tmpdir3();
+  return join3(home, `.${product}`);
 }
 function resolveProductDir(product, explicit) {
   return explicit ?? process.env.LAUNCHER_DIR ?? defaultProductDir(product);
 }
 function tokensPath(dir) {
-  return join2(dir, "tokens.json");
+  return join3(dir, "tokens.json");
 }
 function statePath(dir) {
-  return join2(dir, "state.json");
+  return join3(dir, "state.json");
 }
 function payloadDir(dir) {
-  return join2(dir, "payload");
+  return join3(dir, "payload");
 }
 function readTokens(dir) {
   try {
-    const data = JSON.parse(readFileSync2(tokensPath(dir), "utf8"));
+    const data = JSON.parse(readFileSync3(tokensPath(dir), "utf8"));
     if (typeof data.accessToken !== "string" || !data.accessToken) return null;
     if (typeof data.expiresAt !== "number" || !Number.isFinite(data.expiresAt)) return null;
     const tokens = { accessToken: data.accessToken, expiresAt: data.expiresAt };
@@ -524,21 +830,21 @@ function readTokens(dir) {
   }
 }
 function writeTokens(dir, tokens) {
-  mkdirSync2(dir, { recursive: true });
+  mkdirSync3(dir, { recursive: true });
   try {
-    writeFileSync2(tokensPath(dir), `${JSON.stringify(tokens)}
+    writeFileSync3(tokensPath(dir), `${JSON.stringify(tokens)}
 `, { mode: 384 });
   } catch {
-    writeFileSync2(tokensPath(dir), `${JSON.stringify(tokens)}
+    writeFileSync3(tokensPath(dir), `${JSON.stringify(tokens)}
 `);
   }
 }
 function clearTokens(dir) {
-  rmSync2(tokensPath(dir), { force: true });
+  rmSync3(tokensPath(dir), { force: true });
 }
 function readState(dir) {
   try {
-    const data = JSON.parse(readFileSync2(statePath(dir), "utf8"));
+    const data = JSON.parse(readFileSync3(statePath(dir), "utf8"));
     if (typeof data.version !== "string" || !data.version) return null;
     return { version: data.version, updatedAt: typeof data.updatedAt === "string" ? data.updatedAt : "" };
   } catch {
@@ -546,18 +852,18 @@ function readState(dir) {
   }
 }
 function writeState(dir, state) {
-  mkdirSync2(dir, { recursive: true });
-  writeFileSync2(statePath(dir), `${JSON.stringify(state, null, 2)}
+  mkdirSync3(dir, { recursive: true });
+  writeFileSync3(statePath(dir), `${JSON.stringify(state, null, 2)}
 `);
 }
 function wipeProductDir(dir) {
-  rmSync2(tokensPath(dir), { force: true });
-  rmSync2(statePath(dir), { force: true });
-  rmSync2(payloadDir(dir), { force: true, recursive: true });
+  rmSync3(tokensPath(dir), { force: true });
+  rmSync3(statePath(dir), { force: true });
+  rmSync3(payloadDir(dir), { force: true, recursive: true });
 }
 
 // src/index.ts
-var LAUNCHER_VERSION = true ? "0.1.2" : readVersionFromPackage();
+var LAUNCHER_VERSION = true ? "0.1.4" : readVersionFromPackage();
 function defaultPrint(message) {
   process.stdout.write(`${message}
 `);
@@ -604,12 +910,11 @@ async function run(rawOptions = {}) {
       case "update":
         return await doUpdate(config, dir, rawOptions, print);
       case "doctor":
-        doDoctor(config, dir, print);
-        return 0;
+        return doDoctor(config, dir, rawOptions, print);
+      case "autoupdate":
+        return doAutoupdate(config, rawOptions, positional.slice(1), print);
       default:
-        print(`unknown command: ${command}`);
-        printUsage(config, print);
-        return 2;
+        return doForward(config, dir, rawOptions, command, argv, print);
     }
   } catch (error) {
     if (error instanceof NeedsLoginError) {
@@ -628,8 +933,9 @@ function flagValue(argv, flag) {
 }
 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> [--config <path>] [--dir <path>]");
+  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)");
 }
 async function runFile(file, args, printErr) {
   if (!file) {
@@ -637,7 +943,7 @@ async function runFile(file, args, printErr) {
     return 1;
   }
   const abs = resolve(process.cwd(), file);
-  if (!existsSync3(abs)) {
+  if (!existsSync4(abs)) {
     printErr(`cannot run ${file}: no such file.`);
     return 1;
   }
@@ -723,10 +1029,10 @@ async function fetchAccessTokenOrLogin(config, dir, options, print) {
   if (!after) throw new Error("sign-in did not produce a token");
   return after.accessToken;
 }
-function readPayloadEntry(dir) {
+function readPayloadArgv(dir, key) {
   try {
-    const parsed = JSON.parse(readFileSync3(join3(payloadDir(dir), "payload.json"), "utf8"));
-    const entry = parsed.entry;
+    const parsed = JSON.parse(readFileSync4(join4(payloadDir(dir), "payload.json"), "utf8"));
+    const entry = parsed[key];
     if (typeof entry === "string") {
       const parts = entry.trim().split(/\s+/).filter(Boolean);
       return parts.length > 0 ? parts : null;
@@ -739,67 +1045,251 @@ function readPayloadEntry(dir) {
     return null;
   }
 }
+function readPayloadEntry(dir) {
+  return readPayloadArgv(dir, "entry");
+}
+function readPayloadRun(dir) {
+  return readPayloadArgv(dir, "run");
+}
+function readPayloadVerbs(dir) {
+  try {
+    const parsed = JSON.parse(readFileSync4(join4(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)) {
+      return verbs;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
 function resolveEntry(entry) {
   return entry[0] === "$self" ? [process.execPath, ...entry.slice(1)] : entry;
 }
 function needsShell(command) {
   if (process.platform !== "win32") return false;
   if (/\.(cmd|bat)$/i.test(command)) return true;
-  return !existsSync3(command);
+  return !existsSync4(command);
+}
+function quoteForShell(arg) {
+  return /[\s"&|<>^%]/.test(arg) ? `"${arg.replace(/"/g, '\\"')}"` : arg;
 }
-function defaultRunEntry(entry, cwd) {
+function defaultRunEntry(entry, cwd, env) {
   const [command, ...args] = entry;
-  const result = spawnSync(command, args, {
+  const shell = needsShell(command);
+  const commandLine = shell ? [command, ...args].map(quoteForShell).join(" ") : command;
+  const result = spawnSync2(commandLine, shell ? [] : args, {
     cwd,
     stdio: "inherit",
-    shell: needsShell(command),
+    shell,
+    env: env ?? process.env,
     windowsHide: true
   });
   if (result.error) return { ok: false, error: result.error.message };
-  return { ok: result.status === 0, error: result.status === 0 ? void 0 : `exit code ${result.status}` };
+  const code = typeof result.status === "number" ? result.status : void 0;
+  return { ok: result.status === 0, error: result.status === 0 ? void 0 : `exit code ${result.status}`, code };
+}
+function faceProduct(config) {
+  const known = { mmi: "mmi-hub", jerv: "jerv-hub" };
+  return known[config.product] ?? config.product;
+}
+function faceFor(config, options) {
+  const tty = options.tty ?? Boolean(process.stdout.isTTY);
+  if (!tty) return null;
+  try {
+    return createFace({
+      product: faceProduct(config),
+      color: !process.env.NO_COLOR && process.env.TERM !== "dumb",
+      columns: process.stdout.columns
+    });
+  } catch {
+    return null;
+  }
+}
+function since(start) {
+  return (Date.now() - start) / 1e3;
+}
+function printReceipt(face, config, print, ready, lines) {
+  const name = face ? face.identity.name : config.product;
+  const headline = ready ? `${name} is ready.` : `${name} is installed, but not ready yet.`;
+  if (!face) {
+    print(headline);
+    for (const line of lines) print(line.trim());
+    return;
+  }
+  const glyph = ready ? "\u2714" : "\u2716";
+  for (const line of face.receipt([`${glyph}  ${headline}`, ...lines])) print(line);
+  print(face.signOff());
+}
+function printStep(face, print, title, seconds, kind = "ok") {
+  print(face ? face.step(title, seconds, kind) : title);
 }
 async function doInstall(config, dir, options, print) {
   const fetchImpl = options.fetchImpl ?? fetch;
+  const face = faceFor(config, options);
   const accessToken = await fetchAccessTokenOrLogin(config, dir, options, print);
+  const started = Date.now();
   const manifest = await fetchVerifiedManifest(config, accessToken, fetchImpl);
   await downloadAndUnpack(config, dir, manifest, accessToken, { fetchImpl });
   writeState(dir, { version: manifest.version, updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
-  print(`installed ${config.product} ${manifest.version} into ${dir}.`);
+  printStep(face, print, `installed ${config.product} ${manifest.version}`, since(started));
+  return finishLastMile(config, dir, options, print, face, manifest.version);
+}
+async function doUpdate(config, dir, options, print) {
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const face = faceFor(config, options);
+  if (face) for (const line of face.welcome()) print(line);
+  const accessToken = await fetchAccessTokenOrLogin(config, dir, options, print);
+  const started = Date.now();
+  const manifest = await fetchVerifiedManifest(config, accessToken, fetchImpl);
+  const current = readState(dir);
+  if (current && current.version === manifest.version && existsSync4(payloadDir(dir))) {
+    printStep(face, print, `${config.product} is already up to date at ${manifest.version}`, since(started));
+    return finishLastMile(config, dir, options, print, face, manifest.version);
+  }
+  await downloadAndUnpack(config, dir, manifest, accessToken, { fetchImpl });
+  writeState(dir, { version: manifest.version, updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
+  printStep(face, print, `updated ${config.product} to ${manifest.version}`, since(started));
+  return finishLastMile(config, dir, options, print, face, manifest.version);
+}
+function payloadEnv(dir) {
+  const stored = readTokens(dir);
+  if (!stored?.accessToken) return void 0;
+  return { ...process.env, MM_INSTALLER_TOKEN: stored.accessToken };
+}
+var NEVER_A_PROGRAM = /\.(tgz|tar|gz|bz2|xz|zip|json|txt|md|lock)$/i;
+function payloadFileAsCommand(entry, payload) {
+  const first = entry[0];
+  if (!first || first === "$self") return null;
+  if (first.includes("/") || first.includes("\\")) return null;
+  const candidate = join4(payload, first);
+  if (!existsSync4(candidate)) return null;
+  if (NEVER_A_PROGRAM.test(first)) return first;
+  if (process.platform === "win32") return null;
+  try {
+    return (statSync(candidate).mode & 73) === 0 ? first : null;
+  } catch {
+    return null;
+  }
+}
+function finishLastMile(config, dir, options, print, face, version) {
   const entry = readPayloadEntry(dir);
+  const payload = payloadDir(dir);
   if (!entry) {
-    print(`next step: run ${join3(payloadDir(dir), config.binName)} to start ${config.product}.`);
+    printReceipt(face, config, print, true, [
+      `    Installed ${version} into ${dir}`,
+      `    next step: run ${join4(payload, config.binName)} to start ${config.product}.`
+    ]);
     return 0;
   }
-  const payload = payloadDir(dir);
   const command = resolveEntry(entry);
-  const runEntry = options.runEntry ?? defaultRunEntry;
-  const result = runEntry(command, payload);
+  const dataFile = payloadFileAsCommand(entry, payload);
+  if (dataFile) {
+    printStep(face, print, `The payload names ${dataFile} as its command, but that is a file, not a program`, null, "fail");
+    printReceipt(face, config, print, false, [
+      `    Downloaded ${version} into ${dir}`,
+      `    This payload was built wrong: its entry must be a command, not one of its own files.`,
+      `    Nothing on this machine can finish it \u2014 report it to the ${config.product} maintainers.`
+    ]);
+    return 2;
+  }
+  const started = Date.now();
+  const result = (options.runEntry ?? defaultRunEntry)(command, payload, payloadEnv(dir));
   if (result.ok) {
-    print(`${config.product} is ready.`);
+    printStep(face, print, "Armed this machine", since(started));
+    printReceipt(face, config, print, true, [
+      `    Installed ${version} into ${dir}`,
+      `    Check health any time:  ${config.binName} doctor`
+    ]);
     return 0;
   }
-  print(`could not finish the last mile automatically${result.error ? ` (${result.error})` : ""}. Run it yourself:`);
-  print(`  (cd ${payload} && ${command.join(" ")})`);
-  return 0;
+  const code = result.code ?? 1;
+  printStep(
+    face,
+    print,
+    result.code === void 0 ? `Arming this machine could not start: ${result.error ?? `could not run ${command[0]}`}` : `Arming this machine did not finish (exit code ${code})`,
+    null,
+    "fail"
+  );
+  printReceipt(face, config, print, false, [
+    `    Downloaded ${version} into ${dir}`,
+    `    Finish it with:  (cd ${payload} && ${command.join(" ")})`
+  ]);
+  return code;
 }
-async function doUpdate(config, dir, options, print) {
-  const fetchImpl = options.fetchImpl ?? fetch;
-  const accessToken = await fetchAccessTokenOrLogin(config, dir, options, print);
-  const manifest = await fetchVerifiedManifest(config, accessToken, fetchImpl);
-  const current = readState(dir);
-  if (current && current.version === manifest.version && existsSync3(payloadDir(dir))) {
-    print(`${config.product} is already up to date at ${manifest.version}.`);
+function doForward(config, dir, options, command, argv, print) {
+  if (command && existsSync4(command)) {
+    print(`${command} is a file, not a command \u2014 did you mean \`--run ${command}\`?`);
+    return 2;
+  }
+  const target = readPayloadRun(dir);
+  const verbs = readPayloadVerbs(dir);
+  const declared = verbs === "*" || Array.isArray(verbs) && command !== void 0 && verbs.includes(command);
+  if (!target || !declared) {
+    print(`unknown command: ${command}`);
+    printUsage(config, print);
+    return 2;
+  }
+  const forwarded = [...resolveEntry(target), ...argv];
+  const result = (options.runEntry ?? defaultRunEntry)(forwarded, payloadDir(dir), payloadEnv(dir));
+  if (!result.ok && result.code === void 0) {
+    print(`failed: ${result.error ?? `could not run ${forwarded[0]}`}`);
+    return 1;
+  }
+  return result.code ?? 0;
+}
+function doAutoupdate(config, options, args, print) {
+  const mode = args[0] ?? "status";
+  const scheduleOptions = options.autoupdate ?? {};
+  const command = options.autoupdate?.command ?? [process.execPath, "update"];
+  if (mode === "on") {
+    try {
+      enableSchedule(config, command, scheduleOptions);
+    } catch (error) {
+      print(error.message);
+      return 1;
+    }
+    const state2 = querySchedule(config, scheduleOptions);
+    print(`auto-update: on (${state2.cadence ?? "hourly"})`);
     return 0;
   }
-  await downloadAndUnpack(config, dir, manifest, accessToken, { fetchImpl });
-  writeState(dir, { version: manifest.version, updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
-  print(`updated ${config.product} to ${manifest.version}.`);
+  if (mode === "off") {
+    try {
+      disableSchedule(config, scheduleOptions);
+    } catch (error) {
+      print(error.message);
+      return 1;
+    }
+    print("auto-update: off");
+    return 0;
+  }
+  if (mode !== "status") {
+    print(`unknown autoupdate mode: ${mode} \u2014 use on, off or status.`);
+    return 1;
+  }
+  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}`);
   return 0;
 }
-function doDoctor(config, dir, print) {
+function doDoctor(config, dir, options, print) {
+  doLauncherDoctor(config, dir, options, print);
+  const target = readPayloadRun(dir);
+  const verbs = readPayloadVerbs(dir);
+  const chains = target !== null && (verbs === "*" || Array.isArray(verbs) && verbs.includes("doctor"));
+  if (!chains) return 0;
+  const result = (options.runEntry ?? defaultRunEntry)([...resolveEntry(target), "doctor"], payloadDir(dir), payloadEnv(dir));
+  return result.code ?? (result.ok ? 0 : 1);
+}
+function doLauncherDoctor(config, dir, options, print) {
   const tokens = readTokens(dir);
   const state = readState(dir);
-  const payloadPresent = existsSync3(payloadDir(dir));
+  const payloadPresent = existsSync4(payloadDir(dir));
   print(`product:  ${config.product}`);
   print(`host:     ${config.host}`);
   print(`login:    ${config.loginKind}`);
@@ -811,7 +1301,11 @@ function doDoctor(config, dir, print) {
     print("token:    none \u2014 run login first.");
   }
   print(`payload:  ${state ? state.version : "none"}${payloadPresent ? "" : " (not downloaded)"}`);
-  print(`paths:    tokens ${join3(dir, "tokens.json")}, state ${join3(dir, "state.json")}, payload ${payloadDir(dir)}`);
+  print(`paths:    tokens ${join4(dir, "tokens.json")}, state ${join4(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"}`
+  );
 }
 var invokedAsMain = typeof process.argv[1] === "string" && (() => {
   try {
@@ -841,6 +1335,8 @@ export {
   defaultRunEntry,
   ensureFreshToken,
   readPayloadEntry,
+  readPayloadRun,
+  readPayloadVerbs,
   resolveEntry,
   run,
   runFile