@metaphi-ai/hum 0.1.26 → 0.1.29

package/dist/install.mjs

@@ -0,0 +1,119 @@
+// src/install.js
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+var win = process.platform === "win32";
+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 engineDir = (env = process.env) => path.join(humHome(env), "engine");
+var enginePython = (env = process.env) => win ? path.join(engineDir(env), "Scripts", "python.exe") : path.join(engineDir(env), "bin", "python");
+var stampPath = (env) => path.join(engineDir(env), "version");
+var statePath = (env) => path.join(humHome(env), "engine-install.json");
+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(enginePython(env), ASK_VERSION);
+  return r && r.status === 0 ? String(r.stdout).trim() : null;
+}
+function installedVersion(env = process.env, runImpl = run) {
+  try {
+    return fs.readFileSync(stampPath(env), "utf8").trim() || null;
+  } catch {
+  }
+  if (!fs.existsSync(enginePython(env))) return null;
+  const v = importedVersion(env, runImpl);
+  if (v) {
+    try {
+      fs.writeFileSync(stampPath(env), `${v}
+`);
+    } catch {
+    }
+  }
+  return v;
+}
+var readInstallState = (env = process.env) => {
+  try {
+    return JSON.parse(fs.readFileSync(statePath(env), "utf8"));
+  } catch {
+    return null;
+  }
+};
+var writeInstallState = (s, env) => {
+  try {
+    fs.mkdirSync(humHome(env), { recursive: true });
+    fs.writeFileSync(statePath(env), JSON.stringify(s));
+  } catch {
+  }
+};
+function needsInstall(version, { env = process.env, installed = () => installedVersion(env), now = Date.now(), state = readInstallState(env) } = {}) {
+  if (!version || env.HUM_ENGINE || env.HUM_ENGINE_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 installEngine(version, { env = process.env, say = (m) => console.log(`hum: ${m}`), runImpl = run, now = Date.now() } = {}) {
+  const home = humHome(env);
+  const dir = engineDir(env);
+  const python = enginePython(env);
+  const localBin = path.join(os.homedir(), ".local", "bin");
+  const uvNames = ["uv", path.join(localBin, win ? "uv.exe" : "uv")];
+  const uv = () => uvNames.find((u) => {
+    const r = runImpl(u, ["--version"]);
+    return r && r.status === 0;
+  });
+  const spec = env.HUM_ENGINE_SPEC || `hum-cli==${version}`;
+  const outcome = (ok, error = null, got = version) => {
+    writeInstallState({ version: got, wanted: version, ok, error, at: now }, env);
+    return { ok, version: got, error };
+  };
+  try {
+    let u = uv();
+    if (!u) {
+      say("installing uv (it creates the Python environment for the part of hum that does the work) \u2026");
+      const r = win ? runImpl("powershell", ["-ExecutionPolicy", "ByPass", "-c", "irm https://astral.sh/uv/install.ps1 | iex"], { stdio: "inherit" }) : runImpl("sh", ["-c", "curl -LsSf https://astral.sh/uv/install.sh | sh"], { stdio: "inherit" });
+      u = r && r.status === 0 ? uv() : null;
+      if (!u) return outcome(false, `could not install uv; install it from https://astral.sh/uv and run:  ${npmFix(version)}`);
+    }
+    say(`installing ${env.HUM_ENGINE_SPEC ? spec : `hum ${version}`} into ${dir} \u2026`);
+    fs.mkdirSync(home, { recursive: true });
+    try {
+      fs.unlinkSync(stampPath(env));
+    } catch {
+    }
+    if (!fs.existsSync(python)) {
+      const args = ["venv", "--quiet", "--python", "3.12", ...fs.existsSync(dir) ? ["--clear"] : [], dir];
+      if ((runImpl(u, args, { stdio: "inherit" }) || {}).status !== 0) return outcome(false, "uv venv failed");
+    }
+    if ((runImpl(u, ["pip", "install", "--quiet", "--python", python, spec], { stdio: "inherit" }) || {}).status !== 0) return outcome(false, `uv pip install ${spec} failed`);
+    const got = importedVersion(env, runImpl);
+    if (!got) return outcome(false, "hum did not import after the install");
+    if (got !== version && !env.HUM_ENGINE_SPEC) return outcome(false, `installed ${got}, wanted ${version}`, got);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(stampPath(env), `${got}
+`);
+    const list = runImpl(u, ["tool", "list"]);
+    if (list && list.status === 0 && /^hum-cli\b/m.test(list.stdout)) {
+      const rm = runImpl(u, ["tool", "uninstall", "hum-cli"]);
+      if (rm && rm.status === 0) say(`removed the uv install of hum-cli and its shims in ${localBin}; hum lives in ${dir} now`);
+    }
+    say(`hum ${got} ready`);
+    return outcome(true, null, got);
+  } catch (e) {
+    return outcome(false, e && e.message ? e.message : String(e));
+  }
+}
+export {
+  ASK_VERSION,
+  NPM_FIX,
+  engineDir,
+  enginePython,
+  humHome,
+  importedVersion,
+  installEngine,
+  installedVersion,
+  needsInstall,
+  npmFix,
+  readInstallState
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metaphi-ai/hum",
-  "version": "0.1.26",
+  "version": "0.1.29",
   "description": "Hum (हम): a self-improving coding agent for your terminal.",
   "license": "UNLICENSED",
   "type": "module",

package/scripts/postinstall.js

@@ -1,58 +1,17 @@
-// The engine, installed beside the person's Hum data: ~/.hum/engine (HUM_HOME/engine), a plain
-// Python environment holding hum-cli at this package's version. No launcher shims are written
-// anywhere — `hum` starts the engine through the environment's own interpreter — so nothing of
-// ours lands in ~/.local/bin, and nothing there can shadow the `hum` npm installed.
-// uv creates the environment (and fetches a Python if the machine has none); it is installed
-// when missing. Quiet when the engine is already at this version; never fails the npm install.
-import { execFileSync, spawnSync } from 'node:child_process';
+// npm's postinstall: complete the install at this package's version. The work is in
+// dist/install.mjs — the same code `hum` runs at start when the two halves differ — and the
+// outcome lands in ~/.hum/engine-install.json, because npm shows none of this unless it is
+// run with --foreground-scripts. Never fails the npm install.
 import fs from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 
-const win = process.platform === 'win32';
 const here = path.dirname(fileURLToPath(import.meta.url));
 const version = JSON.parse(fs.readFileSync(path.join(here, '..', 'package.json'), 'utf8')).version;
-const home = process.env.HUM_HOME || path.join(os.homedir(), '.hum');
-const env = path.join(home, 'engine');
-const python = win ? path.join(env, 'Scripts', 'python.exe') : path.join(env, 'bin', 'python');
-const localBin = path.join(os.homedir(), '.local', 'bin');
-const say = (m) => console.log(`hum: ${m}`);
+// a URL, not a path: on Windows `C:\…` is not something the ESM loader will import
+const { installedVersion, installEngine, npmFix } = await import(pathToFileURL(path.join(here, '..', 'dist', 'install.mjs')).href);
 
-const run = (cmd, args, opts = {}) => spawnSync(cmd, args, { encoding: 'utf8', windowsHide: true, ...opts });
-const uvNames = ['uv', path.join(localBin, win ? 'uv.exe' : 'uv')];
-const uv = () => uvNames.find((u) => run(u, ['--version']).status === 0);
-
-const installed = () => {
-  const r = run(python, ['-c', 'import hum; print(hum.__version__)']);
-  return r.status === 0 ? r.stdout.trim() : null;
-};
-
-try {
-  if (installed() === version) process.exit(0);
-  let u = uv();
-  if (!u) {
-    say('installing uv (it creates the engine\'s Python environment) …');
-    const r = win
-      ? run('powershell', ['-ExecutionPolicy', 'ByPass', '-c', 'irm https://astral.sh/uv/install.ps1 | iex'], { stdio: 'inherit' })
-      : run('sh', ['-c', 'curl -LsSf https://astral.sh/uv/install.sh | sh'], { stdio: 'inherit' });
-    u = r.status === 0 ? uv() : null;
-    if (!u) { say('could not install uv; install it from https://astral.sh/uv and run:  npm rebuild -g @metaphi-ai/hum'); process.exit(0); }
-  }
-  say(`installing the engine ${version} into ${env} …`);
-  fs.mkdirSync(home, { recursive: true });
-  if (run(u, ['venv', '--quiet', '--python', '3.12', env], { stdio: 'inherit' }).status !== 0) throw new Error('uv venv failed');
-  if (run(u, ['pip', 'install', '--quiet', '--python', python, `hum-cli==${version}`], { stdio: 'inherit' }).status !== 0) throw new Error('uv pip install failed');
-  if (installed() !== version) throw new Error('the engine did not import after install');
-
-  // An earlier version installed the engine with `uv tool install`, which wrote launcher shims
-  // (hum, hum-engine) into ~/.local/bin — where they shadow the `hum` npm installed, and where a
-  // managed Windows machine refuses them. That engine is redundant now; take it and its shims out.
-  const list = run(u, ['tool', 'list']);
-  if (list.status === 0 && /^hum-cli\b/m.test(list.stdout)) {
-    if (run(u, ['tool', 'uninstall', 'hum-cli']).status === 0) say(`removed the uv install of hum-cli and its shims in ${localBin}; the engine lives in ${env} now`);
-  }
-  say(`engine ${version} ready`);
-} catch (e) {
-  say(`engine install failed (${e.message}); run:  npm rebuild -g @metaphi-ai/hum`);
+if (installedVersion() !== version) {
+  const r = installEngine(version);
+  if (!r.ok) console.log(`hum: the install did not finish (${r.error}); run:  ${npmFix(version)}`);
 }