ymmv-cli 0.1.4 → 0.2.0

package/README.md

@@ -2,8 +2,8 @@
 
 **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.
+Editor, OS, shell, terminal, browser, font (and more) — published to a clean
+page at `ymmv.fyi/<handle>` in about 10 seconds.
 
 ```sh
 npx ymmv-cli            # detect your stack, confirm, go live at ymmv.fyi/<you>
@@ -16,7 +16,8 @@ Install once for the short `ymmv` command:
 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 (the device flow you know from `gh`
+/ `npm login`, ~10s).
 
 ## Commands
 

package/dist/cli.js

@@ -11,7 +11,11 @@ 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 })
+    body: JSON.stringify({ access_token: accessToken }),
+    // Never follow a redirect: a 30x must fail (the existing `!res.ok` guard rejects the resulting
+    // opaqueredirect), not re-POST the GitHub access_token to the redirect target or read a
+    // redirected 200 as a successful mint. Mirrors publish/delete in api.ts.
+    redirect: "manual"
   });
   if (!res.ok) {
     const body = await res.json().catch(() => ({}));
@@ -30,7 +34,10 @@ async function mintYmmvToken(accessToken) {
 async function revokeYmmvToken(token) {
   const res = await fetch(`${BASE}/api/v1/auth/logout`, {
     method: "POST",
-    headers: { authorization: `Bearer ${token}` }
+    headers: { authorization: `Bearer ${token}` },
+    // Never follow a redirect: a 30x→200 must not read as a successful revoke (which would delete the
+    // local file while the server token stays live). Same guard as mint + publish/delete.
+    redirect: "manual"
   });
   if (!res.ok) throw new Error(`logout failed: ${res.status}`);
   const body = await res.json().catch(() => ({}));
@@ -67,6 +74,101 @@ function isCuratedKey(value) {
   return CURATED_KEY_SET.has(value);
 }
 
+// ../shared/dist/tools.js
+var TOOLS = [
+  // ── editor (envTokens mirror EDITOR_NAMES) ────────────────────────────────
+  { key: "editor", canonical: "Neovim", envTokens: ["nvim"], aliases: ["nvim"] },
+  { key: "editor", canonical: "Vim", envTokens: ["vim", "vi"] },
+  // `vi` is a detector default only, not a diff alias
+  {
+    key: "editor",
+    canonical: "VS Code",
+    envTokens: ["code"],
+    // NOT "code": elementary OS ships a distinct editor literally named "Code", so bare "code"
+    // is ambiguous as a diff alias (it stays an envToken — detecting $EDITOR=code as VS Code is fine).
+    aliases: ["vscode", "vsc", "visual studio code"]
+  },
+  { key: "editor", canonical: "VS Code Insiders", envTokens: ["code-insiders"] },
+  { key: "editor", canonical: "VSCodium", envTokens: ["codium"] },
+  { key: "editor", canonical: "Emacs", envTokens: ["emacs"] },
+  { key: "editor", canonical: "Nano", envTokens: ["nano"] },
+  { key: "editor", canonical: "Helix", envTokens: ["hx", "helix"], aliases: ["hx"] },
+  { key: "editor", canonical: "Sublime Text", envTokens: ["subl"], aliases: ["subl", "sublime"] },
+  { key: "editor", canonical: "Micro", envTokens: ["micro"] },
+  { key: "editor", canonical: "IntelliJ IDEA", envTokens: ["idea"], aliases: ["idea", "intellij"] },
+  { key: "editor", canonical: "Zed", envTokens: ["zed"] },
+  { key: "editor", canonical: "Pico", envTokens: ["pico"] },
+  // ── shell (envTokens mirror SHELL_NAMES) ──────────────────────────────────
+  { key: "shell", canonical: "zsh", envTokens: ["zsh"] },
+  { key: "shell", canonical: "bash", envTokens: ["bash"] },
+  { key: "shell", canonical: "fish", envTokens: ["fish"] },
+  { key: "shell", canonical: "sh", envTokens: ["sh"] },
+  { key: "shell", canonical: "dash", envTokens: ["dash"] },
+  { key: "shell", canonical: "ksh", envTokens: ["ksh"] },
+  { key: "shell", canonical: "tcsh", envTokens: ["tcsh"] },
+  { key: "shell", canonical: "csh", envTokens: ["csh"] },
+  { key: "shell", canonical: "Nushell", envTokens: ["nu", "nushell"], aliases: ["nu"] },
+  { key: "shell", canonical: "PowerShell", envTokens: ["pwsh", "powershell"], aliases: ["pwsh"] },
+  { key: "shell", canonical: "Elvish", envTokens: ["elvish"] },
+  { key: "shell", canonical: "xonsh", envTokens: ["xonsh"] },
+  // ── terminal (envTokens mirror TERM_PROGRAMS) ─────────────────────────────
+  { key: "terminal", canonical: "iTerm2", envTokens: ["iterm.app"], aliases: ["iterm"] },
+  { key: "terminal", canonical: "Terminal", envTokens: ["apple_terminal"] },
+  // "terminal" too generic to alias
+  { key: "terminal", canonical: "VS Code", envTokens: ["vscode"] },
+  // integrated terminal ($TERM_PROGRAM=vscode)
+  { key: "terminal", canonical: "WezTerm", envTokens: ["wezterm"] },
+  { key: "terminal", canonical: "Ghostty", envTokens: ["ghostty"] },
+  { key: "terminal", canonical: "Hyper", envTokens: ["hyper"] },
+  { key: "terminal", canonical: "Rio", envTokens: ["rio"] },
+  { key: "terminal", canonical: "kitty", envTokens: ["kitty"] },
+  { key: "terminal", canonical: "Tabby", envTokens: ["tabby"] },
+  { key: "terminal", canonical: "Warp", envTokens: ["warpterminal"] },
+  // `warpterminal` env id ≠ typed "Warp"
+  // ── 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: "multiplexer", canonical: "GNU Screen", aliases: ["screen"] }
+  // matches detector's "GNU Screen"
+];
+
+// ../shared/dist/normalize.js
+var WS = /\s+/g;
+function fold(value) {
+  return value.toLowerCase().normalize("NFC").replace(WS, "");
+}
+function buildAliases(tools) {
+  const out = {};
+  for (const tool of tools) {
+    const target = fold(tool.canonical);
+    let bucket = out[tool.key];
+    if (bucket === void 0) {
+      bucket = {};
+      out[tool.key] = bucket;
+    }
+    for (const variant of [tool.canonical, ...tool.aliases ?? []]) {
+      const folded = fold(variant);
+      if (folded === target)
+        continue;
+      bucket[folded] = target;
+    }
+  }
+  return out;
+}
+var ALIASES = buildAliases(TOOLS);
+var RAW_COMPARE_KEYS = /* @__PURE__ */ new Set(["dotfiles"]);
+function canonical(key, value) {
+  if (RAW_COMPARE_KEYS.has(key))
+    return value.trim();
+  const folded = fold(value);
+  const hit = ALIASES[key]?.[folded];
+  return typeof hit === "string" ? hit : folded;
+}
+
 // ../shared/dist/diff.js
 function toLookup(entries) {
   const map = /* @__PURE__ */ new Map();
@@ -75,9 +177,9 @@ function toLookup(entries) {
   }
   return map;
 }
-function classify(mine, theirs) {
+function classify(key, mine, theirs) {
   if (mine !== null && theirs !== null) {
-    return mine.trim() === theirs.trim() ? "same" : "changed";
+    return canonical(key, mine) === canonical(key, theirs) ? "same" : "changed";
   }
   return mine !== null ? "only_mine" : "only_theirs";
 }
@@ -93,7 +195,7 @@ function diff(mine, theirs) {
     if (mineValue === null && theirsValue === null) {
       continue;
     }
-    const status = classify(mineValue, theirsValue);
+    const status = classify(key, mineValue, theirsValue);
     if (status === "same") {
       shared += 1;
     } else {
@@ -112,6 +214,74 @@ function diff(mine, theirs) {
 // ../shared/dist/github.js
 var GITHUB_CLIENT_ID = "Ov23liMoD29eizQcN1KZ";
 
+// ../shared/dist/types.js
+var SCHEMA_VERSION = 1;
+
+// ../shared/dist/parse.js
+var MAX_PARSE_ENTRIES = 256;
+var MAX_PARSE_EXTRAS = 256;
+var MAX_PARSE_VALUE = 4096;
+var MAX_PARSE_LABEL = 4096;
+var ProfileParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ProfileParseError";
+  }
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function parseProfile(raw) {
+  if (!isRecord(raw))
+    throw new ProfileParseError("profile is not an object");
+  if (raw.schema_version !== SCHEMA_VERSION) {
+    throw new ProfileParseError(`unsupported schema_version: ${String(raw.schema_version)}`);
+  }
+  if (typeof raw.handle !== "string")
+    throw new ProfileParseError("handle is not a string");
+  if (typeof raw.updated_at !== "string")
+    throw new ProfileParseError("updated_at is not a string");
+  if (!Array.isArray(raw.entries))
+    throw new ProfileParseError("entries is not an array");
+  if (raw.entries.length > MAX_PARSE_ENTRIES) {
+    throw new ProfileParseError(`too many entries (>${MAX_PARSE_ENTRIES})`);
+  }
+  const entries = [];
+  for (let i = 0; i < raw.entries.length; i++) {
+    const entry = raw.entries[i];
+    if (!isRecord(entry) || typeof entry.key !== "string" || typeof entry.value !== "string") {
+      throw new ProfileParseError(`entry ${i} is not {key,value} strings`);
+    }
+    if (entry.value.length > MAX_PARSE_VALUE) {
+      throw new ProfileParseError(`entry ${i} value exceeds ${MAX_PARSE_VALUE} chars`);
+    }
+    entries.push({ key: entry.key, value: entry.value });
+  }
+  if (!Array.isArray(raw.extras))
+    throw new ProfileParseError("extras is not an array");
+  if (raw.extras.length > MAX_PARSE_EXTRAS) {
+    throw new ProfileParseError(`too many extras (>${MAX_PARSE_EXTRAS})`);
+  }
+  const extras = [];
+  for (let i = 0; i < raw.extras.length; i++) {
+    const extra = raw.extras[i];
+    if (!isRecord(extra) || typeof extra.label !== "string" || typeof extra.value !== "string") {
+      throw new ProfileParseError(`extra ${i} is not {label,value} strings`);
+    }
+    if (extra.label.length > MAX_PARSE_LABEL || extra.value.length > MAX_PARSE_VALUE) {
+      throw new ProfileParseError(`extra ${i} exceeds the length ceiling`);
+    }
+    extras.push({ label: extra.label, value: extra.value });
+  }
+  return {
+    schema_version: SCHEMA_VERSION,
+    handle: raw.handle,
+    entries,
+    extras,
+    updated_at: raw.updated_at
+  };
+}
+
 // ../shared/dist/reserved.js
 var RESERVED_ROUTES = ["api", "login", "logout"];
 var CLI_VERBS = ["login", "logout", "set", "delete", "view", "help"];
@@ -122,9 +292,6 @@ 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";
@@ -135,7 +302,10 @@ function tokenFilePath() {
 }
 async function saveToken(data) {
   const path = tokenFilePath();
-  await mkdir(dirname(path), { recursive: true });
+  const dir = dirname(path);
+  await mkdir(dir, { recursive: true, mode: 448 });
+  if (process.platform !== "win32") await chmod(dir, 448).catch(() => {
+  });
   const tmp = `${path}.${randomUUID()}.tmp`;
   const stored = { base: BASE, token: data.token, handle: data.handle };
   try {
@@ -198,6 +368,8 @@ async function pollForToken(dc, deps = {}) {
   const now = deps.now ?? Date.now;
   let interval = dc.interval || 5;
   const deadline = now() + dc.expires_in * 1e3;
+  let transientFailures = 0;
+  const MAX_TRANSIENT_FAILURES = 5;
   while (now() < deadline) {
     await sleep(interval * 1e3);
     const res = await doFetch(TOKEN_URL, {
@@ -209,7 +381,23 @@ async function pollForToken(dc, deps = {}) {
         grant_type: "urn:ietf:params:oauth:grant-type:device_code"
       })
     });
-    const tok = await res.json();
+    let tok;
+    if (res.ok) {
+      try {
+        tok = await res.json();
+      } catch {
+        tok = void 0;
+      }
+    }
+    if (tok === void 0) {
+      if (++transientFailures >= MAX_TRANSIENT_FAILURES) {
+        throw new Error(
+          "GitHub isn't responding to the login poll \u2014 check your connection and run `ymmv login` again."
+        );
+      }
+      continue;
+    }
+    transientFailures = 0;
     if (tok.access_token) return tok.access_token;
     switch (tok.error) {
       case "authorization_pending":
@@ -308,7 +496,7 @@ async function fetchProfileJson(handle) {
   if (!res.ok) {
     throw new Error(`fetch failed: ${res.status} ${await res.text()}`);
   }
-  return await res.json();
+  return parseProfile(await res.json());
 }
 async function deleteProfile() {
   const cred = await ensureLogin();
@@ -336,51 +524,17 @@ function basename(p) {
 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"
+var namesFor = (key) => {
+  const map = {};
+  for (const tool of TOOLS) {
+    if (tool.key !== key) continue;
+    for (const token of tool.envTokens ?? []) map[token] = tool.canonical;
+  }
+  return map;
 };
+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)`;
   switch (platform) {

package/package.json

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