@litfamily/lithermes 1.0.0

package/src/lib/config.js

@@ -0,0 +1,229 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const { writeFileAtomic } = require("./files");
+const modelConfig = require("./modelConfig");
+
+function configPath(hermesHome) {
+  return path.join(hermesHome, "config.yaml");
+}
+
+function readConfig(hermesHome) {
+  const file = configPath(hermesHome);
+  return fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
+}
+
+function findPluginsBlock(lines) {
+  const start = lines.findIndex((line) => /^plugins:\s*$/.test(line));
+  if (start === -1) return null;
+  let end = lines.length;
+  for (let i = start + 1; i < lines.length; i += 1) {
+    if (/^\S/.test(lines[i]) && !/^---\s*$/.test(lines[i])) {
+      end = i;
+      break;
+    }
+  }
+  return { start, end, lines: lines.slice(start, end) };
+}
+
+function configHasLitHermes(text) {
+  const block = findPluginsBlock(text.split(/\r?\n/));
+  if (!block) return false;
+  return block.lines.some((line, index) => {
+    if (/^\s*enabled:\s*\[[^\]]*lithermes[^\]]*\]/.test(line)) return true;
+    if (!/^\s*enabled:\s*$/.test(line)) return false;
+    for (let i = index + 1; i < block.lines.length; i += 1) {
+      const child = block.lines[i];
+      if (/^\s{2}\S/.test(child) && !/^\s{2,}-/.test(child)) return false;
+      if (/^\s*-\s*lithermes\s*$/.test(child)) return true;
+    }
+    return false;
+  });
+}
+
+function enableLitHermesConfig(text) {
+  if (configHasLitHermes(text)) return text;
+  if (!text.trim()) {
+    return "plugins:\n  enabled:\n    - lithermes\n";
+  }
+  const trailingNewline = text.endsWith("\n");
+  const lines = text.split(/\r?\n/);
+  if (!trailingNewline && lines[lines.length - 1] === "") lines.pop();
+  const block = findPluginsBlock(lines);
+  if (block) {
+    for (let i = block.start + 1; i < block.end; i += 1) {
+      const line = lines[i];
+      if (/^\s{2}enabled:\s*\[[^\]]*\]/.test(line)) {
+        lines[i] = line.replace(/\[([^\]]*)\]/, (_match, inner) => {
+          const values = inner.split(",").map((item) => item.trim()).filter(Boolean);
+          values.push("lithermes");
+          return `[${values.join(", ")}]`;
+        });
+        return `${lines.join("\n")}${trailingNewline ? "\n" : ""}`;
+      }
+      if (/^\s{2}enabled:\s*$/.test(line)) {
+        lines.splice(i + 1, 0, "    - lithermes");
+        return `${lines.join("\n")}${trailingNewline ? "\n" : ""}`;
+      }
+    }
+    lines.splice(block.start + 1, 0, "  enabled:", "    - lithermes");
+    return `${lines.join("\n")}${trailingNewline ? "\n" : ""}`;
+  }
+  const suffix = text.endsWith("\n") ? "" : "\n";
+  return `${text}${suffix}plugins:\n  enabled:\n    - lithermes\n`;
+}
+
+function disableLitHermesConfig(text) {
+  const trailingNewline = text.endsWith("\n");
+  const lines = text.split(/\r?\n/);
+  const block = findPluginsBlock(lines);
+  if (!block) return text;
+  for (let i = block.start + 1; i < block.end; i += 1) {
+    const line = lines[i];
+    if (/^\s{2}enabled:\s*\[[^\]]*lithermes[^\]]*\]/.test(line)) {
+      const inner = line.match(/\[([^\]]*)\]/)?.[1] || "";
+      const values = inner.split(",").map((item) => item.trim()).filter((item) => item && item !== "lithermes");
+      lines[i] = `  enabled: [${values.join(", ")}]`;
+    }
+    if (/^\s*-\s*lithermes\s*$/.test(line)) {
+      lines.splice(i, 1);
+      i -= 1;
+      block.end -= 1;
+    }
+  }
+  return `${lines.join("\n")}${trailingNewline ? "\n" : ""}`;
+}
+
+function findTopBlock(lines, key) {
+  const re = new RegExp(`^${key}:\\s*$`);
+  const start = lines.findIndex((line) => re.test(line));
+  if (start === -1) return null;
+  let end = lines.length;
+  for (let i = start + 1; i < lines.length; i += 1) {
+    if (/^\S/.test(lines[i]) && !/^---\s*$/.test(lines[i])) {
+      end = i;
+      break;
+    }
+  }
+  return { start, end };
+}
+
+function readDisplaySkinConfig(text) {
+  const lines = String(text || "").split(/\r?\n/);
+  const block = findTopBlock(lines, "display");
+  if (!block) return null;
+  for (let i = block.start + 1; i < block.end; i += 1) {
+    const m = /^\s{2}skin:\s*(\S.*?)\s*$/.exec(lines[i]);
+    if (m) return m[1];
+  }
+  return null;
+}
+
+function setDisplaySkinConfig(text, skinName) {
+  const value = String(skinName || "").trim();
+  if (!value) return text;
+  const trailingNewline = !text || text.endsWith("\n");
+  const lines = String(text || "").split(/\r?\n/);
+  if (!trailingNewline && lines[lines.length - 1] === "") lines.pop();
+  const block = findTopBlock(lines, "display");
+  if (block) {
+    for (let i = block.start + 1; i < block.end; i += 1) {
+      if (/^\s{2}skin:\s*/.test(lines[i])) {
+        lines[i] = `  skin: ${value}`;
+        return `${lines.join("\n").replace(/\n*$/, "")}\n`;
+      }
+    }
+    lines.splice(block.start + 1, 0, `  skin: ${value}`);
+    return `${lines.join("\n").replace(/\n*$/, "")}\n`;
+  }
+  const body = lines.join("\n").replace(/\n*$/, "");
+  const prefix = body ? `${body}\n` : "";
+  return `${prefix}display:\n  skin: ${value}\n`;
+}
+
+function readTuiAgentsNudgeConfig(text) {
+  const lines = String(text || "").split(/\r?\n/);
+  const block = findTopBlock(lines, "display");
+  if (!block) return null;
+  for (let i = block.start + 1; i < block.end; i += 1) {
+    const m = /^\s{2}tui_agents_nudge:\s*(\S.*?)\s*$/.exec(lines[i]);
+    if (m) return m[1];
+  }
+  return null;
+}
+
+// Managed key for helper-agent visibility (Hermes display.tui_agents_nudge).
+// Set only when absent: an explicit user value, true or false, is preserved.
+function setTuiAgentsNudgeConfig(text) {
+  if (readTuiAgentsNudgeConfig(text) !== null) return text;
+  const trailingNewline = !text || text.endsWith("\n");
+  const lines = String(text || "").split(/\r?\n/);
+  if (!trailingNewline && lines[lines.length - 1] === "") lines.pop();
+  const block = findTopBlock(lines, "display");
+  if (block) {
+    lines.splice(block.start + 1, 0, "  tui_agents_nudge: true");
+    return `${lines.join("\n").replace(/\n*$/, "")}\n`;
+  }
+  const body = lines.join("\n").replace(/\n*$/, "");
+  const prefix = body ? `${body}\n` : "";
+  return `${prefix}display:\n  tui_agents_nudge: true\n`;
+}
+
+function clearDisplaySkinConfig(text) {
+  const lines = String(text || "").split(/\r?\n/);
+  const block = findTopBlock(lines, "display");
+  if (!block) return text;
+  for (let i = block.start + 1; i < block.end; i += 1) {
+    if (/^\s{2}skin:\s*/.test(lines[i])) {
+      lines.splice(i, 1);
+      break;
+    }
+  }
+  return `${lines.join("\n").replace(/\n*$/, "")}\n`;
+}
+
+function readOutputStyleConfig(text) {
+  const m = /^outputStyle:\s*(\S.*?)\s*$/m.exec(String(text || ""));
+  return m ? m[1] : null;
+}
+
+function setOutputStyleConfig(text, styleId) {
+  const value = String(styleId || "").trim();
+  if (!value) return text;
+  const str = String(text || "");
+  if (/^outputStyle:\s*\S/m.test(str)) {
+    const updated = str.replace(/^outputStyle:\s*(\S.*?)$/m, `outputStyle: ${value}`);
+    return `${updated.replace(/\n*$/, "")}\n`;
+  }
+  const body = str.replace(/\n*$/, "");
+  const prefix = body ? `${body}\n` : "";
+  return `${prefix}outputStyle: ${value}\n`;
+}
+
+function clearOutputStyleConfig(text) {
+  const str = String(text || "");
+  const updated = str.split(/\r?\n/).filter((line) => !/^outputStyle:\s*/.test(line)).join("\n");
+  return `${updated.replace(/\n*$/, "")}\n`;
+}
+
+function writeConfig(hermesHome, text) {
+  fs.mkdirSync(hermesHome, { recursive: true });
+  writeFileAtomic(configPath(hermesHome), text, "utf8");
+}
+
+module.exports = {
+  ...modelConfig,
+  clearDisplaySkinConfig,
+  clearOutputStyleConfig,
+  configHasLitHermes,
+  configPath,
+  disableLitHermesConfig,
+  enableLitHermesConfig,
+  readConfig,
+  readDisplaySkinConfig,
+  readOutputStyleConfig,
+  readTuiAgentsNudgeConfig,
+  setDisplaySkinConfig,
+  setOutputStyleConfig,
+  setTuiAgentsNudgeConfig,
+  writeConfig,
+};

