@tgcloud/cli 0.1.0

package/src/utils/prompt.js

@@ -0,0 +1,220 @@
+import { createInterface } from 'readline';
+
+// A single persistent line reader feeding a queue, shared across all prompts in
+// the process.
+//
+// Why not readline.question per prompt: question() only captures the line that
+// arrives WHILE it is waiting. With piped / non-TTY input (scripts, CI, tests)
+// the producer writes every line at once and ends stdin; lines that arrive
+// between prompts (or before the next question() is set up) are emitted by
+// readline with no one listening and are lost — so a multi-step prompt sequence
+// silently stops applying. Buffering every 'line' into a queue decouples input
+// capture from prompt timing, so early/piped lines survive until consumed.
+//
+// Call closePrompts() once the interactive flow ends so the open stdin handle
+// doesn't keep the process alive.
+let _rl;
+const _lines = [];     // buffered input lines not yet consumed
+let _waiter = null;    // resolver for a prompt awaiting the next line
+let _closed = false;
+
+function ensureReader() {
+  if (_rl) return;
+  _rl = createInterface({ input: process.stdin });
+  _rl.on('line', (line) => {
+    if (_waiter) {
+      const w = _waiter;
+      _waiter = null;
+      w(line);
+    } else {
+      _lines.push(line);
+    }
+  });
+  _rl.on('close', () => {
+    _closed = true;
+    if (_waiter) {
+      const w = _waiter;
+      _waiter = null;
+      w(null); // EOF — no more input
+    }
+  });
+}
+
+function nextLine() {
+  ensureReader();
+  if (_lines.length) return Promise.resolve(_lines.shift());
+  if (_closed) return Promise.resolve(null);
+  return new Promise((resolve) => { _waiter = resolve; });
+}
+
+export function closePrompts() {
+  if (_rl) {
+    _rl.close();
+    _rl = undefined;
+  }
+  _lines.length = 0;
+  _waiter = null;
+  _closed = false;
+}
+
+export async function ask(question) {
+  // The reader has no output stream, so print the prompt ourselves; in a TTY the
+  // terminal echoes the typed answer, in a pipe there's nothing to echo.
+  process.stdout.write(question);
+  const line = await nextLine();
+  return line == null ? '' : line.trim();
+}
+
+export async function confirm(question) {
+  // Uppercase N signals the default: empty input (or anything but y/yes) → false,
+  // matching askLetter's uppercased-default convention.
+  const answer = await ask(`${question} (y/N) `);
+  return answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes';
+}
+
+/**
+ * Ask the user to pick one of several single-letter choices.
+ *
+ * @param {string} question  — e.g. `chalk.red('Apply drop_table old_sessions?')`
+ * @param {string} choices   — allowed letters, e.g. "ynaq". First letter is
+ *                             the default (shown uppercase); hitting Enter
+ *                             returns it.
+ * Returns the chosen letter (lowercase).
+ * Reprompts on invalid input.
+ */
+export async function askChoice(question, choices) {
+  const lower = choices.toLowerCase();
+  const def = lower[0];
+  const label = lower.split('').map((c, i) => (i === 0 ? c.toUpperCase() : c)).join('/');
+
+  while (true) {
+    const raw = await ask(`${question} (${label}) `);
+    const input = raw.trim().toLowerCase();
+    if (input === '') return def;
+    if (input.length === 1 && lower.includes(input)) return input;
+    // invalid → reprompt
+  }
+}
+
+// Returned by askLetter when input ends before a choice is made (Ctrl-D at a
+// TTY, or piped input exhausted). Callers guarding destructive actions must
+// treat this as "abort", never as the first option — see the migration flow.
+export const EOF = Symbol('prompt-eof');
+
+/**
+ * Like `askChoice` but with descriptive labels rendered as `[k]label`.
+ *
+ * A default is applied on empty input ONLY when an option is explicitly marked
+ * `default: true` (rendered uppercase). With no explicit default, empty input
+ * reprompts — so a bare Enter can never trigger a destructive choice by accident.
+ * End-of-input returns the EOF sentinel rather than silently picking an option.
+ *
+ * @param {string} question
+ * @param {Array<{key:string,label:string,default?:boolean}>} options
+ * Returns the chosen key (lowercase), or EOF. Reprompts on empty (no default) or invalid input.
+ */
+export async function askLetter(question, options) {
+  const explicit = options.find((o) => o.default);
+  const def = explicit ? explicit.key.toLowerCase() : null;
+  // If the label starts with the key letter (e.g. key='y' label='yes'),
+  // render it as `[y]es` rather than the duplicating `[y]yes`; the default
+  // option's key is shown uppercase so the Enter behavior is visible.
+  const renderOpt = (o) => {
+    const k = o.key.toLowerCase();
+    const shown = o.default ? o.key.toUpperCase() : o.key;
+    const lbl = o.label;
+    return lbl.toLowerCase().startsWith(k)
+      ? `[${shown}]${lbl.slice(1)}`
+      : `[${shown}]${lbl}`;
+  };
+  const opts = options.map(renderOpt).join(' / ');
+  const valid = new Set(options.map((o) => o.key.toLowerCase()));
+
+  while (true) {
+    process.stdout.write(`${question} ${opts} `);
+    const line = await nextLine();
+    if (line == null) return EOF;            // Ctrl-D / end of piped input → abort
+    const input = line.trim().toLowerCase();
+    if (input === '') {
+      if (def) return def;
+      continue;                              // no explicit default → never auto-pick
+    }
+    if (input.length === 1 && valid.has(input)) return input;
+  }
+}
+
+/**
+ * Block until the user presses Enter. Used in non-interactive blocks of the
+ * migration walk-through (manual / undocumented sections) to acknowledge
+ * the message before continuing.
+ */
+export async function waitForEnter(prompt = 'Press Enter to continue...') {
+  process.stdout.write(prompt);
+  await nextLine();
+}
+
+/**
+ * Prompt for a secret input without echoing characters.
+ * Uses raw mode on stdin to suppress echo; no external dependency.
+ *
+ * If the current stdin isn't a TTY (e.g. piped), falls back to reading a line
+ * without masking — secret won't be echoed visibly since it's not interactive.
+ */
+export function askPassword(question) {
+  return new Promise((resolve, reject) => {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+
+    stdout.write(question);
+
+    if (!stdin.isTTY || typeof stdin.setRawMode !== 'function') {
+      // Non-interactive (piped/CI): read through the SHARED line queue, not a
+      // private readline. A private interface on stdin never fires its callback
+      // on EOF, so the login loop hangs and the process exits 0 without saving.
+      // nextLine() resolves null on EOF, letting the caller stop instead of
+      // spinning on empty input. No echo suppression — not a terminal.
+      nextLine().then((line) => resolve(line == null ? null : line.trim()));
+      return;
+    }
+
+    let input = '';
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding('utf8');
+
+    const cleanup = () => {
+      stdin.setRawMode(false);
+      stdin.pause();
+      stdin.removeListener('data', onData);
+    };
+
+    const onData = (chunk) => {
+      // chunk may contain multiple characters (e.g. pasted token)
+      for (const ch of chunk) {
+        if (ch === '\r' || ch === '\n') {
+          cleanup();
+          stdout.write('\n');
+          resolve(input.trim());
+          return;
+        }
+        if (ch === '\u0003') {
+          // Ctrl-C
+          cleanup();
+          stdout.write('\n');
+          process.exit(130);
+        }
+        if (ch === '\u007f' || ch === '\b') {
+          // Backspace
+          input = input.slice(0, -1);
+          continue;
+        }
+        // Ignore other control characters
+        const code = ch.charCodeAt(0);
+        if (code < 32) continue;
+        input += ch;
+      }
+    };
+
+    stdin.on('data', onData);
+  });
+}

package/src/utils/spinner.js

@@ -0,0 +1,5 @@
+import ora from 'ora';
+
+export function createSpinner(text) {
+  return ora({ text, color: 'cyan' });
+}