nunmai 0.1.2 → 0.1.4

package/README.md

@@ -15,10 +15,13 @@ engine; the first run opens the AI-account wizard (Claude, ChatGPT, Kimi,
 Gemini, OpenRouter).
 
 - macOS, Linux, Windows 10/11 (PowerShell), Android (Termux).
-- **Local install** (`npm install nunmai`, no `-g`): run it with `npx nunmai`.
+- **Local install** (`npm install nunmai`, no `-g`): run it once with `npx nunmai`.
   npm ≥ 11.19 blocks dependency install scripts by default, so the engine is
-  installed on the first `npx nunmai` run. To get a plain `nunmai` command from
-  a local install, allow the script: `npm install nunmai --allow-scripts=nunmai`.
+  installed on that first run. The launcher then puts a plain `nunmai` command
+  on your PATH itself — `~/.local/bin` on macOS/Linux, `%LOCALAPPDATA%\nunmai\bin`
+  (registered on the user PATH) on Windows — so after opening a new terminal
+  `nunmai` just works. To skip even that first `npx`, allow the script:
+  `npm install nunmai --allow-scripts=nunmai`.
 - If npm skipped the install script (`--ignore-scripts`, `CI` set, or the
   allow-scripts policy above), the install simply happens on the first run.
 - After `nunmai uninstall`, the `nunmai` command falls back to this launcher —

package/bin/nunmai.js

@@ -33,11 +33,27 @@ const IS_WIN = process.platform === "win32";
 const SELF = fs.realpathSync(__filename);
 const DRY = process.env.NUNMAI_BOOTSTRAP_DRY_RUN === "1";
 
