ymmv-cli 0.4.0 → 0.5.0

package/README.md

@@ -2,34 +2,51 @@
 
 **Share your dev tool-stack from the terminal.**
 
-Editor, OS, shell, terminal, browser, font (and more) — published to a clean
-page at `ymmv.fyi/<handle>` in about 10 seconds.
+Editor, OS, shell, terminal, theme, AI tool (and more), published to a
+clean page at `ymmv.fyi/<handle>` in about 10 seconds. See a live one:
+[ymmv.fyi/bardisty](https://ymmv.fyi/bardisty).
+
+![Running npx ymmv-cli to detect, confirm, and publish a dev stack to a live ymmv.fyi page](https://raw.githubusercontent.com/ymmv-fyi/ymmv/main/docs/demo.gif)
 
 ```sh
 npx ymmv-cli            # detect your stack, confirm, go live at ymmv.fyi/<you>
 npx ymmv-cli bardisty   # view someone's stack in the terminal
 ```
 
+Viewing someone while you're logged in diffs their stack against yours:
+
+```
+          bardisty  you
+~ Editor  Zed       VS Code
+= Shell   bash      bash
+~ Theme   Gruvbox   Catppuccin
+~ Font    Lilex     JetBrains Mono
+
+  3 differ · 1 shared — your mileage may vary
+```
+
 Install once for the short `ymmv` command:
 
 ```sh
 npm i -g ymmv-cli
 ```
 
-First run includes a one-time GitHub sign-in (the device flow you know from `gh`
-/ `npm login`, ~10s).
+First run includes a one-time GitHub sign-in. Works on macOS, Linux, Windows,
+and WSL. Nothing is published until you confirm (detection only pre-fills), and
+`ymmv delete` removes everything. Releases are published from GitHub Actions
+via npm Trusted Publishing, with provenance.
 
 ## Commands
 
-- `ymmv` — detect, confirm, and publish (re-run any time to update)
-- `ymmv <handle>` — view a profile, or diff it against yours when you're logged in
-- `ymmv set editor Neovim` — change one value
-- `ymmv set --extra "Keyboard=HHKB"` — add a free-form line of your own
-- `ymmv unset editor` — remove one value (`ymmv set editor -` works too); `ymmv unset --extra "Keyboard"` removes an extra
-- `ymmv delete` — remove your profile
-- `ymmv login` / `ymmv logout` — sign in / out
+- `ymmv` detects, confirms, and publishes (re-run any time to update)
+- `ymmv <handle>` views a profile, or diffs it against yours when you're logged in
+- `ymmv set editor Neovim` changes one value
+- `ymmv set --extra "Keyboard=HHKB"` adds a free-form line of your own
+- `ymmv unset editor` removes one value (`ymmv set editor -` works too); `ymmv unset --extra "Keyboard"` removes an extra
+- `ymmv delete` removes your profile
+- `ymmv login` / `ymmv logout` sign in / out
 
-Every profile is open JSON too — `GET https://ymmv.fyi/api/v1/u/<handle>`.
+Every profile is open JSON too: `GET https://ymmv.fyi/api/v1/u/<handle>`.
 
 ## License
 

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { readFileSync } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
 
 // src/config.ts
 var BASE = (process.env.YMMV_API ?? "https://ymmv.fyi").replace(/\/+$/, "");
@@ -44,16 +44,22 @@ async function revokeYmmvToken(token) {
   return body.revoked === true;
 }
 
+// src/commands.ts
+import { readFileSync, statSync } from "fs";
+
 // ../shared/dist/keys.js
 var CURATED_KEYS = [
   "editor",
   "os",
   "shell",
+  "prompt",
   "terminal",
   "browser",
   "window-manager",
   "font",
+  "theme",
   "multiplexer",
+  "version-manager",
   "dotfiles",
   "ai-tool"
 ];
@@ -61,11 +67,14 @@ var KEY_LABELS = {
   editor: "Editor",
   os: "OS",
   shell: "Shell",
+  prompt: "Prompt",
   terminal: "Terminal",
   browser: "Browser",
   "window-manager": "Window Manager",
   font: "Font",
+  theme: "Theme",
   multiplexer: "Multiplexer",
+  "version-manager": "Version Manager",
   dotfiles: "Dotfiles",
   "ai-tool": "AI Tool"
 };
@@ -122,16 +131,95 @@ var TOOLS = [
   { key: "terminal", canonical: "Hyper", envTokens: ["hyper"] },
   { key: "terminal", canonical: "Rio", envTokens: ["rio"] },
   { key: "terminal", canonical: "kitty", envTokens: ["kitty"] },
+  // kitty refuses TERM_PROGRAM (its issue #3317); detect.ts probes KITTY_WINDOW_ID instead — token kept for the day that changes
   { key: "terminal", canonical: "Tabby", envTokens: ["tabby"] },
   { key: "terminal", canonical: "Warp", envTokens: ["warpterminal"] },
   // `warpterminal` env id ≠ typed "Warp"
+  { key: "terminal", canonical: "GNOME Console", envTokens: ["kgx"] },
+  // $TERM_PROGRAM=kgx since GNOME 45
+  { key: "terminal", canonical: "mintty", envTokens: ["mintty"] },
+  // Git Bash/MSYS2 console, ≥3.1.5
+  { key: "terminal", canonical: "Zed", envTokens: ["zed"] },
+  // Zed's built-in terminal (~0.145+)
+  // ── browser (envTokens mirror BROWSER_NAMES: $BROWSER basenames) ──────────
+  { key: "browser", canonical: "Firefox", envTokens: ["firefox"], aliases: ["ff"] },
+  // Hyphenated Linux binary names double as diff aliases (kde/plasma precedent): unlike `vi`,
+  // each unambiguously names exactly that browser, so a TYPED "google-chrome" should diff-equal
+  // a DETECTED "Chrome".
+  {
+    key: "browser",
+    canonical: "Chrome",
+    envTokens: ["chrome", "google-chrome"],
+    aliases: ["google chrome", "google-chrome"]
+    // NOT Chromium — distinct browser
+  },
+  {
+    key: "browser",
+    canonical: "Edge",
+    envTokens: ["msedge", "microsoft-edge"],
+    aliases: ["microsoft edge", "microsoft-edge"]
+  },
+  {
+    key: "browser",
+    canonical: "Chromium",
+    envTokens: ["chromium", "chromium-browser"],
+    aliases: ["chromium-browser"]
+  },
+  {
+    key: "browser",
+    canonical: "Brave",
+    envTokens: ["brave", "brave-browser"],
+    aliases: ["brave-browser"]
+  },
+  { key: "browser", canonical: "LibreWolf", envTokens: ["librewolf"] },
+  {
+    key: "browser",
+    canonical: "Vivaldi",
+    envTokens: ["vivaldi", "vivaldi-stable"],
+    aliases: ["vivaldi-stable"]
+  },
+  { key: "browser", canonical: "Zen", envTokens: ["zen", "zen-browser"], aliases: ["zen-browser"] },
+  { key: "browser", canonical: "qutebrowser", envTokens: ["qutebrowser"] },
+  // ── window-manager (envTokens mirror WM_NAMES: XDG_CURRENT_DESKTOP list entries +
+  //    DESKTOP_SESSION basenames, lowercased). Deliberate: canonical names are what users put on
+  //    profiles — the DE name (GNOME, KDE Plasma), not its compositor (Mutter, KWin). Compositors
+  //    with their own socket vars (Hyprland/Sway/i3/niri) are ALSO probed directly in detect.ts;
+  //    WMs with no env footprint at all (river, bspwm, dwm, Qtile, awesome) have no tokens — a
+  //    dead token would only inflate the pinned detector fixtures. ──────────
+  { key: "window-manager", canonical: "GNOME", envTokens: ["gnome"] },
+  {
+    key: "window-manager",
+    canonical: "KDE Plasma",
+    envTokens: ["kde", "plasma"],
+    aliases: ["kde", "plasma"]
+  },
+  { key: "window-manager", canonical: "Hyprland", envTokens: ["hyprland"] },
+  { key: "window-manager", canonical: "Sway", envTokens: ["sway"] },
+  { key: "window-manager", canonical: "i3", envTokens: ["i3"] },
+  { key: "window-manager", canonical: "niri", envTokens: ["niri"] },
+  { key: "window-manager", canonical: "COSMIC", envTokens: ["cosmic"] },
+  { key: "window-manager", canonical: "Cinnamon", envTokens: ["cinnamon", "x-cinnamon"] },
+  { key: "window-manager", canonical: "MATE", envTokens: ["mate"] },
+  { key: "window-manager", canonical: "XFCE", envTokens: ["xfce"] },
+  { key: "window-manager", canonical: "LXQt", envTokens: ["lxqt"] },
+  { key: "window-manager", canonical: "Budgie", envTokens: ["budgie"] },
+  { key: "window-manager", canonical: "Pantheon", envTokens: ["pantheon"] },
+  { key: "window-manager", canonical: "Unity", envTokens: ["unity"] },
+  // ── prompt (presence-detected in detect.ts — entries exist for diff aliases only; fold
+  //    already equates case/space variants, so single-word tools need no entry) ──
+  { key: "prompt", canonical: "Powerlevel10k", aliases: ["p10k"] },
+  // NOT p9k — distinct predecessor
+  { key: "prompt", canonical: "Oh My Posh", aliases: ["oh-my-posh", "omp"] },
+  // hyphens survive fold
+  // ── theme (never detected — aliases for spellings fold can't equate: hyphens + the é) ──
+  { key: "theme", canonical: "Ros\xE9 Pine", aliases: ["rose pine", "rose-pine"] },
+  { key: "theme", canonical: "Tokyo Night", aliases: ["tokyo-night"] },
+  { key: "theme", canonical: "One Dark", aliases: ["one-dark"] },
   // ── diff-only synonyms (no detector for these fields) ─────────────────────
-  { key: "browser", canonical: "Firefox", aliases: ["ff"] },
-  { key: "browser", canonical: "Chrome", aliases: ["google chrome"] },
-  // NOT Chromium — distinct browser
-  { key: "browser", canonical: "Edge", aliases: ["microsoft edge"] },
   { key: "os", canonical: "macOS", aliases: ["osx", "os x", "mac"] },
   { key: "os", canonical: "Windows", aliases: ["win"] },
+  { key: "os", canonical: "Arch Linux", aliases: ["arch"] },
+  // os-release NAME= vs what people type
   { key: "multiplexer", canonical: "GNU Screen", aliases: ["screen"] }
   // matches detector's "GNU Screen"
 ];
@@ -661,7 +749,7 @@ function firstToken(s) {
   return s.trim().split(/\s+/)[0] ?? "";
 }
 var namesFor = (key) => {
-  const map = {};
+  const map = /* @__PURE__ */ Object.create(null);
   for (const tool of TOOLS) {
     if (tool.key !== key) continue;
     for (const token of tool.envTokens ?? []) map[token] = tool.canonical;
@@ -671,15 +759,44 @@ var namesFor = (key) => {
 var SHELL_NAMES = namesFor("shell");
 var EDITOR_NAMES = namesFor("editor");
 var TERM_PROGRAMS = namesFor("terminal");
-function detectOS(env, platform) {
-  if (env.WSL_DISTRO_NAME) return `${env.WSL_DISTRO_NAME} (WSL)`;
+var BROWSER_NAMES = namesFor("browser");
+var WM_NAMES = namesFor("window-manager");
+var TERM_EXACT = Object.assign(/* @__PURE__ */ Object.create(null), {
+  "xterm-kitty": "kitty",
+  "xterm-ghostty": "Ghostty",
+  foot: "foot",
+  alacritty: "Alacritty"
+});
+var BROWSER_DISPATCHERS = /* @__PURE__ */ new Set([
+  "xdg-open",
+  "wslview",
+  "sensible-browser",
+  "x-www-browser",
+  "www-browser",
+  "open",
+  "gio",
+  "browser.sh",
+  "browser.cmd"
+]);
+function linuxDistro(read) {
+  if (!read) return void 0;
+  try {
+    const line = read("/etc/os-release").split("\n").find((l) => l.startsWith("NAME="));
+    const name = line?.slice("NAME=".length).trim().replace(/^["']|["']$/g, "");
+    return name?.trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function detectOS(env, platform, opts) {
+  if (platform === "linux" && env.WSL_DISTRO_NAME) return `${env.WSL_DISTRO_NAME} (WSL)`;
   switch (platform) {
     case "darwin":
       return "macOS";
     case "win32":
       return "Windows";
     case "linux":
-      return "Linux";
+      return linuxDistro(opts.readTextFile) ?? "Linux";
     default:
       return platform;
   }
@@ -691,6 +808,9 @@ function detectShell(env, platform) {
     return SHELL_NAMES[key] ?? basename(raw);
   }
   if (platform === "win32") {
+    const firstSeg = env.PSModulePath?.split(";")[0]?.trim().toLowerCase() ?? "";
+    if (/[\\/]documents[\\/](windows)?powershell[\\/]modules$/.test(firstSeg)) return "PowerShell";
+    if (env.PROMPT) return env.ComSpec ? basename(env.ComSpec) : "cmd";
     if (env.PSModulePath) return "PowerShell";
     if (env.ComSpec) return basename(env.ComSpec);
   }
@@ -699,18 +819,37 @@ function detectShell(env, platform) {
 function detectTerminal(env) {
   const tp = env.TERM_PROGRAM?.trim();
   if (tp && tp.toLowerCase() !== "tmux") {
+    if (tp.toLowerCase() === "vscode" && env.CURSOR_TRACE_ID) return "Cursor";
     return TERM_PROGRAMS[tp.toLowerCase()] ?? tp;
   }
+  if (env.TERMINAL_EMULATOR === "JetBrains-JediTerm") return "JetBrains";
   if (env.WT_SESSION) return "Windows Terminal";
   if (env.KONSOLE_VERSION) return "Konsole";
   if (env.ALACRITTY_WINDOW_ID || env.ALACRITTY_SOCKET) return "Alacritty";
+  if (env.KITTY_WINDOW_ID || env.KITTY_PID) return "kitty";
+  if (env.GNOME_TERMINAL_SERVICE || env.GNOME_TERMINAL_SCREEN) return "GNOME Terminal";
+  if (env.TILIX_ID) return "Tilix";
+  if (env.TERMINATOR_UUID) return "Terminator";
+  if (env.ConEmuANSI || env.ConEmuPID) return "ConEmu";
+  if (env.XTERM_VERSION) return "xterm";
+  const t = env.TERM?.trim().toLowerCase();
+  if (t && TERM_EXACT[t]) return TERM_EXACT[t];
   return void 0;
 }
 function detectEditor(env) {
   const raw = env.VISUAL ?? env.EDITOR;
-  if (!raw) return void 0;
-  const bin = basename(firstToken(raw));
-  return EDITOR_NAMES[bin.toLowerCase()] ?? bin;
+  if (raw) {
+    const bin = basename(firstToken(raw));
+    return EDITOR_NAMES[bin.toLowerCase()] ?? bin;
+  }
+  if (env.NVIM) return "Neovim";
+  if (env.VIM_TERMINAL) return "Vim";
+  if (env.INSIDE_EMACS) return "Emacs";
+  if (env.CURSOR_TRACE_ID) return "Cursor";
+  const tp = env.TERM_PROGRAM?.trim().toLowerCase();
+  if (tp === "vscode") return "VS Code";
+  if (tp === "zed" || env.ZED_TERM === "true") return "Zed";
+  return void 0;
 }
 function detectMultiplexer(env) {
   if (env.TMUX) return "tmux";
@@ -718,17 +857,92 @@ function detectMultiplexer(env) {
   if (env.STY) return "GNU Screen";
   return void 0;
 }
-function detectStack(env, platform) {
+function detectPrompt(env) {
+  if (env.STARSHIP_SHELL || env.STARSHIP_SESSION_KEY) return "Starship";
+  if (env.POSH_SHELL || env.POSH_SESSION_ID || env.POSH_THEME) return "Oh My Posh";
+  if (env.P9K_TTY || env._P9K_TTY) return "Powerlevel10k";
+  if (env.SPACESHIP_VERSION) return "Spaceship";
+  if (Object.keys(env).some((k) => k.startsWith("_tide_"))) return "Tide";
+  return void 0;
+}
+function detectVersionManager(env) {
+  const path = env.PATH ?? "";
+  if (env.MISE_SHELL || env.__MISE_ORIG_PATH || /[\\/]mise[\\/]shims/i.test(path)) return "mise";
+  if (env.ASDF_DIR || env.ASDF_DATA_DIR || /\.asdf[\\/]shims/i.test(path)) return "asdf";
+  if (env.PROTO_HOME) return "proto";
+  if (env.VOLTA_HOME) return "Volta";
+  if (env.FNM_MULTISHELL_PATH || env.FNM_DIR) return "fnm";
+  if (env.NVM_DIR) return "nvm";
+  if (env.PYENV_SHELL || env.PYENV_ROOT) return "pyenv";
+  if (env.RBENV_SHELL || env.RBENV_ROOT) return "rbenv";
+  return void 0;
+}
+function detectWindowManager(env) {
+  if (env.HYPRLAND_INSTANCE_SIGNATURE) return "Hyprland";
+  if (env.NIRI_SOCKET) return "niri";
+  if (env.SWAYSOCK) return "Sway";
+  if (env.I3SOCK) return "i3";
+  for (const part of env.XDG_CURRENT_DESKTOP?.split(":") ?? []) {
+    const hit = WM_NAMES[part.trim().toLowerCase()];
+    if (hit) return hit;
+  }
+  const ds = env.DESKTOP_SESSION;
+  if (ds) {
+    const hit = WM_NAMES[basename(ds).toLowerCase()];
+    if (hit) return hit;
+  }
+  if (env.KDE_FULL_SESSION || env.KDE_SESSION_VERSION) return "KDE Plasma";
+  return void 0;
+}
+function detectBrowser(env) {
+  const raw = env.BROWSER;
+  if (!raw) return void 0;
+  const trimmed = raw.trim();
+  if (/^[A-Za-z]:[\\/]/.test(trimmed) || trimmed.includes("\\")) {
+    const bin = basename(trimmed);
+    if (!bin || BROWSER_DISPATCHERS.has(bin.toLowerCase())) return void 0;
+    return BROWSER_NAMES[bin.toLowerCase()] ?? bin;
+  }
+  for (const candidate of trimmed.split(":")) {
+    const bin = basename(firstToken(candidate));
+    if (!bin) continue;
+    if (BROWSER_DISPATCHERS.has(bin.toLowerCase())) continue;
+    const hit = BROWSER_NAMES[bin.toLowerCase()];
+    if (hit) return hit;
+    if (candidate.startsWith("/") && /\s/.test(candidate.trim())) {
+      const whole = basename(candidate.trim().replace(/\s+%[a-zA-Z].*$/, ""));
+      if (whole && !whole.includes("/")) return BROWSER_NAMES[whole.toLowerCase()] ?? whole;
+    }
+    return bin;
+  }
+  return void 0;
+}
+function detectAiTool(env) {
+  if (env.AGENT?.trim().toLowerCase() === "amp") return "Amp";
+  if (env.CLAUDECODE) return "Claude Code";
+  if (env.CODEX_THREAD_ID) return "Codex";
+  if (env.GEMINI_CLI) return "Gemini CLI";
+  if (env.OPENCODE) return "opencode";
+  if (env.COPILOT_CLI) return "GitHub Copilot";
+  if (env.CURSOR_TRACE_ID || env.CURSOR_AGENT) return "Cursor";
+  return void 0;
+}
+function detectStack(env, platform, opts = {}) {
   const out = /* @__PURE__ */ new Map();
   const set = (key, value) => {
     if (value?.trim()) out.set(key, value.trim());
   };
   try {
-    set("os", detectOS(env, platform));
+    set("os", detectOS(env, platform, opts));
     set("shell", detectShell(env, platform));
+    set("prompt", detectPrompt(env));
     set("terminal", detectTerminal(env));
     set("editor", detectEditor(env));
     set("multiplexer", detectMultiplexer(env));
+    set("version-manager", detectVersionManager(env));
+    set("window-manager", detectWindowManager(env));
+    set("browser", detectBrowser(env));
+    set("ai-tool", detectAiTool(env));
   } catch {
   }
   return out;
@@ -752,6 +966,9 @@ function entriesFromMap(map) {
     return value ? [{ key, value }] : [];
   });
 }
+function unknownEntries(existing) {
+  return (existing?.entries ?? []).filter((e) => !isCuratedKey(e.key));
+}
 function applySet(existing, target) {
   const entries = (existing?.entries ?? []).map((e) => ({ ...e }));
   const extras = (existing?.extras ?? []).map((x) => ({ ...x }));
@@ -829,20 +1046,49 @@ async function promptEntries(defaults, prompter) {
   return entriesFromMap(chosen);
 }
 async function publish(io) {
+  if (!io.interactive && !io.yes) {
+    console.error("Non-interactive publish needs -y (nothing publishes unconfirmed): ymmv -y");
+    process.exitCode = 1;
+    return;
+  }
   const cred = await ensureLogin();
   const handle = requireHandle(cred);
   if (!handle) return;
-  const detected = detectStack(process.env, process.platform);
+  const detected = detectStack(process.env, process.platform, {
+    readTextFile: (p) => {
+      const st = statSync(p);
+      if (!st.isFile() || st.size > 64 * 1024) throw new Error("not a readable os-release");
+      return readFileSync(p, "utf8");
+    }
+  });
   const existing = await fetchProfileJson(handle);
   assertHandleUnchanged(existing, handle);
   const defaults = buildDefaults(existing, detected);
+  const carried = unknownEntries(existing);
   let entries = entriesFromMap(defaults);
   const extras = existing?.extras ?? [];
   if (io.interactive && io.prompter) {
     entries = await promptEntries(defaults, io.prompter);
   }
+  entries = [...entries, ...carried];
   const profile = newProfile(handle, entries, extras);
   console.log(renderProfile(profile, { color: colorEnabled() }));
+  if (carried.length > 0) {
+    const s = carried.length === 1 ? "" : "s";
+    console.log(`(+${carried.length} newer field${s} kept as-is \u2014 upgrade ymmv-cli to edit them)`);
+    for (const e of carried) {
+      console.log(`    ${sanitizeValue(e.key)} = ${sanitizeValue(e.value)}`);
+    }
+  }
+  const publishedLabels = new Set(
+    entries.filter((e) => isCuratedKey(e.key)).map((e) => KEY_LABELS[e.key].toLowerCase())
+  );
+  for (const x of extras) {
+    if (publishedLabels.has(x.label.trim().toLowerCase())) {
+      const label = sanitizeValue(x.label.trim());
+      console.log(`(extra "${label}" duplicates a curated field \u2014 ymmv unset --extra "${label}")`);
+    }
+  }
   if (io.interactive && io.prompter && !io.yes) {
     const go = await io.prompter.confirm(`Publish to ymmv.fyi/${handle}?`, true);
     if (!go) {
@@ -941,6 +1187,10 @@ async function runDelete(io) {
 // src/prompt.ts
 import { stdin, stdout } from "process";
 import { createInterface } from "readline/promises";
+function promptLine(label, def) {
+  const clean = def ? sanitizeValue(def) : def;
+  return `  ${label}${clean ? ` [${clean}]` : ""}: `;
+}
 function makePrompter() {
   let rl = null;
   const io = () => {
@@ -949,8 +1199,9 @@ function makePrompter() {
   };
   return {
     async ask(label, def) {
-      const answer = (await io().question(`  ${label}${def ? ` [${def}]` : ""}: `)).trim();
-      return answer === "" ? def ?? "" : answer;
+      const clean = def ? sanitizeValue(def) : def;
+      const answer = (await io().question(promptLine(label, def))).trim();
+      return answer === "" ? clean ?? "" : answer;
     },
     async confirm(question, defYes) {
       const answer = (await io().question(`  ${question} ${defYes ? "[Y/n]" : "[y/N]"} `)).trim().toLowerCase();
@@ -1053,6 +1304,7 @@ var HELP = `ymmv \u2014 terminal-native developer tool-stack profiles (ymmv.fyi)
 
 Usage:
   ymmv                      detect your stack, confirm, and publish your profile
+  ymmv -y                   publish without prompts (required when stdin isn't a TTY)
   ymmv <handle>             view a profile \u2014 logged in, see the diff vs yours
   ymmv view <handle>        explicit view (when a handle collides with a verb)
   ymmv set <key> <value>    set one curated key
@@ -1063,8 +1315,8 @@ Usage:
   ymmv login | logout       GitHub device-flow auth
   ymmv help | --version
 
-Curated keys: editor, os, shell, terminal, browser, window-manager, font,
-              multiplexer, dotfiles, ai-tool
+Curated keys: editor, os, shell, prompt, terminal, browser, window-manager,
+              font, theme, multiplexer, version-manager, dotfiles, ai-tool
 
 Respects NO_COLOR. Point YMMV_API at a dev Worker to target one.
 Publish your own: npx ymmv-cli`;
@@ -1092,7 +1344,7 @@ async function logout() {
 }
 function printVersion() {
   try {
-    const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+    const pkg = JSON.parse(readFileSync2(new URL("../package.json", import.meta.url), "utf8"));
     console.log(`ymmv-cli ${pkg.version ?? "unknown"}`);
   } catch {
     console.log("ymmv-cli (version unknown)");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ymmv-cli",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Publish and diff terminal-native developer tool-stack profiles at ymmv.fyi.",
   "type": "module",
   "bin": {