@inthedark/wb 0.0.2 → 0.0.4

package/WorkbenchBootstrap.mjs

@@ -9,7 +9,7 @@ import path from "node:path";
 import { randomUUID } from "node:crypto";
 import { fileURLToPath } from "node:url";
 import { DatabaseSync } from "node:sqlite";
-import WorkbenchBootstrapPrompt from "./WorkbenchBootstrapPrompt.mjs";
+import WorkbenchInstallPrompt from "./WorkbenchInstallPrompt.mjs";
 import WorkbenchBootstrapCommand from "./WorkbenchBootstrapCommand.mjs";
 
 export default class WorkbenchBootstrap {
@@ -17,7 +17,7 @@ export default class WorkbenchBootstrap {
     home = os.homedir(),
     packageRoot = path.dirname(fileURLToPath(import.meta.url)),
     environment = process.env,
-    prompt = new WorkbenchBootstrapPrompt(),
+    prompt = new WorkbenchInstallPrompt(),
     commands = new WorkbenchBootstrapCommand(),
     write = text => process.stdout.write(text),
   } = {}) {

package/WorkbenchInstallPrompt.mjs

@@ -0,0 +1,269 @@
+/*
+ * Exports:
+ * - WorkbenchInstallPrompt (default): owns dependency-free installer terminal interaction and the pinned cube header.
+ */
+import path from "node:path";
+import os from "node:os";
+import { emitKeypressEvents } from "node:readline";
+import { INSTALLER_CUBE_ROWS, installerCubeWidth, renderInstallerCube } from "./installer-cube.mjs";
+
+const WORDMARK = "w o r k b e n c h";
+const FRAME_INTERVAL_MS = 80;
+// Install log rows kept below a pinned header; shorter terminals skip pinning.
+const LOG_ROWS = 8;
+
+function scheduleFrames(tick) {
+  const timer = setInterval(tick, FRAME_INTERVAL_MS);
+  timer.unref?.();
+  return () => clearInterval(timer);
+}
+
+export default class WorkbenchInstallPrompt {
+  constructor({
+    input = process.stdin,
+    output = process.stdout,
+    platform = process.platform,
+    cwd = process.cwd(),
+    home = os.homedir(),
+    schedule = scheduleFrames,
+    now = () => performance.now(),
+    signals = process,
+  } = {}) {
+    this.input = input;
+    this.output = output;
+    this.schedule = schedule;
+    this.now = now;
+    this.signals = signals;
+    this.paths = platform === "win32" ? path.win32 : path.posix;
+    this.windows = platform === "win32";
+    this.cwd = cwd;
+    this.home = home;
+    this.active = false;
+  }
+
+  suffix(value) {
+    const name = this.paths.basename(value);
+    const comparable = this.windows ? name.toLowerCase() : name;
+    if (comparable === "wb" || comparable === "workbench") return "";
+    return `${value.endsWith(this.paths.sep) || (this.windows && value.endsWith("/")) ? "" : this.paths.sep}wb`;
+  }
+
+  destination(value) {
+    if (!value.trim()) throw new Error("Choose an installation directory.");
+    if (/[\u0000-\u001f\u007f]/u.test(value)) throw new Error("Installation paths cannot contain control characters.");
+    const expanded = value === "~" ? this.home
+      : value.startsWith("~/") || (this.windows && value.startsWith("~\\"))
+        ? this.paths.join(this.home, value.slice(2)) : value;
+    return this.paths.resolve(this.cwd, `${expanded}${this.suffix(expanded)}`);
+  }
+
+  location(label, initialValue) {
+    let characters = Array.from(initialValue);
+    let cursor = characters.length;
+    return this.interact(
+      () => {
+        const value = characters.join("");
+        const suffix = this.suffix(value);
+        // Keep a bounded one-line viewport so redraw never overwrites earlier setup output.
+        const available = Math.max(8, (this.output.columns || 80) - label.length - suffix.length - 4);
+        const start = Math.max(0, cursor - available + 1);
+        const visible = characters.slice(start, start + available).join("");
+        const prefix = `${label}: `;
+        this.output.write(`\r\u001b[2K${prefix}${visible}\u001b[2m${suffix}\u001b[22m`);
+        this.output.write(`\r\u001b[${prefix.length + characters.slice(start, cursor).join("").length + 1}G`);
+      },
+      (text, key, accept) => {
+        if (key.name === "return") {
+          accept(this.destination(characters.join("")));
+          return;
+        }
+        if (key.name === "left") cursor = Math.max(0, cursor - 1);
+        else if (key.name === "right") cursor = Math.min(characters.length, cursor + 1);
+        else if (key.name === "home" || (key.ctrl && key.name === "a")) cursor = 0;
+        else if (key.name === "end" || (key.ctrl && key.name === "e")) cursor = characters.length;
+        else if (key.name === "backspace" && cursor > 0) characters.splice(--cursor, 1);
+        else if (key.name === "delete") characters.splice(cursor, 1);
+        else if (text && !key.ctrl && !key.meta && !/[\u0000-\u001f\u007f]/u.test(text)) {
+          const added = Array.from(text);
+          characters.splice(cursor, 0, ...added);
+          cursor += added.length;
+        }
+      },
+    );
+  }
+
+  choose(label, choices) {
+    if (!choices.length) return Promise.reject(new Error("A setup choice needs options."));
+    let selected = 0;
+    let rendered = false;
+    return this.interact(
+      () => {
+        if (rendered && choices.length > 1) this.output.write(`\r\u001b[${choices.length - 1}A`);
+        this.output.write(choices.map((choice, index) =>
+          `\r\u001b[2K${index === selected ? `> \u001b[7m${choice}\u001b[27m` : `  ${choice}`}`,
+        ).join("\n"));
+        rendered = true;
+      },
+      (_text, key, accept) => {
+        if (key.name === "up") selected = (selected + choices.length - 1) % choices.length;
+        else if (key.name === "down" || key.name === "tab") selected = (selected + 1) % choices.length;
+        else if (key.name === "return") accept(choices[selected]);
+      },
+      label,
+      choices.length,
+    );
+  }
+
+  /** Cube height that fits above the wordmark, label and prompt without scrolling the screen; 0 for none. */
+  cubeRows(label, promptLines) {
+    const columns = this.output.columns || 80;
+    const rows = this.output.rows || 24;
+    const labelLines = label
+      ? label.split("\n").reduce((total, line) => total + Math.max(1, Math.ceil(line.length / columns)), 0)
+      : 0;
+    // Wordmark, blank line, label, prompt. Scrolling would misplace every home-anchored redraw.
+    let cube = Math.min(INSTALLER_CUBE_ROWS.max, rows - 2 - labelLines - promptLines);
+    while (cube >= INSTALLER_CUBE_ROWS.min && installerCubeWidth(cube) > columns) cube--;
+    return cube >= INSTALLER_CUBE_ROWS.min ? cube : 0;
+  }
+
+  /** Animated cube frames, an in-place redraw and the centred wordmark for a header of `cubeRows` (0 for wordmark only). */
+  header(cubeRows) {
+    const started = this.now();
+    const frame = () => renderInstallerCube((this.now() - started) / 1000, cubeRows).join("\r\n");
+    return {
+      frame,
+      // Save and restore the cursor around each frame so prompts and output below never move.
+      draw: () => this.output.write(`\u001b7\u001b[H${frame()}\u001b8`),
+      wordmark: cubeRows
+        ? WORDMARK.padStart(Math.floor((installerCubeWidth(cubeRows) + WORDMARK.length) / 2))
+        : WORDMARK,
+    };
+  }
+
+  /** Runs `task` with the animated header pinned above a scroll region holding its output. */
+  async withHeader(task) {
+    const cubeRows = this.output.isTTY && !this.active ? this.cubeRows("", LOG_ROWS) : 0;
+    if (!cubeRows) return await task();
+    const rows = this.output.rows || 24;
+    const top = cubeRows + 3;
+    const { frame, draw, wordmark } = this.header(cubeRows);
+    let pinned = true;
+    // Resetting the region homes the cursor; save/restore keeps it where the output left off.
+    const release = () => {
+      if (!pinned) return;
+      pinned = false;
+      this.output.write("\u001b7\u001b[r\u001b8");
+    };
+    // Default SIGINT exits without cleanup and would trap the shell inside the region.
+    const interrupt = () => {
+      release();
+      process.exit(130);
+    };
+    process.once("exit", release);
+    process.once("SIGINT", interrupt);
+    let stopAnimation = () => {};
+    try {
+      // Blank lines push earlier shell output into scrollback instead of erasing it.
+      this.output.write(`${"\r\n".repeat(rows)}\u001b[H${frame()}\r\n${wordmark}\r\n\u001b[${top};${rows}r\u001b[${top};1H`);
+      stopAnimation = this.schedule(() => { if (pinned) draw(); });
+      return await task();
+    } finally {
+      stopAnimation();
+      process.removeListener("exit", release);
+      process.removeListener("SIGINT", interrupt);
+      release();
+    }
+  }
+
+  interact(render, handle, label = "", promptLines = 1) {
+    if (!this.input.isTTY || !this.output.isTTY) {
+      return Promise.reject(new Error("Workbench setup needs an interactive terminal; no changes were accepted."));
+    }
+    if (this.active) return Promise.reject(new Error("Another setup prompt is active."));
+    this.active = true;
+    const wasRaw = this.input.isRaw;
+    // A fresh stdin is neither flowing nor paused; leaving it flowing would let this
+    // process keep reading the console and steal keys from later child prompts.
+    const wasFlowing = this.input.readableFlowing === true;
+    emitKeypressEvents(this.input);
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      let screenActive = false;
+      let stopAnimation = null;
+      const restoreScreen = () => {
+        if (!screenActive) return;
+        screenActive = false;
+        this.output.write("\u001b[0m\u001b[?1049l");
+      };
+      const finish = (error, value) => {
+        if (settled) return;
+        settled = true;
+        stopAnimation?.();
+        stopAnimation = null;
+        this.input.removeListener("keypress", onKey);
+        this.input.removeListener("end", onEnd);
+        this.input.removeListener("error", onError);
+        this.signals.removeListener("SIGINT", onEnd);
+        process.removeListener("exit", restoreScreen);
+        try {
+          this.input.setRawMode(Boolean(wasRaw));
+          if (!wasFlowing) this.input.pause();
+        } catch (cleanupError) {
+          error ??= cleanupError;
+        }
+        try { restoreScreen(); }
+        catch (cleanupError) { error ??= cleanupError; }
+        this.active = false;
+        if (error) reject(error);
+        else resolve(value);
+      };
+      const onEnd = () => finish(new DOMException("Setup cancelled.", "AbortError"));
+      const onError = (error) => finish(error);
+      const onKey = (text, key = {}) => {
+        if ((key.ctrl && (key.name === "c" || key.name === "d")) || key.name === "escape") {
+          onEnd();
+          return;
+        }
+        try {
+          handle(text, key, (value) => finish(null, value));
+          if (!settled) render();
+        } catch (error) {
+          finish(error);
+        }
+      };
+      this.input.once("end", onEnd);
+      this.input.once("error", onError);
+      this.signals.once("SIGINT", onEnd);
+      try {
+        this.input.setRawMode(true);
+        screenActive = true;
+        process.once("exit", restoreScreen);
+        const cubeRows = this.cubeRows(label, promptLines);
+        const { frame, draw, wordmark } = this.header(cubeRows);
+        this.output.write(`\u001b[?1049h\u001b[2J\u001b[H${cubeRows ? `${frame()}\r\n` : ""}${wordmark}\r\n\r\n${label ? `${label}\r\n` : ""}`);
+        render();
+        if (cubeRows) {
+          stopAnimation = this.schedule(() => {
+            if (settled) return;
+            try { draw(); }
+            catch (error) { finish(error); }
+          });
+        }
+        let bufferedInterrupt = false;
+        for (let chunk = this.input.read(); chunk !== null; chunk = this.input.read()) {
+          const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString();
+          bufferedInterrupt ||= text.includes("\u0003") || text.includes("\u0004");
+        }
+        if (bufferedInterrupt) {
+          onEnd();
+          return;
+        }
+        this.input.on("keypress", onKey);
+        this.input.resume();
+      } catch (error) {
+        finish(error);
+      }
+    });
+  }
+}

package/installer-cube.mjs

@@ -0,0 +1,113 @@
+/*
+ * Exports:
+ * - INSTALLER_CUBE_ROWS: largest and smallest cube heights worth drawing, in terminal rows.
+ * - installerCubeWidth: terminal columns a cube frame of the given height occupies.
+ * - renderInstallerCube: raycast one antialiased ASCII frame of the spinning installer cube.
+ */
+
+export const INSTALLER_CUBE_ROWS = Object.freeze({ max: 21, min: 11 });
+
+// Terminal cells are roughly twice as tall as they are wide.
+const CELL_ASPECT = 2.05;
+const RAMP = " .:-=+*#%@";
+const SAMPLES = 4;
+const TILT = 0.35;
+const SPIN = 0.8;
+const START = 0.35;
+const CAMERA = 5.2;
+const FOCAL = 2.9;
+const BORDER = 0.1;
+const STROKE = 0.09;
+const DOT = 0.12;
+const TOP_FILL = 0.4;
+
+// Face glyphs live in face space: u to the right and v up when the face is viewed from outside.
+const GLYPHS = {
+  check: { strokes: [[[-0.45, 0], [-0.12, -0.38], [0.48, 0.42]]], dots: [] },
+  x: { strokes: [[[-0.42, -0.42], [0.42, 0.42]], [[-0.42, 0.42], [0.42, -0.42]]], dots: [] },
+  question: {
+    strokes: [[[-0.32, 0.22], [-0.22, 0.42], [0, 0.5], [0.22, 0.42], [0.32, 0.22], [0.22, 0.06], [0, -0.04], [0, -0.18]]],
+    dots: [[0, -0.42]],
+  },
+  dots: { strokes: [], dots: [[-0.42, 0], [0, 0], [0.42, 0]] },
+};
+
+// Indexed by axis then sign: [x-, x+], [y-, y+], [z-, z+]. Each basis satisfies u x v = normal.
+const FACES = [
+  [{ u: [0, 0, 1], v: [0, 1, 0], glyph: GLYPHS.dots }, { u: [0, 0, -1], v: [0, 1, 0], glyph: GLYPHS.question }],
+  [{ u: [1, 0, 0], v: [0, 0, 1], glyph: null }, { u: [1, 0, 0], v: [0, 0, -1], glyph: null, fill: TOP_FILL }],
+  [{ u: [-1, 0, 0], v: [0, 1, 0], glyph: GLYPHS.x }, { u: [1, 0, 0], v: [0, 1, 0], glyph: GLYPHS.check }],
+];
+
+export function installerCubeWidth(rows) {
+  return Math.round(rows * 2.2);
+}
+
+function segmentDistance(px, py, [ax, ay], [bx, by]) {
+  const dx = bx - ax, dy = by - ay;
+  const t = Math.max(0, Math.min(1, ((px - ax) * dx + (py - ay) * dy) / (dx * dx + dy * dy)));
+  return Math.hypot(px - ax - t * dx, py - ay - t * dy);
+}
+
+function glyphCovers(glyph, u, v) {
+  for (const stroke of glyph.strokes) {
+    for (let index = 1; index < stroke.length; index++) {
+      if (segmentDistance(u, v, stroke[index - 1], stroke[index]) < STROKE) return true;
+    }
+  }
+  return glyph.dots.some(([x, y]) => Math.hypot(u - x, v - y) < DOT);
+}
+
+/** Brightness 0..1 where a camera ray through (px, py) meets the cube, given world-to-object rotation. */
+function shade(toObject, origin, px, py) {
+  const direction = toObject(px / FOCAL, py / FOCAL, -1);
+  let near = -Infinity, far = Infinity, axis = -1, side = 0;
+  for (let index = 0; index < 3; index++) {
+    let enter = (-1 - origin[index]) / direction[index];
+    let leave = (1 - origin[index]) / direction[index];
+    let entered = 0;
+    if (enter > leave) { [enter, leave] = [leave, enter]; entered = 1; }
+    if (enter > near) { near = enter; axis = index; side = entered; }
+    if (leave < far) far = leave;
+  }
+  if (near > far || far < 0) return 0;
+  const face = FACES[axis][side];
+  const x = origin[0] + direction[0] * near, y = origin[1] + direction[1] * near, z = origin[2] + direction[2] * near;
+  const u = x * face.u[0] + y * face.u[1] + z * face.u[2];
+  const v = x * face.v[0] + y * face.v[1] + z * face.v[2];
+  if (1 - Math.max(Math.abs(u), Math.abs(v)) < BORDER) return 1;
+  if (face.fill) return face.fill;
+  return face.glyph && glyphCovers(face.glyph, u, v) ? 0.95 : 0;
+}
+
+/** One frame: exactly `rows` strings of exactly installerCubeWidth(rows) printable ASCII characters. */
+export function renderInstallerCube(seconds, rows = INSTALLER_CUBE_ROWS.max) {
+  const width = installerCubeWidth(rows);
+  const spin = START + seconds * SPIN;
+  const cs = Math.cos(spin), ss = Math.sin(spin), ct = Math.cos(TILT), st = Math.sin(TILT);
+  // Undo the tilt about X, then the spin about Y.
+  const toObject = (x, y, z) => {
+    const ty = y * ct + z * st, tz = -y * st + z * ct;
+    return [x * cs - tz * ss, ty, x * ss + tz * cs];
+  };
+  const origin = toObject(0, 0, CAMERA);
+  const lines = [];
+  for (let row = 0; row < rows; row++) {
+    let line = "";
+    for (let column = 0; column < width; column++) {
+      let coverage = 0;
+      for (let j = 0; j < SAMPLES; j++) {
+        // Nudge the view up slightly so the cube sits centred rather than low in its box.
+        const py = -(row + (j + 0.5) / SAMPLES - rows / 2) / (rows / 2) - 0.12;
+        for (let i = 0; i < SAMPLES; i++) {
+          const px = (column + (i + 0.5) / SAMPLES - width / 2) / (rows * CELL_ASPECT / 2);
+          coverage += shade(toObject, origin, px, py);
+        }
+      }
+      const level = Math.pow(coverage / (SAMPLES * SAMPLES), 0.75);
+      line += RAMP[Math.min(RAMP.length - 1, Math.round(level * (RAMP.length - 1)))];
+    }
+    lines.push(line);
+  }
+  return lines;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inthedark/wb",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "type": "module",
   "repository": {
     "type": "git",
@@ -14,7 +14,7 @@
     "node": ">=22.13.0"
   },
   "bin": {
-    "wb": "./wb"
+    "wb": "wb"
   },
   "exports": {
     ".": {
@@ -26,7 +26,8 @@
     "wb",
     "WorkbenchBootstrap.mjs",
     "WorkbenchBootstrapCommand.mjs",
-    "WorkbenchBootstrapPrompt.mjs",
+    "WorkbenchInstallPrompt.mjs",
+    "installer-cube.mjs",
     "index.mjs",
     "index.d.ts",
     "store-definitions.mjs",

package/WorkbenchBootstrapPrompt.mjs

@@ -1,71 +0,0 @@
-/*
- * Exports:
- * - WorkbenchBootstrapPrompt (default): owns the stable dependency-free consent and destination prompts used before cloning.
- */
-import os from "node:os";
-import path from "node:path";
-import { createInterface } from "node:readline/promises";
-
-export default class WorkbenchBootstrapPrompt {
-  constructor({
-    input = process.stdin,
-    output = process.stdout,
-    platform = process.platform,
-    cwd = process.cwd(),
-    home = os.homedir(),
-    ask,
-  } = {}) {
-    this.input = input;
-    this.output = output;
-    this.paths = platform === "win32" ? path.win32 : path.posix;
-    this.windows = platform === "win32";
-    this.cwd = cwd;
-    this.home = home;
-    this.ask = ask ?? (question => this.question(question));
-  }
-
-  suffix(value) {
-    const name = this.paths.basename(value);
-    const comparable = this.windows ? name.toLowerCase() : name;
-    if (comparable === "wb" || comparable === "workbench") return "";
-    return `${value.endsWith(this.paths.sep) || (this.windows && value.endsWith("/")) ? "" : this.paths.sep}wb`;
-  }
-
-  destination(value) {
-    if (!value.trim()) throw new Error("Choose an installation directory.");
-    if (/[\u0000-\u001f\u007f]/u.test(value)) throw new Error("Installation paths cannot contain control characters.");
-    const expanded = value === "~" ? this.home
-      : value.startsWith("~/") || (this.windows && value.startsWith("~\\"))
-        ? this.paths.join(this.home, value.slice(2)) : value;
-    return this.paths.resolve(this.cwd, `${expanded}${this.suffix(expanded)}`);
-  }
-
-  async choose(label, choices) {
-    if (!choices.length) throw new Error("A setup choice needs options.");
-    const options = choices.map((choice, index) => `${index + 1}) ${choice}`).join("  ");
-    while (true) {
-      const answer = (await this.ask(`${label}\n${options}\nChoose [1]: `)).trim();
-      const selected = answer === "" ? 0 : Number(answer) - 1;
-      if (Number.isInteger(selected) && selected >= 0 && selected < choices.length) return choices[selected];
-      this.output.write(`Choose a number from 1 to ${choices.length}.\n`);
-    }
-  }
-
-  async location(label, initialValue) {
-    const answer = await this.ask(`${label} [${initialValue}]: `);
-    return this.destination(answer.trim() || initialValue);
-  }
-
-  withHeader(task) {
-    return task();
-  }
-
-  async question(text) {
-    if (!this.input.isTTY || !this.output.isTTY) {
-      throw new Error("Workbench setup needs an interactive terminal; no changes were accepted.");
-    }
-    const terminal = createInterface({ input: this.input, output: this.output });
-    try { return await terminal.question(text); }
-    finally { terminal.close(); }
-  }
-}