+// Marker stamped into the Windows fallback shim (a .cmd that re-enters this
+// file). findLauncher() must never treat that shim as the engine launcher or
+// `nunmai` would recurse into itself forever.
+const WIN_SHIM_MARKER = "rem nunmai-npm-shim";
+
+function winBinDir() {
+  // Same managed dir install.ps1 uses for the real launchers (Set-PathVariable):
+  // %NUNMAI_HOME%\bin, defaulting to %LOCALAPPDATA%\nunmai\bin.
+  const home = os.homedir();
+  const nunmaiHome = process.env.NUNMAI_HOME || path.join(process.env.LOCALAPPDATA || path.join(home, "AppData", "Local"), "nunmai");
+  return path.join(nunmaiHome, "bin");
+}
+
+function isWinShim(p) {
+  try { return p.toLowerCase().endsWith(".cmd") && fs.readFileSync(p, "utf8").includes(WIN_SHIM_MARKER); } catch (_) { return false; }
+}
+
 function candidates() {
   const home = os.homedir();
   if (IS_WIN) {
-    const nunmaiHome = process.env.NUNMAI_HOME || path.join(process.env.LOCALAPPDATA || path.join(home, "AppData", "Local"), "nunmai");
-    const bin = path.join(nunmaiHome, "bin");
+    const bin = winBinDir();
     return [path.join(bin, "nunmai.exe"), path.join(bin, "nunmai.cmd")];
   }
   const list = [];
@@ -52,6 +68,7 @@ function findLauncher() {
   for (const p of candidates()) {
     try {
       if (fs.realpathSync(p) === SELF) continue; // never recurse into this shim
+      if (IS_WIN && isWinShim(p)) continue;      // ...nor into the Windows .cmd shim
       fs.accessSync(p, fs.constants.X_OK);
       return p;
     } catch (_) { /* not there */ }
@@ -64,7 +81,7 @@ function ensureFallbackLauncher() {
   // ./node_modules/.bin, which is not on PATH. Make sure `nunmai` resolves
   // anyway by linking this shim into ~/.local/bin (or $PREFIX/bin on Termux).
   // The real installer replaces the link with the engine launcher (ln -sf).
-  if (IS_WIN) return null;
+  if (IS_WIN) return ensureWinFallbackLauncher();
   const binDir = process.env.PREFIX && fs.existsSync(path.join(process.env.PREFIX, "bin"))
     ? path.join(process.env.PREFIX, "bin")
     : path.join(os.homedir(), ".local", "bin");
@@ -83,6 +100,51 @@ function ensureFallbackLauncher() {
   }
 }
 
+function ensureWinFallbackLauncher() {
+  // Windows twin of the symlink above: drop a nunmai.cmd shim into the managed
+  // bin dir and register that dir on the User PATH, so a plain `nunmai` works
+  // after a local `npm install nunmai` (where npm >= 11.19 skips postinstall
+  // and node_modules\.bin is not on PATH). install.ps1 later overwrites the
+  // shim with the real launcher (Install-NunmaiCommandLaunchers) and keeps the
+  // same PATH entry, so nothing here has to be undone.
+  const binDir = winBinDir();
+  const target = path.join(binDir, "nunmai.cmd");
+  try {
+    fs.mkdirSync(binDir, { recursive: true });
+    // Never clobber a real engine launcher.
+    if (fs.existsSync(path.join(binDir, "nunmai.exe"))) return null;
+    if (fs.existsSync(target) && !isWinShim(target)) return null;
+    const body = `@echo off\r\n${WIN_SHIM_MARKER}: ${SELF}\r\n"${process.execPath}" "${SELF}" %*\r\n`;
+    fs.writeFileSync(target, body);
+    ensureWinUserPath(binDir);
+    return target;
+  } catch (e) {
+    console.error(`nunmai: could not stage launcher into ${binDir}: ${e.message}`);
+    return null;
+  }
+}
+
+function ensureWinUserPath(binDir) {
+  // Persist binDir at the front of the User PATH (registry), the same way
+  // install.ps1's Set-PathVariable does. Idempotent; best effort.
+  const norm = (p) => p.trim().replace(/[\\/]+$/, "").toLowerCase();
+  const onPath = (process.env.PATH || "").split(";").some((p) => norm(p) === norm(binDir));
+  if (onPath || DRY) return;
+  const ps = [
+    `$d='${binDir.replace(/'/g, "''")}'`,
+    "$cur=[Environment]::GetEnvironmentVariable('Path','User')",
+    "$items=@(); if ($cur) { $items=@($cur -split ';') }",
+    "if (-not ($items | Where-Object { $_.TrimEnd('\\') -ieq $d })) { [Environment]::SetEnvironmentVariable('Path', ((@($d) + $items) -join ';'), 'User'); exit 0 }",
+    "exit 3",
+  ].join("; ");
+  const r = spawnSync("powershell", ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", ps], { stdio: "ignore" });
+  if (r.status === 0) {
+    console.log(`nunmai: added ${binDir} to your user PATH (open a new terminal, then run \`nunmai\`).`);
+  } else if (r.status !== 3) {
+    console.error(`nunmai: could not update the user PATH automatically. Add this folder to PATH to use \`nunmai\` directly: ${binDir}`);
+  }
+}
+
 function ensurePathLine(binDir) {
   // Add ~/.local/bin to PATH in the user's shell rc if it is not there already.
   if (binDir !== path.join(os.homedir(), ".local", "bin")) return;
@@ -168,12 +230,49 @@ function postinstall() {
   return 0;
 }
 
+// Commands that must never trigger an engine install when the engine is
+// absent: a user asking to remove, or merely inspect, Nunmai should not be
+// handed a multi-minute full install first.
+function handleWithoutEngine(argv) {
+  const cmd = (argv[0] || "").toLowerCase();
+  if (cmd === "uninstall") {
+    let removed = false;
+    if (IS_WIN) {
+      // Drop our own .cmd shim (never a real launcher — those carry no marker).
+      const shim = path.join(winBinDir(), "nunmai.cmd");
+      if (isWinShim(shim)) { try { fs.unlinkSync(shim); removed = true; } catch (_) { /* best effort */ } }
+    }
+    console.log("Nunmai Engine is not installed on this machine — nothing to remove." + (removed ? " (Removed the launcher shim.)" : ""));
+    console.log("To remove this npm launcher too:  npm uninstall -g nunmai   (or `npm uninstall nunmai` for a local install)");
+    return 0;
+  }
+  if (cmd === "--version" || cmd === "-v" || cmd === "version") {
+    console.log(`nunmai launcher ${require("../package.json").version} (engine not installed — run \`nunmai\` to install)`);
+    return 0;
+  }
+  if (cmd === "--help" || cmd === "-h" || cmd === "help") {
+    console.log([
+      "Nunmai Engine is not installed on this machine yet.",
+      "",
+      "  nunmai            install the engine, then start it",
+      "  nunmai --version  show the launcher version",
+      "  nunmai uninstall  remove the engine (nothing to remove right now)",
+      "",
+      `Manual install: ${manualHint().trim()}`,
+    ].join("\n"));
+    return 0;
+  }
+  return null;
+}
+
 function main() {
   const argv = process.argv.slice(2);
   if (argv[0] === "--bootstrap-postinstall") process.exit(postinstall());
 
   let launcher = findLauncher();
   if (!launcher) {
+    const handled = handleWithoutEngine(argv);
+    if (handled !== null) process.exit(handled);
     const code = install(false);
     if (code !== 0) {
       console.error(`\nnunmai: installer exited with code ${code}. You can retry it manually:\n${manualHint()}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nunmai",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Nunmai Engine — `npm i nunmai` (global or local) installs the engine with all features and dependencies; run `nunmai` to start.",
   "license": "MIT",
   "homepage": "https://nunmai.in",