@z0ne/installer 0.1.0

package/lib/ui.js

@@ -0,0 +1,208 @@
+"use strict";
+// Minimal zero-dependency terminal UI: colors, prompts, interactive pickers.
+// Falls back to plain defaults when stdin/stdout is not a TTY (CI / piped).
+
+const readline = require("readline");
+
+const CTRL_C = "";
+const DEL = "";
+const ESC = "";
+const UP = ESC + "[A";
+const DOWN = ESC + "[B";
+
+const useColor = !!process.stdout.isTTY && !process.env.NO_COLOR;
+const wrap = (open, close) => (s) =>
+  useColor ? "\x1b[" + open + "m" + s + "\x1b[" + close + "m" : String(s);
+
+const fmt = {
+  bold: wrap(1, 22),
+  dim: wrap(2, 22),
+  red: wrap(31, 39),
+  green: wrap(32, 39),
+  yellow: wrap(33, 39),
+  cyan: wrap(36, 39),
+  gray: wrap(90, 39),
+};
+
+const log = (s = "") => process.stdout.write(s + "\n");
+const ok = (s) => log(fmt.green("  + ") + s);
+const warn = (s) => log(fmt.yellow("  ! ") + s);
+const err = (s) => log(fmt.red("  x ") + s);
+const info = (s) => log(fmt.gray("  - ") + s);
+
+const isInteractive = () => !!(process.stdin.isTTY && process.stdout.isTTY);
+
+function ask(question, def) {
+  if (!isInteractive()) return Promise.resolve(def || "");
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const suffix = def ? fmt.gray(" (" + def + ")") : "";
+  return new Promise((resolve) => {
+    rl.question("  " + question + suffix + " ", (answer) => {
+      rl.close();
+      resolve(answer.trim() || def || "");
+    });
+  });
+}
+
+// Masked input for API keys: raw mode so the key never echoes to the terminal.
+function askHidden(question) {
+  if (!isInteractive()) return Promise.resolve("");
+  return new Promise((resolve) => {
+    process.stdout.write("  " + question + " " + fmt.gray("(input hidden) "));
+    const stdin = process.stdin;
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    let buf = "";
+    const onData = (chunk) => {
+      for (const ch of chunk) {
+        if (ch === "\r" || ch === "\n") {
+          stdin.setRawMode(false);
+          stdin.pause();
+          stdin.removeListener("data", onData);
+          process.stdout.write("\n");
+          resolve(buf.trim());
+          return;
+        }
+        if (ch === CTRL_C) {
+          stdin.setRawMode(false);
+          process.stdout.write("\n");
+          process.exit(130);
+        }
+        if (ch === DEL || ch === "\b") buf = buf.slice(0, -1);
+        else if (ch >= " ") buf += ch;
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+
+async function confirm(question, def = true) {
+  if (!isInteractive()) return def;
+  const a = await ask(question + (def ? " [Y/n]" : " [y/N]"));
+  if (!a) return def;
+  return /^y(es)?$/i.test(a);
+}
+
+// Interactive list picker. items: [{value, label, hint}]
+// - single: arrows + enter, type to filter
+// - multi:  space toggles, enter confirms, type to filter
+function listPicker({ title, items, multi = false, preselected = [], defValue = null }) {
+  if (!isInteractive()) {
+    if (multi) {
+      const pre = new Set(preselected);
+      return Promise.resolve(items.filter((it) => pre.has(it.value)).map((it) => it.value));
+    }
+    const def = items.find((it) => it.value === defValue) || items[0];
+    return Promise.resolve(def ? def.value : null);
+  }
+
+  return new Promise((resolve) => {
+    const stdin = process.stdin;
+    const out = process.stdout;
+    const chosen = new Set(preselected);
+    const MAXROWS = 12;
+    let filter = "";
+    let cursor = Math.max(0, items.findIndex((it) => it.value === defValue));
+    let lastRows = 0;
+
+    const visible = () => {
+      const f = filter.toLowerCase();
+      return f
+        ? items.filter((it) => (it.label + " " + (it.hint || "")).toLowerCase().includes(f))
+        : items;
+    };
+
+    const render = (final = false) => {
+      const list = visible();
+      if (cursor >= list.length) cursor = Math.max(0, list.length - 1);
+      let start = Math.max(0, Math.min(cursor - Math.floor(MAXROWS / 2), list.length - MAXROWS));
+      const end = Math.min(list.length, start + MAXROWS);
+      const rows = [];
+      const keys = multi
+        ? "space toggle - enter confirm - type to filter"
+        : "arrows move - enter select - type to filter";
+      rows.push("  " + fmt.bold(title) + "  " + fmt.gray(keys));
+      rows.push(
+        "  " +
+          (filter
+            ? fmt.cyan("filter: " + filter)
+            : fmt.gray(list.length + " option" + (list.length === 1 ? "" : "s")))
+      );
+      if (!list.length) rows.push(fmt.gray("    (no match)"));
+      for (let i = start; i < end; i++) {
+        const it = list[i];
+        const mark = multi ? (chosen.has(it.value) ? fmt.green("[x] ") : fmt.gray("[ ] ")) : "";
+        const line = mark + it.label + (it.hint ? "  " + fmt.gray(it.hint) : "");
+        rows.push(i === cursor && !final ? fmt.cyan("  > ") + line : "    " + line);
+      }
+      if (end < list.length) rows.push(fmt.gray("    ... " + (list.length - end) + " more"));
+      if (lastRows) {
+        readline.moveCursor(out, 0, -lastRows);
+        readline.cursorTo(out, 0);
+        readline.clearScreenDown(out);
+      }
+      out.write(rows.join("\n") + "\n");
+      lastRows = rows.length;
+    };
+
+    const done = (result) => {
+      stdin.setRawMode(false);
+      stdin.pause();
+      stdin.removeListener("data", onData);
+      resolve(result);
+    };
+
+    const onData = (chunk) => {
+      const list = visible();
+      if (chunk === CTRL_C) {
+        stdin.setRawMode(false);
+        out.write("\n");
+        process.exit(130);
+      } else if (chunk === "\r" || chunk === "\n") {
+        if (multi) return done([...chosen]);
+        if (list[cursor]) return done(list[cursor].value);
+        return;
+      } else if (chunk === UP) {
+        cursor = Math.max(0, cursor - 1);
+      } else if (chunk === DOWN) {
+        cursor = Math.min(list.length - 1, cursor + 1);
+      } else if (chunk === " " && multi) {
+        const it = list[cursor];
+        if (it) chosen.has(it.value) ? chosen.delete(it.value) : chosen.add(it.value);
+      } else if (chunk === DEL || chunk === "\b") {
+        filter = filter.slice(0, -1);
+        cursor = 0;
+      } else if (!chunk.startsWith(ESC)) {
+        for (const ch of chunk) if (ch >= " ") filter += ch;
+        cursor = 0;
+      }
+      render();
+    };
+
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    stdin.on("data", onData);
+    render();
+  });
+}
+
+const selectOne = (title, items, defValue) => listPicker({ title, items, defValue });
+const selectMany = (title, items, preselected) =>
+  listPicker({ title, items, multi: true, preselected });
+
+module.exports = {
+  fmt,
+  log,
+  ok,
+  warn,
+  err,
+  info,
+  ask,
+  askHidden,
+  confirm,
+  selectOne,
+  selectMany,
+  isInteractive,
+};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@z0ne/installer",
+  "version": "0.1.0",
+  "description": "Point coding agents at z0ne.ai — Claude Code, Codex, OpenCode, Cline, Hermes, OpenClaw. One key, one command. Optionally installs a Claude Code statusline.",
+  "license": "MIT",
+  "homepage": "https://z0ne.ai",
+  "bin": {
+    "z0ne-installer": "bin/cli.js"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "z0ne",
+    "ai",
+    "gateway",
+    "claude-code",
+    "codex",
+    "opencode",
+    "cline",
+    "hermes",
+    "openclaw",
+    "installer",
+    "cli",
+    "statusline"
+  ]
+}