@mutmutco/installer-launcher 0.1.2 → 0.1.4

package/dist/launcher.sea.cjs

@@ -24,18 +24,326 @@ __export(index_exports, {
   defaultRunEntry: () => defaultRunEntry,
   ensureFreshToken: () => ensureFreshToken,
   readPayloadEntry: () => readPayloadEntry,
+  readPayloadRun: () => readPayloadRun,
+  readPayloadVerbs: () => readPayloadVerbs,
   resolveEntry: () => resolveEntry,
   run: () => run,
   runFile: () => runFile
 });
 module.exports = __toCommonJS(index_exports);
-var import_node_child_process2 = require("node:child_process");
-var import_node_fs4 = require("node:fs");
-var import_node_path3 = require("node:path");
+var import_node_child_process3 = require("node:child_process");
+var import_node_fs5 = require("node:fs");
+var import_node_path4 = require("node:path");
 var import_node_url2 = require("node:url");
 
-// src/config.ts
+// 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
+var import_node_child_process = require("node:child_process");
 var import_node_fs = require("node:fs");
+var import_node_os = require("node:os");
+var import_node_path = require("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 = (0, import_node_child_process.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 ?? (0, import_node_os.tmpdir)();
+  return process.env.HOME ?? (0, import_node_os.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 = (0, import_node_path.join)(home, "Library", "LaunchAgents");
+    (0, import_node_fs.mkdirSync)(dir2, { recursive: true });
+    const plist = (0, import_node_path.join)(dir2, `${label2}.plist`);
+    (0, import_node_fs.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 = (0, import_node_path.join)(home, ".config", "systemd", "user");
+  (0, import_node_fs.mkdirSync)(dir, { recursive: true });
+  (0, import_node_fs.writeFileSync)((0, import_node_path.join)(dir, `${label}.service`), linuxService(command));
+  (0, import_node_fs.writeFileSync)((0, import_node_path.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}`]);
+    (0, import_node_fs.rmSync)((0, import_node_path.join)(home, "Library", "LaunchAgents", `${label2}.plist`), { force: true });
+    return;
+  }
+  const label = scheduleLabel(config);
+  const dir = (0, import_node_path.join)(home, ".config", "systemd", "user");
+  exec("systemctl", ["--user", "disable", "--now", `${label}.timer`]);
+  (0, import_node_fs.rmSync)((0, import_node_path.join)(dir, `${label}.service`), { force: true });
+  (0, import_node_fs.rmSync)((0, import_node_path.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 = (0, import_node_path.join)(home, "Library", "LaunchAgents", `${scheduleLabel(config)}.plist`);
+    if (!(0, import_node_fs.existsSync)(plist)) return { supported: true, enabled: false };
+    return { supported: true, enabled: true, cadence: "hourly" };
+  }
+  const timer = (0, import_node_path.join)(home, ".config", "systemd", "user", `${scheduleLabel(config)}.timer`);
+  if (!(0, import_node_fs.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
+var import_node_fs2 = require("node:fs");
 var import_node_sea = require("node:sea");
 
 // src/module-url.ts
@@ -58,10 +366,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((0, import_node_fs.readFileSync)(explicit, "utf8"));
+    return parseProductConfig((0, import_node_fs2.readFileSync)(explicit, "utf8"));
   }
   try {
-    return parseProductConfig((0, import_node_fs.readFileSync)(devFallback, "utf8"));
+    return parseProductConfig((0, import_node_fs2.readFileSync)(devFallback, "utf8"));
   } catch {
   }
   try {
@@ -116,14 +424,14 @@ function field(record, key) {
 }
 
 // src/login-github.ts
-var import_node_child_process = require("node:child_process");
+var import_node_child_process2 = require("node:child_process");
 var realSleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
 function openBrowser(url) {
   if (process.env.LAUNCHER_NO_OPEN === "1") return;
   const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "rundll32" : "xdg-open";
   const args = process.platform === "win32" ? ["url.dll,FileProtocolHandler", url] : [url];
   try {
-    const child = (0, import_node_child_process.spawn)(opener, args, { detached: true, stdio: "ignore", windowsHide: true });
+    const child = (0, import_node_child_process2.spawn)(opener, args, { detached: true, stdio: "ignore", windowsHide: true });
     child.on("error", () => {
     });
     child.unref();
@@ -350,9 +658,9 @@ function page(title, body) {
 
 // src/payload.ts
 var import_node_crypto2 = require("node:crypto");
-var import_node_fs2 = require("node:fs");
-var import_node_os = require("node:os");
-var import_node_path = require("node:path");
+var import_node_fs3 = require("node:fs");
+var import_node_os2 = require("node:os");
+var import_node_path2 = require("node:path");
 
 // src/canonical.ts
 function canonicalJson(value) {
@@ -492,56 +800,56 @@ async function fetchFileBytes(config, accessToken, path, fetchImpl) {
 }
 async function downloadAndUnpack(config, dir, manifest, accessToken, options = {}) {
   const fetchImpl = options.fetchImpl ?? fetch;
-  const staging = (0, import_node_path.join)((0, import_node_os.tmpdir)(), `launcher-${config.product}-${Date.now()}-${Math.floor(Math.random() * 1e6)}`);
-  (0, import_node_fs2.mkdirSync)(staging, { recursive: true });
+  const staging = (0, import_node_path2.join)((0, import_node_os2.tmpdir)(), `launcher-${config.product}-${Date.now()}-${Math.floor(Math.random() * 1e6)}`);
+  (0, import_node_fs3.mkdirSync)(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 = (0, import_node_path.join)(staging, entry.path);
-      (0, import_node_fs2.mkdirSync)((0, import_node_path.dirname)(dest), { recursive: true });
-      (0, import_node_fs2.writeFileSync)(dest, bytes);
+      const dest = (0, import_node_path2.join)(staging, entry.path);
+      (0, import_node_fs3.mkdirSync)((0, import_node_path2.dirname)(dest), { recursive: true });
+      (0, import_node_fs3.writeFileSync)(dest, bytes);
     }
-    const target = (0, import_node_path.join)(dir, "payload");
-    (0, import_node_fs2.mkdirSync)(dir, { recursive: true });
-    (0, import_node_fs2.rmSync)(target, { force: true, recursive: true });
-    (0, import_node_fs2.renameSync)(staging, target);
+    const target = (0, import_node_path2.join)(dir, "payload");
+    (0, import_node_fs3.mkdirSync)(dir, { recursive: true });
+    (0, import_node_fs3.rmSync)(target, { force: true, recursive: true });
+    (0, import_node_fs3.renameSync)(staging, target);
   } catch (error) {
-    (0, import_node_fs2.rmSync)(staging, { force: true, recursive: true });
+    (0, import_node_fs3.rmSync)(staging, { force: true, recursive: true });
     throw error;
   }
   return manifest.version;
 }
 
 // src/store.ts
-var import_node_fs3 = require("node:fs");
-var import_node_os2 = require("node:os");
-var import_node_path2 = require("node:path");
+var import_node_fs4 = require("node:fs");
+var import_node_os3 = require("node:os");
+var import_node_path3 = require("node:path");
 function defaultProductDir(product) {
   if (process.platform === "win32") {
-    const base = process.env.LOCALAPPDATA ?? (0, import_node_path2.join)((0, import_node_os2.tmpdir)(), "launcher-fallback");
-    return (0, import_node_path2.join)(base, product);
+    const base = process.env.LOCALAPPDATA ?? (0, import_node_path3.join)((0, import_node_os3.tmpdir)(), "launcher-fallback");
+    return (0, import_node_path3.join)(base, product);
   }
-  const home = process.env.HOME ?? (0, import_node_os2.tmpdir)();
-  return (0, import_node_path2.join)(home, `.${product}`);
+  const home = process.env.HOME ?? (0, import_node_os3.tmpdir)();
+  return (0, import_node_path3.join)(home, `.${product}`);
 }
 function resolveProductDir(product, explicit) {
   return explicit ?? process.env.LAUNCHER_DIR ?? defaultProductDir(product);
 }
 function tokensPath(dir) {
-  return (0, import_node_path2.join)(dir, "tokens.json");
+  return (0, import_node_path3.join)(dir, "tokens.json");
 }
 function statePath(dir) {
-  return (0, import_node_path2.join)(dir, "state.json");
+  return (0, import_node_path3.join)(dir, "state.json");
 }
 function payloadDir(dir) {
-  return (0, import_node_path2.join)(dir, "payload");
+  return (0, import_node_path3.join)(dir, "payload");
 }
 function readTokens(dir) {
   try {
-    const data = JSON.parse((0, import_node_fs3.readFileSync)(tokensPath(dir), "utf8"));
+    const data = JSON.parse((0, import_node_fs4.readFileSync)(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 };
@@ -553,21 +861,21 @@ function readTokens(dir) {
   }
 }
 function writeTokens(dir, tokens) {
-  (0, import_node_fs3.mkdirSync)(dir, { recursive: true });
+  (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
   try {
-    (0, import_node_fs3.writeFileSync)(tokensPath(dir), `${JSON.stringify(tokens)}
+    (0, import_node_fs4.writeFileSync)(tokensPath(dir), `${JSON.stringify(tokens)}
 `, { mode: 384 });
   } catch {
-    (0, import_node_fs3.writeFileSync)(tokensPath(dir), `${JSON.stringify(tokens)}
+    (0, import_node_fs4.writeFileSync)(tokensPath(dir), `${JSON.stringify(tokens)}
 `);
   }
 }
 function clearTokens(dir) {
-  (0, import_node_fs3.rmSync)(tokensPath(dir), { force: true });
+  (0, import_node_fs4.rmSync)(tokensPath(dir), { force: true });
 }
 function readState(dir) {
   try {
-    const data = JSON.parse((0, import_node_fs3.readFileSync)(statePath(dir), "utf8"));
+    const data = JSON.parse((0, import_node_fs4.readFileSync)(statePath(dir), "utf8"));
     if (typeof data.version !== "string" || !data.version) return null;
     return { version: data.version, updatedAt: typeof data.updatedAt === "string" ? data.updatedAt : "" };
   } catch {
@@ -575,18 +883,18 @@ function readState(dir) {
   }
 }
 function writeState(dir, state) {
-  (0, import_node_fs3.mkdirSync)(dir, { recursive: true });
-  (0, import_node_fs3.writeFileSync)(statePath(dir), `${JSON.stringify(state, null, 2)}
+  (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
+  (0, import_node_fs4.writeFileSync)(statePath(dir), `${JSON.stringify(state, null, 2)}
 `);
 }
 function wipeProductDir(dir) {
-  (0, import_node_fs3.rmSync)(tokensPath(dir), { force: true });
-  (0, import_node_fs3.rmSync)(statePath(dir), { force: true });
-  (0, import_node_fs3.rmSync)(payloadDir(dir), { force: true, recursive: true });
+  (0, import_node_fs4.rmSync)(tokensPath(dir), { force: true });
+  (0, import_node_fs4.rmSync)(statePath(dir), { force: true });
+  (0, import_node_fs4.rmSync)(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}
 `);
@@ -633,12 +941,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) {
@@ -657,16 +964,17 @@ 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) {
     printErr("launcher --run needs a file to run.");
     return 1;
   }
-  const abs = (0, import_node_path3.resolve)(process.cwd(), file);
-  if (!(0, import_node_fs4.existsSync)(abs)) {
+  const abs = (0, import_node_path4.resolve)(process.cwd(), file);
+  if (!(0, import_node_fs5.existsSync)(abs)) {
     printErr(`cannot run ${file}: no such file.`);
     return 1;
   }
@@ -752,10 +1060,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((0, import_node_fs4.readFileSync)((0, import_node_path3.join)(payloadDir(dir), "payload.json"), "utf8"));
-    const entry = parsed.entry;
+    const parsed = JSON.parse((0, import_node_fs5.readFileSync)((0, import_node_path4.join)(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;
@@ -768,67 +1076,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((0, import_node_fs5.readFileSync)((0, import_node_path4.join)(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 !(0, import_node_fs4.existsSync)(command);
+  return !(0, import_node_fs5.existsSync)(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 = (0, import_node_child_process2.spawnSync)(command, args, {
+  const shell = needsShell(command);
+  const commandLine = shell ? [command, ...args].map(quoteForShell).join(" ") : command;
+  const result = (0, import_node_child_process3.spawnSync)(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() });
+  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 && (0, import_node_fs5.existsSync)(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() });
-  print(`installed ${config.product} ${manifest.version} into ${dir}.`);
+  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 = (0, import_node_path4.join)(payload, first);
+  if (!(0, import_node_fs5.existsSync)(candidate)) return null;
+  if (NEVER_A_PROGRAM.test(first)) return first;
+  if (process.platform === "win32") return null;
+  try {
+    return ((0, import_node_fs5.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 ${(0, import_node_path3.join)(payloadDir(dir), config.binName)} to start ${config.product}.`);
+    printReceipt(face, config, print, true, [
+      `    Installed ${version} into ${dir}`,
+      `    next step: run ${(0, import_node_path4.join)(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 && (0, import_node_fs4.existsSync)(payloadDir(dir))) {
-    print(`${config.product} is already up to date at ${manifest.version}.`);
+function doForward(config, dir, options, command, argv, print) {
+  if (command && (0, import_node_fs5.existsSync)(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 = (0, import_node_fs4.existsSync)(payloadDir(dir));
+  const payloadPresent = (0, import_node_fs5.existsSync)(payloadDir(dir));
   print(`product:  ${config.product}`);
   print(`host:     ${config.host}`);
   print(`login:    ${config.loginKind}`);
@@ -840,7 +1332,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 ${(0, import_node_path3.join)(dir, "tokens.json")}, state ${(0, import_node_path3.join)(dir, "state.json")}, payload ${payloadDir(dir)}`);
+  print(`paths:    tokens ${(0, import_node_path4.join)(dir, "tokens.json")}, state ${(0, import_node_path4.join)(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 {
@@ -871,6 +1367,8 @@ if (invokedAsMain) {
   defaultRunEntry,
   ensureFreshToken,
   readPayloadEntry,
+  readPayloadRun,
+  readPayloadVerbs,
   resolveEntry,
   run,
   runFile