package/src/lib/files.js

@@ -0,0 +1,126 @@
+const crypto = require("node:crypto");
+const fs = require("node:fs");
+const path = require("node:path");
+
+function listFiles(root) {
+  const out = [];
+  if (!fs.existsSync(root)) return out;
+  for (const name of fs.readdirSync(root)) {
+    if (name === "__pycache__" || name.endsWith(".pyc")) continue;
+    const full = path.join(root, name);
+    const stat = fs.statSync(full);
+    if (stat.isDirectory()) {
+      out.push(...listFiles(full));
+    } else if (stat.isFile()) {
+      out.push(full);
+    }
+  }
+  return out;
+}
+
+function sha256(file) {
+  return crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex");
+}
+
+function copyTree(src, dest) {
+  const copied = [];
+  for (const file of listFiles(src)) {
+    const relative = path.relative(src, file);
+    const target = path.join(dest, relative);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.copyFileSync(file, target);
+    copied.push({ path: relative, sha256: sha256(target) });
+  }
+  return copied;
+}
+
+function cleanPythonCache(root) {
+  let removed = 0;
+  if (!fs.existsSync(root)) return removed;
+  for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+    const full = path.join(root, entry.name);
+    if (entry.isDirectory() && entry.name === "__pycache__") {
+      fs.rmSync(full, { recursive: true, force: true });
+      removed += 1;
+    } else if (entry.isDirectory()) {
+      removed += cleanPythonCache(full);
+    } else if (entry.isFile() && /\.py[co]$/.test(entry.name)) {
+      fs.rmSync(full, { force: true });
+      removed += 1;
+    }
+  }
+  return removed;
+}
+
+function inspectPythonCache(root) {
+  let entries = 0;
+  if (!fs.existsSync(root)) return entries;
+  for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+    const full = path.join(root, entry.name);
+    if (entry.isDirectory()) {
+      entries += inspectPythonCache(full);
+    } else if (entry.isFile() && /\.py[co]$/.test(entry.name)) {
+      entries += 1;
+    }
+  }
+  return entries;
+}
+
+// Atomic write: write to a .tmp sibling, fsync, then rename into place.
+// fsync failure is non-fatal (degrades gracefully — still renames).
+function writeFileAtomic(filePath, data, encoding) {
+  const enc = encoding || "utf8";
+  const prefix = `.${path.basename(filePath)}.${process.pid}.`;
+  let tmp;
+  let fd;
+  try {
+    for (let attempt = 0; attempt < 10; attempt += 1) {
+      tmp = path.join(path.dirname(filePath), `${prefix}${crypto.randomBytes(8).toString("hex")}.tmp`);
+      try {
+        fd = fs.openSync(tmp, "wx", 0o600);
+        break;
+      } catch (error) {
+        if (error.code !== "EEXIST" || attempt === 9) throw error;
+      }
+    }
+    fs.fchmodSync(fd, 0o600);
+    fs.writeSync(fd, data, null, enc);
+    try {
+      fs.fsyncSync(fd);
+    } catch {
+      // fsync not supported on all platforms/fs; degrade gracefully
+    }
+    fs.closeSync(fd);
+    fd = undefined;
+    fs.renameSync(tmp, filePath);
+  } catch (error) {
+    if (fd !== undefined) {
+      try {
+        fs.closeSync(fd);
+      } catch {
+        // Preserve the original write/close error.
+      }
+    }
+    if (tmp && fs.existsSync(tmp)) fs.unlinkSync(tmp);
+    throw error;
+  }
+}
+
+function removeEmptyDirs(dir, stopAt) {
+  let current = dir;
+  while (current && current !== stopAt && current.startsWith(stopAt) && fs.existsSync(current)) {
+    if (fs.readdirSync(current).length > 0) break;
+    fs.rmdirSync(current);
+    current = path.dirname(current);
+  }
+}
+
+module.exports = {
+  cleanPythonCache,
+  copyTree,
+  inspectPythonCache,
+  listFiles,
+  removeEmptyDirs,
+  sha256,
+  writeFileAtomic,
+};

