@gorlitzer-labs/seldon 0.1.7 → 0.1.9

package/README.md

@@ -16,7 +16,7 @@ Pick the tools you want from a checklist; each installs via its native method
 ## Install
 
 ```bash
-npm i -g @gorlitzer-labs/seldon
+pnpm add -g @gorlitzer-labs/seldon     # or: bun add -g …  ·  npm i -g …
 seldon                 # open the checklist — ↑↓ move · space pick · a all · enter install
 ```
 
@@ -28,6 +28,34 @@ seldon doctor                    # check external deps (tmux, sops, age, tailsca
 seldon list                      # everything available
 ```
 
+## Start the stack
+
+One command brings up the always-on services and prints where to go:
+
+```bash
+seldon up        # starts the voice (demerzel) + the supervisor (factory watch),
+                 # then prints: Voice → http://localhost:8770, how to put agents
+                 # to work, rooms, phone access
+seldon status    # what's running (pids)
+seldon down      # stop everything
+```
+
+`seldon up` only starts what's installed. demerzel serves the voice UI on
+`http://localhost:8770`; its first run needs a one-time model fetch (~25 GB) and
+`up` prints the exact command if they're missing. Logs live in `~/.seldon/run/`.
+
+## Uninstall
+
+```bash
+seldon uninstall comb demerzel   # remove specific modules (asks to confirm)
+seldon uninstall --all           # remove the whole stack (also drops ~/.seldon)
+seldon uninstall <ids> --yes     # skip the confirm prompt
+```
+
+Node tools are removed from the global store; demerzel's isolated venv and
+bifrost's binary + config are deleted. Your system Python, tmux, tailscale,
+sops/age are never touched.
+
 ## The stack
 
 | module | what it is | ships via |
@@ -51,10 +79,15 @@ It's a stack, not a bundle — install only what you use:
 
 ## Package managers
 
-Node tools install via **pnpm** or **bun** if present (much faster than npm), else npm —
-override with `seldon install --pm=pnpm|bun|npm`. demerzel (Python) always installs into
-its **own isolated venv** — never your system/active Python — using **uv** if available,
-else `python3 -m venv` + pip.
+Node tools install with **pnpm** when it can global-install (much faster than npm),
+else **npm**. **bun** is supported but opt-in — `seldon install --pm=bun` (also
+`--pm=pnpm|npm` to force any of them).
+
+demerzel (Python) always installs into its **own isolated venv** — never your
+system or active Python. It pins **CPython 3.12** (its `kokoro` pin caps Python at
+`<3.13`) and uses **uv** to provision a standalone 3.12: if `uv` isn't present,
+seldon bootstraps it into `~/.seldon/bin` with no shell/PATH changes. If uv can't
+be installed, it falls back to a matching `python3.12` on PATH.
 
 ## From a checkout
 

package/bin/seldon.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 // seldon — the Seldon stack installer. Pick your tools; install each via its
 // native method. Zero dependencies: a raw-terminal checklist, no build step.
-import { execSync, spawnSync } from "node:child_process";
+import { execSync, spawnSync, spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import path from "node:path";
 import fs from "node:fs";
@@ -170,7 +170,9 @@ function installPython(m, dev) {
     run(py, ["-m", "venv", venv]);
     ok = run(path.join(venv, "bin", "pip"), ["install", "-r", req]);
   }
-  if (ok) console.log(C.dim(`  run it: ${path.join(dest, m.bin)}  (isolated venv at ${venv})`));
+  // demerzel has no standalone binary — it runs as a module from its venv.
+  if (ok && m.id === "demerzel") console.log(C.dim(`  run it: seldon up   (starts the voice on http://localhost:8770; first run fetches models)`));
+  else if (ok) console.log(C.dim(`  run it: ${path.join(dest, m.bin)}  (isolated venv at ${venv})`));
   return ok;
 }
 
@@ -194,6 +196,174 @@ function doInstall(ids, { dev } = {}) {
   console.log("\n" + C.bold("Done. ") + C.green(good.join(", ") || "—") + (bad.length ? "  " + C.red("failed: " + bad.join(", ")) : ""));
 }
 
