@metaphi-ai/hum 0.1.8 → 0.1.10

package/dist/cli.mjs

@@ -84524,7 +84524,7 @@ import net from "node:net";
 import os4 from "node:os";
 import path2 from "node:path";
 import crypto from "node:crypto";
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 var runDir = () => path2.join(process.env.HUM_HOME || path2.join(os4.homedir(), ".hum"), "run");
 var readRun = (id) => {
   try {
@@ -84535,74 +84535,170 @@ var readRun = (id) => {
 };
 var EngineError = class extends Error {
 };
-var ENGINE_CANDIDATES = [
-  process.env.HUM_ENGINE,
-  // explicit: a command to run (e.g. `python -m hum.cli engine`)
-  "hum-engine",
-  // uv tool install hum-cli
-  path2.join(os4.homedir(), ".local", "bin", process.platform === "win32" ? "hum-engine.exe" : "hum-engine")
-  // uv's bin dir, off PATH
-];
-function spawnEngine(cwd2, { task = null, images = [], resume = null } = {}) {
+var win = process.platform === "win32";
+var exists = (p) => {
+  try {
+    fs3.accessSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+};
+function uvToolDirs() {
+  const dirs = [];
+  if (process.env.UV_TOOL_DIR) dirs.push(process.env.UV_TOOL_DIR);
+  if (win) {
+    for (const base of [process.env.APPDATA, process.env.LOCALAPPDATA]) if (base) dirs.push(path2.join(base, "uv", "tools"));
+  } else dirs.push(path2.join(process.env.XDG_DATA_HOME || path2.join(os4.homedir(), ".local", "share"), "uv", "tools"));
+  if (!dirs.some(exists)) {
+    for (const uv of ["uv", path2.join(os4.homedir(), ".local", "bin", win ? "uv.exe" : "uv")]) {
+      try {
+        const r = spawnSync(uv, ["tool", "dir"], { encoding: "utf8", windowsHide: true });
+        if (r.status === 0 && r.stdout.trim()) {
+          dirs.push(r.stdout.trim());
+          break;
+        }
+      } catch {
+      }
+    }
+  }
+  return dirs;
+}
+function enginePython(dirs = uvToolDirs()) {
+  for (const dir of dirs) for (const name of ["hum-cli", "hum"]) {
+    const py = win ? path2.join(dir, name, "Scripts", "python.exe") : path2.join(dir, name, "bin", "python");
+    if (exists(py)) return py;
+  }
+  return null;
+}
+function siblingEngine(execPath = process.execPath) {
+  let dir;
+  try {
+    dir = path2.dirname(fs3.realpathSync(execPath));
+  } catch {
+    return null;
+  }
+  const p = path2.join(dir, "engine", win ? "hum-engine.exe" : "hum-engine");
+  return exists(p) ? p : null;
+}
+function homeEngine(env3 = process.env) {
+  const home = env3.HUM_HOME || path2.join(os4.homedir(), ".hum");
+  const py = win ? path2.join(home, "engine", "Scripts", "python.exe") : path2.join(home, "engine", "bin", "python");
+  return exists(py) ? py : null;
+}
+function engineCandidates(env3 = process.env) {
+  const out = [];
+  if (env3.HUM_ENGINE) {
+    const [bin, ...args2] = env3.HUM_ENGINE.split(" ");
+    out.push({ bin, args: args2, where: "HUM_ENGINE" });
+  }
+  const sib = siblingEngine();
+  if (sib) out.push({ bin: sib, args: ["engine"], where: "beside hum" });
+  const home = homeEngine(env3);
+  if (home) out.push({ bin: home, args: ["-m", "hum.cli", "engine"], where: "HUM_HOME/engine" });
+  const py = enginePython();
+  if (py) out.push({ bin: py, args: ["-m", "hum.cli", "engine"], where: "the engine's interpreter" });
+  out.push({ bin: "hum-engine", args: [], where: "PATH" });
+  out.push({ bin: path2.join(os4.homedir(), ".local", "bin", win ? "hum-engine.exe" : "hum-engine"), args: [], where: "uv's bin dir" });
+  return out;
+}
+function engineCommand(argv, candidates = engineCandidates()) {
+  for (const c of candidates) {
+    if (c.args[c.args.length - 1] !== "engine") continue;
+    return { bin: c.bin, args: [...c.args.slice(0, -1), ...argv], where: c.where };
+  }
+  return null;
+}
+function startFailure(failures) {
+  const refused = failures.find((f) => f.error && f.error.code !== "ENOENT");
+  if (!refused) {
+    return "Hum's engine is not installed. Run:  uv tool install hum-cli   (or set HUM_ENGINE to the command that starts it)";
+  }
+  const what = refused.error.code || refused.error.message;
+  const lines = [
+    `Hum's engine is installed (${refused.bin}) but this machine would not start it: ${what}.`
+  ];
+  if (win) {
+    lines.push("On a managed Windows machine that is usually Device Guard / WDAC refusing an executable it does not know.");
+    lines.push(`To see the policy's own message, run:  "${refused.bin}" --help`);
+    const dir = uvToolDirs()[0];
+    lines.push(`If uv's environment is elsewhere, point Hum at its interpreter:  set HUM_ENGINE=${path2.join(dir || "<uv tool dir>", "hum-cli", "Scripts", "python.exe")} -m hum.cli engine`);
+  } else {
+    lines.push('Set HUM_ENGINE to a command that starts it, e.g.  HUM_ENGINE="python -m hum.cli engine"');
+  }
+  return lines.join("\n");
+}
+function attempt({ bin, args: args2 }, cwd2, { task, images, resume }) {
   return new Promise((resolve, reject) => {
-    const tryNext = (i) => {
-      const cmd = ENGINE_CANDIDATES[i];
-      if (cmd === void 0) {
-        reject(new EngineError(
-          "Hum's engine is not installed. Run:  uv tool install hum-cli   (or set HUM_ENGINE to the command that starts it)"
-        ));
+    const runId = crypto.randomBytes(6).toString("hex");
+    fs3.mkdirSync(runDir(), { recursive: true });
+    const logPath = path2.join(runDir(), `${runId}.log`);
+    const log = fs3.openSync(logPath, "a");
+    const argv = [...args2, "-C", cwd2, "--run-id", runId];
+    if (task) argv.push("--task", task);
+    for (const p of images) argv.push("--image", p);
+    if (resume) argv.push("--resume", resume);
+    let settled = false;
+    const settle = (fn) => {
+      if (!settled) {
+        settled = true;
+        fn();
+      }
+    };
+    let child;
+    try {
+      child = spawn(bin, argv, { stdio: ["ignore", log, log], detached: true, windowsHide: true });
+    } catch (e) {
+      fs3.closeSync(log);
+      reject({ spawn: e });
+      return;
+    }
+    fs3.closeSync(log);
+    let died = false;
+    child.on("error", (e) => settle(() => reject({ spawn: e })));
+    child.on("exit", () => {
+      died = true;
+    });
+    const t0 = Date.now();
+    const poll = () => {
+      if (settled) return;
+      const rec = readRun(runId);
+      if (rec && rec.port) {
+        child.unref();
+        settle(() => resolve(rec));
         return;
       }
-      if (!cmd) {
-        tryNext(i + 1);
+      if (died && !rec) {
+        settle(() => reject({ died: logPath }));
         return;
       }
-      const runId = crypto.randomBytes(6).toString("hex");
-      fs3.mkdirSync(runDir(), { recursive: true });
-      const log = fs3.openSync(path2.join(runDir(), `${runId}.log`), "a");
-      const [bin, ...rest] = cmd.split(" ");
-      const args2 = [...rest, "-C", cwd2, "--run-id", runId];
-      if (task) args2.push("--task", task);
-      for (const p of images) args2.push("--image", p);
-      if (resume) args2.push("--resume", resume);
-      let child;
-      try {
-        child = spawn(bin, args2, { stdio: ["ignore", log, log], detached: true, windowsHide: true });
-      } catch {
-        tryNext(i + 1);
+      if (Date.now() - t0 > 25e3) {
+        settle(() => reject({ timeout: true }));
         return;
       }
-      let failed = false;
-      child.on("error", () => {
-        failed = true;
-        tryNext(i + 1);
-      });
-      child.on("exit", () => {
-        failed = true;
-      });
-      const t0 = Date.now();
-      const poll = () => {
-        const rec = readRun(runId);
-        if (rec && rec.port) {
-          child.unref();
-          resolve(rec);
-          return;
-        }
-        if (failed && !rec) {
-          reject(new EngineError(`the engine did not start (see ${path2.join(runDir(), `${runId}.log`)})`));
-          return;
-        }
-        if (Date.now() - t0 > 25e3) {
-          reject(new EngineError("the engine did not start in time"));
-          return;
-        }
-        setTimeout(poll, 50);
-      };
-      poll();
+      setTimeout(poll, 50);
     };
-    tryNext(0);
+    poll();
   });
 }
+async function spawnEngine(cwd2, { task = null, images = [], resume = null, candidates = engineCandidates() } = {}) {
+  const failures = [];
+  for (const cand of candidates) {
+    if (!cand.bin) continue;
+    try {
+      return await attempt(cand, cwd2, { task, images, resume });
+    } catch (f) {
+      if (f && f.spawn) {
+        failures.push({ ...cand, error: f.spawn });
+        continue;
+      }
+      if (f && f.died) throw new EngineError(`the engine did not start (see ${f.died})`);
+      if (f && f.timeout) throw new EngineError("the engine did not start in time");
+      throw f;
+    }
+  }
+  throw new EngineError(startFailure(failures));
+}
 var Engine = class {
   constructor(port2) {
     this.port = port2;
@@ -84676,6 +84772,27 @@ var Engine = class {
 var import_jsx_runtime3 = __toESM(require_jsx_runtime(), 1);
 import fs4 from "node:fs";
 import path3 from "node:path";
+import { spawnSync as spawnSync2 } from "node:child_process";
+var ENGINE_COMMANDS = /* @__PURE__ */ new Set(["run", "login", "logout", "whoami", "model", "key", "sessions", "show", "sync", "skill", "ps", "stop", "hooks", "engine"]);
+var argv0 = process.argv.slice(2);
+if (argv0[0] === "--version" || argv0[0] === "-V") {
+  process.stdout.write(`hum ${true ? "0.1.10" : "0.0.0"}
+`);
+  process.exit(0);
+}
+if (ENGINE_COMMANDS.has(argv0[0])) {
+  const cmd = engineCommand(argv0);
+  if (!cmd) {
+    process.stderr.write(startFailure([]) + "\n");
+    process.exit(1);
+  }
+  const r = spawnSync2(cmd.bin, cmd.args, { stdio: "inherit", windowsHide: true });
+  if (r.error) {
+    process.stderr.write(startFailure([{ bin: cmd.bin, error: r.error }]) + "\n");
+    process.exit(1);
+  }
+  process.exit(r.status === null ? 1 : r.status);
+}
 function parseArgs(argv) {
   const a = { task: null, resume: null, cwd: process.cwd(), images: [] };
   for (let i = 0; i < argv.length; i += 1) {

package/package.json

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

package/scripts/postinstall.js

@@ -1,23 +1,58 @@
-// Make sure the engine is installed: `hum-engine` on PATH (uv tool install hum-cli).
-// Quiet when it already is; installs uv first when it is missing; never fails the npm install.
-import { execSync, spawnSync } from 'node:child_process';
+// 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';
+import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 
-const which = (cmd) => spawnSync(process.platform === 'win32' ? 'where' : 'which', [cmd], { stdio: 'ignore' }).status === 0;
-const local = path.join(os.homedir(), '.local', 'bin');
-const sh = (cmd) => { try { execSync(cmd, { stdio: 'inherit', env: { ...process.env, PATH: `${local}${path.delimiter}${process.env.PATH || ''}` } }); return true; } catch { return false; } };
+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}`);
 
-if (which('hum-engine') || spawnSync(path.join(local, 'hum-engine'), ['--help'], { stdio: 'ignore' }).status === 0) {
-  process.exit(0);
-}
-console.log('hum: installing the engine (uv tool install hum-cli) …');
-if (!which('uv') && spawnSync(path.join(local, 'uv'), ['--version'], { stdio: 'ignore' }).status !== 0) {
-  const ok = process.platform === 'win32'
-    ? sh('powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"')
-    : sh('curl -LsSf https://astral.sh/uv/install.sh | sh');
-  if (!ok) { console.log('hum: could not install uv; install it from https://astral.sh/uv then run: uv tool install hum-cli'); process.exit(0); }
-}
-if (!sh('uv tool install --quiet hum-cli')) {
-  console.log('hum: engine install failed; run manually:  uv tool install hum-cli');
+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`);
 }