package/src/lib/hermesDiscovery.js

@@ -0,0 +1,122 @@
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+
+class LitHermesError extends Error {
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.exitCode = exitCode;
+  }
+}
+
+function expandHome(value) {
+  if (!value) return value;
+  if (value === "~") return os.homedir();
+  if (value.startsWith("~/")) return path.join(os.homedir(), value.slice(2));
+  return value;
+}
+
+function defaultHermesHome(flags = {}) {
+  return path.resolve(expandHome(flags["hermes-home"] || process.env.HERMES_HOME || "~/.hermes"));
+}
+
+function assertPluginParent(hermesHome) {
+  const parent = path.join(hermesHome, "plugins");
+  const stat = fs.lstatSync(parent, { throwIfNoEntry: false });
+  if (stat && !stat.isDirectory()) {
+    throw new LitHermesError(`Refusing to modify plugins through a symlink or non-directory at ${parent}.`, 5);
+  }
+}
+
+// The selected home may be an explicit alias; its managed state child may not.
+// A captured identity also rejects replacement directories at later checkpoints.
+function assertManagedDirectory(parent, expected) {
+  const stat = fs.lstatSync(parent, { throwIfNoEntry: false }) || null;
+  if ((stat && !stat.isDirectory()) || (expected !== undefined
+    && (Boolean(stat) !== Boolean(expected) || (stat && (stat.dev !== expected.dev || stat.ino !== expected.ino))))) {
+    throw new LitHermesError(`Refusing unsafe or replaced LitHermes state directory at ${parent}.`, 5);
+  }
+  return stat;
+}
+
+function assertStateParent(hermesHome, expected) {
+  return assertManagedDirectory(path.join(hermesHome, "lithermes"), expected);
+}
+
+function defaultHermesRepo(flags = {}, hermesHome = defaultHermesHome(flags)) {
+  if (flags["hermes-repo"]) return path.resolve(expandHome(flags["hermes-repo"]));
+  const candidate = path.join(hermesHome, "hermes-agent");
+  return fs.existsSync(candidate) ? candidate : null;
+}
+
+function detectHermesRuntimeRepo() {
+  const executable = (process.env.PATH || "").split(path.delimiter)
+    .map((entry) => path.join(entry, "hermes"))
+    .find((entry) => fs.existsSync(entry));
+  if (!executable) return null;
+  try {
+    const firstLine = fs.readFileSync(executable, "utf8").split(/\r?\n/, 1)[0];
+    const interpreter = firstLine.startsWith("#!") ? firstLine.slice(2).trim() : "";
+    const runtimeRepo = path.dirname(path.dirname(path.dirname(interpreter)));
+    return fs.existsSync(path.join(runtimeRepo, "hermes_cli")) ? runtimeRepo : null;
+  } catch {
+    return null;
+  }
+}
+
+function inspectHermesHostCapabilities(hermesRepo) {
+  const unavailable = { concurrencyHard: false, delegationRouteHard: false, runtimeHard: false };
+  if (!hermesRepo) return unavailable;
+  try {
+    const delegation = fs.readFileSync(path.join(hermesRepo, "tools", "delegate_tool.py"), "utf8");
+    const runtime = fs.readFileSync(path.join(hermesRepo, "hermes_cli", "runtime_provider.py"), "utf8");
+    const runtimeStem = ["co", "dex"].join("");
+    return {
+      concurrencyHard: delegation.includes("_get_max_concurrent_children")
+        && delegation.includes('cfg.get("max_concurrent_children")')
+        && delegation.includes("max(1, int(val))"),
+      delegationRouteHard: delegation.includes('configured_model = str(cfg.get("model")')
+        && delegation.includes('delegation_cfg.get("reasoning_effort")')
+        && delegation.includes("effective_model = model or parent_agent.model"),
+      runtimeHard: runtime.includes(`provider == "openai-${runtimeStem}"`)
+        && runtime.includes(`api_mode = "${runtimeStem}_responses"`),
+    };
+  } catch {
+    return unavailable;
+  }
+}
+
+function ensureHermesHome(flags = {}, { forInstall = false } = {}) {
+  const hermesHome = defaultHermesHome(flags);
+  if (!fs.existsSync(hermesHome)) {
+    if (forInstall) {
+      fs.mkdirSync(hermesHome, { recursive: true });
+    } else {
+      throw new LitHermesError(`Hermes installation not found at ${hermesHome}. Pass --hermes-home PATH to select it.`, 2);
+    }
+  }
+  return {
+    hermesHome,
+    hermesRepo: defaultHermesRepo(flags, hermesHome),
+  };
+}
+
+function detectHermesVersion() {
+  const result = spawnSync("hermes", ["--version"], { encoding: "utf8", timeout: 15000 });
+  return result.status === 0 ? (result.stdout || result.stderr || "") : "";
+}
+
+module.exports = {
+  assertPluginParent,
+  assertStateParent,
+  assertManagedDirectory,
+  LitHermesError,
+  defaultHermesHome,
+  defaultHermesRepo,
+  detectHermesRuntimeRepo,
+  detectHermesVersion,
+  ensureHermesHome,
+  expandHome,
+  inspectHermesHostCapabilities,
+};

