@metaphi-ai/hum 0.2.9 → 0.2.11

package/bin/hum.js

@@ -1,7 +1,11 @@
 #!/usr/bin/env node
-// `hum` from npm: the Ink front-end, which starts Hum's core (Python, installed by postinstall
-// via uv) and talks to it over localhost. Everything the person sees is here; everything the
-// session records is in the core.
+// `hum` from npm: the launcher. It starts the newest release installed under ~/.hum/versions
+// (a session installs a newer one there in the background while it runs) and, when none is newer
+// than this package, this package's own front-end, which starts Hum's core (Python) and talks to
+// it over localhost. Everything the person sees is there; everything the session records is in
+// the core. This file is what npm put on PATH and it changes only when npm reinstalls it: keep
+// it small, and keep it running whatever the versions directory holds.
+import fs from 'node:fs';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import path from 'node:path';
 
@@ -15,4 +19,11 @@ if (Number(process.versions.node.split('.')[0]) < NODE_FLOOR) {
 
 const here = path.dirname(fileURLToPath(import.meta.url));
 // a URL, not a path: on Windows `C:\…` is not something the ESM loader will import
-await import(pathToFileURL(path.join(here, '..', 'dist', 'cli.mjs')).href);
+const asUrl = (p) => pathToFileURL(p).href;
+let entry = path.join(here, '..', 'dist', 'cli.mjs');
+try {
+  const own = JSON.parse(fs.readFileSync(path.join(here, '..', 'package.json'), 'utf8')).version;
+  const { chosenEntry } = await import(asUrl(path.join(here, '..', 'dist', 'install.mjs')));
+  entry = chosenEntry(own) || entry;
+} catch { /* this package's own */ }
+await import(asUrl(entry));

package/dist/cli.mjs

@@ -88432,20 +88432,29 @@ import { spawnSync } from "node:child_process";
 import fs3 from "node:fs";
 import os3 from "node:os";
 import path from "node:path";
-function importedVersion(env3 = process.env, runImpl = run) {
-  const r = runImpl(corePython(env3), ASK_VERSION);
+function readyVersions(env3 = process.env) {
+  let names = [];
+  try {
+    names = fs3.readdirSync(versionsDir(env3));
+  } catch {
+    return [];
+  }
+  return names.filter((v) => isVersion(v) && fs3.existsSync(readyFile(env3, v))).sort((a, b) => newer(a, b) ? -1 : newer(b, a) ? 1 : 0);
+}
+function importedVersion(env3 = process.env, version = MINE, runImpl = run) {
+  const r = runImpl(corePython(env3, version), ASK_VERSION);
   return r && r.status === 0 ? String(r.stdout).trim() : null;
 }
-function installedVersion(env3 = process.env, runImpl = run) {
+function installedVersion(env3 = process.env, version = MINE, runImpl = run) {
   try {
-    return fs3.readFileSync(stampPath(env3), "utf8").trim() || null;
+    return fs3.readFileSync(stampPath(env3, version), "utf8").trim() || null;
   } catch {
   }
-  if (!fs3.existsSync(corePython(env3))) return null;
-  const v = importedVersion(env3, runImpl);
+  if (!fs3.existsSync(corePython(env3, version))) return null;
+  const v = importedVersion(env3, version, runImpl);
   if (v) {
     try {
-      fs3.writeFileSync(stampPath(env3), `${v}
+      fs3.writeFileSync(stampPath(env3, version), `${v}
 `);
     } catch {
     }
@@ -88458,22 +88467,21 @@ function trustedPython(env3 = process.env, runImpl = run) {
   const p = r && r.status === 0 ? String(r.stdout).trim().split(/\r?\n/).pop() : "";
   return /^[a-z]:\\.+\\python(w)?\.exe$/i.test(p) ? p : null;
 }
-function sslBlocked(env3 = process.env, runImpl = run) {
-  const r = runImpl(corePython(env3), ASK_SSL);
+function sslBlocked(env3 = process.env, version = MINE, runImpl = run) {
+  const r = runImpl(corePython(env3, version), ASK_SSL);
   if (r && r.status === 0) return null;
   const text = String(r && (r.stderr || r.stdout) || "ssl did not import").trim().split(/\r?\n/).filter(Boolean).pop() || "ssl did not import";
   return text;
 }
-function needsInstall(version, { env: env3 = process.env, installed = () => installedVersion(env3), now = Date.now(), state = readInstallState(env3) } = {}) {
+function needsInstall(version, { env: env3 = process.env, installed = () => installedVersion(env3, version), now = Date.now(), state = readInstallState(env3) } = {}) {
   if (!version || env3.HUM_CORE || env3.HUM_CORE_PORT) return false;
   if (installed() === version) return false;
   if (state && !state.ok && state.version === version && now - (state.at || 0) < 10 * 60 * 1e3) return false;
   return true;
 }
 function installCore(version, { env: env3 = process.env, say = (m) => console.log(`hum: ${m}`), runImpl = run, now = Date.now() } = {}) {
-  const home = humHome(env3);
-  const dir = coreDir(env3);
-  const python = corePython(env3);
+  const dir = coreDir(env3, version);
+  const python = corePython(env3, version);
   const localBin = path.join(os3.homedir(), ".local", "bin");
   const uvNames = ["uv", path.join(localBin, win ? "uv.exe" : "uv")];
   const uv = () => uvNames.find((u) => {
@@ -88494,9 +88502,9 @@ function installCore(version, { env: env3 = process.env, say = (m) => console.lo
       if (!u) return outcome(false, `could not install uv; install it from https://astral.sh/uv and run:  ${npmFix(version)}`);
     }
     say(`installing ${env3.HUM_CORE_SPEC ? spec : `hum ${version}`} into ${dir} \u2026`);
-    fs3.mkdirSync(home, { recursive: true });
+    fs3.mkdirSync(path.dirname(dir), { recursive: true });
     try {
-      fs3.unlinkSync(stampPath(env3));
+      fs3.unlinkSync(stampPath(env3, version));
     } catch {
     }
     const trusted = trustedPython(env3, runImpl);
@@ -88504,20 +88512,20 @@ function installCore(version, { env: env3 = process.env, say = (m) => console.lo
     const pipIn = () => (runImpl(u, ["pip", "install", "--quiet", "--python", python, spec], { stdio: "inherit" }) || {}).status === 0;
     if (!fs3.existsSync(python) && !makeVenv(fs3.existsSync(dir))) return outcome(false, "uv venv failed");
     if (!pipIn()) return outcome(false, `uv pip install ${spec} failed`);
-    let got = importedVersion(env3, runImpl);
+    let got = importedVersion(env3, version, runImpl);
     if (!got) return outcome(false, "hum did not import after the install");
     if (got !== version && !env3.HUM_CORE_SPEC) return outcome(false, `installed ${got}, wanted ${version}`, got);
-    let blocked = sslBlocked(env3, runImpl);
+    let blocked = sslBlocked(env3, version, runImpl);
     if (blocked && trusted) {
       say(`the policy here refuses the environment's OpenSSL (${blocked}); rebuilding it on ${trusted} \u2026`);
       if (makeVenv(true) && pipIn()) {
-        got = importedVersion(env3, runImpl) || got;
-        blocked = sslBlocked(env3, runImpl);
+        got = importedVersion(env3, version, runImpl) || got;
+        blocked = sslBlocked(env3, version, runImpl);
       }
     }
     if (blocked) return outcome(false, sslAdvice(env3, version));
     fs3.mkdirSync(dir, { recursive: true });
-    fs3.writeFileSync(stampPath(env3), `${got}
+    fs3.writeFileSync(stampPath(env3, version), `${got}
 `);
     const list2 = runImpl(u, ["tool", "list"]);
     if (list2 && list2.status === 0 && /^hum-cli\b/m.test(list2.stdout)) {
@@ -88530,21 +88538,118 @@ function installCore(version, { env: env3 = process.env, say = (m) => console.lo
     return outcome(false, e && e.message ? e.message : String(e));
   }
 }
-var win, npmFix, NPM_FIX, humHome, coreDir, corePython, stampPath, statePath, run, ASK_VERSION, ASK_SSL, sslAdvice, readInstallState, writeInstallState;
+function installPackage(version, { env: env3 = process.env, say = (m) => console.log(`hum: ${m}`), runImpl = run } = {}) {
+  const dest = pkgDir(env3, version);
+  const stage = path.join(versionDir(env3, version), "npm");
+  say(`fetching hum ${version} \u2026`);
+  fs3.rmSync(stage, { recursive: true, force: true });
+  fs3.mkdirSync(stage, { recursive: true });
+  const r = runImpl(win ? "npm.cmd" : "npm", [
+    "install",
+    "--prefix",
+    stage,
+    "--ignore-scripts",
+    "--no-audit",
+    "--no-fund",
+    "--no-package-lock",
+    "--loglevel=error",
+    `@metaphi-ai/hum@${version}`
+  ], { shell: win, env: { ...env3, npm_config_update_notifier: "false" } });
+  const got = path.join(stage, "node_modules", "@metaphi-ai", "hum");
+  if (!r || r.status !== 0 || !fs3.existsSync(path.join(got, "dist", "cli.mjs"))) {
+    const why = String(r && (r.stderr || r.stdout) || "").trim().split(/\r?\n/).filter(Boolean).pop() || `npm exited ${r ? r.status : "without running"}`;
+    fs3.rmSync(stage, { recursive: true, force: true });
+    return { ok: false, error: `npm could not fetch @metaphi-ai/hum@${version}: ${why}` };
+  }
+  fs3.rmSync(dest, { recursive: true, force: true });
+  fs3.renameSync(got, dest);
+  fs3.rmSync(stage, { recursive: true, force: true });
+  return { ok: true, error: null };
+}
+function prune(env3 = process.env, { keep = MINE, say = () => {
+}, now = Date.now() } = {}) {
+  let names = [];
+  try {
+    names = fs3.readdirSync(versionsDir(env3)).filter(isVersion);
+  } catch {
+    return [];
+  }
+  const ready = readyVersions(env3);
+  const stay = /* @__PURE__ */ new Set([keep, ...ready.slice(0, 3)]);
+  const gone = [];
+  for (const v of names) {
+    if (stay.has(v)) continue;
+    if (!ready.includes(v)) {
+      let at = 0;
+      try {
+        at = fs3.statSync(versionDir(env3, v)).mtimeMs;
+      } catch {
+      }
+      if (now - at < 30 * 60 * 1e3) continue;
+    }
+    try {
+      fs3.rmSync(versionDir(env3, v), { recursive: true, force: true });
+      gone.push(v);
+      say(`removed hum ${v}`);
+    } catch {
+    }
+  }
+  return gone.sort((a, b) => newer(a, b) ? -1 : newer(b, a) ? 1 : 0);
+}
+function installVersion(version, { env: env3 = process.env, say = (m) => console.log(`hum: ${m}`), runImpl = run, now = Date.now() } = {}) {
+  if (!isVersion(version)) return { ok: false, error: `not a version: ${version}` };
+  try {
+    fs3.mkdirSync(versionDir(env3, version), { recursive: true });
+    try {
+      fs3.unlinkSync(readyFile(env3, version));
+    } catch {
+    }
+    if (!fs3.existsSync(entryFile(env3, version))) {
+      const p = installPackage(version, { env: env3, say, runImpl });
+      if (!p.ok) return p;
+    }
+    if (installedVersion(env3, version, runImpl) !== version) {
+      const c = installCore(version, { env: env3, say, runImpl, now });
+      if (!c.ok) return { ok: false, error: c.error };
+    }
+    fs3.writeFileSync(readyFile(env3, version), `${version}
+`);
+    say(`hum ${version} is ready; the next hum you start is ${version}`);
+    prune(env3, { say });
+    return { ok: true, error: null };
+  } catch (e) {
+    return { ok: false, error: e && e.message ? e.message : String(e) };
+  }
+}
+var win, MINE, npmFix, NPM_FIX, humHome, versionsDir, versionDir, pkgDir, coreDir, corePython, readyFile, entryFile, stampPath, statePath, isVersion, newer, run, ASK_VERSION, ASK_SSL, sslAdvice, readInstallState, writeInstallState;
 var init_install = __esm({
   "src/install.js"() {
     win = process.platform === "win32";
+    MINE = true ? "0.2.11" : "";
     npmFix = (version = "") => `npm i -g @metaphi-ai/hum@${version || "latest"} --foreground-scripts`;
     NPM_FIX = npmFix("latest");
     humHome = (env3 = process.env) => env3.HUM_HOME || path.join(os3.homedir(), ".hum");
-    coreDir = (env3 = process.env) => path.join(humHome(env3), "core");
-    corePython = (env3 = process.env) => win ? path.join(coreDir(env3), "Scripts", "python.exe") : path.join(coreDir(env3), "bin", "python");
-    stampPath = (env3) => path.join(coreDir(env3), "version");
+    versionsDir = (env3 = process.env) => path.join(humHome(env3), "versions");
+    versionDir = (env3 = process.env, version = MINE) => path.join(versionsDir(env3), version);
+    pkgDir = (env3 = process.env, version = MINE) => path.join(versionDir(env3, version), "pkg");
+    coreDir = (env3 = process.env, version = MINE) => path.join(versionDir(env3, version), "core");
+    corePython = (env3 = process.env, version = MINE) => win ? path.join(coreDir(env3, version), "Scripts", "python.exe") : path.join(coreDir(env3, version), "bin", "python");
+    readyFile = (env3 = process.env, version = MINE) => path.join(versionDir(env3, version), "ready");
+    entryFile = (env3 = process.env, version = MINE) => path.join(pkgDir(env3, version), "dist", "cli.mjs");
+    stampPath = (env3, version) => path.join(coreDir(env3, version), "version");
     statePath = (env3) => path.join(humHome(env3), "core-install.json");
+    isVersion = (v) => /^\d+\.\d+\.\d+$/.test(v);
+    newer = (a, b) => {
+      const pa = String(a).split(".").map(Number), pb = String(b).split(".").map(Number);
+      for (let i = 0; i < 3; i += 1) {
+        if ((pa[i] || 0) !== (pb[i] || 0)) return (pa[i] || 0) > (pb[i] || 0);
+      }
+      return false;
+    };
     run = (cmd, args2, opts = {}) => spawnSync(cmd, args2, { encoding: "utf8", windowsHide: true, ...opts });
     ASK_VERSION = ["-I", "-c", "import hum; print(hum.__version__)"];
     ASK_SSL = ["-I", "-c", "import ssl"];
-    sslAdvice = (env3, version) => `the machine's application control blocked Python's OpenSSL DLL in ${coreDir(env3)}; install Python 3.12 from python.org (Microsoft signs it), then run  ${npmFix(version)}`;
+    sslAdvice = (env3, version) => `the machine's application control blocked Python's OpenSSL DLL in ${coreDir(env3, version)}; install Python 3.12 from python.org (Microsoft signs it), then run  ${npmFix(version)}`;
     readInstallState = (env3 = process.env) => {
       try {
         return JSON.parse(fs3.readFileSync(statePath(env3), "utf8"));
@@ -88559,6 +88664,24 @@ var init_install = __esm({
       } catch {
       }
     };
+    if (process.argv[1] && /install\.mjs$/.test(process.argv[1]) && process.argv[2] === "install") {
+      const log = path.join(humHome(), "update.log");
+      const say = (m) => {
+        try {
+          fs3.appendFileSync(log, `${(/* @__PURE__ */ new Date()).toISOString()} ${m}
+`);
+        } catch {
+        }
+      };
+      const runLogged = (cmd, args2, opts = {}) => {
+        const r2 = run(cmd, args2, { ...opts, stdio: "pipe" });
+        if (r2 && r2.status !== 0 && (r2.stderr || r2.stdout)) say(String(r2.stderr || r2.stdout).trim().split(/\r?\n/).slice(-5).join("\n"));
+        return r2;
+      };
+      const r = installVersion(process.argv[3] || "", { say, runImpl: runLogged });
+      if (!r.ok) say(`hum ${process.argv[3]} did not install: ${r.error}`);
+      process.exit(r.ok ? 0 : 1);
+    }
   }
 });
 
@@ -88566,6 +88689,7 @@ var init_install = __esm({
 import fs4 from "node:fs";
 import os4 from "node:os";
 import path2 from "node:path";
+import { fileURLToPath } from "node:url";
 import { spawn, spawnSync as spawnSync2 } from "node:child_process";
 async function latestVersion(fetchImpl = globalThis.fetch, env3 = process.env) {
   if (env3.HUM_NO_UPDATE_CHECK || typeof fetchImpl !== "function") return "";
@@ -88588,20 +88712,9 @@ function installLayout(execPath = process.execPath, env3 = process.env) {
   }
   return { kind: "native", exe, dir: path2.dirname(real), base: path2.dirname(path2.dirname(real)) };
 }
-function packageVersion(entry = process.argv[1]) {
-  try {
-    const dir = path2.dirname(fs4.realpathSync(entry));
-    return JSON.parse(fs4.readFileSync(path2.join(dir, "..", "package.json"), "utf8")).version || "";
-  } catch {
-    return "";
-  }
-}
-function installerArgv(version, platform2 = process.platform, layout2 = { kind: "native" }, log = "") {
+function installerArgv(version, platform2 = process.platform, layout2 = { kind: "native" }, log = "", node = process.execPath) {
   const base = dist();
-  if (layout2.kind === "npm") {
-    const cmd = `npm i -g --ignore-scripts @metaphi-ai/hum@${version || "latest"}`;
-    return platform2 === "win32" ? ["cmd.exe", ["/d", "/s", "/c", `"${cmd}${log ? ` >> "${log}" 2>&1` : ""}"`], { windowsVerbatimArguments: true }] : ["/bin/sh", ["-c", cmd], {}];
-  }
+  if (layout2.kind === "npm") return [node, [installerScript(), "install", version], {}];
   if (platform2 === "win32") {
     const cmd = `irm ${base}/install.ps1 | iex`;
     return ["powershell", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", log ? `& { ${cmd} } *>> '${log}'` : cmd], {}];
@@ -88613,6 +88726,7 @@ function startBackgroundUpdate(version, { env: env3 = process.env, now = Date.no
   const s = readState(env3);
   if (s.version === version && now - (s.started || 0) < 30 * 60 * 1e3) return false;
   const hidden = platform2 === "win32";
+  const ownLog = layout2.kind === "npm";
   const log = path2.join(humHome2(env3), "update.log");
   let out = "ignore";
   let logged = false;
@@ -88620,15 +88734,15 @@ function startBackgroundUpdate(version, { env: env3 = process.env, now = Date.no
     fs4.mkdirSync(humHome2(env3), { recursive: true });
     out = fs4.openSync(log, "w");
     logged = true;
-    if (hidden) {
+    if (hidden || ownLog) {
       fs4.closeSync(out);
       out = "ignore";
     }
   } catch {
     out = "ignore";
   }
-  const [bin, args2, extra] = installerArgv(version, platform2, layout2, hidden && logged ? log : "");
-  const io = hidden ? { stdio: "ignore", windowsHide: true } : { detached: true, stdio: ["ignore", out, out], windowsHide: true };
+  const [bin, args2, extra] = installerArgv(version, platform2, layout2, hidden && logged && !ownLog ? log : "");
+  const io = hidden ? { stdio: "ignore", windowsHide: true } : { detached: true, stdio: ownLog ? "ignore" : ["ignore", out, out], windowsHide: true };
   try {
     const child = spawnImpl(bin, args2, { ...io, ...extra, env: { ...env3, HUM_VERSION: version, HUM_DIST: dist(env3) } });
     child.unref();
@@ -88651,7 +88765,7 @@ function updateNotice(mine, { running = "", latest = "", env: env3 = process.env
   if (drift) return drift;
   if (env3.HUM_NO_UPDATE_CHECK || !mine || !latest || !newer(latest, mine)) return "";
   if (env3.HUM_NO_AUTO_UPDATE || layout2.kind === "python") return `hum ${latest} is out \xB7 ${updateCommand(layout2)}`;
-  if (readyVersion(layout2, latest)) return `hum ${latest} is ready \xB7 restart hum to use it`;
+  if (readyVersion(layout2, latest, env3)) return `hum ${latest} is ready \xB7 restart hum to use it`;
   if (startBackgroundUpdate(latest, { env: env3, spawnImpl, layout: layout2, now, platform: platform2 })) return `hum ${latest} is installing in the background \xB7 it takes effect the next time you start hum`;
   if (readState(env3).version === latest) return `hum ${latest} is still installing in the background (${path2.join(humHome2(env3), "update.log")} has the details)`;
   return "";
@@ -88673,45 +88787,54 @@ function watchReady(mine, latest, onReady, { env: env3 = process.env, layout: la
   if (t.unref) t.unref();
   return () => clearInterval(t);
 }
-function updateNow(layout2 = installLayout()) {
+async function updateNow(layout2 = installLayout(), { mine = MINE, latest = latestVersion, install = installVersion, write = (m) => process.stdout.write(m) } = {}) {
   if (layout2.kind === "native") {
     const [bin, args2] = installerArgv();
     return spawnSync2(bin, args2, { stdio: "inherit", env: { ...process.env, HUM_DIST: dist() } }).status ?? 1;
   }
   if (layout2.kind === "python") {
     const r2 = spawnSync2(win2() ? "uv.exe" : "uv", ["tool", "upgrade", "hum-cli"], { stdio: "inherit", windowsHide: true });
-    if (r2.error || r2.status !== 0) process.stdout.write(`update with your package manager:  ${updateCommand(layout2)}
+    if (r2.error || r2.status !== 0) write(`update with your package manager:  ${updateCommand(layout2)}
 `);
     return r2.error ? 1 : r2.status ?? 1;
   }
-  const r = spawnSync2(win2() ? "npm.cmd" : "npm", ["i", "-g", "@metaphi-ai/hum@latest"], { stdio: "inherit", shell: win2() });
-  return r.status ?? 1;
+  const v = await latest();
+  if (!v) {
+    write(`could not read the latest release from ${dist()}
+`);
+    return 1;
+  }
+  if (mine && !newer(v, mine)) {
+    write(`hum ${mine} is the latest
+`);
+    return 0;
+  }
+  const r = install(v, { say: (m) => write(`hum: ${m}
+`) });
+  if (!r.ok) write(`hum: ${r.error}
+`);
+  return r.ok ? 0 : 1;
 }
-var dist, humHome2, win2, newer, updateCommand, readyVersion, stateFile, readState, writeState;
+var dist, humHome2, win2, updateCommand, readyVersion, installerScript, stateFile, readState, writeState;
 var init_update = __esm({
   "src/update.js"() {
+    init_install();
     init_install();
     dist = (env3 = process.env) => (env3.HUM_DIST || "https://humboldt.metaphi.ai").replace(/\/+$/, "");
     humHome2 = (env3 = process.env) => env3.HUM_HOME || path2.join(os4.homedir(), ".hum");
     win2 = () => process.platform === "win32";
-    newer = (a, b) => {
-      const pa = String(a).split(".").map(Number), pb = String(b).split(".").map(Number);
-      for (let i = 0; i < 3; i += 1) {
-        if ((pa[i] || 0) !== (pb[i] || 0)) return (pa[i] || 0) > (pb[i] || 0);
-      }
-      return false;
-    };
     updateCommand = (layout2 = installLayout(), platform2 = process.platform) => {
       if (layout2.kind === "native") return platform2 === "win32" ? `irm ${dist()}/install.ps1 | iex` : `curl -fsSL ${dist()}/install.sh | sh`;
       if (layout2.kind === "python") return "uv tool upgrade hum-cli   (or: pip install -U hum-cli)";
       return "npm i -g @metaphi-ai/hum@latest";
     };
-    readyVersion = (layout2, version, pkg = packageVersion) => {
+    readyVersion = (layout2, version, env3 = process.env) => {
       if (!version) return "";
       if (layout2.kind === "native") return fs4.existsSync(path2.join(layout2.base, version, layout2.exe)) ? version : "";
-      if (layout2.kind === "npm") return pkg() === version ? version : "";
+      if (layout2.kind === "npm") return fs4.existsSync(readyFile(env3, version)) ? version : "";
       return "";
     };
+    installerScript = () => fileURLToPath(new URL("./install.mjs", import.meta.url));
     stateFile = (env3 = process.env) => path2.join(humHome2(env3), "update.json");
     readState = (env3 = process.env) => {
       try {
@@ -88774,12 +88897,12 @@ function siblingCore(execPath = process.execPath) {
   const p = path3.join(dir, "core", win3 ? "hum-core.exe" : "hum-core");
   return exists(p) ? p : null;
 }
-function homeCore(env3 = process.env) {
-  const home = env3.HUM_HOME || path3.join(os5.homedir(), ".hum");
-  const py = win3 ? path3.join(home, "core", "Scripts", "python.exe") : path3.join(home, "core", "bin", "python");
+function homeCore(env3 = process.env, version = MINE) {
+  if (!version) return null;
+  const py = corePython(env3, version);
   return exists(py) ? py : null;
 }
-function coreCandidates(env3 = process.env) {
+function coreCandidates(env3 = process.env, version = MINE) {
   const out = [];
   if (env3.HUM_CORE) {
     const [bin, ...args2] = env3.HUM_CORE.split(" ");
@@ -88787,8 +88910,8 @@ function coreCandidates(env3 = process.env) {
   }
   const sib = siblingCore();
   if (sib) out.push({ bin: sib, args: ["core"], where: "beside hum" });
-  const home = homeCore(env3);
-  if (home) out.push({ bin: home, args: ["-m", "hum.cli", "core"], where: "HUM_HOME/core" });
+  const home = homeCore(env3, version);
+  if (home) out.push({ bin: home, args: ["-m", "hum.cli", "core"], where: "HUM_HOME/versions" });
   const py = corePython2();
   if (py) out.push({ bin: py, args: ["-m", "hum.cli", "core"], where: "the interpreter beside it" });
   out.push({ bin: "hum-core", args: [], where: "PATH" });
@@ -88805,9 +88928,9 @@ function coreCommand(argv, candidates = coreCandidates()) {
   }
   return null;
 }
-function candidateVersion(c, { env: env3 = process.env, runImpl = spawnSync3 } = {}) {
+function candidateVersion(c, { env: env3 = process.env, runImpl = spawnSync3, version = MINE } = {}) {
   if (!c || !c.bin) return null;
-  if (c.where === "HUM_HOME/core") return installedVersion(env3);
+  if (c.where === "HUM_HOME/versions") return installedVersion(env3, version);
   const interp = c.args.length >= 3 && c.args[c.args.length - 3] === "-m" && c.args[c.args.length - 2] === "hum.cli";
   let r;
   try {
@@ -88832,10 +88955,10 @@ function clientEnv() {
     platform: process.platform,
     arch: process.arch,
     terminal: process.env.TERM_PROGRAM || (process.env.WT_SESSION ? "Windows Terminal" : process.env.TERM || ""),
-    tui: true ? "0.2.9" : ""
+    tui: true ? "0.2.11" : ""
   };
 }
-function startFailure(failures, { npm = /^(node|bun)(\.exe)?$/i.test(String(process.execPath).split(/[\\/]/).pop()), platform: platform2 = process.platform, version = true ? "0.2.9" : "" } = {}) {
+function startFailure(failures, { npm = /^(node|bun)(\.exe)?$/i.test(String(process.execPath).split(/[\\/]/).pop()), platform: platform2 = process.platform, version = true ? "0.2.11" : "" } = {}) {
   const refused = failures.find((f) => f.error && f.error.code !== "ENOENT");
   const fix = npm ? npmFix(version) : updateCommand({ kind: "native" }, platform2);
   if (!refused) {
@@ -89658,10 +89781,12 @@ async function diagnose({
     if (env3.HUM_CORE && running && running.version === mine) checks.push(check2("warn", `HUM_CORE is set (${env3.HUM_CORE}): it decides what runs, ahead of any install`, "unset HUM_CORE"));
     if (layout2.kind === "npm") {
       const st = readInstallState(env3);
-      const stamp = installedVersion(env3, runImpl);
+      const stamp = installedVersion(env3, mine, runImpl);
       if (st && !st.ok) checks.push(check2(stamp === mine ? "warn" : "fail", `the last install attempt (wanted ${st.wanted || st.version}) did not finish: ${st.error}`, npmFix2(mine)));
-      else if (!stamp) checks.push(check2("fail", `nothing installed under ${coreDir(env3)}`, npmFix2(mine)));
-      else checks.push(check2(stamp === mine ? "ok" : "warn", `${coreDir(env3)} holds ${stamp}`, stamp === mine ? "" : npmFix2(mine)));
+      else if (!stamp) checks.push(check2("fail", `nothing installed under ${coreDir(env3, mine)}`, npmFix2(mine)));
+      else checks.push(check2(stamp === mine ? "ok" : "warn", `${coreDir(env3, mine)} holds ${stamp}`, stamp === mine ? "" : npmFix2(mine)));
+      const ready = readyVersions(env3);
+      if (ready.length) checks.push(check2("ok", `installed here: ${ready.join(", ")} (the newest starts next)`));
     }
     if (layout2.kind === "native") {
       const sib = path6.join(layout2.dir, "core", isWin(platform2) ? "hum-core.exe" : "hum-core");
@@ -89686,7 +89811,7 @@ async function diagnose({
     else if (latest) checks.push(check2("ok", `${mine} is the latest release`));
     sections.push({ key: "updates", title: "Updates", checks });
   }
-  const interp = running && running.args.length >= 3 && running.args[running.args.length - 2] === "hum.cli" ? running.bin : exists2(corePython(env3)) ? corePython(env3) : null;
+  const interp = running && running.args.length >= 3 && running.args[running.args.length - 2] === "hum.cli" ? running.bin : exists2(corePython(env3, mine)) ? corePython(env3, mine) : null;
   let toolServers = null;
   {
     const checks = [];
@@ -90291,7 +90416,7 @@ var input_default = MultilineInput;
 
 // src/app.jsx
 var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1);
-var MINE = true ? "0.2.9" : "";
+var MINE2 = true ? "0.2.11" : "";
 var fmtDur = (s) => s < 60 ? `${Math.max(1, Math.round(s))}s` : `${Math.floor(s / 60)}m ${Math.round(s % 60)}s`;
 var plural = (n, w) => `${n} ${w}${n === 1 ? "" : "s"}`;
 var firstResp = (e) => e.first_response_s ? ` \xB7 first response ${e.first_response_s.toFixed(1)}s` : "";
@@ -90679,7 +90804,7 @@ function App2({ core: core2, task, resume, images = [], peek = peekSession, upda
         (ev.questions || []).forEach(addAsk);
         if (ev.fresh) append({ kind: "wordmark" });
         setLatest({ version: ev.version || "", latest_version: ev.latest_version || "", release_notes_url: ev.release_notes_url || "" });
-        append({ kind: "banner", lines: bannerLines(ev, homeRel, MINE), instruction: ev.session ? ev.instruction : null });
+        append({ kind: "banner", lines: bannerLines(ev, homeRel, MINE2), instruction: ev.session ? ev.instruction : null });
         if (ev.note) append({ kind: "warn", text: ev.note });
         setGoal(ev.goal_state && ev.goal_state.text ? ev.goal_state : ev.goal ? { text: ev.goal, status: "active", exchanges: 0 } : null);
         if (ev.goal_state && ev.goal_state.text) append({ kind: "info", text: goalLine(ev.goal_state) });
@@ -91053,7 +91178,7 @@ function App2({ core: core2, task, resume, images = [], peek = peekSession, upda
   const noticedRef = (0, import_react36.useRef)("");
   (0, import_react36.useEffect)(() => {
     if (!latest) return void 0;
-    const mine = MINE || latest.version || "0.0.0";
+    const mine = MINE2 || latest.version || "0.0.0";
     const want = latest.latest_version || "";
     const line = update(mine, { running: latest.version || "", latest: want });
     if (line && noticedRef.current !== line) {
@@ -92116,33 +92241,33 @@ init_update();
 init_install();
 var import_jsx_runtime4 = __toESM(require_jsx_runtime(), 1);
 import { spawnSync as spawnSync5 } from "node:child_process";
-var MINE2 = true ? "0.2.9" : "0.0.0";
+var MINE3 = true ? "0.2.11" : "0.0.0";
 var layout = installLayout();
 function completeInstall() {
-  if (layout.kind !== "npm" || !needsInstall(MINE2)) return;
+  if (layout.kind !== "npm" || !needsInstall(MINE3)) return;
   const say = (m) => process.stderr.write(`hum: ${m}
 `);
-  say(`updating to ${MINE2} \u2026`);
-  const r = installCore(MINE2, { say });
-  if (!r.ok) say(`the update did not finish: ${r.error} \xB7 ${npmFix(MINE2)}`);
+  say(`updating to ${MINE3} \u2026`);
+  const r = installCore(MINE3, { say });
+  if (!r.ok) say(`the update did not finish: ${r.error} \xB7 ${npmFix(MINE3)}`);
 }
 var CORE_COMMANDS = /* @__PURE__ */ new Set(["run", "login", "logout", "whoami", "model", "key", "sessions", "show", "sync", "skill", "persona", "ps", "stop", "hooks", "core"]);
 var argv0 = process.argv.slice(2);
 if (argv0[0] === "--version" || argv0[0] === "-V") {
-  process.stdout.write(`hum ${MINE2}
+  process.stdout.write(`hum ${MINE3}
 `);
   if (layout.kind === "npm") {
     const r = runningVersion();
-    const drift = mismatchLine(MINE2, r ? r.version : "", { layout });
+    const drift = mismatchLine(MINE3, r ? r.version : "", { layout });
     if (drift) process.stdout.write(`${drift}
 `);
   }
   process.exit(0);
 }
-if (argv0[0] === "update") process.exit(updateNow());
+if (argv0[0] === "update") process.exit(await updateNow());
 if (argv0[0] === "doctor") {
   const { doctor: doctor2 } = await Promise.resolve().then(() => (init_doctor(), doctor_exports));
-  process.exit(await doctor2({ json: argv0.includes("--json"), mine: MINE2, layout }));
+  process.exit(await doctor2({ json: argv0.includes("--json"), mine: MINE3, layout }));
 }
 if (CORE_COMMANDS.has(argv0[0]) || argv0[0] === "agents" && argv0.includes("--json") || wantsPlain(argv0)) {
   completeInstall();

package/dist/install.mjs

@@ -4,29 +4,59 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 var win = process.platform === "win32";
+var MINE = typeof HUM_VERSION === "string" ? HUM_VERSION : "";
 var npmFix = (version = "") => `npm i -g @metaphi-ai/hum@${version || "latest"} --foreground-scripts`;
 var NPM_FIX = npmFix("latest");
 var humHome = (env = process.env) => env.HUM_HOME || path.join(os.homedir(), ".hum");
-var coreDir = (env = process.env) => path.join(humHome(env), "core");
-var corePython = (env = process.env) => win ? path.join(coreDir(env), "Scripts", "python.exe") : path.join(coreDir(env), "bin", "python");
-var stampPath = (env) => path.join(coreDir(env), "version");
+var versionsDir = (env = process.env) => path.join(humHome(env), "versions");
+var versionDir = (env = process.env, version = MINE) => path.join(versionsDir(env), version);
+var pkgDir = (env = process.env, version = MINE) => path.join(versionDir(env, version), "pkg");
+var coreDir = (env = process.env, version = MINE) => path.join(versionDir(env, version), "core");
+var corePython = (env = process.env, version = MINE) => win ? path.join(coreDir(env, version), "Scripts", "python.exe") : path.join(coreDir(env, version), "bin", "python");
+var readyFile = (env = process.env, version = MINE) => path.join(versionDir(env, version), "ready");
+var entryFile = (env = process.env, version = MINE) => path.join(pkgDir(env, version), "dist", "cli.mjs");
+var stampPath = (env, version) => path.join(coreDir(env, version), "version");
 var statePath = (env) => path.join(humHome(env), "core-install.json");
+var isVersion = (v) => /^\d+\.\d+\.\d+$/.test(v);
+var newer = (a, b) => {
+  const pa = String(a).split(".").map(Number), pb = String(b).split(".").map(Number);
+  for (let i = 0; i < 3; i += 1) {
+    if ((pa[i] || 0) !== (pb[i] || 0)) return (pa[i] || 0) > (pb[i] || 0);
+  }
+  return false;
+};
+function readyVersions(env = process.env) {
+  let names = [];
+  try {
+    names = fs.readdirSync(versionsDir(env));
+  } catch {
+    return [];
+  }
+  return names.filter((v) => isVersion(v) && fs.existsSync(readyFile(env, v))).sort((a, b) => newer(a, b) ? -1 : newer(b, a) ? 1 : 0);
+}
+function chosenEntry(own, env = process.env) {
+  for (const v of readyVersions(env)) {
+    if (own && !newer(v, own)) break;
+    if (fs.existsSync(entryFile(env, v)) && fs.existsSync(corePython(env, v))) return entryFile(env, v);
+  }
+  return null;
+}
 var run = (cmd, args, opts = {}) => spawnSync(cmd, args, { encoding: "utf8", windowsHide: true, ...opts });
 var ASK_VERSION = ["-I", "-c", "import hum; print(hum.__version__)"];
-function importedVersion(env = process.env, runImpl = run) {
-  const r = runImpl(corePython(env), ASK_VERSION);
+function importedVersion(env = process.env, version = MINE, runImpl = run) {
+  const r = runImpl(corePython(env, version), ASK_VERSION);
   return r && r.status === 0 ? String(r.stdout).trim() : null;
 }
-function installedVersion(env = process.env, runImpl = run) {
+function installedVersion(env = process.env, version = MINE, runImpl = run) {
   try {
-    return fs.readFileSync(stampPath(env), "utf8").trim() || null;
+    return fs.readFileSync(stampPath(env, version), "utf8").trim() || null;
   } catch {
   }
-  if (!fs.existsSync(corePython(env))) return null;
-  const v = importedVersion(env, runImpl);
+  if (!fs.existsSync(corePython(env, version))) return null;
+  const v = importedVersion(env, version, runImpl);
   if (v) {
     try {
-      fs.writeFileSync(stampPath(env), `${v}
+      fs.writeFileSync(stampPath(env, version), `${v}
 `);
     } catch {
     }
@@ -40,13 +70,13 @@ function trustedPython(env = process.env, runImpl = run) {
   return /^[a-z]:\\.+\\python(w)?\.exe$/i.test(p) ? p : null;
 }
 var ASK_SSL = ["-I", "-c", "import ssl"];
-function sslBlocked(env = process.env, runImpl = run) {
-  const r = runImpl(corePython(env), ASK_SSL);
+function sslBlocked(env = process.env, version = MINE, runImpl = run) {
+  const r = runImpl(corePython(env, version), ASK_SSL);
   if (r && r.status === 0) return null;
   const text = String(r && (r.stderr || r.stdout) || "ssl did not import").trim().split(/\r?\n/).filter(Boolean).pop() || "ssl did not import";
   return text;
 }
-var sslAdvice = (env, version) => `the machine's application control blocked Python's OpenSSL DLL in ${coreDir(env)}; install Python 3.12 from python.org (Microsoft signs it), then run  ${npmFix(version)}`;
+var sslAdvice = (env, version) => `the machine's application control blocked Python's OpenSSL DLL in ${coreDir(env, version)}; install Python 3.12 from python.org (Microsoft signs it), then run  ${npmFix(version)}`;
 var readInstallState = (env = process.env) => {
   try {
     return JSON.parse(fs.readFileSync(statePath(env), "utf8"));
@@ -61,16 +91,15 @@ var writeInstallState = (s, env) => {
   } catch {
   }
 };
-function needsInstall(version, { env = process.env, installed = () => installedVersion(env), now = Date.now(), state = readInstallState(env) } = {}) {
+function needsInstall(version, { env = process.env, installed = () => installedVersion(env, version), now = Date.now(), state = readInstallState(env) } = {}) {
   if (!version || env.HUM_CORE || env.HUM_CORE_PORT) return false;
   if (installed() === version) return false;
   if (state && !state.ok && state.version === version && now - (state.at || 0) < 10 * 60 * 1e3) return false;
   return true;
 }
 function installCore(version, { env = process.env, say = (m) => console.log(`hum: ${m}`), runImpl = run, now = Date.now() } = {}) {
-  const home = humHome(env);
-  const dir = coreDir(env);
-  const python = corePython(env);
+  const dir = coreDir(env, version);
+  const python = corePython(env, version);
   const localBin = path.join(os.homedir(), ".local", "bin");
   const uvNames = ["uv", path.join(localBin, win ? "uv.exe" : "uv")];
   const uv = () => uvNames.find((u) => {
@@ -91,9 +120,9 @@ function installCore(version, { env = process.env, say = (m) => console.log(`hum
       if (!u) return outcome(false, `could not install uv; install it from https://astral.sh/uv and run:  ${npmFix(version)}`);
     }
     say(`installing ${env.HUM_CORE_SPEC ? spec : `hum ${version}`} into ${dir} \u2026`);
-    fs.mkdirSync(home, { recursive: true });
+    fs.mkdirSync(path.dirname(dir), { recursive: true });
     try {
-      fs.unlinkSync(stampPath(env));
+      fs.unlinkSync(stampPath(env, version));
     } catch {
     }
     const trusted = trustedPython(env, runImpl);
@@ -101,20 +130,20 @@ function installCore(version, { env = process.env, say = (m) => console.log(`hum
     const pipIn = () => (runImpl(u, ["pip", "install", "--quiet", "--python", python, spec], { stdio: "inherit" }) || {}).status === 0;
     if (!fs.existsSync(python) && !makeVenv(fs.existsSync(dir))) return outcome(false, "uv venv failed");
     if (!pipIn()) return outcome(false, `uv pip install ${spec} failed`);
-    let got = importedVersion(env, runImpl);
+    let got = importedVersion(env, version, runImpl);
     if (!got) return outcome(false, "hum did not import after the install");
     if (got !== version && !env.HUM_CORE_SPEC) return outcome(false, `installed ${got}, wanted ${version}`, got);
-    let blocked = sslBlocked(env, runImpl);
+    let blocked = sslBlocked(env, version, runImpl);
     if (blocked && trusted) {
       say(`the policy here refuses the environment's OpenSSL (${blocked}); rebuilding it on ${trusted} \u2026`);
       if (makeVenv(true) && pipIn()) {
-        got = importedVersion(env, runImpl) || got;
-        blocked = sslBlocked(env, runImpl);
+        got = importedVersion(env, version, runImpl) || got;
+        blocked = sslBlocked(env, version, runImpl);
       }
     }
     if (blocked) return outcome(false, sslAdvice(env, version));
     fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(stampPath(env), `${got}
+    fs.writeFileSync(stampPath(env, version), `${got}
 `);
     const list = runImpl(u, ["tool", "list"]);
     if (list && list.status === 0 && /^hum-cli\b/m.test(list.stdout)) {
@@ -127,20 +156,133 @@ function installCore(version, { env = process.env, say = (m) => console.log(`hum
     return outcome(false, e && e.message ? e.message : String(e));
   }
 }
+function installPackage(version, { env = process.env, say = (m) => console.log(`hum: ${m}`), runImpl = run } = {}) {
+  const dest = pkgDir(env, version);
+  const stage = path.join(versionDir(env, version), "npm");
+  say(`fetching hum ${version} \u2026`);
+  fs.rmSync(stage, { recursive: true, force: true });
+  fs.mkdirSync(stage, { recursive: true });
+  const r = runImpl(win ? "npm.cmd" : "npm", [
+    "install",
+    "--prefix",
+    stage,
+    "--ignore-scripts",
+    "--no-audit",
+    "--no-fund",
+    "--no-package-lock",
+    "--loglevel=error",
+    `@metaphi-ai/hum@${version}`
+  ], { shell: win, env: { ...env, npm_config_update_notifier: "false" } });
+  const got = path.join(stage, "node_modules", "@metaphi-ai", "hum");
+  if (!r || r.status !== 0 || !fs.existsSync(path.join(got, "dist", "cli.mjs"))) {
+    const why = String(r && (r.stderr || r.stdout) || "").trim().split(/\r?\n/).filter(Boolean).pop() || `npm exited ${r ? r.status : "without running"}`;
+    fs.rmSync(stage, { recursive: true, force: true });
+    return { ok: false, error: `npm could not fetch @metaphi-ai/hum@${version}: ${why}` };
+  }
+  fs.rmSync(dest, { recursive: true, force: true });
+  fs.renameSync(got, dest);
+  fs.rmSync(stage, { recursive: true, force: true });
+  return { ok: true, error: null };
+}
+function prune(env = process.env, { keep = MINE, say = () => {
+}, now = Date.now() } = {}) {
+  let names = [];
+  try {
+    names = fs.readdirSync(versionsDir(env)).filter(isVersion);
+  } catch {
+    return [];
+  }
+  const ready = readyVersions(env);
+  const stay = /* @__PURE__ */ new Set([keep, ...ready.slice(0, 3)]);
+  const gone = [];
+  for (const v of names) {
+    if (stay.has(v)) continue;
+    if (!ready.includes(v)) {
+      let at = 0;
+      try {
+        at = fs.statSync(versionDir(env, v)).mtimeMs;
+      } catch {
+      }
+      if (now - at < 30 * 60 * 1e3) continue;
+    }
+    try {
+      fs.rmSync(versionDir(env, v), { recursive: true, force: true });
+      gone.push(v);
+      say(`removed hum ${v}`);
+    } catch {
+    }
+  }
+  return gone.sort((a, b) => newer(a, b) ? -1 : newer(b, a) ? 1 : 0);
+}
+function installVersion(version, { env = process.env, say = (m) => console.log(`hum: ${m}`), runImpl = run, now = Date.now() } = {}) {
+  if (!isVersion(version)) return { ok: false, error: `not a version: ${version}` };
+  try {
+    fs.mkdirSync(versionDir(env, version), { recursive: true });
+    try {
+      fs.unlinkSync(readyFile(env, version));
+    } catch {
+    }
+    if (!fs.existsSync(entryFile(env, version))) {
+      const p = installPackage(version, { env, say, runImpl });
+      if (!p.ok) return p;
+    }
+    if (installedVersion(env, version, runImpl) !== version) {
+      const c = installCore(version, { env, say, runImpl, now });
+      if (!c.ok) return { ok: false, error: c.error };
+    }
+    fs.writeFileSync(readyFile(env, version), `${version}
+`);
+    say(`hum ${version} is ready; the next hum you start is ${version}`);
+    prune(env, { say });
+    return { ok: true, error: null };
+  } catch (e) {
+    return { ok: false, error: e && e.message ? e.message : String(e) };
+  }
+}
+if (process.argv[1] && /install\.mjs$/.test(process.argv[1]) && process.argv[2] === "install") {
+  const log = path.join(humHome(), "update.log");
+  const say = (m) => {
+    try {
+      fs.appendFileSync(log, `${(/* @__PURE__ */ new Date()).toISOString()} ${m}
+`);
+    } catch {
+    }
+  };
+  const runLogged = (cmd, args, opts = {}) => {
+    const r2 = run(cmd, args, { ...opts, stdio: "pipe" });
+    if (r2 && r2.status !== 0 && (r2.stderr || r2.stdout)) say(String(r2.stderr || r2.stdout).trim().split(/\r?\n/).slice(-5).join("\n"));
+    return r2;
+  };
+  const r = installVersion(process.argv[3] || "", { say, runImpl: runLogged });
+  if (!r.ok) say(`hum ${process.argv[3]} did not install: ${r.error}`);
+  process.exit(r.ok ? 0 : 1);
+}
 export {
   ASK_SSL,
   ASK_VERSION,
+  MINE,
   NPM_FIX,
+  chosenEntry,
   coreDir,
   corePython,
+  entryFile,
   humHome,
   importedVersion,
   installCore,
+  installPackage,
+  installVersion,
   installedVersion,
   needsInstall,
+  newer,
   npmFix,
+  pkgDir,
+  prune,
   readInstallState,
+  readyFile,
+  readyVersions,
   sslAdvice,
   sslBlocked,
-  trustedPython
+  trustedPython,
+  versionDir,
+  versionsDir
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metaphi-ai/hum",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "description": "Hum: a self-improving coding agent for your terminal.",
   "license": "UNLICENSED",
   "type": "module",

package/scripts/postinstall.js

@@ -11,7 +11,7 @@ const version = JSON.parse(fs.readFileSync(path.join(here, '..', 'package.json')
 // a URL, not a path: on Windows `C:\…` is not something the ESM loader will import
 const { installedVersion, installCore, npmFix } = await import(pathToFileURL(path.join(here, '..', 'dist', 'install.mjs')).href);
 
-if (installedVersion() !== version) {
+if (installedVersion(process.env, version) !== version) {
   const r = installCore(version);
   if (!r.ok) console.log(`hum: the install did not finish (${r.error}); run:  ${npmFix(version)}`);
 }