omnius 1.0.769 → 1.0.772

package/README.md

@@ -15,6 +15,24 @@ npm install -g omnius
 omnius
 ```
 
+The base install is compiler-free: a fresh machine does not need `make`, a C++
+toolchain, or Python just to install and launch Omnius. The installer provisions
+the AIWG companion separately without its optional native semantic-index addon,
+so an unavailable native build cannot roll back the Omnius CLI.
+
+If npm succeeds but a new terminal reports `omnius: command not found`, inspect
+the global prefix and add its command directory to `PATH`:
+
+```bash
+npm prefix -g
+export PATH="$(npm prefix -g)/bin:$PATH"
+hash -r
+omnius --version
+```
+
+Persist that export in the profile used by your shell, or open a new terminal
+after an nvm/fnm setup change. `npx omnius@latest` is an immediate fallback.
+
 Requirements:
 
 - Node.js 22 or newer

package/dist/index.js

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/dist/index.js
-size: 38793014 bytes
-sha256: f71239ae51ef2586dd1fc9aa8d33c5ebcbe803c2d5e712c22a98e40b65afd3e8
+size: 38796721 bytes
+sha256: e7253b477691e39572bce708cfed52e4fa14a68d09a1214d80c4e89fee9411dd

package/dist/postinstall-daemon.cjs

@@ -12,8 +12,8 @@
  *        Windows → Scheduled Task "OmniusDaemon" (onlogon)
  *   3. Start (or restart) the service so the daemon is live IMMEDIATELY —
  *      no need to launch `omnius` in any terminal.
- *   4. Never exit non-zero. npm install must not fail because of a service
- *      manager quirk or a permission quirk. We warn and move on.
+ *   4. Keep optional companion/service failures non-fatal. Only a corrupt
+ *      core install (for example a missing launcher) fails npm installation.
  *
  * Opt-out: set env OMNIUS_SKIP_DAEMON_INSTALL=1 before `npm i -g`.
  *
@@ -37,10 +37,22 @@ var PORT = parseInt(process.env.OMNIUS_PORT || "11435", 10);
 var SERVICE_LABEL = "omnius-daemon";
 var LAUNCHD_LABEL = "ai.omnius.daemon";
 var WIN_TASK_NAME = "OmniusDaemon";
-var REQUIRED_AIWG_VERSION = "2026.5.11";
+var REQUIRED_AIWG_VERSION = readCompanionAiwgVersion();
 var INSTALL_STEPS = 8;
 var DISCOVERY_NOTICE_PRINTED = false;
 
+function readCompanionAiwgVersion() {
+  try {
+    var pkg = JSON.parse(fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf8"));
+    var version = pkg && pkg.omniusInstall && pkg.omniusInstall.aiwgVersion;
+    return typeof version === "string" && /^\d{4}\.\d+\.\d+(?:[-.][0-9A-Za-z]+)?$/.test(version)
+      ? version
+      : "";
+  } catch (e) {
+    return "";
+  }
+}
+
 // ─── Helpers ────────────────────────────────────────────────────────────────
 
 function log(msg) {
@@ -303,6 +315,10 @@ function ensureGlobalAiwgInstall() {
     log("OMNIUS_SKIP_AIWG_INSTALL=1 — skipping AIWG CLI install.");
     return;
   }
+  if (!REQUIRED_AIWG_VERSION) {
+    warn("Package metadata is missing omniusInstall.aiwgVersion; optional AIWG CLI setup was skipped.");
+    return;
+  }
   if (!hasCmd("npm")) {
     warn("npm not found; cannot ensure aiwg@" + REQUIRED_AIWG_VERSION + ".");
     return;
@@ -316,13 +332,13 @@ function ensureGlobalAiwgInstall() {
   log("Ensuring global AIWG CLI: " + target + (installed ? " (was " + installed + ")" : ""));
   try {
     cp.execSync(
-      "npm install -g " + shellQuote(target) + " --prefer-online --cache-min=0 --no-audit --fund=false",
+      "npm install -g " + shellQuote(target) + " --omit=optional --ignore-scripts --prefer-online --cache-min=0 --no-audit --fund=false",
       { stdio: quietInstall() ? "pipe" : "inherit", timeout: 180000 }
     );
     log("AIWG CLI ready: " + target);
   } catch (e) {
     warn("Could not install " + target + " globally (non-fatal): " + (e && e.message ? e.message : String(e)));
-    warn("Manual fix: npm install -g " + target);
+    warn("Manual fix: npm install -g " + target + " --omit=optional --ignore-scripts");
   }
 }
 
@@ -419,6 +435,73 @@ function resolveOmniusBinary() {
   return null;
 }
 
+function normalizedPath(value) {
+  try {
+    var resolved = path.resolve(String(value || "")).replace(/[\\/]+$/, "");
+    return IS_WIN ? resolved.toLowerCase() : resolved;
+  } catch (e) {
+    return "";
+  }
+}
+
+function pathContainsDirectory(directory) {
+  var target = normalizedPath(directory);
+  if (!target) return false;
+  return String(process.env.PATH || "").split(path.delimiter).some(function (entry) {
+    return normalizedPath(entry) === target;
+  });
+}
+
+// npm normally creates the global bin entry before postinstall. Verify that
+// core contract and repair a missing POSIX symlink when the prefix is writable.
+// This intentionally does not edit shell profiles: a child installer cannot
+// change its parent shell, and guessing nvm/fnm/asdf ownership is unsafe.
+function ensureCoreCommandAvailable() {
+  var launcher = path.resolve(__dirname, "launcher.cjs");
+  if (!fs.existsSync(launcher)) {
+    warn("Core launcher is missing from the installed package: " + launcher);
+    return false;
+  }
+  try { fs.chmodSync(launcher, 0o755); } catch (e) {}
+
+  var prefix = process.env.npm_config_prefix || process.env.NPM_CONFIG_PREFIX || runCapture("npm prefix -g");
+  if (!prefix) {
+    warn("Could not resolve npm's global prefix; launcher is available at " + launcher + ".");
+    return true;
+  }
+
+  var binDir = IS_WIN ? prefix : path.join(prefix, "bin");
+  var commandPath = path.join(binDir, IS_WIN ? "omnius.cmd" : "omnius");
+  if (!IS_WIN && !fs.existsSync(commandPath)) {
+    try {
+      fs.mkdirSync(binDir, { recursive: true });
+      try {
+        var existingEntry = fs.lstatSync(commandPath);
+        if (existingEntry.isSymbolicLink()) fs.unlinkSync(commandPath);
+      } catch (e) {}
+      fs.symlinkSync(launcher, commandPath);
+      log("Repaired missing global command link: " + commandPath);
+    } catch (e) {
+      warn("Could not repair global command link " + commandPath + ": " + (e && e.message ? e.message : String(e)));
+    }
+  }
+
+  if (fs.existsSync(commandPath)) log("Omnius command installed: " + commandPath);
+  else warn("npm did not create the expected Omnius command entry: " + commandPath);
+
+  if (!pathContainsDirectory(binDir)) {
+    warn("npm's global command directory is not on PATH: " + binDir);
+    if (IS_WIN) {
+      warn("Add that directory to your user PATH, open a new terminal, then run `omnius`.");
+    } else {
+      warn("For this shell: export PATH=" + shellQuote(binDir) + ":\"$PATH\"");
+      warn("Then run `hash -r` and `omnius`. Add the same export to your shell profile for future terminals.");
+    }
+    warn("Immediate fallback: npx omnius@latest");
+  }
+  return fs.existsSync(commandPath) || fs.existsSync(launcher);
+}
+
 // Find a Node binary we can use in the service ExecStart.
 // On nvm systems this is important — /usr/bin/node is often too old.
 function resolveNodeBinary() {
@@ -1008,6 +1091,8 @@ function repairBrokenWrappers() {
 }
 
 function main() {
+  if (!ensureCoreCommandAvailable()) return fatalExit(1);
+
   // Always do the nexus cleanup first, regardless of opt-out.
   progress(1, INSTALL_STEPS, "Cleaning stale Nexus runtime state");
   cleanNexus();
@@ -1122,11 +1207,15 @@ function runMainAfterKill() {
 }
 
 function safeExit(code) {
-  // Never exit non-zero from postinstall — it breaks `npm i -g`.
+  // Optional setup failures must not break `npm i -g`.
   printDiscoveryPrimer();
   process.exit(typeof code === "number" ? 0 : 0);
 }
 
+function fatalExit(code) {
+  process.exit(typeof code === "number" && code !== 0 ? code : 1);
+}
+
 // Guard against any unhandled throw — postinstall must not crash npm.
 try {
   main();

package/dist/preinstall.cjs

@@ -13,6 +13,19 @@
 
 "use strict";
 
+// npm's `engines` field is advisory unless the user enables engine-strict.
+// Fail before touching any running daemon so an unsupported runtime cannot
+// leave the existing installation stopped or half-replaced.
+var NODE_MAJOR = parseInt(String(process.versions && process.versions.node || "").split(".")[0], 10);
+if (!NODE_MAJOR || NODE_MAJOR < 22) {
+  process.stderr.write(
+    "\n  [preinstall] Omnius requires Node.js 22 or newer; detected " +
+    String(process.versions && process.versions.node || "unknown") + ".\n" +
+    "  Install a current Node.js release, then run `npm install -g omnius` again.\n\n"
+  );
+  process.exit(1);
+}
+
 // A coordinated self-update owns the exact PID/service lifecycle and verifies
 // the replacement runtime afterward.  The generic install hook must not race
 // it by sweeping the configured port or killing an unattested process.
@@ -89,18 +102,32 @@ function killPidFile(pidFile) {
     if (!fs.existsSync(pidFile)) return false;
     var n = parseInt(fs.readFileSync(pidFile, "utf8").trim(), 10);
     if (!n || n <= 0) return false;
+    if (!isAttestedOmniusDaemon(n)) return false;
     try { process.kill(n, "SIGTERM"); log("SIGTERM " + pidFile + " (pid " + n + ")"); return true; }
     catch (e) { /* dead */ }
   } catch (e) {}
   return false;
 }
 
+function processCommandLine(pid) {
+  if (IS_WIN) return "";
+  try { return fs.readFileSync("/proc/" + pid + "/cmdline", "utf8").replace(/\0/g, " "); } catch (e) {}
+  return "";
+}
+
+function isAttestedOmniusDaemon(pid) {
+  var cmd = processCommandLine(pid);
+  return /(?:^|[\\/\s])omnius(?:[\\/\s]|$)|[\\/]omnius[\\/]dist[\\/]index\.js\b|launcher\.cjs\b/i.test(cmd) &&
+    /\bserve\b/.test(cmd) && /--daemon\b/.test(cmd);
+}
+
 progress(1, 3, "Preparing Omnius service handoff");
 stopServiceManager();
 killPidFile(path.join(HOME, ".omnius", "daemon.pid"));
 progress(2, 3, "Stopped old daemon handles");
 
-// Final: lsof-based sweep for any process still holding 11435.
+// Final: stop only an attested Omnius daemon still holding 11435. A generic
+// package lifecycle hook must never kill an unrelated service on this port.
 try {
   var port = parseInt(process.env.OMNIUS_PORT || "11435", 10);
   var out = "";
@@ -112,7 +139,7 @@ try {
   if (out) {
     out.split(/\s+/).forEach(function (s) {
       var n = parseInt(s, 10);
-      if (Number.isFinite(n) && n > 0 && n !== process.pid) {
+      if (Number.isFinite(n) && n > 0 && n !== process.pid && isAttestedOmniusDaemon(n)) {
         try { process.kill(n, "SIGTERM"); log("SIGTERM port-holder pid " + n); } catch (e) {}
       }
     });

package/docs/getting-started/install.md

@@ -16,6 +16,23 @@ npm install -g omnius
 omnius
 ```
 
+No compiler toolchain is required for the base install. Omnius installs its
+AIWG companion separately without optional native indexing modules, so missing
+`make`, C++, or Python cannot abort installation of the CLI.
+
+If npm completes but the shell cannot find `omnius`, npm's global command
+directory is not on that shell's `PATH`. Repair the current shell with:
+
+```bash
+export PATH="$(npm prefix -g)/bin:$PATH"
+hash -r
+omnius --version
+```
+
+Persist the same export in your shell profile (or open a new terminal after
+configuring nvm/fnm). You can use `npx omnius@latest` immediately without
+waiting for a profile reload.
+
 The first launch opens the setup flow, probes local capabilities, and asks which endpoint and model path to use.
 
 The installer prints a short agent-discovery primer. It does not print keys or