ymmv-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 the ymmv.fyi authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,34 @@
+# ymmv-cli
+
+**Share your dev tool-stack from the terminal.**
+
+Editor, OS, shell, terminal, fonts, AI tools — published to a clean page at `ymmv.fyi/<your-handle>`
+in about 10 seconds.
+
+```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
+```
+
+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).
+
+## 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 delete` — remove your profile
+- `ymmv login` / `ymmv logout` — sign in / out
+
+Every profile is open JSON too — `GET https://ymmv.fyi/api/v1/u/<handle>`.
+
+## License
+
+MIT. Source + issues: <https://github.com/ymmv-fyi/ymmv>.

package/dist/index.js

@@ -0,0 +1,902 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { readFileSync } from "fs";
+import { pathToFileURL } from "url";
+
+// src/config.ts
+var BASE = (process.env.YMMV_API ?? "https://ymmv.fyi").replace(/\/+$/, "");
+
+// src/auth-http.ts
+async function mintYmmvToken(accessToken) {
+  const res = await fetch(`${BASE}/api/v1/auth/token`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ access_token: accessToken })
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    if (res.status === 503) {
+      throw new Error(body.message ?? "GitHub is unavailable \u2014 run `ymmv login` again shortly.");
+    }
+    throw new Error(`login failed: ${res.status} ${body.error ?? ""}`.trim());
+  }
+  return await res.json();
+}
+async function revokeYmmvToken(token) {
+  const res = await fetch(`${BASE}/api/v1/auth/logout`, {
+    method: "POST",
+    headers: { authorization: `Bearer ${token}` }
+  });
+  if (!res.ok) throw new Error(`logout failed: ${res.status}`);
+  const body = await res.json().catch(() => ({}));
+  return body.revoked === true;
+}
+
+// ../shared/dist/keys.js
+var CURATED_KEYS = [
+  "editor",
+  "os",
+  "shell",
+  "terminal",
+  "browser",
+  "window-manager",
+  "font",
+  "multiplexer",
+  "dotfiles",
+  "ai-tool"
+];
+var KEY_LABELS = {
+  editor: "Editor",
+  os: "OS",
+  shell: "Shell",
+  terminal: "Terminal",
+  browser: "Browser",
+  "window-manager": "Window Manager",
+  font: "Font",
+  multiplexer: "Multiplexer",
+  dotfiles: "Dotfiles",
+  "ai-tool": "AI Tool"
+};
+var CURATED_KEY_SET = new Set(CURATED_KEYS);
+function isCuratedKey(value) {
+  return CURATED_KEY_SET.has(value);
+}
+
+// ../shared/dist/diff.js
+function toLookup(entries) {
+  const map = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    map.set(entry.key, entry.value);
+  }
+  return map;
+}
+function classify(mine, theirs) {
+  if (mine !== null && theirs !== null) {
+    return mine.trim() === theirs.trim() ? "same" : "changed";
+  }
+  return mine !== null ? "only_mine" : "only_theirs";
+}
+function diff(mine, theirs) {
+  const mineLookup = toLookup(mine.entries);
+  const theirsLookup = toLookup(theirs.entries);
+  const rows = [];
+  let differ = 0;
+  let shared = 0;
+  for (const key of CURATED_KEYS) {
+    const mineValue = mineLookup.get(key) ?? null;
+    const theirsValue = theirsLookup.get(key) ?? null;
+    if (mineValue === null && theirsValue === null) {
+      continue;
+    }
+    const status = classify(mineValue, theirsValue);
+    if (status === "same") {
+      shared += 1;
+    } else {
+      differ += 1;
+    }
+    rows.push({ key, label: KEY_LABELS[key], mine: mineValue, theirs: theirsValue, status });
+  }
+  return {
+    rows,
+    extras: { mine: [...mine.extras], theirs: [...theirs.extras] },
+    differ,
+    shared
+  };
+}
+
+// ../shared/dist/reserved.js
+var RESERVED_ROUTES = ["api", "login", "logout"];
+var CLI_VERBS = ["login", "logout", "set", "delete", "view", "help"];
+var RESERVED = [.../* @__PURE__ */ new Set([...RESERVED_ROUTES, ...CLI_VERBS])];
+var RESERVED_SET = new Set(RESERVED);
+var HANDLE_RE = /^[a-zA-Z0-9](?:-?[a-zA-Z0-9])*$/;
+function isValidHandle(handle) {
+  return handle.length >= 1 && handle.length <= 39 && HANDLE_RE.test(handle);
+}
+
+// ../shared/dist/types.js
+var SCHEMA_VERSION = 1;
+
+// src/token-store.ts
+import { randomUUID } from "crypto";
+import { chmod, mkdir, readFile, rename, rm, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+import envPaths from "env-paths";
+function tokenFilePath() {
+  return join(envPaths("ymmv", { suffix: "" }).config, "token.json");
+}
+async function saveToken(data) {
+  const path = tokenFilePath();
+  await mkdir(dirname(path), { recursive: true });
+  const tmp = `${path}.${randomUUID()}.tmp`;
+  const stored = { base: BASE, token: data.token, handle: data.handle };
+  try {
+    await writeFile(tmp, JSON.stringify(stored), { mode: 384 });
+    if (process.platform !== "win32") await chmod(tmp, 384);
+    await rename(tmp, path);
+  } catch (e) {
+    await rm(tmp, { force: true }).catch(() => {
+    });
+    throw e;
+  }
+}
+async function loadToken() {
+  let raw;
+  try {
+    raw = await readFile(tokenFilePath(), "utf8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (parsed.base !== BASE || typeof parsed.token !== "string") return null;
+  return parsed;
+}
+async function deleteToken() {
+  await rm(tokenFilePath(), { force: true });
+}
+async function peekBase() {
+  try {
+    const parsed = JSON.parse(await readFile(tokenFilePath(), "utf8"));
+    return typeof parsed.base === "string" ? parsed.base : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/device-flow.ts
+var CLIENT_ID = "Ov23liMoD29eizQcN1KZ";
+var DEVICE_CODE_URL = "https://github.com/login/device/code";
+var TOKEN_URL = "https://github.com/login/oauth/access_token";
+var realSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function requestDeviceCode(deps = {}) {
+  const doFetch = deps.fetch ?? globalThis.fetch;
+  const res = await doFetch(DEVICE_CODE_URL, {
+    method: "POST",
+    headers: { accept: "application/json" },
+    body: new URLSearchParams({ client_id: CLIENT_ID })
+  });
+  if (!res.ok) {
+    throw new Error(`device code request failed: ${res.status} ${await res.text()}`);
+  }
+  return await res.json();
+}
+async function pollForToken(dc, deps = {}) {
+  const doFetch = deps.fetch ?? globalThis.fetch;
+  const sleep = deps.sleep ?? realSleep;
+  const now = deps.now ?? Date.now;
+  let interval = dc.interval || 5;
+  const deadline = now() + dc.expires_in * 1e3;
+  while (now() < deadline) {
+    await sleep(interval * 1e3);
+    const res = await doFetch(TOKEN_URL, {
+      method: "POST",
+      headers: { accept: "application/json" },
+      body: new URLSearchParams({
+        client_id: CLIENT_ID,
+        device_code: dc.device_code,
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+      })
+    });
+    const tok = await res.json();
+    if (tok.access_token) return tok.access_token;
+    switch (tok.error) {
+      case "authorization_pending":
+        break;
+      case "slow_down":
+        interval = Math.max(tok.interval ?? 0, interval + 5);
+        break;
+      case "access_denied":
+        throw new Error("Authorization denied. Run `ymmv login` to try again.");
+      case "expired_token":
+        throw new Error("Device code expired \u2014 run `ymmv login` again.");
+      default:
+        throw new Error(`device flow failed: ${tok.error ?? "unknown error"}`);
+    }
+  }
+  throw new Error("Device code expired \u2014 run `ymmv login` again.");
+}
+async function login(deps = {}) {
+  if (!process.stdin.isTTY) {
+    throw new Error(
+      "Device login needs an interactive terminal \u2014 run `ymmv login` in a real terminal (a piped or CI shell can't complete the GitHub device flow)."
+    );
+  }
+  const dc = await requestDeviceCode(deps);
+  console.log(`
+  Open ${dc.verification_uri} and enter code: ${dc.user_code}
+`);
+  const accessToken = await pollForToken(dc, deps);
+  const { token, handle } = await mintYmmvToken(accessToken);
+  try {
+    await saveToken({ token, handle });
+  } catch (e) {
+    await revokeYmmvToken(token).catch(() => {
+    });
+    throw e;
+  }
+  console.log(
+    handle ? `  Logged in as ${handle}.
+` : "  Logged in \u2014 no handle bound (your GitHub username is a reserved word).\n"
+  );
+}
+
+// src/api.ts
+async function rateLimitMessage(res) {
+  const retry = res.headers.get("retry-after");
+  let msg = "rate limited \u2014 too many requests";
+  try {
+    const body = await res.json();
+    if (typeof body?.message === "string" && body.message) msg = body.message;
+  } catch {
+  }
+  return retry ? `${msg} (retry in ${retry}s)` : msg;
+}
+async function ensureLogin() {
+  const existing = await loadToken();
+  if (existing) return existing;
+  await login();
+  const fresh = await loadToken();
+  if (!fresh) throw new Error("login did not persist a token \u2014 run `ymmv login`.");
+  return fresh;
+}
+async function publishProfile(profile) {
+  const send = (c) => fetch(`${BASE}/api/v1/profile`, {
+    method: "POST",
+    headers: { "content-type": "application/json", authorization: `Bearer ${c.token}` },
+    // Send the login-bound handle, never a caller-guessed one — the official client never claims
+    // a handle it doesn't own.
+    body: JSON.stringify({ ...profile, handle: c.handle ?? profile.handle }),
+    redirect: "manual"
+    // a mutation must never follow a redirect into a false success
+  });
+  let cred = await ensureLogin();
+  let res = await send(cred);
+  if (res.status === 401 || res.status === 409) {
+    if (res.status === 401) await deleteToken();
+    await login();
+    cred = await ensureLogin();
+    res = await send(cred);
+    if (res.status === 401) throw new Error("authentication failed \u2014 run `ymmv login`.");
+    if (res.status === 409) {
+      throw new Error(
+        "that handle is taken by another account (your GitHub handle may have been reused)."
+      );
+    }
+  }
+  if (res.status === 429) throw new Error(await rateLimitMessage(res));
+  if (!res.ok) {
+    throw new Error(`publish failed: ${res.status} ${await res.text()}`);
+  }
+  const data = await res.json();
+  console.log(`Published ${data.handle} -> ${BASE}/${data.handle}`);
+}
+async function fetchProfileJson(handle) {
+  const res = await fetch(`${BASE}/api/v1/u/${encodeURIComponent(handle)}`);
+  if (res.status === 404) return null;
+  if (!res.ok) {
+    throw new Error(`fetch failed: ${res.status} ${await res.text()}`);
+  }
+  return await res.json();
+}
+async function deleteProfile() {
+  const cred = await ensureLogin();
+  const res = await fetch(`${BASE}/api/v1/profile`, {
+    method: "DELETE",
+    headers: { authorization: `Bearer ${cred.token}` },
+    redirect: "manual"
+  });
+  if (res.status === 401) {
+    throw new Error("session expired \u2014 run `ymmv login`, then `ymmv delete` again.");
+  }
+  if (res.status === 429) throw new Error(await rateLimitMessage(res));
+  if (!res.ok) {
+    throw new Error(`delete failed: ${res.status} ${await res.text()}`);
+  }
+}
+
+// src/detect.ts
+function basename(p) {
+  const trimmed = p.replace(/[\\/]+$/, "");
+  const slash = Math.max(trimmed.lastIndexOf("/"), trimmed.lastIndexOf("\\"));
+  const name = slash >= 0 ? trimmed.slice(slash + 1) : trimmed;
+  return name.replace(/\.exe$/i, "");
+}
+function firstToken(s) {
+  return s.trim().split(/\s+/)[0] ?? "";
+}
+var SHELL_NAMES = {
+  zsh: "zsh",
+  bash: "bash",
+  fish: "fish",
+  sh: "sh",
+  dash: "dash",
+  ksh: "ksh",
+  tcsh: "tcsh",
+  csh: "csh",
+  nu: "Nushell",
+  nushell: "Nushell",
+  pwsh: "PowerShell",
+  powershell: "PowerShell",
+  elvish: "Elvish",
+  xonsh: "xonsh"
+};
+var EDITOR_NAMES = {
+  nvim: "Neovim",
+  vim: "Vim",
+  vi: "Vim",
+  code: "VS Code",
+  "code-insiders": "VS Code Insiders",
+  codium: "VSCodium",
+  emacs: "Emacs",
+  nano: "Nano",
+  hx: "Helix",
+  helix: "Helix",
+  subl: "Sublime Text",
+  micro: "Micro",
+  idea: "IntelliJ IDEA",
+  zed: "Zed",
+  pico: "Pico"
+};
+var TERM_PROGRAMS = {
+  "iterm.app": "iTerm2",
+  apple_terminal: "Terminal",
+  vscode: "VS Code",
+  wezterm: "WezTerm",
+  ghostty: "Ghostty",
+  hyper: "Hyper",
+  rio: "Rio",
+  kitty: "kitty",
+  tabby: "Tabby",
+  warpterminal: "Warp"
+};
+function detectOS(env, platform) {
+  if (env.WSL_DISTRO_NAME) return `${env.WSL_DISTRO_NAME} (WSL)`;
+  switch (platform) {
+    case "darwin":
+      return "macOS";
+    case "win32":
+      return "Windows";
+    case "linux":
+      return "Linux";
+    default:
+      return platform;
+  }
+}
+function detectShell(env, platform) {
+  const raw = env.SHELL ?? env.STARSHIP_SHELL;
+  if (raw) {
+    const key = basename(raw).toLowerCase();
+    return SHELL_NAMES[key] ?? basename(raw);
+  }
+  if (platform === "win32") {
+    if (env.PSModulePath) return "PowerShell";
+    if (env.ComSpec) return basename(env.ComSpec);
+  }
+  return void 0;
+}
+function detectTerminal(env) {
+  const tp = env.TERM_PROGRAM?.trim();
+  if (tp && tp.toLowerCase() !== "tmux") {
+    return TERM_PROGRAMS[tp.toLowerCase()] ?? tp;
+  }
+  if (env.WT_SESSION) return "Windows Terminal";
+  if (env.KONSOLE_VERSION) return "Konsole";
+  if (env.ALACRITTY_WINDOW_ID || env.ALACRITTY_SOCKET) return "Alacritty";
+  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;
+}
+function detectMultiplexer(env) {
+  if (env.TMUX) return "tmux";
+  if (env.ZELLIJ) return "Zellij";
+  if (env.STY) return "GNU Screen";
+  return void 0;
+}
+function detectStack(env, platform) {
+  const out = /* @__PURE__ */ new Map();
+  const set = (key, value) => {
+    if (value?.trim()) out.set(key, value.trim());
+  };
+  try {
+    set("os", detectOS(env, platform));
+    set("shell", detectShell(env, platform));
+    set("terminal", detectTerminal(env));
+    set("editor", detectEditor(env));
+    set("multiplexer", detectMultiplexer(env));
+  } catch {
+  }
+  return out;
+}
+
+// src/profile-ops.ts
+function buildDefaults(existing, detected) {
+  const existingByKey = new Map(
+    (existing?.entries ?? []).map((e) => [e.key, e.value])
+  );
+  const out = /* @__PURE__ */ new Map();
+  for (const key of CURATED_KEYS) {
+    const value = existingByKey.get(key) ?? detected.get(key);
+    if (value?.trim()) out.set(key, value.trim());
+  }
+  return out;
+}
+function entriesFromMap(map) {
+  return CURATED_KEYS.flatMap((key) => {
+    const value = map.get(key);
+    return value ? [{ key, value }] : [];
+  });
+}
+function applySet(existing, target) {
+  const entries = (existing?.entries ?? []).map((e) => ({ ...e }));
+  const extras = (existing?.extras ?? []).map((x) => ({ ...x }));
+  if (target.kind === "curated") {
+    const i = entries.findIndex((e) => e.key === target.key);
+    const next = { key: target.key, value: target.value };
+    if (i >= 0) entries[i] = next;
+    else entries.push(next);
+  } else {
+    const i = extras.findIndex((x) => x.label.toLowerCase() === target.label.toLowerCase());
+    const next = { label: target.label, value: target.value };
+    if (i >= 0) extras[i] = next;
+    else extras.push(next);
+  }
+  return { entries, extras };
+}
+
+// src/render.ts
+var ESC = String.fromCharCode(27);
+var CSI = `${ESC}[`;
+var CODES = {
+  amber: `${CSI}93m`,
+  // DESIGN: amber == ANSI bright-yellow
+  faint: `${CSI}90m`,
+  bold: `${CSI}1m`,
+  reset: `${CSI}0m`
+};
+var NO_CODES = { amber: "", faint: "", bold: "", reset: "" };
+function palette(color) {
+  return color ? CODES : NO_CODES;
+}
+var ESC_INTRODUCERS = `${String.fromCharCode(27)}${String.fromCharCode(155)}`;
+var BEL = String.fromCharCode(7);
+var ANSI_RE = new RegExp(
+  `[${ESC_INTRODUCERS}][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d/#&.:=?%@~_]*)*)?${BEL})|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))`,
+  "g"
+);
+var CTRL_RE = new RegExp(
+  `[${String.fromCharCode(0)}-${String.fromCharCode(31)}${String.fromCharCode(127)}-${String.fromCharCode(159)}]`,
+  "g"
+);
+var BIDI_RE = new RegExp(
+  `[${String.fromCharCode(8234)}-${String.fromCharCode(8238)}${String.fromCharCode(8294)}-${String.fromCharCode(8297)}${String.fromCharCode(8206)}${String.fromCharCode(8207)}]`,
+  "g"
+);
+function sanitizeValue(value) {
+  return value.replace(ANSI_RE, "").replace(CTRL_RE, "").replace(BIDI_RE, "");
+}
+function useColor(env, isTTY) {
+  if (env.NO_COLOR !== void 0) return false;
+  if (env.FORCE_COLOR !== void 0) return env.FORCE_COLOR !== "0";
+  return isTTY;
+}
+function orderedEntries(profile) {
+  const byKey = new Map(
+    (profile.entries ?? []).map((e) => [e.key, e.value])
+  );
+  return CURATED_KEYS.flatMap((key) => {
+    const value = byKey.get(key);
+    return value === void 0 ? [] : [{ label: KEY_LABELS[key], value: sanitizeValue(value) }];
+  });
+}
+function renderProfile(profile, opts) {
+  const c = palette(opts.color);
+  const rows = orderedEntries(profile);
+  const extras = (profile.extras ?? []).map((x) => ({
+    label: sanitizeValue(x.label),
+    value: sanitizeValue(x.value)
+  }));
+  const labelW = Math.max(
+    0,
+    ...rows.map((r) => r.label.length),
+    ...extras.map((x) => x.label.length)
+  );
+  const lines = ["", `  ${c.bold}${sanitizeValue(profile.handle)}${c.reset}`, ""];
+  for (const r of rows) {
+    lines.push(`  ${c.faint}${r.label.padEnd(labelW)}${c.reset}  ${r.value}`);
+  }
+  if (extras.length) {
+    lines.push("");
+    for (const x of extras) {
+      lines.push(`  ${c.faint}${x.label.padEnd(labelW)}${c.reset}  ${x.value}`);
+    }
+  }
+  lines.push("", `  ${c.faint}updated ${sanitizeValue(profile.updated_at)}${c.reset}`, "");
+  return lines.join("\n");
+}
+var MISSING = "\u2014";
+function extrasBlock(extras, theirsLabel, mineLabel, c) {
+  if (!extras.theirs.length && !extras.mine.length) return [];
+  const out = ["", `  ${c.faint}extras${c.reset}`];
+  const line = (who, label, value) => `  ${c.faint}${who}${c.reset}  ${sanitizeValue(label)} = ${sanitizeValue(value)}`;
+  for (const x of extras.theirs) out.push(line(theirsLabel, x.label, x.value));
+  for (const x of extras.mine) out.push(line(mineLabel, x.label, x.value));
+  return out;
+}
+function renderDiff(result, opts) {
+  const c = palette(opts.color);
+  const theirsLabel = sanitizeValue(opts.theirsLabel);
+  const mineLabel = sanitizeValue(opts.mineLabel);
+  const cells = result.rows.map((r) => ({
+    label: r.label,
+    theirs: r.theirs === null ? MISSING : sanitizeValue(r.theirs),
+    mine: r.mine === null ? MISSING : sanitizeValue(r.mine),
+    differ: r.status !== "same"
+  }));
+  const labelW = Math.max(3, ...cells.map((r) => r.label.length));
+  const theirsW = Math.max(theirsLabel.length, ...cells.map((r) => r.theirs.length));
+  const lines = [""];
+  lines.push(
+    `  ${c.faint}${"".padEnd(labelW)}  ${theirsLabel.padEnd(theirsW)}  ${mineLabel}${c.reset}`
+  );
+  for (const r of cells) {
+    if (!opts.color) {
+      const sym = r.differ ? "~" : "=";
+      lines.push(`${sym} ${r.label.padEnd(labelW)}  ${r.theirs.padEnd(theirsW)}  ${r.mine}`);
+    } else if (r.differ) {
+      lines.push(
+        `${c.amber}\u2022${c.reset} ${r.label.padEnd(labelW)}  ${r.theirs.padEnd(theirsW)}  ${c.amber}${r.mine}${c.reset}`
+      );
+    } else {
+      lines.push(
+        `  ${c.faint}${r.label.padEnd(labelW)}  ${r.theirs.padEnd(theirsW)}  ${r.mine}${c.reset}`
+      );
+    }
+  }
+  lines.push(...extrasBlock(result.extras, theirsLabel, mineLabel, c));
+  lines.push(
+    "",
+    `  ${c.faint}${result.differ} differ \xB7 ${result.shared} shared \u2014 your mileage may vary${c.reset}`,
+    ""
+  );
+  return lines.join("\n");
+}
+function nudge(color) {
+  const c = palette(color);
+  return `
+  ${c.amber}publish yours to diff \u2192${c.reset} run ${c.bold}ymmv${c.reset}
+`;
+}
+function notFound(handle) {
+  return `
+  no ymmv profile for "${sanitizeValue(handle)}" yet.
+  publish one at ymmv.fyi with: npx ymmv-cli
+`;
+}
+
+// src/commands.ts
+function colorEnabled() {
+  return useColor(process.env, Boolean(process.stdout.isTTY));
+}
+function requireHandle(cred) {
+  if (cred.handle) return cred.handle;
+  console.error(
+    "Your GitHub username is a reserved word, so no handle is bound. Rename on GitHub, then run `ymmv login` again."
+  );
+  process.exitCode = 1;
+  return null;
+}
+function newProfile(handle, entries, extras) {
+  return {
+    schema_version: SCHEMA_VERSION,
+    handle,
+    entries,
+    extras,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function promptEntries(defaults, prompter) {
+  const chosen = /* @__PURE__ */ new Map();
+  for (const key of CURATED_KEYS) {
+    const answer = (await prompter.ask(KEY_LABELS[key], defaults.get(key))).trim();
+    const value = answer === "-" ? "" : answer;
+    if (value) chosen.set(key, value);
+  }
+  return entriesFromMap(chosen);
+}
+async function publish(io) {
+  const cred = await ensureLogin();
+  const handle = requireHandle(cred);
+  if (!handle) return;
+  const detected = detectStack(process.env, process.platform);
+  const existing = await fetchProfileJson(handle);
+  const defaults = buildDefaults(existing, detected);
+  let entries = entriesFromMap(defaults);
+  const extras = existing?.extras ?? [];
+  if (io.interactive && io.prompter) {
+    entries = await promptEntries(defaults, io.prompter);
+  }
+  const profile = newProfile(handle, entries, extras);
+  console.log(renderProfile(profile, { color: colorEnabled() }));
+  if (io.interactive && io.prompter && !io.yes) {
+    const go = await io.prompter.confirm(`Publish to ymmv.fyi/${handle}?`, true);
+    if (!go) {
+      console.log("Aborted \u2014 nothing published.");
+      return;
+    }
+  }
+  await publishProfile(profile);
+}
+async function view(handle) {
+  const theirs = await fetchProfileJson(handle);
+  const c = colorEnabled();
+  if (!theirs) {
+    console.log(notFound(handle));
+    return;
+  }
+  const cred = await loadToken();
+  if (cred?.handle) {
+    const mine = await fetchProfileJson(cred.handle).catch(() => null);
+    if (mine && mine.handle.toLowerCase() !== theirs.handle.toLowerCase()) {
+      console.log(
+        renderDiff(diff(mine, theirs), { color: c, theirsLabel: theirs.handle, mineLabel: "you" })
+      );
+      return;
+    }
+    if (!mine) {
+      console.log(renderProfile(theirs, { color: c }));
+      console.log(nudge(c));
+      return;
+    }
+  }
+  console.log(renderProfile(theirs, { color: c }));
+}
+async function runSet(target) {
+  const cred = await ensureLogin();
+  const handle = requireHandle(cred);
+  if (!handle) return;
+  const existing = await fetchProfileJson(handle);
+  const { entries, extras } = applySet(existing, target);
+  await publishProfile(newProfile(handle, entries, extras));
+  if (target.kind === "curated") {
+    console.log(`Set ${KEY_LABELS[target.key]} = ${target.value}.`);
+  } else {
+    console.log(`Set extra ${target.label} = ${target.value}.`);
+  }
+}
+async function runDelete(io) {
+  const cred = await ensureLogin();
+  const target = cred.handle ? `ymmv.fyi/${cred.handle}` : "your profile";
+  if (!io.yes) {
+    if (!io.interactive || !io.prompter) {
+      console.error(
+        `Refusing to delete ${target} without confirmation. Re-run with -y to confirm: ymmv delete -y`
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const go = await io.prompter.confirm(`Delete ${target}? This is permanent`, false);
+    if (!go) {
+      console.log("Cancelled \u2014 nothing deleted.");
+      return;
+    }
+  }
+  await deleteProfile();
+  await deleteToken();
+  console.log(`Deleted ${target}. Run \`ymmv\` to publish again.`);
+}
+
+// src/prompt.ts
+import { stdin, stdout } from "process";
+import { createInterface } from "readline/promises";
+function makePrompter() {
+  let rl = null;
+  const io = () => {
+    rl ??= createInterface({ input: stdin, output: stdout });
+    return rl;
+  };
+  return {
+    async ask(label, def) {
+      const answer = (await io().question(`  ${label}${def ? ` [${def}]` : ""}: `)).trim();
+      return answer === "" ? def ?? "" : answer;
+    },
+    async confirm(question, defYes) {
+      const answer = (await io().question(`  ${question} ${defYes ? "[Y/n]" : "[y/N]"} `)).trim().toLowerCase();
+      if (answer === "") return defYes;
+      return answer === "y" || answer === "yes";
+    },
+    close() {
+      rl?.close();
+      rl = null;
+    }
+  };
+}
+
+// src/resolve.ts
+var SET_USAGE = 'usage: ymmv set <key> <value>  |  ymmv set --extra "Label=Value"';
+var EXTRA_USAGE = 'usage: ymmv set --extra "Label=Value"';
+function hasYes(args) {
+  return args.includes("-y") || args.includes("--yes");
+}
+function parseSet(rest) {
+  const head = rest[0];
+  if (head === "--extra" || head === "-e") {
+    const spec = rest.slice(1).join(" ").trim();
+    const eq = spec.indexOf("=");
+    if (eq <= 0) return { kind: "error", message: EXTRA_USAGE };
+    const label = spec.slice(0, eq).trim();
+    const value2 = spec.slice(eq + 1).trim();
+    if (!label || !value2) return { kind: "error", message: EXTRA_USAGE };
+    return { kind: "set", target: { kind: "extra", label, value: value2 } };
+  }
+  if (!head) return { kind: "error", message: SET_USAGE };
+  if (!isCuratedKey(head)) {
+    return {
+      kind: "error",
+      message: `"${head}" is not a curated key. Valid keys: ${CURATED_KEYS.join(", ")}.
+For anything else, use: ymmv set --extra "Label=Value".`
+    };
+  }
+  const value = rest.slice(1).join(" ").trim();
+  if (!value) return { kind: "error", message: `usage: ymmv set ${head} <value>` };
+  return { kind: "set", target: { kind: "curated", key: head, value } };
+}
+function resolveArg(argv) {
+  const first = argv[0];
+  if (first === "-h" || first === "--help" || first === "help") return { kind: "help" };
+  if (first === "-V" || first === "-v" || first === "--version") return { kind: "version" };
+  if (first === void 0) return { kind: "publish", yes: false };
+  if (first === "-y" || first === "--yes") return { kind: "publish", yes: true };
+  if (first === "login") return { kind: "login" };
+  if (first === "logout") return { kind: "logout" };
+  if (first === "delete") return { kind: "delete", yes: hasYes(argv.slice(1)) };
+  if (first === "set") return parseSet(argv.slice(1));
+  if (first === "view") {
+    const handle = argv[1];
+    if (!handle) return { kind: "error", message: "usage: ymmv view <handle>" };
+    if (!isValidHandle(handle)) {
+      return { kind: "error", message: `"${handle}" is not a valid GitHub handle.` };
+    }
+    return { kind: "view", handle };
+  }
+  if (first.startsWith("-")) {
+    return { kind: "error", message: `unknown option "${first}". Run \`ymmv help\`.` };
+  }
+  if (!isValidHandle(first)) {
+    return {
+      kind: "error",
+      message: `"${first}" is not a valid GitHub handle. Run \`ymmv help\`.`
+    };
+  }
+  return { kind: "view", handle: first };
+}
+
+// src/index.ts
+var HELP = `ymmv \u2014 terminal-native developer tool-stack profiles (ymmv.fyi)
+
+Usage:
+  ymmv                      detect your stack, confirm, and publish your profile
+  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
+  ymmv set --extra "L=V"    set a free-form extra
+  ymmv delete               delete your profile (permanent)
+  ymmv login | logout       GitHub device-flow auth
+  ymmv help | --version
+
+Curated keys: editor, os, shell, terminal, browser, window-manager, font,
+              multiplexer, dotfiles, ai-tool
+
+Respects NO_COLOR. Point YMMV_API at a dev Worker to target one.
+Publish your own: npx ymmv-cli`;
+async function logout() {
+  const stored = await loadToken();
+  if (!stored) {
+    const otherBase = await peekBase();
+    console.log(
+      otherBase && otherBase !== BASE ? `Not logged in to ${BASE} (a token for ${otherBase} exists \u2014 set YMMV_API to that to log out of it).` : "Not logged in."
+    );
+    return;
+  }
+  let revoked;
+  try {
+    revoked = await revokeYmmvToken(stored.token);
+  } catch {
+    console.error(
+      "Couldn't reach the server to revoke \u2014 your token is still active. Run `ymmv logout` again when connected."
+    );
+    process.exitCode = 1;
+    return;
+  }
+  await deleteToken();
+  console.log(revoked ? "Logged out." : "Logged out (no active session on this server).");
+}
+function printVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+    console.log(`ymmv-cli ${pkg.version ?? "unknown"}`);
+  } catch {
+    console.log("ymmv-cli (version unknown)");
+  }
+}
+async function interactive(run, yes) {
+  const isTTY = Boolean(process.stdin.isTTY);
+  const prompter = isTTY ? makePrompter() : void 0;
+  try {
+    await run({ interactive: isTTY, prompter, yes });
+  } finally {
+    prompter?.close();
+  }
+}
+async function main(argv) {
+  const cmd = resolveArg(argv);
+  switch (cmd.kind) {
+    case "publish":
+      await interactive(publish, cmd.yes);
+      break;
+    case "view":
+      await view(cmd.handle);
+      break;
+    case "set":
+      await runSet(cmd.target);
+      break;
+    case "delete":
+      await interactive(runDelete, cmd.yes);
+      break;
+    case "login":
+      await login();
+      break;
+    case "logout":
+      await logout();
+      break;
+    case "help":
+      console.log(HELP);
+      break;
+    case "version":
+      printVersion();
+      break;
+    case "error":
+      console.error(cmd.message);
+      process.exitCode = 1;
+      break;
+  }
+}
+var invokedPath = process.argv[1];
+if (invokedPath && import.meta.url === pathToFileURL(invokedPath).href) {
+  main(process.argv.slice(2)).catch((err) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exitCode = 1;
+  });
+}
+export {
+  main
+};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "ymmv-cli",
+  "version": "0.1.0",
+  "description": "Publish and diff terminal-native developer tool-stack profiles at ymmv.fyi.",
+  "type": "module",
+  "bin": {
+    "ymmv": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "license": "MIT",
+  "author": "the ymmv.fyi authors",
+  "homepage": "https://ymmv.fyi",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ymmv-fyi/ymmv.git",
+    "directory": "packages/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/ymmv-fyi/ymmv/issues"
+  },
+  "keywords": [
+    "ymmv",
+    "uses",
+    "dotfiles",
+    "developer-tools",
+    "profile",
+    "diff",
+    "cli",
+    "terminal"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "env-paths": "^3"
+  },
+  "devDependencies": {
+    "@types/node": "^22",
+    "@ymmv/shared": "workspace:*",
+    "tsup": "^8"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc -p tsconfig.json",
+    "test": "vitest run"
+  }
+}