@gorlitzer-labs/seldon 0.1.8 → 0.1.10

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,45 @@ 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 model set (~25 GB) is a one-time download —
+`seldon install demerzel` **offers to fetch it right there** ([y/N]), and `seldon up`
+offers again if it's still missing. Nothing that big is ever pulled silently.
+Logs live in `~/.seldon/run/`.
+
+**Try a different LLM** (e.g. PrismML's Bonsai 2, ~5.9 GB, much smaller than the
+default): set `DEMERZEL_LLM` to any MLX-compatible HF repo before install/up, and
+both the fetch and the runtime follow it:
+
+```bash
+DEMERZEL_LLM=mlx-community/<bonsai-2-repo> seldon install demerzel   # fetch that model
+DEMERZEL_LLM=mlx-community/<bonsai-2-repo> seldon up                 # run it
+```
+
+## 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 +90,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;
 }
 
@@ -182,7 +184,7 @@ function installOne(m, dev) {
   return ok;
 }
 
-function doInstall(ids, { dev } = {}) {
+async function doInstall(ids, { dev } = {}) {
   ids = withRequires(ids);
   console.log(C.bold(`\nInstalling: `) + ids.join(", ") + (dev ? C.dim("  (dev: link from checkout)") : ""));
   console.log(C.bold("\nPreflight:"));
@@ -192,6 +194,8 @@ function doInstall(ids, { dev } = {}) {
   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(good.join(", ") || "—") + (bad.length ? "  " + C.red("failed: " + bad.join(", ")) : ""));
+  // demerzel's models are the heavy part — offer to pull them now, at install time.
+  if (good.includes("demerzel")) await ensureDemerzelModels({ ask: true });
 }
 
 // ---- uninstall --------------------------------------------------------------
@@ -278,6 +282,113 @@ async function doUninstall(ids, { yes = false, all = false } = {}) {
   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"));
+
+// Fetch demerzel's model set (~25 GB) — offered, never silent. Respects the
+// chosen LLM (DEMERZEL_LLM) so `seldon install demerzel` / `seldon up` pull the
+// model you'll actually run. --models forces yes, --no-models forces skip.
+async function ensureDemerzelModels({ ask = true } = {}) {
+  if (!demerzelInstalled() || !platformOk(byId.demerzel)) return false;
+  if (demerzelModelsReady()) return true;
+  const home = path.join(SELDON_HOME, "demerzel");
+  const force = process.argv.includes("--models");
+  const skip = process.argv.includes("--no-models");
+  let doit = force;
+  if (!doit && !skip) doit = process.stdin.isTTY
+    ? await confirm(C.gold("\n  Download Demerzel's voice models now (~25 GB, one time)? [y/N] "))
+    : false; // never pull 25 GB non-interactively without --models
+  if (!doit) { console.log(C.dim("  models not fetched — the voice stays off until they are (seldon up will offer again).")); return false; }
+  const llm = process.env.DEMERZEL_LLM;
+  console.log(C.dim(`  fetching Demerzel models${llm ? ` (LLM ${llm})` : ""} — ~25 GB, resumable…`));
+  return run(path.join(home, ".venv/bin/python"), [path.join(home, "scripts/fetch-models.py")], { cwd: home, env: { ...process.env } });
+}
+
+async 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()) await ensureDemerzelModels({ ask: true });  // offer the fetch inline
+      if (demerzelModelsReady()) {
+        const r = startDaemon("demerzel", path.join(home, ".venv/bin/python"), ["-m", "demerzel.server"], { cwd: home, env: { ...process.env } });
+        go.push(`${C.bold("Voice")}   ${C.cyan("http://localhost:8770")}   ${C.dim(r.already ? "(already up)" : "(starting — models load, ~30s)")}`);
+      } else {
+        later.push("Voice (demerzel): models not fetched yet — run `seldon up` again when you're ready to pull them.");
+      }
+    }
+  }
+
+  // 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 = [
   " ███████╗███████╗██╗     ██████╗  ██████╗ ███╗   ██╗",
@@ -349,6 +460,8 @@ 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)
@@ -387,11 +500,14 @@ const ids = tokens.filter((id) => byId[id]);           // only the valid module
     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; }
   const picked = await tui();
   if (!picked) { console.log(C.dim("nothing installed.")); return; }
   if (!picked.length) { console.log(C.dim("nothing selected.")); return; }
-  doInstall(picked, { dev });
+  await doInstall(picked, { dev });
 })();

package/package.json

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