+// ---- uninstall --------------------------------------------------------------
+// Remove a node CLI from the global store. `rm -g` is the same verb for pnpm,
+// npm and bun; try the chosen PM first, then any other present (a tool may have
+// been installed under a different one). Removing an absent package is success.
+function uninstallNpm(m) {
+  const pm = nodePM();
+  const tried = new Set();
+  for (const cand of [pm, "pnpm", "npm", "bun"]) {
+    if (tried.has(cand) || !has(cand)) continue;
+    tried.add(cand);
+    if (run(cand, ["rm", "-g", m.pkg])) return true;
+  }
+  console.log(C.dim(`  ${m.id} not found in any global store (already gone)`));
+  return true;
+}
+
+// demerzel & co: the isolated venv lives under ~/.seldon/<id>. Just delete it.
+function uninstallPython(m) {
+  const dest = path.join(process.env.HOME, ".seldon", m.id);
+  if (fs.existsSync(dest)) { fs.rmSync(dest, { recursive: true, force: true }); console.log(C.dim(`  removed ${dest}`)); }
+  else console.log(C.dim(`  ${m.id} not present`));
+  return true;
+}
+
+// bifrost: a single script in ~/bin or ~/.local/bin, plus ~/.config/bifrost.
+function uninstallShell(m) {
+  let removed = false;
+  for (const p of [path.join(process.env.HOME, "bin", m.bin), path.join(process.env.HOME, ".local", "bin", m.bin)]) {
+    if (fs.existsSync(p)) { fs.rmSync(p, { force: true }); console.log(C.dim(`  removed ${p}`)); removed = true; }
+  }
+  const cfg = path.join(process.env.HOME, ".config", m.id);
+  if (fs.existsSync(cfg)) { fs.rmSync(cfg, { recursive: true, force: true }); console.log(C.dim(`  removed ${cfg}`)); removed = true; }
+  if (!removed) console.log(C.dim(`  ${m.id} not present`));
+  return true;
+}
+
+function uninstallOne(m) {
+  console.log("\n" + C.bold(`▸ ${m.id}`) + C.dim(` — remove`));
+  const fn = { npm: uninstallNpm, shell: uninstallShell, python: uninstallPython }[m.method];
+  const ok = fn(m);
+  console.log(ok ? C.green(`  ✓ ${m.id} removed`) : C.red(`  ✗ ${m.id} failed`));
+  return ok;
+}
+
+// A single y/N prompt. Built on the same raw-keypress mechanism as the picker
+// (proven to release stdin and let the process exit) rather than
+// readline.createInterface, whose stdin stayed entangled and hung after abort.
+// One keypress: 'y' = yes, anything else (incl. Ctrl-C) = no.
+function confirm(question) {
+  return new Promise((resolve) => {
+    if (!process.stdin.isTTY) return resolve(true); // non-interactive: assume yes (paired with an explicit ids/--all)
+    process.stdout.write(question);
+    readline.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    const onKey = (str, key) => {
+      process.stdin.off("keypress", onKey);
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+      process.stdin.unref();
+      process.stdout.write((str || "") + "\n");
+      resolve(/^y$/i.test(str || "") && !(key && key.ctrl));
+    };
+    process.stdin.on("keypress", onKey);
+  });
+}
+
+async function doUninstall(ids, { yes = false, all = false } = {}) {
+  const targets = all ? MODULES.map((m) => m.id) : ids;
+  if (!targets.length) { console.log(C.red("nothing to uninstall — name modules or use `seldon uninstall --all`.")); process.exitCode = 1; return; }
+  console.log(C.bold("\nUninstall: ") + targets.join(", "));
+  console.log(C.dim("  removes their global CLI / isolated venv — never your system Python, tmux, tailscale, etc."));
+  if (!yes && !(await confirm(C.gold("\nProceed? [y/N] ")))) { console.log(C.dim("aborted.")); return; }
+  const results = targets.map((id) => [id, uninstallOne(byId[id])]);
+  // A full uninstall also drops the isolated ~/.seldon (demerzel + the uv/CPython it bootstrapped).
+  if (all) {
+    const root = path.join(process.env.HOME, ".seldon");
+    if (fs.existsSync(root)) { fs.rmSync(root, { recursive: true, force: true }); console.log(C.dim(`\n  removed ${root} (isolated uv/venv store)`)); }
+  }
+  const good = results.filter(([, r]) => r).map(([i]) => i);
+  const bad = results.filter(([, r]) => !r).map(([i]) => i);
+  console.log("\n" + C.bold("Done. ") + C.green("removed: " + (good.join(", ") || "—")) + (bad.length ? "  " + C.red("failed: " + bad.join(", ")) : ""));
+}
+
+// ---- up / down / status : the friendly front door ---------------------------
+// The stack's only always-on services are the voice (demerzel) and the
+// supervisor loop (factory watch). We run them as detached background daemons,
+// track them by pidfile under ~/.seldon/run, and print one map of where to go.
+const RUN_DIR = path.join(process.env.HOME, ".seldon", "run");
+const SELDON_HOME = path.join(process.env.HOME, ".seldon");
+const pidFile = (name) => path.join(RUN_DIR, name + ".pid");
+const readPid = (name) => { try { return parseInt(fs.readFileSync(pidFile(name), "utf8").trim(), 10) || 0; } catch { return 0; } };
+const isAlive = (pid) => { try { process.kill(pid, 0); return true; } catch { return false; } };
+const daemonUp = (name) => { const p = readPid(name); return p && isAlive(p) ? p : 0; };
+
+function startDaemon(name, cmd, args, opts = {}) {
+  if (daemonUp(name)) return { already: true, pid: readPid(name) };
+  fs.mkdirSync(RUN_DIR, { recursive: true });
+  const log = fs.openSync(path.join(RUN_DIR, name + ".log"), "a");
+  const child = spawn(cmd, args, { detached: true, stdio: ["ignore", log, log], ...opts });
+  fs.writeFileSync(pidFile(name), String(child.pid));
+  child.unref();
+  return { pid: child.pid };
+}
+function stopDaemon(name) {
+  const pid = readPid(name);
+  if (!pid || !isAlive(pid)) { try { fs.rmSync(pidFile(name), { force: true }); } catch {} return false; }
+  try { process.kill(-pid, "SIGTERM"); } catch { try { process.kill(pid, "SIGTERM"); } catch {} }
+  try { fs.rmSync(pidFile(name), { force: true }); } catch {}
+  return true;
+}
+// demerzel needs its model set in the HF cache before it can serve.
+function demerzelModelsReady() {
+  const hub = path.join(process.env.HOME, ".cache", "huggingface", "hub");
+  try { return fs.existsSync(hub) && fs.readdirSync(hub).some((d) => d.startsWith("models--")); } catch { return false; }
+}
+const demerzelInstalled = () => fs.existsSync(path.join(SELDON_HOME, "demerzel", ".venv", "bin", "python"));
+
+function up() {
+  console.log(C.gold("\n  seldon — bringing the stack up\n"));
+  const go = [];      // where-to-go lines
+  const later = [];   // things that need one action first
+
+  // Voice — demerzel (background daemon)
+  const dem = byId.demerzel;
+  if (demerzelInstalled()) {
+    const home = path.join(SELDON_HOME, "demerzel");
+    if (!platformOk(dem)) later.push("Voice (demerzel) needs macOS on Apple silicon — skipped here.");
+    else if (!demerzelModelsReady()) later.push(`Voice (demerzel) needs its models once (~25 GB):\n      ${path.join(home, ".venv/bin/python")} ${path.join(home, "scripts/fetch-models.py")}\n      then re-run  seldon up`);
+    else {
+      const r = startDaemon("demerzel", path.join(home, ".venv/bin/python"), ["-m", "demerzel.server"], { cwd: home });
+      go.push(`${C.bold("Voice")}   ${C.cyan("http://localhost:8770")}   ${C.dim(r.already ? "(already up)" : "(starting — models load, ~30s)")}`);
+    }
+  }
+
+  // Supervisor — factory watch (background daemon, the "let it work" loop)
+  if (has("factory")) {
+    const r = startDaemon("factory-watch", "factory", ["watch", "--all"]);
+    go.push(`${C.bold("Supervisor")}  ${C.dim(r.already ? "already running" : "running")} — heals agents, catches stalls   ${C.dim("· live view: factory board")}`);
+  }
+
+  // The rest are on-demand, not daemons — point at the command.
+  if (has("factory")) go.push(`${C.bold("Put agents to work")}  ${C.cyan('factory new "<your idea>"')}   ${C.dim("→ repo · foundation · apiary hive")}`);
+  if (has("apiary"))  go.push(`${C.bold("Agent rooms")}  ${C.cyan("apiary ps")}   ${C.dim("(active rooms + join links)")}`);
+  if (has("bifrost")) go.push(`${C.bold("Across machines / phone")}  ${C.cyan("bifrost sessions")}`);
+
+  if (go.length) { console.log(C.bold("  Where to go:")); for (const l of go) console.log("   • " + l); }
+  else console.log(C.dim("  nothing to start — install services first: seldon install factory demerzel"));
+  if (later.length) { console.log("\n" + C.gold("  First, one step:")); for (const l of later) console.log("   • " + l); }
+  console.log("\n  " + C.dim("stop everything: seldon down   ·   check state: seldon status") + "\n");
+}
+
+function down() {
+  const names = ["demerzel", "factory-watch"];
+  const stopped = names.filter((n) => stopDaemon(n));
+  console.log(stopped.length ? C.green("stopped: ") + stopped.join(", ") : C.dim("nothing was running."));
+}
+
+function statusCmd() {
+  console.log(C.bold("\nseldon services\n"));
+  const rows = [["Voice (demerzel)", "demerzel"], ["Supervisor (factory watch)", "factory-watch"]];
+  for (const [label, name] of rows) {
+    const pid = daemonUp(name);
+    console.log(`  ${label.padEnd(28)} ${pid ? C.green("up") + C.dim(` (pid ${pid})`) : C.dim("down")}`);
+  }
+  console.log(C.dim(`\n  logs: ${RUN_DIR}/<service>.log\n`));
+}
+
 // ---- the checklist TUI ------------------------------------------------------
 const BANNER = [
   " ███████╗███████╗██╗     ██████╗  ██████╗ ███╗   ██╗",
@@ -265,11 +435,16 @@ function help() {
 ${C.bold("seldon")} — install the Seldon stack, pick what you use.
 
   ${C.bold("seldon")}                 open the checklist (space to pick, enter to install)
+  ${C.bold("seldon up")}              start the stack (voice + supervisor) and print where to go
+  ${C.bold("seldon status")}          what's running   ·   ${C.bold("seldon down")}  stop it
   ${C.bold("seldon install")} [ids…]  install everything picked, or the named modules
+  ${C.bold("seldon uninstall")} ids…  remove the named modules (global CLI / isolated venv)
+  ${C.bold("seldon uninstall --all")} remove the whole stack (also drops ~/.seldon)
   ${C.bold("seldon doctor")} [ids…]   check external deps (tmux, sops, age, tailscale, python…)
   ${C.bold("seldon list")}            list the modules
   ${C.bold("seldon --dev")}           link node modules from this checkout instead of npm
   ${C.bold("seldon install --pm=pnpm")}  force the node package manager (pnpm|bun|npm; auto-detected)
+  ${C.dim("uninstall takes --yes to skip the confirm prompt.")}
 
   ${C.dim("node tools install via pnpm/bun if present (faster), else npm.")}
   ${C.dim("python (demerzel) installs into its own isolated venv — never your system Python;")}
@@ -283,7 +458,8 @@ const argv = process.argv.slice(2);
 const dev = argv.includes("--dev");
 const args = argv.filter((a) => !a.startsWith("--"));
 const cmd = args[0];
-const ids = args.slice(1).filter((id) => byId[id]);
+const tokens = args.slice(1);                          // raw names after the command
+const ids = tokens.filter((id) => byId[id]);           // only the valid module ids
 
 (async () => {
   if (argv.includes("--help") || cmd === "help") return help();
@@ -293,6 +469,15 @@ const ids = args.slice(1).filter((id) => byId[id]);
     if (ids.length) return doInstall(ids, { dev });
     // install with no ids -> fall through to the picker
   }
+  if (cmd === "uninstall") {
+    const all = argv.includes("--all");
+    const bad = tokens.filter((t) => !byId[t]);
+    if (bad.length) { console.log(C.red(`unknown module(s): ${bad.join(", ")}`)); console.log(C.dim(`modules: ${MODULES.map((m) => m.id).join(", ")}`)); process.exitCode = 1; return; }
+    return doUninstall(ids, { all, yes: argv.includes("--yes") });
+  }
+  if (cmd === "up") return up();
+  if (cmd === "down") return down();
+  if (cmd === "status") return statusCmd();
   if (cmd && cmd !== "install") { help(); process.exitCode = 1; return; }
   // interactive
   if (!process.stdin.isTTY) { console.log(C.red("no TTY — use: seldon install <ids…>")); process.exitCode = 1; return; }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gorlitzer-labs/seldon",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Install the Seldon stack — pick your tools from a checklist; each installs via its native method.",
   "type": "module",
   "bin": {