@metaphi-ai/hum 0.1.9 → 0.1.11

package/dist/cli.mjs

@@ -84571,18 +84571,44 @@ function enginePython(dirs = uvToolDirs()) {
   }
   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) {
@@ -84642,11 +84668,15 @@ function attempt({ bin, args: args2 }, cwd2, { task, images, resume }) {
         settle(() => resolve(rec));
         return;
       }
+      if (rec && rec.error) {
+        settle(() => reject({ failed: rec.error }));
+        return;
+      }
       if (died && !rec) {
         settle(() => reject({ died: logPath }));
         return;
       }
-      if (Date.now() - t0 > 25e3) {
+      if (Date.now() - t0 > 9e4) {
         settle(() => reject({ timeout: true }));
         return;
       }
@@ -84655,6 +84685,20 @@ function attempt({ bin, args: args2 }, cwd2, { task, images, resume }) {
     poll();
   });
 }
+function failureMessage(error) {
+  return error.message + (error.hint ? `
+  ${error.hint}` : "");
+}
+function diedMessage(logPath, text = null) {
+  let tail2 = "";
+  try {
+    tail2 = (text ?? fs3.readFileSync(logPath, "utf8")).trim().split("\n").slice(-3).join("\n").trim();
+  } catch {
+  }
+  return `the engine did not start${tail2 ? `:
+${tail2}` : ""}
+(its log: ${logPath})`;
+}
 async function spawnEngine(cwd2, { task = null, images = [], resume = null, candidates = engineCandidates() } = {}) {
   const failures = [];
   for (const cand of candidates) {
@@ -84666,7 +84710,8 @@ async function spawnEngine(cwd2, { task = null, images = [], resume = null, cand
         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.failed) throw new EngineError(failureMessage(f.failed));
+      if (f && f.died) throw new EngineError(diedMessage(f.died));
       if (f && f.timeout) throw new EngineError("the engine did not start in time");
       throw f;
     }
@@ -84746,6 +84791,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.11" : "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.9",
+  "version": "0.1.11",
   "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`);
 }