package/src/lib/hud.js

@@ -0,0 +1,135 @@
+const os = require("node:os");
+const path = require("node:path");
+const readline = require("node:readline");
+const skins = require("./skins");
+const {
+  readConfig,
+  writeConfig,
+  setDisplaySkinConfig,
+  clearDisplaySkinConfig,
+  readDisplaySkinConfig,
+} = require("./config");
+
+function resolveHome(flags = {}) {
+  const fromFlag = flags["hermes-home"];
+  if (typeof fromFlag === "string" && fromFlag.trim()) return path.resolve(fromFlag);
+  const env = (process.env.HERMES_HOME || "").trim();
+  if (env) return path.resolve(env);
+  return path.join(os.homedir(), ".hermes");
+}
+
+// ANSI helpers — all output goes through these so no-color paths stay clean.
+const BOLD  = (s, on) => on ? `\x1b[1m${s}\x1b[22m` : s;
+const DIM   = (s, on) => on ? `\x1b[2m${s}\x1b[22m` : s;
+const FG256 = (code, s, on) => on ? `\x1b[38;5;${code}m${s}\x1b[39m` : s;
+
+function listHud({ color = false, hermesHome = null } = {}) {
+  const current = hermesHome ? readDisplaySkinConfig(readConfig(hermesHome)) : null;
+
+  // Header — fire brand mark + neon label when color is on
+  const brand = color ? "🔥" : "[fire]";
+  const header = color
+    ? `${brand} ${BOLD("LitHermes HUD", true)} ${DIM("— neon accents", true)}`
+    : `${brand} LitHermes HUD — neon accents`;
+  const lines = [header, ""];
+  const ignitionActive = current === skins.skinName(skins.IGNITION.accent) ? " *" : "";
+  lines.push(`      ${skins.swatch(skins.IGNITION.hex, { color })} ignition  orange / lime / ivory / navy${ignitionActive}`);
+
+  for (const theme of skins.NAMED_THEMES) {
+    const sw = skins.swatch(theme.hex, { color });
+    const activeMark = current === skins.skinName(theme.accent) ? (color ? " 🔥" : " *") : "";
+    const label = color ? BOLD(skins.skinName(theme.accent), true) : skins.skinName(theme.accent);
+    lines.push(`      ${sw} ${label}  ${theme.label}${activeMark}`);
+  }
+
+  skins.HUD_ACCENTS.forEach((a, i) => {
+    const sw = skins.swatch(a.hex, { color, code: a.code });
+    const isActive = current === skins.skinName(a.accent);
+
+    // Active indicator: 🔥 in color, * in plain
+    const activeMark = isActive ? (color ? " 🔥" : " *") : "";
+
+    // Mood label — dimmed in color mode for a secondary-info feel
+    const moodText = a.mood ? `  ${DIM(a.mood, color)}` : "";
+
+    // Accent name — bold + accent color when active, plain bold otherwise
+    const accentLabel = color
+      ? (isActive
+          ? BOLD(FG256(a.code, a.accent.padEnd(9), true), true)
+          : BOLD(a.accent.padEnd(9), true))
+      : a.accent.padEnd(9);
+
+    const hexLabel = color ? DIM(a.hex, true) : a.hex;
+
+    lines.push(
+      `  ${String(i + 1).padStart(2)}. ${sw} ${accentLabel} ${hexLabel}${moodText}${activeMark}`
+    );
+  });
+
+  lines.push("");
+  const applyCmd  = color ? BOLD("lithermes hud <accent>", true) : "lithermes hud <accent>";
+  const clearCmd  = color ? BOLD("lithermes hud off", true) : "lithermes hud off";
+  const skinCmd   = color ? BOLD("/skin lithermes-<accent>", true) : "/skin lithermes-<accent>";
+  lines.push(`Apply:     ${applyCmd}   (e.g. lithermes hud rose, or hud 1)`);
+  lines.push(`Clear:     ${clearCmd}`);
+  lines.push(`In Hermes: ${skinCmd}  (or set display.skin in config.yaml)`);
+  return lines.join("\n");
+}
+
+function applyHud(token, flags = {}) {
+  const entry = skins.findAccent(token);
+  if (!entry) {
+    const names = [
+      ...skins.HUD_ACCENTS.map((a) => a.accent),
+      skins.IGNITION.accent,
+      ...skins.NAMED_THEMES.map((a) => skins.skinName(a.accent)),
+    ].join(", ");
+    const err = new Error(`unknown accent '${token}'. choose one of: ${names}`);
+    err.exitCode = 4;
+    throw err;
+  }
+  const home = resolveHome(flags);
+  const written = skins.installSkins(home);
+  const name = skins.skinName(entry.accent);
+  const before = readConfig(home);
+  const after = setDisplaySkinConfig(before, name);
+  if (after !== before) writeConfig(home, after);
+  return [
+    `LitHermes HUD set to ${entry.label} (${name}).`,
+    `Installed ${written.length} skins -> ${skins.skinsDir(home)}`,
+    `config: display.skin: ${name}`,
+    `Restart Hermes, or run \`/skin ${name}\` in a session, to apply.`,
+  ].join("\n");
+}
+
+function clearHud(flags = {}) {
+  const home = resolveHome(flags);
+  const before = readConfig(home);
+  const after = clearDisplaySkinConfig(before);
+  if (after !== before) writeConfig(home, after);
+  return "LitHermes HUD cleared (display.skin removed). Restart Hermes to revert to the default skin.";
+}
+
+// Interactive accent picker used during `lithermes install` on a TTY.
+// Returns the chosen accent entry, or null to skip (empty / unknown answer).
+function promptAccent({ input = process.stdin, output = process.stdout, color = false } = {}) {
+  return new Promise((resolve) => {
+    output.write("Choose a Hermes HUD accent:\n");
+    output.write("      ignition  orange / lime / ivory / navy\n");
+    skins.HUD_ACCENTS.forEach((a, i) => {
+      const sw = skins.swatch(a.hex, { color, code: a.code });
+      output.write(`  ${String(i + 1).padStart(2)}. ${sw} ${a.accent}\n`);
+    });
+    const rl = readline.createInterface({ input, output, terminal: color && Boolean(output.isTTY) });
+    // Resolve to null if the stream closes without an answer (e.g. piped input
+    // that ends without a newline); the question callback resolves first when an
+    // answer arrives, so this is a no-op in the normal path.
+    rl.on("close", () => resolve(null));
+    rl.question("Pick 1-10 or name, including ignition (Enter to skip): ", (answer) => {
+      resolve(skins.findAccent(answer)); // resolve BEFORE close so the answer wins
+      rl.close();
+    });
+  });
+}
+
+module.exports = { resolveHome, listHud, applyHud, clearHud, promptAccent };