@openagents-org/agent-launcher 0.2.173 → 0.2.175

package/src/paths.js

@@ -11,7 +11,7 @@
 const path = require('path');
 const fs = require('fs');
 const os = require('os');
-const { execSync } = require('child_process');
+const { execSync, execFileSync } = require('child_process');
 
 const IS_WINDOWS = process.platform === 'win32';
 const IS_MACOS = process.platform === 'darwin';
@@ -50,6 +50,14 @@ function getExtraBinDirs() {
   // Common: ~/.local/bin (pipx, user installs)
   _push(dirs, path.join(HOME, '.local', 'bin'));
 
+  // Every JS package manager's global bin, plus the npm prefix the user
+  // actually configured. Shared by both platforms — an agent installed with
+  // pnpm/bun/yarn is no less installed than one npm dropped.
+  _addPackageManagerPaths(dirs);
+
+  // CLIs whose own installer script picks a directory of its own.
+  _addAgentInstallerPaths(dirs);
+
   // Aider (uv tool install) — its executable honors XDG_BIN_HOME /
   // XDG_DATA_HOME/../bin / ~/.local/bin and also always lands in the uv tools
   // venv. A GUI/daemon process won't see the installer's PATH edit, so add the
@@ -80,6 +88,11 @@ function getExtraBinDirs() {
   // Legacy: shared node_modules/.bin (for backward compat with pre-isolation installs)
   _push(dirs, path.join(portableNode, 'node_modules', '.bin'));
 
+  // Last, and the widest net: whatever the user's login shell puts on PATH. See
+  // loginShellDirs() for why a GUI launch needs this at all. Ranked below every
+  // dir above so a copy this launcher installed still wins over a global one.
+  for (const d of loginShellDirs()) _push(dirs, d);
+
   // Filter to existing directories only, deduplicate
   const seen = new Set();
   const value = dirs.filter(d => {
@@ -165,10 +178,29 @@ function whichBinary(name) {
       timeout: 5000,
       windowsHide: true,
     });
-    let value = null;
+    const hits = [];
     for (const line of result.split(/\r?\n/)) {
       const hit = line.trim();
-      if (hit && fs.existsSync(hit)) { value = hit; break; }
+      if (hit && fs.existsSync(hit)) hits.push(hit);
+    }
+    let value = hits[0] || null;
+    if (IS_WINDOWS && hits.length) {
+      // `where` can list npm's extensionless POSIX shim (node_modules/.bin/
+      // claude, a sh script) ahead of claude.cmd. Windows cannot execute that
+      // file — spawning it fails and the probe misreports an installed CLI as
+      // "not installed" while the chat adapters (which prefer .cmd) work fine.
+      // Prefer a hit Windows can run; failing that, a runnable sibling of the
+      // shim; only then fall back to the raw first hit.
+      const RUNNABLE = /\.(cmd|exe|bat|com)$/i;
+      const runnable = hits.find((h) => RUNNABLE.test(h));
+      if (runnable) {
+        value = runnable;
+      } else {
+        for (const h of hits) {
+          const sibling = ['.cmd', '.exe', '.bat'].map((e) => h + e).find((c) => fs.existsSync(c));
+          if (sibling) { value = sibling; break; }
+        }
+      }
     }
     whichBinaryCache.set(cacheKey, { value, at: Date.now() });
     return value;
@@ -236,6 +268,238 @@ function whereBinary(names, env) {
   return null;
 }
 
+/**
+ * Global bin directories for every JS package manager we might find an agent
+ * CLI in — plus the npm prefix the user has actually configured.
+ *
+ * `npm install -g` only lands in the default prefix when nobody moved it, and
+ * moving it is the standard advice for avoiding `sudo` (`npm config set prefix
+ * ~/.npm-global`). pnpm/bun/yarn each own a different directory again. Missing
+ * any of them makes a perfectly working CLI read as "not installed" — the
+ * launcher then offers to install a second copy of something already there.
+ * Windows already consulted `npm config get prefix`; Unix never did, which is
+ * the half of that check this function restores.
+ */
+function _addPackageManagerPaths(dirs) {
+  // npm's configured prefix. On Windows the shims sit in the prefix itself; on
+  // Unix they sit in <prefix>/bin. Cached for the process — it costs a spawn
+  // and the value does not change while the app is open.
+  const prefix = _npmPrefix();
+  if (prefix) {
+    _push(dirs, IS_WINDOWS ? prefix : path.join(prefix, 'bin'));
+    // A Windows prefix can still carry a bin/ (Git-bash-flavoured setups).
+    if (IS_WINDOWS) _push(dirs, path.join(prefix, 'bin'));
+  }
+
+  // pnpm — PNPM_HOME when exported, else the per-platform default.
+  if (process.env.PNPM_HOME) _push(dirs, process.env.PNPM_HOME);
+  if (IS_WINDOWS) {
+    if (process.env.LOCALAPPDATA) _push(dirs, path.join(process.env.LOCALAPPDATA, 'pnpm'));
+  } else {
+    if (IS_MACOS) _push(dirs, path.join(HOME, 'Library', 'pnpm'));
+    _push(dirs, path.join(HOME, '.local', 'share', 'pnpm'));
+  }
+
+  // bun — the install root is relocatable via BUN_INSTALL.
+  const bunRoot = process.env.BUN_INSTALL || path.join(HOME, '.bun');
+  _push(dirs, path.join(bunRoot, 'bin'));
+
+  // yarn (both the v1 global bin and the classic global node_modules/.bin)
+  _push(dirs, path.join(HOME, '.yarn', 'bin'));
+  _push(dirs, path.join(HOME, '.config', 'yarn', 'global', 'node_modules', '.bin'));
+
+  // deno
+  const denoRoot = process.env.DENO_INSTALL || path.join(HOME, '.deno');
+  _push(dirs, path.join(denoRoot, 'bin'));
+
+  // Version-manager shim dirs — asdf and mise put every tool's shim here, so a
+  // CLI installed under a non-default runtime still resolves.
+  _push(dirs, path.join(process.env.ASDF_DATA_DIR || path.join(HOME, '.asdf'), 'shims'));
+  _push(dirs, path.join(HOME, '.local', 'share', 'mise', 'shims'));
+
+  // Windows package managers that install CLIs outside any of the above.
+  if (IS_WINDOWS) {
+    _push(dirs, path.join(process.env.SCOOP || path.join(HOME, 'scoop'), 'shims'));
+    if (process.env.ChocolateyInstall) _push(dirs, path.join(process.env.ChocolateyInstall, 'bin'));
+  }
+}
+
+/**
+ * Install dirs chosen by an agent CLI's own installer script.
+ *
+ * These never appear on a GUI process's PATH: the script edits a shell rc file
+ * (Unix) or the registry (Windows), neither of which reaches an already-running
+ * app. Cursor/Amp/Hermes are handled in the per-platform blocks for historical
+ * reasons; anything added here is picked up on both.
+ */
+function _addAgentInstallerPaths(dirs) {
+  // opencode — `curl -fsSL https://opencode.ai/install | bash` defaults to
+  // ~/.opencode/bin and honours OPENCODE_INSTALL_DIR. Reported as
+  // "launcher can't see my opencode" (#648).
+  _push(dirs, process.env.OPENCODE_INSTALL_DIR || path.join(HOME, '.opencode', 'bin'));
+
+  // kimi — the npm package (@moonshot-ai/kimi-code) declares a real `kimi` bin,
+  // but its postinstall ALSO drops a native build in ~/.kimi-code/bin and puts
+  // that on PATH by editing a shell rc file. A running app never sees that
+  // edit, and for a user who took the native route it is the only copy there is.
+  _push(dirs, path.join(HOME, '.kimi-code', 'bin'));
+
+  // Legacy npm prefixes the opencode/copilot adapters have always searched.
+  // They were known to the adapter that SPAWNS the CLI but not to the
+  // installer that decides whether it EXISTS — so an agent could run fine and
+  // still be offered for install. See the coverage test in
+  // test/agent-detection-matrix.test.js.
+  _push(dirs, path.join(HOME, '.npm-global', 'bin'));
+  _push(dirs, path.join(HOME, '.openagents', 'npm-global', 'bin'));
+
+  // The plain ~/bin some installers fall back to when ~/.local/bin is absent.
+  _push(dirs, path.join(HOME, 'bin'));
+
+  if (IS_WINDOWS && process.env.LOCALAPPDATA) {
+    const lad = process.env.LOCALAPPDATA;
+    // antigravity (agy) — install.sh targets ~/.local/bin, the Windows
+    // installer %LOCALAPPDATA%\agy\bin. Only the adapter knew the latter.
+    _push(dirs, path.join(lad, 'agy', 'bin'));
+    // cursor-agent also ships under Programs\ on some Windows installs — the
+    // cursor adapter checks both, the installer only knew one.
+    _push(dirs, path.join(lad, 'Programs', 'cursor-agent'));
+  }
+}
+
+let npmPrefixCache;
+
+/**
+ * Where the user's `npm install -g` puts things, or null. Probed once.
+ *
+ * Read from npm's own configuration rather than by asking an npm binary,
+ * because WHICH npm answers is not a question we can settle: the launcher
+ * prepends its bundled runtime to PATH, Homebrew may have another, and each
+ * reports its OWN builtin default. Only a prefix the user deliberately set is
+ * interesting here — the builtin defaults are already covered by the
+ * well-known dirs — and that setting lives in exactly two places:
+ *
+ *   1. $NPM_CONFIG_PREFIX  (npm's env override, highest precedence)
+ *   2. `prefix=` in ~/.npmrc  (what `npm config set prefix …` writes)
+ *
+ * Falling back to spawning npm only when neither is present keeps the common
+ * case free of a subprocess entirely.
+ */
+function _npmPrefix() {
+  if (npmPrefixCache !== undefined) return npmPrefixCache;
+  npmPrefixCache = null;
+  const accept = (value) => {
+    const v = String(value || '').trim().replace(/^["']|["']$/g, '');
+    if (!v || v === 'undefined') return false;
+    // ~ is not expanded by npm's config reader for us.
+    const abs = v.startsWith('~') ? path.join(HOME, v.slice(1)) : v;
+    try {
+      if (!fs.existsSync(abs)) return false;
+    } catch {
+      return false;
+    }
+    npmPrefixCache = abs;
+    return true;
+  };
+
+  if (accept(process.env.NPM_CONFIG_PREFIX)) return npmPrefixCache;
+
+  try {
+    const npmrc = fs.readFileSync(path.join(HOME, '.npmrc'), 'utf-8');
+    for (const line of npmrc.split(/\r?\n/)) {
+      const m = /^\s*prefix\s*=\s*(.+?)\s*$/.exec(line);
+      if (m && accept(m[1])) return npmPrefixCache;
+    }
+  } catch {}
+
+  try {
+    const out = execSync('npm config get prefix', {
+      encoding: 'utf-8',
+      timeout: 8000,
+      windowsHide: true,
+      stdio: ['ignore', 'pipe', 'ignore'],
+      // The user's PATH first: it is their npm we are asking about.
+      env: { ...process.env, PATH: _basePATH() },
+    }).trim();
+    accept(out);
+  } catch {}
+  return npmPrefixCache;
+}
+
+/**
+ * PATH for the internal probes above — the process PATH plus the well-known
+ * dirs, WITHOUT recursing back into getExtraBinDirs() (which is what calls us).
+ */
+function _basePATH() {
+  const seed = [];
+  if (IS_WINDOWS) {
+    if (process.env.APPDATA) seed.push(path.join(process.env.APPDATA, 'npm'));
+    seed.push(path.join(process.env.ProgramFiles || 'C:\\Program Files', 'nodejs'));
+  } else {
+    seed.push('/usr/local/bin', '/opt/homebrew/bin', path.join(HOME, '.local', 'bin'));
+  }
+  try { seed.push(path.dirname(process.execPath)); } catch {}
+  // Process PATH FIRST — these seeds are a fallback for a GUI launch with no
+  // PATH at all, not a preference. Putting them ahead would answer questions
+  // about Homebrew's tooling on a machine whose real toolchain is elsewhere.
+  return (process.env.PATH ? process.env.PATH + SEP : '') + seed.join(SEP);
+}
+
+const SHELL_PROBE_TIMEOUT_MS = 6000;
+const SHELL_ENV_DELIM = '__OPENAGENTS_ENV__';
+let loginShellDirsCache;
+
+/**
+ * The PATH entries a login shell would hand the user, harvested once.
+ *
+ * This is the general form of every "installed but not detected" report. A
+ * launcher started from Finder / the Dock / a desktop entry does NOT inherit
+ * the shell's environment — macOS hands a GUI app `/usr/bin:/bin:/usr/sbin:
+ * /sbin` and nothing else. So every CLI the user installed through their own
+ * shell (nvm on a non-default version, a relocated npm prefix, bun, pnpm, a
+ * hand-rolled ~/bin) is invisible, and no hardcoded list of well-known dirs can
+ * ever be complete enough to cover it. Asking the shell is the only answer that
+ * generalises: whatever `which opencode` finds in a terminal, we find too.
+ *
+ * Runs `$SHELL -ilc env` and reads the PATH line out of a delimited block, so a
+ * chatty rc file (motd, version-manager banners, prompt setup) can't corrupt the
+ * result. Best-effort throughout: no shell, an unusual shell that rejects the
+ * flags, or a hang all fall back to the hardcoded dirs. Set
+ * OPENAGENTS_SKIP_SHELL_PATH=1 to opt out.
+ */
+function loginShellDirs() {
+  if (loginShellDirsCache !== undefined) return loginShellDirsCache;
+  loginShellDirsCache = [];
+  if (IS_WINDOWS) return loginShellDirsCache;
+  if (process.env.OPENAGENTS_SKIP_SHELL_PATH === '1') return loginShellDirsCache;
+  const shell = process.env.SHELL || '/bin/zsh';
+  try {
+    if (!fs.existsSync(shell)) return loginShellDirsCache;
+    const out = execFileSync(
+      shell,
+      ['-ilc', `echo ${SHELL_ENV_DELIM}; command env; echo ${SHELL_ENV_DELIM}`],
+      {
+        encoding: 'utf-8',
+        timeout: SHELL_PROBE_TIMEOUT_MS,
+        killSignal: 'SIGKILL',
+        // stdin closed, stderr dropped: an interactive shell with no tty writes
+        // job-control warnings there and we do not want them in the output.
+        stdio: ['ignore', 'pipe', 'ignore'],
+        maxBuffer: 4 * 1024 * 1024,
+      },
+    );
+    const parts = String(out).split(SHELL_ENV_DELIM);
+    if (parts.length < 3) return loginShellDirsCache;
+    const line = parts[1].split(/\r?\n/).find((l) => l.startsWith('PATH='));
+    if (!line) return loginShellDirsCache;
+    const seen = new Set();
+    for (const d of line.slice('PATH='.length).split(SEP)) {
+      const dir = d.trim();
+      if (dir && !seen.has(dir)) { seen.add(dir); loginShellDirsCache.push(dir); }
+    }
+  } catch {}
+  return loginShellDirsCache;
+}
+
 // ---- Windows paths ----
 
 function _addWindowsPaths(dirs) {
@@ -250,14 +514,8 @@ function _addWindowsPaths(dirs) {
   // npm global bin (default location)
   if (appData) _push(dirs, path.join(appData, 'npm'));
 
-  // npm global bin (custom prefix — e.g. user configured npm prefix to D:\node\node_global)
-  try {
-    const npmPrefix = execSync('npm config get prefix', {
-      encoding: 'utf-8', timeout: 5000, windowsHide: true,
-      stdio: ['pipe', 'pipe', 'pipe'],
-    }).trim();
-    if (npmPrefix) _push(dirs, npmPrefix);
-  } catch {}
+  // npm's custom prefix (e.g. D:\node\node_global) is added for BOTH platforms
+  // by _addPackageManagerPaths — see the note there.
 
   // Portable Node.js installed by OpenAgents Launcher
   _push(dirs, path.join(HOME, '.openagents', 'nodejs'));
@@ -339,6 +597,8 @@ function _addUnixPaths(dirs) {
   // nvm
   const nvmDir = process.env.NVM_DIR || path.join(HOME, '.nvm');
   try {
+    // The version the shell that spawned us is on, when it exported it.
+    if (process.env.NVM_BIN) _push(dirs, process.env.NVM_BIN);
     // Find current nvm version
     const defaultPath = path.join(nvmDir, 'alias', 'default');
     if (fs.existsSync(defaultPath)) {
@@ -349,6 +609,14 @@ function _addUnixPaths(dirs) {
     }
     // Also try current symlink
     _push(dirs, path.join(nvmDir, 'current', 'bin'));
+    // Then EVERY installed version, newest first. `npm install -g` writes into
+    // whichever version was active in that terminal, which is routinely not the
+    // default alias — a user who ran `nvm use 20 && npm i -g opencode` has a
+    // real, working CLI that the default-alias-only lookup above cannot see.
+    // Newest-first so the most likely copy still wins.
+    for (const v of _installedNvmVersions(nvmDir)) {
+      _push(dirs, path.join(nvmDir, 'versions', 'node', v, 'bin'));
+    }
   } catch {}
 
   // fnm
@@ -403,6 +671,23 @@ function _push(arr, dir) {
   if (dir) arr.push(dir);
 }
 
+/** Every node version nvm has installed, newest first. */
+function _installedNvmVersions(nvmDir) {
+  try {
+    return fs
+      .readdirSync(path.join(nvmDir, 'versions', 'node'))
+      .filter((v) => /^v\d+\./.test(v))
+      .sort((a, b) => {
+        const pa = a.slice(1).split('.').map(Number);
+        const pb = b.slice(1).split('.').map(Number);
+        for (let i = 0; i < 3; i++) if ((pb[i] || 0) !== (pa[i] || 0)) return (pb[i] || 0) - (pa[i] || 0);
+        return 0;
+      });
+  } catch {
+    return [];
+  }
+}
+
 function _resolveNvmVersion(nvmDir, alias) {
   // Handle direct version like 'v22.14.0'
   if (alias.startsWith('v')) {
@@ -482,6 +767,23 @@ function defaultAgentWorkdir(agentName) {
 function clearBinaryLookupCache() {
   extraBinDirsCache = { value: null, at: 0, path: '' };
   whichBinaryCache.clear();
+  // The login-shell / npm-prefix probes are deliberately NOT cleared: they each
+  // cost a process spawn, they answer a question about the machine rather than
+  // about any install, and this is called after every install/uninstall.
+}
+
+/**
+ * Pay the one-time probe cost (login shell + npm prefix) up front.
+ *
+ * getExtraBinDirs() is synchronous and every caller is on a path where a ~1s
+ * stall is felt — the marketplace listing, a readiness check, spawning an
+ * agent. Calling this once while a splash screen is already up moves that cost
+ * somewhere nobody is waiting on. Safe to call more than once; safe to skip.
+ */
+function primeBinaryLookup() {
+  try { loginShellDirs(); } catch {}
+  try { _npmPrefix(); } catch {}
+  try { getExtraBinDirs(); } catch {}
 }
 
 /**
@@ -581,6 +883,8 @@ module.exports = {
   whereBinary,
   resolveBinaryInKnownDirs,
   clearBinaryLookupCache,
+  primeBinaryLookup,
+  loginShellDirs,
   getRuntimePrefix,
   getCorePrefix,
   defaultAgentWorkdir,

package/src/probe.js

@@ -28,6 +28,7 @@
 const os = require('os');
 const { spawn } = require('child_process');
 const { getEnhancedEnv } = require('./paths');
+const { shouldUseShellForBinary } = require('./adapters/health-status');
 const { formatAuthGuidance } = require('./auth-guidance');
 const { testLLMConnection } = require('./utils');
 
@@ -51,6 +52,7 @@ const CODE = {
   NETWORK: 'network',
   TIMEOUT: 'timeout',
   EMPTY_RESPONSE: 'empty_response',
+  BAD_MODEL: 'bad_model',
   CLI_ERROR: 'cli_error',
 };
 
@@ -86,19 +88,30 @@ function authFlavor(entry, agentEnv) {
  * Classify a failed live check into a code. Pattern-matches the combined
  * output; callers turn the code into guidance via buildGuidance().
  */
-function classifyFailure(output, { timedOut = false, spawnError = null } = {}) {
-  if (spawnError && /ENOENT/.test(String(spawnError))) return CODE.NOT_INSTALLED;
-  if (timedOut) return CODE.TIMEOUT;
-  const text = String(output || '').toLowerCase();
-  if (!text && spawnError) return CODE.CLI_ERROR;
-
+/** Classify an error by its OUTPUT TEXT alone; null when nothing matches. */
+function classifyOutputText(text) {
   if (/credit balance|insufficient[_ ]?(quota|credits|funds)|payment required|\b402\b|billing/.test(text)) return CODE.OUT_OF_CREDIT;
   if (/rate[- ]?limit|too many requests|\b429\b|overloaded|\b529\b/.test(text)) return CODE.RATE_LIMITED;
   if (/enotfound|econnrefused|econnreset|etimedout|eai_again|fetch failed|socket hang up|network error|self[- ]signed certificate|unable to get local issuer/.test(text)) return CODE.NETWORK;
   if (/api key.{0,24}(not set|not found|missing)|no api key|missing api key|environment variable.{0,40}(is )?(not set|required)/.test(text)) return CODE.MISSING_API_KEY;
   if (/invalid.{0,12}(api.?key|x-api-key|token)|incorrect api key|authentication[_ ]?error|invalid credentials|\b401\b|unauthorized|forbidden|\b403\b/.test(text)) return CODE.INVALID_API_KEY;
   if (/not logged in|not authenticated|login required|please (log ?in|sign ?in|authenticate)|run .{0,40}login|no credentials/.test(text)) return CODE.NOT_LOGGED_IN;
-  return CODE.CLI_ERROR;
+  if (/unrecognized_model|issue with the selected model|unknown model|model.{0,40}(does not exist|not found|not exist|is not supported)/.test(text)) return CODE.BAD_MODEL;
+  return null;
+}
+
+function classifyFailure(output, { timedOut = false, spawnError = null } = {}) {
+  if (spawnError && /ENOENT/.test(String(spawnError))) return CODE.NOT_INSTALLED;
+  const text = String(output || '').toLowerCase();
+  if (timedOut) {
+    // A CLI that retries a hard API error (bad key, unknown model, quota)
+    // until the probe clock runs out is NOT "waiting for interactive input" —
+    // the collected output already names the real problem. Only an output
+    // with no recognizable error is a genuine timeout.
+    return (text && classifyOutputText(text)) || CODE.TIMEOUT;
+  }
+  if (!text && spawnError) return CODE.CLI_ERROR;
+  return classifyOutputText(text) || CODE.CLI_ERROR;
 }
 
 /** Human next-steps for a code. Plain strings, no markup, no secrets. */
@@ -145,6 +158,9 @@ function buildGuidance(code, entry, agentEnv, extra = {}) {
     case CODE.EMPTY_RESPONSE:
       lines.push(`${label} exited without producing a response. Run its CLI manually on the device to see what it prints.`);
       break;
+    case CODE.BAD_MODEL:
+      lines.push(`The configured model isn't recognized or isn't served by ${label}'s endpoint. Pick a different model in the launcher (Agents → ${label} → Configure) or edit the agent in the workspace.`);
+      break;
     case CODE.NOT_READY:
       // Caller supplies the static-auth guidance lines instead.
       break;
@@ -255,7 +271,12 @@ async function probeAgentType(connector, type, opts = {}) {
   const altCheck = entry.check_ready && entry.check_ready.alt_check;
   if ((probeArgs && health.binary) || altCheck) {
     const res = probeArgs && health.binary
-      ? await runCommand(health.binary, probeArgs, { env, timeoutMs })
+      // Node refuses to spawn .cmd/.bat without a shell (EINVAL since the
+      // CVE-2024-27980 hardening), which made every Windows CLI probe of an
+      // npm-shim binary fail as "Exited with code 1" with no output.
+      ? await runCommand(health.binary, probeArgs, {
+          env, timeoutMs, shell: shouldUseShellForBinary(health.binary),
+        })
       : await runCommand(altCheck, [], { env, timeoutMs, shell: true });
     const output = `${res.stdout}\n${res.stderr}`;
     if (!res.timedOut && !res.spawnError && res.code === 0 && res.stdout.trim()) {

package/src/registry.js

@@ -96,7 +96,10 @@ class Registry {
       const b = bundled.find(x => x.name === entry.name);
       if (b) {
         if ((!entry.env_config || entry.env_config.length === 0) && b.env_config && b.env_config.length > 0) entry.env_config = b.env_config;
-        if (!entry.resolve_env && b.resolve_env) entry.resolve_env = b.resolve_env;
+        // resolve_env is behavior-critical env mapping tied to the adapter
+        // version shipping WITH this launcher — bundled wins over a (possibly
+        // day-old) cached remote copy, same as install.
+        if (b.resolve_env) entry.resolve_env = b.resolve_env;
         if (b.install) entry.install = { ...b.install };
         if (!entry.check_ready && b.check_ready) entry.check_ready = b.check_ready;
         if (!entry.launch && b.launch) entry.launch = b.launch;