@openagents-org/agent-launcher 0.2.148 → 0.2.150

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openagents-org/agent-launcher",
-  "version": "0.2.148",
+  "version": "0.2.150",
   "description": "OpenAgents Launcher — install, configure, and run AI coding agents from your terminal",
   "main": "src/index.js",
   "bin": {

package/src/installer.js

@@ -471,7 +471,7 @@ class Installer {
     // Prefer the resolved absolute binary path (quoted) over the bare name:
     // it's unambiguous and lets `--version` succeed for binaries resolved via
     // the package-bin fallback (which are not on PATH).
-    const versionCmd = checkCmd || `"${binary}" --version`;
+    const versionCmd = checkCmd || this._versionProbeCommand(binary);
 
     const version = this._detectVersion(binary, versionCmd);
     const readiness = this._evaluateReadiness(agentType, entry, binary);
@@ -504,6 +504,56 @@ class Installer {
     };
   }
 
+  /**
+   * Build the `<binary> --version` probe command for a resolved binary path.
+   *
+   * When the resolved binary is a JS entry (`.mjs`/`.cjs`/`.js` — e.g. OpenClaw,
+   * whose package `bin` is `openclaw.mjs` and is what `_resolvePackageBin`
+   * returns when the `.cmd` shim isn't on PATH), it MUST be run through node.
+   * execSync goes through a shell; on Windows `cmd.exe "C:\…\openclaw.mjs"
+   * --version` finds no PATHEXT association for `.mjs`, so it ShellExecutes the
+   * file and the OS pops the "choose an app to open this .mjs file" dialog. The
+   * launcher polls health/version on a timer, so that dialog reappears over and
+   * over — even at idle, and stacked (one per poll). Prefixing node makes the
+   * probe run headless. Harmless on Unix (node runs a .mjs regardless of any
+   * shebang), so it's applied on every platform for consistency.
+   */
+  _versionProbeCommand(binary) {
+    if (/\.(mjs|cjs|js)$/i.test(binary)) {
+      return `"${this._nodeBinary()}" "${binary}" --version`;
+    }
+    return `"${binary}" --version`;
+  }
+
+  /**
+   * Resolve a node executable to run JS-entry CLIs with. Prefers the launcher's
+   * portable node, then a PATH lookup, then the bare name. Deliberately does NOT
+   * use process.execPath: when the core runs inside the Electron main process
+   * that path is the Electron binary, and `electron foo.mjs` would launch the
+   * app instead of running the script.
+   */
+  _nodeBinary() {
+    const isWin = process.platform === 'win32';
+    const nodeName = isWin ? 'node.exe' : 'node';
+    const portableDir = path.join(os.homedir(), '.openagents', 'nodejs');
+    for (const candidate of [
+      path.join(portableDir, nodeName),
+      path.join(portableDir, 'bin', nodeName),
+    ]) {
+      if (fs.existsSync(candidate)) return candidate;
+    }
+    try {
+      const found = execSync(isWin ? 'where node.exe' : 'which node', {
+        encoding: 'utf-8',
+        timeout: 5000,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: getEnhancedEnv(),
+      }).split(/\r?\n/)[0].trim();
+      if (found) return found;
+    } catch {}
+    return 'node';
+  }
+
   /**
    * Detect a binary's version string, cached briefly. Returns null on failure.
    */

package/src/update-check.js

@@ -115,6 +115,44 @@ function npmPrefixFromBin(npmBin, platform = process.platform) {
   return platform === 'win32' ? binDir : p.dirname(binDir);
 }
 
+/**
+ * Detect when the running launcher lives in an *isolated runtime* — the local
+ * npm project install.sh creates at `~/.openagents/nodejs`, where the package
+ * is at `<dir>/node_modules/@openagents-org/agent-launcher` and `<dir>` has its
+ * own `package.json`.
+ *
+ * This matters because a `-g` install (what a normal global/nvm install needs)
+ * lands in `<dir>/lib/node_modules`, but the isolated runtime's daemon loads
+ * from `<dir>/node_modules` — so `agn update` would report success while the
+ * running code never changed (the acen "update no-op" incident). For an
+ * isolated runtime we must do a *local* install into `<dir>` instead.
+ *
+ * Returns the project dir (`<dir>`) for an isolated runtime, else null (caller
+ * falls back to the global `-g` path). Global/nvm layouts are excluded: their
+ * package sits under `.../lib/node_modules` (basename 'lib') and the prefix
+ * root has no package.json.
+ */
+function isolatedRuntimeDir(opts = {}) {
+  const dir = opts.dir || __dirname; // <pkgRoot>/src
+  const exists = opts.exists || fs.existsSync;
+  // Path impl is injectable so tests can force POSIX/Windows semantics
+  // regardless of the host OS (mirrors npmPrefixFromBin's `platform`).
+  const p = opts.path || path;
+  try {
+    const pkgRoot = p.resolve(dir, '..');              // .../agent-launcher
+    const nodeModules = p.resolve(pkgRoot, '..', '..'); // .../node_modules
+    if (p.basename(nodeModules) !== 'node_modules') return null;
+    const projectDir = p.resolve(nodeModules, '..');    // dir containing node_modules
+    // Global npm layout is <prefix>/lib/node_modules — not an isolated project.
+    if (p.basename(projectDir) === 'lib') return null;
+    // A real local project has its own package.json; a global prefix does not.
+    if (!exists(p.join(projectDir, 'package.json'))) return null;
+    return projectDir;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Locate the npm executable next to the running node binary, falling back to
  * a PATH lookup. On Windows the runnable file is `npm.cmd`; the extensionless
@@ -150,15 +188,28 @@ function runUpdate(opts = {}) {
   const platform = opts.platform || process.platform;
   const spawn = opts.spawn || spawnSync;
   const npmBin = opts.npmBin || findNpmBin({ platform });
-  const prefix = opts.prefix !== undefined ? opts.prefix : npmPrefixFromBin(npmBin, platform);
-  // Use a GLOBAL install (-g). A LOCAL install (`npm install <pkg> --prefix
-  // <dir>`) treats <dir> as a project root and prunes every node_modules entry
-  // not reachable from its package.json. When the prefix is the portable node
-  // dir, that deletes node's own bundled npm/corepack (and other agent runtimes),
-  // breaking every subsequent `agn` command. A global install only adds/updates
-  // the named package into <prefix>/node_modules and never prunes its siblings.
-  const args = ['install', '-g', `${PKG_NAME}@latest`];
-  if (prefix) args.push('--prefix', prefix);
+  const isoDir = opts.isolatedDir !== undefined ? opts.isolatedDir : isolatedRuntimeDir();
+
+  let args;
+  if (isoDir) {
+    // Isolated runtime (install.sh's ~/.openagents/nodejs): a LOCAL npm project
+    // whose package lives in <dir>/node_modules — NOT <dir>/lib/node_modules.
+    // A `-g` install lands in lib/node_modules and silently no-ops the running
+    // launcher/daemon (which loads from node_modules). Install locally into the
+    // project dir instead. `--no-save` leaves package.json untouched (install.sh
+    // owns it), and because <dir>'s package.json already lists our deps npm has
+    // nothing extraneous to prune.
+    args = ['install', '--no-save', `${PKG_NAME}@latest`, '--prefix', isoDir];
+  } else {
+    // Global / nvm install. A LOCAL install (`npm install <pkg> --prefix <dir>`)
+    // here would treat <dir> as a project root and prune every node_modules
+    // entry not reachable from its package.json — deleting node's own bundled
+    // npm/corepack. A global install only adds/updates the named package into
+    // <prefix>/node_modules and never prunes its siblings.
+    const prefix = opts.prefix !== undefined ? opts.prefix : npmPrefixFromBin(npmBin, platform);
+    args = ['install', '-g', `${PKG_NAME}@latest`];
+    if (prefix) args.push('--prefix', prefix);
+  }
 
   // On Windows, npm.cmd is a batch file and must be invoked through cmd.exe.
   // Passing the args via cmd.exe with shell:false lets Node quote paths that
@@ -240,5 +291,6 @@ module.exports = {
   runUpdate,
   findNpmBin,
   npmPrefixFromBin,
+  isolatedRuntimeDir,
   currentVersion,
 };