@ar-ai/brink-cli 0.0.0-stage → 1.0.6

package/support/setup-ui.js

@@ -0,0 +1,333 @@
+"use strict";
+
+const readline = require("node:readline");
+const { mascotLines, credit } = require("./brand");
+const { clean, fit, wrap } = require("./terminal-ui");
+
+const ESC = "\x1b[";
+const SEGMENTS = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+
+function cancellation(message = "Setup cancelled.") {
+  const error = new Error(message);
+  error.name = "AbortError";
+  error.code = "ABORT_ERR";
+  return error;
+}
+
+function eof() {
+  const error = new Error("Input ended before setup was complete.");
+  error.code = "EOF";
+  return error;
+}
+
+function createSetupUI({ input = process.stdin, output = process.stdout } = {}) {
+  const interactive = Boolean(input.isTTY && output.isTTY);
+  const raw = interactive && typeof input.setRawMode === "function";
+  const motion = interactive && process.env.TERM !== "dumb" && !process.env.BRINK_PLAIN;
+  const color = motion && process.env.NO_COLOR === undefined;
+  const wasFlowing = input.readableFlowing === true;
+  let closed = false;
+  let active = null;
+  let lineReader = null;
+  let ended = false;
+  let queuedLines = [];
+  let lineWaiter = null;
+  let lastProgress = null;
+  let currentSection = null;
+  const sections = ["Client", "Key", "Model", "Ready"];
+  const width = () => Math.max(1, (output.columns || 80) - 2);
+  const style = (text, tone) => !color ? text : `${tone === "amber" ? `${ESC}38;2;225;177;99m` : tone === "section" ? `${ESC}38;2;225;177;99m${ESC}1m` : tone === "bold" ? `${ESC}1m` : `${ESC}2m`}${text}${ESC}0m`;
+
+  function line(value = "", tone) {
+    for (const part of wrap(value, width(), Infinity)) {
+      output.write(` ${tone ? style(part, tone) : part}\n`);
+    }
+  }
+
+  function masthead(title, detail, reserve) {
+    const information = [
+      { text: "BRINK", tone: "section" },
+      { text: title, tone: "bold" },
+      { text: detail, tone: "dim" },
+      { text: "", tone: "dim" },
+      { text: "Start with brink", tone: "amber" },
+      { text: credit, tone: "dim" },
+    ];
+    const room = width();
+    const rows = output.rows || 24;
+    const sideBySide = room >= 62;
+    const artBudget = Math.max(0, rows - reserve);
+    const art = motion ? mascotLines(sideBySide ? room - 34 : room, sideBySide ? artBudget : Math.min(3, artBudget - 4)) : [];
+    if (sideBySide && art.length) {
+      const artWidth = art[0].length;
+      const textWidth = room - artWidth - 3;
+      const height = Math.max(art.length, information.length);
+      const textStart = Math.floor((height - information.length) / 2);
+      for (let i = 0; i < height; i++) {
+        const info = information[i - textStart] || { text: "", tone: "dim" };
+        output.write(` ${style(fit(art[i] || "", artWidth), "amber")}${style(" │ ", "dim")}${style(fit(info.text, textWidth).trimEnd(), info.tone)}\n`);
+      }
+    } else {
+      for (const row of art) line(row, "amber");
+      line("BRINK", "section");
+      line(title, "bold");
+      line(detail, "dim");
+      line(credit, "dim");
+    }
+    line("─".repeat(room), "dim");
+  }
+
+  function available() {
+    if (closed) throw cancellation("Setup UI is closed.");
+    if (active) throw new Error("Finish the current setup question before asking another.");
+  }
+  function section(name) {
+    available();
+    const index = sections.indexOf(name);
+    if (index < 0) throw new Error(`Unknown setup section: ${name}`);
+    if (currentSection === name) return;
+    currentSection = name;
+    lastProgress = null;
+    output.write("\n");
+    line(sections.map((title) => title === name ? `[${title}]` : title).join(" > "), "dim");
+    line(fit(` ${index + 1} / ${sections.length}  ${name.toUpperCase()} `, width()), "section");
+  }
+
+  function question(value) {
+    lastProgress = null;
+    output.write("\n");
+    line("─".repeat(Math.min(width(), 48)), "dim");
+    line(value, "bold");
+  }
+
+  function rawPrompt({ initial = "", hidden = false, render, accept, keyHandler }) {
+    available();
+    if (input.readableEnded || input.destroyed) return Promise.reject(eof());
+    if (lineReader) {
+      lineReader.close();
+      lineReader = null;
+      ended = false;
+      queuedLines = [];
+    }
+    return new Promise((resolve, reject) => {
+      let value = initial;
+      let settled = false;
+      const wasRaw = Boolean(input.isRaw);
+      const promptWasFlowing = input.readableFlowing === true;
+      const redraw = () => {
+        if (motion) output.write(`\r${ESC}2K ${fit(render(value), width()).trimEnd()}`);
+      };
+      const cleanup = () => {
+        input.removeListener("keypress", onKey);
+        input.removeListener("end", onEnd);
+        input.removeListener("close", onEnd);
+        input.removeListener("error", onError);
+        output.removeListener("resize", redraw);
+        process.removeListener("SIGINT", onCancel);
+        process.removeListener("exit", onExit);
+        if (!input.destroyed) input.setRawMode(wasRaw);
+        if (!promptWasFlowing) input.pause();
+        active = null;
+      };
+      const finish = (error, answer) => {
+        if (settled) return;
+        settled = true;
+        value = "";
+        cleanup();
+        if (motion) output.write(`\r${ESC}2K`);
+        if (error) line(error.code === "EOF" ? "Input ended." : "Cancelled.", "dim");
+        else if (hidden) line("Key received (hidden).", "dim");
+        else if (answer !== undefined) line(render(answer), "dim");
+        if (error) reject(error);
+        else resolve(answer);
+      };
+      const onCancel = () => finish(cancellation());
+      const onEnd = () => finish(eof());
+      const onError = (error) => finish(error);
+      const onExit = () => { value = ""; cleanup(); };
+      const onKey = (text, key = {}) => {
+        if (settled) return;
+        if ((key.ctrl && key.name === "c") || key.name === "escape") return onCancel();
+        if (key.ctrl && key.name === "d") return onEnd();
+        if (key.name === "return" || key.name === "enter") {
+          const result = accept(value);
+          if (result !== undefined) return finish(null, result);
+          if (!motion) line("Enter a valid choice.", "amber");
+          return redraw();
+        }
+        if (keyHandler) {
+          const next = keyHandler(text, key, value);
+          if (next !== undefined) value = next;
+        } else if (key.name === "backspace" || key.name === "delete") {
+          value = [...SEGMENTS.segment(value)].slice(0, -1).map((part) => part.segment).join("");
+        } else if (key.ctrl && key.name === "u") {
+          value = "";
+        } else if (!key.ctrl && !key.meta && text && !text.includes("\x1b")) {
+          value = (value + text.replace(/[\x00-\x1f\x7f-\x9f]/g, "")).slice(0, 16384);
+        }
+        redraw();
+      };
+      active = { cancel: onCancel };
+      try {
+        input.setRawMode(true);
+        readline.emitKeypressEvents(input);
+        input.on("keypress", onKey);
+        input.once("end", onEnd);
+        input.once("close", onEnd);
+        input.once("error", onError);
+        output.on("resize", redraw);
+        process.on("SIGINT", onCancel);
+        process.on("exit", onExit);
+        if (!motion) line(render(value), "dim");
+        redraw();
+        input.resume();
+      } catch (error) {
+        finish(error);
+      }
+    });
+  }
+
+  function readLine() {
+    available();
+    if (!lineReader) {
+      if (input.readableEnded || input.destroyed) return Promise.reject(eof());
+      lineReader = readline.createInterface({ input, output, terminal: interactive && motion });
+      lineReader.on("line", (value) => {
+        if (lineWaiter) lineWaiter(null, value);
+        else queuedLines.push(value);
+      });
+      lineReader.on("close", () => { ended = true; if (lineWaiter) lineWaiter(eof()); });
+      lineReader.on("SIGINT", () => { if (lineWaiter) lineWaiter(cancellation()); });
+      lineReader.on("error", (error) => { if (lineWaiter) lineWaiter(error); });
+    }
+    if (queuedLines.length) return Promise.resolve(queuedLines.shift());
+    if (ended) return Promise.reject(eof());
+    return new Promise((resolve, reject) => {
+      const onCancel = () => finish(cancellation());
+      const finish = (error, value) => {
+        lineWaiter = null;
+        active = null;
+        process.removeListener("SIGINT", onCancel);
+        if (error) reject(error);
+        else resolve(value);
+      };
+      lineWaiter = finish;
+      active = { cancel: onCancel };
+      process.on("SIGINT", onCancel);
+    });
+  }
+
+  async function choose(prompt, options, defaultIndex = 0) {
+    available();
+    if (!Array.isArray(options) || options.length === 0) throw new Error("A setup choice needs at least one option.");
+    if (!Number.isInteger(defaultIndex) || defaultIndex < 0 || defaultIndex >= options.length) throw new RangeError("Default choice is outside the options.");
+    const labels = options.map((option) => typeof option === "string" ? option : option.label);
+    question(prompt);
+    options.forEach((option, index) => {
+      line(`${index + 1}. ${labels[index]}${index === defaultIndex ? " (default)" : ""}`);
+      if (typeof option === "object" && option.detail) line(`   ${option.detail}`, "dim");
+    });
+    line(raw && motion ? `Arrows / number + Enter  ·  default ${defaultIndex + 1}` : `Number + Enter  ·  default ${defaultIndex + 1}`, "dim");
+    let selected = defaultIndex;
+    const parse = (value) => {
+      if (typeof value === "number") return value;
+      if (!value.trim()) return selected;
+      if (!/^\d+$/.test(value.trim())) return undefined;
+      const index = Number(value.trim()) - 1;
+      return index >= 0 && index < options.length ? index : undefined;
+    };
+    if (raw && motion) {
+      return rawPrompt({
+        render: (value) => {
+          const index = parse(value);
+          return index === undefined ? `Choose 1-${options.length}: ${clean(value)}` : `${index + 1}. ${labels[index]}`;
+        },
+        accept: parse,
+        keyHandler: (text, key, value) => {
+          if (key.name === "up" || key.name === "down") {
+            selected = ((parse(value) ?? selected) + (key.name === "up" ? -1 : 1) + options.length) % options.length;
+            return "";
+          }
+          if (key.name === "backspace") return value.slice(0, -1);
+          if (key.ctrl && key.name === "u") return "";
+          return !key.ctrl && !key.meta && /^\d+$/.test(text || "") ? (value + text).slice(0, 8) : value;
+        },
+      });
+    }
+    for (;;) {
+      output.write(` Choose [${defaultIndex + 1}]: `);
+      const result = parse(await readLine());
+      if (result !== undefined) return result;
+      line(`Please choose a number from 1 to ${options.length}.`, "amber");
+    }
+  }
+
+  async function text(prompt, defaultValue = "") {
+    available();
+    question(prompt);
+    if (defaultValue) line(`Enter to use: ${defaultValue}`, "dim");
+    if (raw && motion) return rawPrompt({ render: (value) => `> ${clean(value)}`, accept: (value) => value || defaultValue });
+    output.write(" > ");
+    return (await readLine()) || defaultValue;
+  }
+
+  async function secret(prompt) {
+    available();
+    if (!raw) {
+      const error = new Error("Hidden key entry needs an interactive terminal. Run brink setup directly in your terminal; do not pipe API keys.");
+      error.code = "SECRET_TTY_REQUIRED";
+      throw error;
+    }
+    question(prompt);
+    line("Paste key + Enter. Input stays hidden.", "dim");
+    line("Ctrl+C cancel  ·  Ctrl+U clear", "dim");
+    return rawPrompt({ hidden: true, render: () => "> [hidden]", accept: (value) => value.trim() });
+  }
+
+  function step(label, detail) {
+    lastProgress = null;
+    line(label, "amber");
+    if (detail) line(detail, "dim");
+  }
+
+  function progress({ label = "Installing...", detail, percent } = {}) {
+    if (closed || active) return;
+    const measured = typeof percent === "number" && Number.isFinite(percent) && percent >= 0 && percent <= 100;
+    const bucket = measured ? Math.floor(percent) : null;
+    const key = `${label}\n${detail || ""}`;
+    const now = Date.now();
+    if (lastProgress && lastProgress.key === key && lastProgress.bucket === bucket) return;
+    if (lastProgress && lastProgress.label === label && (measured || lastProgress.key === key) && now - lastProgress.time < 1000 && bucket !== 100) return;
+    line(`${label}${measured ? ` ${bucket}%` : ""}`, "amber");
+    if (detail) line(detail, "dim");
+    lastProgress = { key, label, bucket, time: now };
+  }
+
+  function welcome() {
+    available();
+    output.write("\n");
+    masthead("Your coding client, connected.", "Client / key / model / ready", 16);
+  }
+
+  function success(lines) {
+    if (closed) return;
+    output.write("\n");
+    const detailRows = lines.reduce((count, value) => count + wrap(value, width(), Infinity).length, 0);
+    masthead("Setup complete.", "Your coding client, connected.", detailRows + 7);
+    section("Ready");
+    for (const value of lines) line(value);
+  }
+
+  function close() {
+    if (closed) return;
+    closed = true;
+    active?.cancel();
+    queuedLines = [];
+    lineReader?.close();
+    if (!wasFlowing) input.pause();
+  }
+
+  return { welcome, section, choose, secret, text, step, progress, success, close };
+}
+
+module.exports = { createSetupUI };