joinhive 2.0.1 → 2.1.0

package/shared/prompt.mjs

@@ -0,0 +1,168 @@
+// shared/prompt — the CLI's interactive moments (select/ask/confirm/pause)
+// and progress rendering (spinner/checkpoints), hand-rolled to keep the pack
+// dependency-light.
+//
+// TTY rules:
+//   - The arrow-key select needs a real TTY; when stdin/stdout isn't one
+//     (CI, pipes, heredocs) every prompt degrades to numbered/plain line
+//     input with identical semantics. install-remote.sh re-attaches /dev/tty
+//     before exec'ing the join, so `curl | bash` lands on the TTY path.
+//   - Ctrl-C during a raw-mode select exits 130 — a half-answered wizard must
+//     never half-provision.
+// Every function accepts {input, output} for tests (fake streams exercise the
+// non-TTY paths without a terminal).
+import { createInterface } from 'node:readline/promises';
+
+const isTTY = (s) => !!(s && s.isTTY);
+const DIM = '\x1b[2m';
+const CYAN = '\x1b[36m';
+const RESET = '\x1b[0m';
+
+const line = async ({ input, output, prompt }) => {
+  // On stdin EOF (</dev/null, closed pipes) a pending question() neither
+  // resolves nor rejects — the event loop just drains and node exits 0
+  // mid-flow. Two guards: an input that ALREADY ended ('end' fires once, so
+  // a second readline on it would wait forever) throws straight away, and a
+  // mid-question EOF is turned into a rejection by racing the close event.
+  // Every caller maps the rejection to "use the default".
+  if (!input || input.readableEnded || input.destroyed || input.closed) {
+    output.write(`${prompt}\n`);
+    throw new Error('input closed');
+  }
+  const rl = createInterface({ input, output });
+  try {
+    return await Promise.race([
+      rl.question(prompt),
+      new Promise((_, reject) => rl.once('close', () => reject(new Error('input closed')))),
+    ]);
+  } finally { rl.close(); }
+};
+
+// One line of text. Empty input takes `def`; `validate` (sync or async)
+// returns true or an error string and re-prompts on failure.
+export const ask = async ({ prompt, def = '', validate = null, input = process.stdin, output = process.stdout }) => {
+  for (;;) {
+    let v;
+    try { v = (await line({ input, output, prompt: `? ${prompt}${def ? ` ${DIM}(${def})${RESET}` : ''} › ` })).trim(); }
+    catch { v = ''; }
+    if (!v) v = def;
+    if (!validate) return v;
+    const ok = await validate(v);
+    if (ok === true) return v;
+    output.write(`  ✗ ${ok || 'invalid'}\n`);
+  }
+};
+
+export const confirm = async ({ prompt, def = true, input = process.stdin, output = process.stdout }) => {
+  let v;
+  try { v = (await line({ input, output, prompt: `? ${prompt} ${def ? '(Y/n)' : '(y/N)'} › ` })).trim().toLowerCase(); }
+  catch { v = ''; }
+  if (!v) return def;
+  return v === 'y' || v === 'yes';
+};
+
+// Hard pause: nothing continues until the human presses Enter.
+export const pause = async ({ prompt, input = process.stdin, output = process.stdout }) => {
+  try { await line({ input, output, prompt: `${prompt} ` }); } catch {}
+};
+
+// Arrow-key select on a TTY; numbered list everywhere else.
+// options: [{label, hint?, value}] -> resolves to the chosen option's value.
+export const select = async ({ title, options, defaultIndex = 0, input = process.stdin, output = process.stdout }) => {
+  if (!Array.isArray(options) || !options.length) throw new Error('select needs options');
+  let idx = Math.min(Math.max(defaultIndex, 0), options.length - 1);
+
+  if (!isTTY(input) || !isTTY(output) || typeof input.setRawMode !== 'function') {
+    output.write(`? ${title}\n`);
+    options.forEach((o, i) => output.write(`  ${i + 1}. ${o.label}${o.hint ? ` ${DIM}— ${o.hint}${RESET}` : ''}${i === idx ? '  (default)' : ''}\n`));
+    let v;
+    try { v = (await line({ input, output, prompt: `  pick 1-${options.length} › ` })).trim(); } catch { v = ''; }
+    const n = Number(v);
+    if (Number.isInteger(n) && n >= 1 && n <= options.length) idx = n - 1;
+    return options[idx].value;
+  }
+
+  const lines = options.length + 1;
+  const render = (first) => {
+    if (!first) output.write(`\x1b[${lines}A`);
+    output.write(`\x1b[0J? ${title} ${DIM}(↑/↓, Enter)${RESET}\n`);
+    options.forEach((o, i) => {
+      const on = i === idx;
+      const label = on ? `${CYAN}❯ ${o.label}${RESET}` : `  ${o.label}`;
+      output.write(`  ${label}${o.hint ? ` ${DIM}— ${o.hint}${RESET}` : ''}\n`);
+    });
+  };
+
+  render(true);
+  input.setRawMode(true);
+  input.resume();
+  const picked = await new Promise((resolve) => {
+    const cleanup = () => { input.off('data', onData); input.setRawMode(false); input.pause(); };
+    const onData = (buf) => {
+      const s = buf.toString();
+      if (s === '\x03') { cleanup(); output.write('\n'); process.exit(130); }
+      if (s === '\r' || s === '\n') { cleanup(); return resolve(idx); }
+      if (/^[1-9]$/.test(s) && Number(s) <= options.length) { idx = Number(s) - 1; cleanup(); return resolve(idx); }
+      if (s === '\x1b[A' || s === 'k') idx = (idx - 1 + options.length) % options.length;
+      else if (s === '\x1b[B' || s === 'j' || s === '\t') idx = (idx + 1) % options.length;
+      else return;
+      render(false);
+    };
+    input.on('data', onData);
+  });
+  output.write(`\x1b[${lines}A\x1b[0J? ${title} › ${CYAN}${options[picked].label}${RESET}\n`);
+  return options[picked].value;
+};
+
+const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
+// Single-line spinner. On non-TTY output each text() prints its own line.
+export const spinner = (text, { output = process.stdout } = {}) => {
+  const tty = isTTY(output);
+  let cur = text;
+  let i = 0;
+  let timer = null;
+  const draw = () => output.write(`\r\x1b[K${CYAN}${FRAMES[i = (i + 1) % FRAMES.length]}${RESET} ${cur}`);
+  if (tty) { draw(); timer = setInterval(draw, 100); } else output.write(`… ${cur}\n`);
+  return {
+    text(t) { cur = t; if (!tty) output.write(`… ${t}\n`); },
+    stop(final) {
+      if (timer) { clearInterval(timer); timer = null; }
+      if (tty) output.write('\r\x1b[K');
+      if (final) output.write(`${final}\n`);
+    },
+  };
+};
+
+// Named checkpoints on one live line: `invite ✓ → bee key ⠸ → grants`.
+// items: [{key, label}]. set(key, 'active'|'done'|'skip') re-renders; stop()
+// finalizes the line. Non-TTY output prints one line per completed step.
+export const checkpoints = (items, { output = process.stdout } = {}) => {
+  const tty = isTTY(output);
+  const state = new Map();
+  let spin = 0;
+  let timer = null;
+  const renderLine = () => items.map(({ key, label }) => {
+    const st = state.get(key);
+    if (st === 'done') return `${label} ✓`;
+    if (st === 'skip') return `${label} ⤼`;
+    if (st === 'active') return `${label} ${CYAN}${FRAMES[spin % FRAMES.length]}${RESET}`;
+    return `${DIM}${label}${RESET}`;
+  }).join(' → ');
+  const draw = () => { spin++; output.write(`\r\x1b[K▸ ${renderLine()}`); };
+  if (tty) { draw(); timer = setInterval(draw, 120); }
+  return {
+    set(key, st = 'done') {
+      if (state.get(key) === st) return;
+      state.set(key, st);
+      if (tty) draw();
+      else if (st === 'done' || st === 'skip') output.write(`  ${st === 'done' ? '✓' : '⤼'} ${items.find((i) => i.key === key)?.label || key}\n`);
+    },
+    has(key) { return state.has(key); },
+    stop(final) {
+      if (timer) { clearInterval(timer); timer = null; }
+      if (tty) output.write('\r\x1b[K');
+      if (final) output.write(`${final}\n`);
+    },
+  };
+};