mixdog 0.7.5 → 0.7.7

package/scripts/resolve-bun.mjs

@@ -0,0 +1,60 @@
+/**
+ * resolve-bun.mjs — locate or npm-install the bun binary for mixdog boot/setup.
+ */
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+const isWin = process.platform === 'win32';
+
+export function findSystemBun() {
+  const cmd = isWin ? 'where.exe' : 'which';
+  const r = spawnSync(cmd, ['bun'], { encoding: 'utf8', windowsHide: true });
+  if (r.status !== 0 || !r.stdout) return null;
+  const lines = r.stdout.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+  const pick = isWin
+    ? (lines.find((l) => l.toLowerCase().endsWith('.exe')) ?? lines[0])
+    : lines[0];
+  if (!pick) return null;
+  return existsSync(pick) ? pick : null;
+}
+
+export function findLocalBun(pluginRoot) {
+  const candidates = [
+    join(pluginRoot, 'node_modules', '.bin', isWin ? 'bun.exe' : 'bun'),
+    join(pluginRoot, 'node_modules', 'bun', 'bin', isWin ? 'bun.exe' : 'bun'),
+  ];
+  for (const p of candidates) if (existsSync(p)) return p;
+  return null;
+}
+
+export function resolveBun(pluginRoot) {
+  return findSystemBun() ?? findLocalBun(pluginRoot);
+}
+
+/**
+ * @param {string} pluginRoot
+ * @param {{ fatal?: boolean }} [opts] — fatal:true (default) exits the process on failure
+ * @returns {boolean} success
+ */
+export function installBunViaNpm(pluginRoot, { fatal = true } = {}) {
+  process.stderr.write(
+    '[bootstrap] bun not found on PATH — installing via npm (npm install --no-save --silent bun)...\n',
+  );
+  const r = spawnSync('npm', ['install', '--no-save', '--silent', 'bun'], {
+    cwd: pluginRoot,
+    stdio: 'inherit',
+    shell: false,
+    windowsHide: true,
+  });
+  if (r.status !== 0 || r.error) {
+    const hint = r.error ? ` (${r.error.message})` : '';
+    process.stderr.write(
+      `[bootstrap] npm install failed${hint}.\n` +
+      '[bootstrap] Please install bun manually: https://bun.sh\n',
+    );
+    if (fatal) process.exit(1);
+    return false;
+  }
+  return true;
+}

package/scripts/run-mcp.mjs

@@ -19,10 +19,14 @@ import { fileURLToPath } from 'url';
 import { createRequire } from 'module';
 import { dirname, join } from 'path';
 import * as fs from 'fs';
-import { createHash, randomUUID } from 'crypto';
-import { execSync, spawn, spawnSync } from 'child_process';
+import { randomUUID } from 'crypto';
+import { execSync, spawn } from 'child_process';
 import * as os from 'os';
-import { assertSafeOwnedDir } from '../src/shared/user-data-guard.mjs';
+import {
+  ensureRuntimeDeps,
+  hasRequiredDeps,
+  renameWithRetrySync,
+} from './ensure-deps.mjs';
 
 // Stable per-terminal session id for this proxy supervisor's lifetime. The
 // child server.mjs is respawned on crash / dev-sync restart, but THIS
@@ -34,29 +38,6 @@ import { assertSafeOwnedDir } from '../src/shared/user-data-guard.mjs';
 // upstream-provided id if one already exists.
 const STABLE_TERMINAL_SESSION_ID = process.env.MIXDOG_SESSION_ID || randomUUID();
 
-const RENAME_RETRY_CODES = new Set(['EPERM', 'EACCES', 'EBUSY', 'EEXIST']);
-const RENAME_BACKOFFS_MS = Object.freeze([25, 50, 100, 200, 400, 800, 1200, 1600]);
-function sleepSync(ms) {
-  try {
-    const buf = new SharedArrayBuffer(4);
-    Atomics.wait(new Int32Array(buf), 0, 0, Math.max(1, Number(ms) || 1));
-  } catch {}
-}
-function renameWithRetrySync(src, dst) {
-  let lastErr = null;
-  for (let attempt = 0; attempt <= RENAME_BACKOFFS_MS.length; attempt++) {
-    try {
-      fs.renameSync(src, dst);
-      return true;
-    } catch (err) {
-      lastErr = err;
-      if (!RENAME_RETRY_CODES.has(err?.code) || attempt >= RENAME_BACKOFFS_MS.length) break;
-      sleepSync(RENAME_BACKOFFS_MS[attempt] + Math.floor(Math.random() * 50));
-    }
-  }
-  throw lastErr;
-}
-
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const __localRoot = join(__dirname, '..');
 
@@ -87,7 +68,6 @@ if (pluginRoot !== __localRoot) {
 }
 const serverPath = join(pluginRoot, 'server.mjs');
 const pluginPkg  = join(pluginRoot, 'package.json');
-const pluginLock = join(pluginRoot, 'bun.lock');
 const pluginNm   = join(pluginRoot, 'node_modules');
 
 process.stderr.write(`[boot-time] tag=run-mcp-entry tMs=${Date.now()}\n`);
@@ -110,17 +90,6 @@ try {
 // server.mjs reads MIXDOG_SUPERVISOR_PID + MIXDOG_SUPERVISOR_CACHE_DIR
 // from its env (set in spawnChild below) to identify the supervisor.
 
-const requiredDepNames = [
-  ['@modelcontextprotocol', 'sdk', 'package.json'],
-  ['zod', 'package.json'],
-  ['zod-to-json-schema', 'package.json'],
-  ['openai', 'package.json'],
-];
-
-function hasRequiredDeps(nmDir) {
-  return requiredDepNames.every((parts) => fs.existsSync(join(nmDir, ...parts)));
-}
-
 // ── Lightweight JSON-RPC line scanner ────────────────────────────────────────
 // Extracts `id` and `method` from a JSON-RPC line without a full JSON.parse.
 // Returns { id, method } (each may be undefined), or null on scan failure.
@@ -256,50 +225,6 @@ function _scanIdMethod(line) {
   }
 }
 
-const LOCK_POLL_MS  = 250;
-const LOCK_MAX_MS   = 15 * 60 * 1000;
-const LOCK_XHOST_MS = 10 * 60 * 1000;
-
-function acquireLock(lockFile) {
-  const start = Date.now();
-  while (Date.now() - start < LOCK_MAX_MS) {
-    try {
-      const body = JSON.stringify({
-        pid:       process.pid,
-        hostname:  os.hostname(),
-        startedAt: Date.now(),
-      });
-      // 'wx' = O_CREAT | O_EXCL — fails atomically if file already exists.
-      fs.writeFileSync(lockFile, body, { flag: 'wx' });
-      return;
-    } catch (e) {
-      if (e.code !== 'EEXIST') throw e;
-      try {
-        const raw  = fs.readFileSync(lockFile, 'utf8');
-        const body = JSON.parse(raw);
-        const st   = fs.statSync(lockFile);
-        const sameHost = body.hostname === os.hostname();
-        let dead = false;
-        if (sameHost) {
-          try { process.kill(body.pid, 0); }
-          catch (ke) { if (ke.code === 'ESRCH') dead = true; }
-        } else {
-          if (Date.now() - st.mtimeMs > LOCK_XHOST_MS) dead = true;
-        }
-        if (dead) fs.unlinkSync(lockFile);
-      } catch { /* lock may have been released between read and stat — retry */ }
-      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, LOCK_POLL_MS);
-    }
-  }
-  throw new Error(
-    `timed out waiting for dependency install lock after ${LOCK_MAX_MS / 60000} minutes`
-  );
-}
-
-function releaseLock(lockFile) {
-  try { fs.unlinkSync(lockFile); } catch {}
-}
-
 function ensureNmSymlink(linkPath, targetPath) {
   const linkType = process.platform === 'win32' ? 'junction' : 'dir';
   // EPERM/EBUSY here is almost always a transient AV / indexer lock on the
@@ -353,32 +278,6 @@ function ensureNmSymlink(linkPath, targetPath) {
   trySymlink();
 }
 
-function sha256(buf) {
-  return createHash('sha256').update(buf).digest('hex');
-}
-
-/**
- * SHA-256 hash that changes iff the resolved dep tree changes.
- * Primary: bun.lock. Fallback: dep-key objects from package.json (so the very
- * first install — before bun.lock exists — still hashes deterministically).
- */
-function computeDepHash(pkgJsonPath, pkgLockPath) {
-  if (fs.existsSync(pkgLockPath)) {
-    return sha256(fs.readFileSync(pkgLockPath));
-  }
-  const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
-  const depKeys = ['dependencies', 'optionalDependencies', 'peerDependencies'];
-  const depObj = {};
-  for (const k of depKeys) {
-    if (pkg[k]) {
-      depObj[k] = Object.fromEntries(
-        Object.entries(pkg[k]).sort(([a], [b]) => a.localeCompare(b))
-      );
-    }
-  }
-  return sha256(Buffer.from(JSON.stringify(depObj)));
-}
-
 const require = createRequire(import.meta.url);
 const { resolvePluginData } = require('../lib/plugin-paths.cjs');
 const dataDir = resolvePluginData();
@@ -433,67 +332,13 @@ try {
 // Install runtime deps into a DEDICATED <dataDir>/.deps/ subdir — NEVER the
 // data root, which holds user data (mixdog-config.json, user-workflow.*,
 // roles/). Running `bun install` with cwd=dataDir would wipe that state.
-const depsDir    = join(dataDir, '.deps');
-const sharedPkg  = join(depsDir, 'package.json');
-const sharedLock = join(depsDir, 'bun.lock');
-const sharedNm   = join(depsDir, 'node_modules');
-const stamp      = join(depsDir, '.deps-stamp');
-const stampTmp   = join(depsDir, '.deps-stamp.tmp');
-const lockFile   = join(depsDir, '.install.lock');
-
-const currentHash = computeDepHash(pluginPkg, pluginLock);
-let storedHash = '';
-try { storedHash = fs.readFileSync(stamp, 'utf8').trim(); } catch {}
-
-const needsInstall = (currentHash !== storedHash) || !hasRequiredDeps(sharedNm);
-
-if (needsInstall) {
-  // Hard guard: refuse to install anywhere that would clobber user data.
-  // assertSafeOwnedDir throws unless depsDir is an owned subdir (.deps).
-  assertSafeOwnedDir(depsDir, dataDir, 'bun install');
-  fs.mkdirSync(depsDir, { recursive: true });
-  acquireLock(lockFile);
-  try {
-    fs.copyFileSync(pluginPkg, sharedPkg);
-    if (fs.existsSync(pluginLock)) fs.copyFileSync(pluginLock, sharedLock);
-
-    const args = fs.existsSync(sharedLock)
-      ? ['install', '--frozen-lockfile']
-      : ['install'];
-    process.stderr.write(`[run-mcp] installing shared deps: bun ${args.join(' ')}\n`);
+ensureRuntimeDeps({
+  dataDir,
+  pluginRoot,
+  bunPath: process.env.BUN_EXEC_PATH,
+});
 
-    // First install on a clean machine downloads + extracts all deps, which
-    // routinely exceeds 30s; too low a ceiling times out into an empty
-    // node_modules and aborts the very first boot. 3 minutes covers a cold
-    // network fetch while still bounding a genuinely stuck install.
-    const INSTALL_TIMEOUT_MS = 180_000;
-    const result = spawnSync(process.env.BUN_EXEC_PATH || process.execPath, args, {
-      cwd: depsDir,
-      stdio: 'inherit',
-      timeout: INSTALL_TIMEOUT_MS,
-      windowsHide: true,
-    });
-    if (result.error?.code === 'ETIMEDOUT' || result.signal === 'SIGTERM') {
-      process.stderr.write(
-        `[run-mcp] WARN: bun install timed out after ${INSTALL_TIMEOUT_MS}ms — ` +
-        `continuing with existing node_modules (stale lock removed)\n`
-      );
-      try { fs.unlinkSync(lockFile); } catch {}
-    } else if (result.status !== 0) {
-      const detail = result.status ?? result.signal ?? 'unknown';
-      process.stderr.write(
-        `[run-mcp] WARN: bun install exited with status ${detail} — ` +
-        `continuing with existing node_modules if available\n`
-      );
-    } else {
-      // Atomic stamp write: tmp + rename so a crash cannot leave it half-written.
-      fs.writeFileSync(stampTmp, currentHash);
-      renameWithRetrySync(stampTmp, stamp);
-    }
-  } finally {
-    releaseLock(lockFile);
-  }
-}
+const sharedNm = join(dataDir, '.deps', 'node_modules');
 
 ensureNmSymlink(pluginNm, sharedNm);
 

package/setup/install.mjs

@@ -2,8 +2,8 @@
 // install.mjs — one-shot bootstrapper that registers the mixdog plugin in the
 // user's Claude Code settings so it auto-loads on the next session start.
 //
-// Run via:  npx -p mixdog mixdog-install   (after the package is published)
-//       or:  node setup/install.mjs          (from a checkout)
+// Run via:  npx mixdog | mixdog install | mixdog-install   (after publish)
+//       or:  node setup/install.mjs             (from a checkout)
 //
 // It merges two keys into the user-scope settings file (preserving everything
 // else that is already there):
@@ -20,20 +20,38 @@ import {
   mkdirSync,
   copyFileSync,
 } from 'node:fs';
-import { join } from 'node:path';
+import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
+import { realpathSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
 import { createInterface } from 'node:readline';
-import { spawn } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import { DEFAULT_MARKETPLACE, DEFAULT_PLUGIN } from '../src/shared/plugin-paths.mjs';
+import { resolveClaudeExecutable } from './locate-claude.mjs';
+import { createSpinner } from './tui.mjs';
 
 const MARKETPLACE = DEFAULT_MARKETPLACE;
 const PLUGIN_REF = `${DEFAULT_PLUGIN}@${DEFAULT_MARKETPLACE}`;
 const REPO = 'trib-plugin/mixdog';        // github owner/repo
 const REPO_URL = 'https://github.com/trib-plugin/mixdog';
 
+/** Claude config root — matches Claude Code (settings + plugins tree). */
+export function claudeConfigBaseDir() {
+  return process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude');
+}
+
 // Claude Code honours CLAUDE_CONFIG_DIR; otherwise the user scope is ~/.claude.
 function settingsDir() {
-  return process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude');
+  return claudeConfigBaseDir();
+}
+
+export function defaultPluginDataDir() {
+  return join(
+    claudeConfigBaseDir(),
+    'plugins',
+    'data',
+    `${DEFAULT_PLUGIN}-${MARKETPLACE}`,
+  );
 }
 
 function loadSettings(file) {
@@ -48,7 +66,7 @@ function isPlainObject(value) {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 
-function registerPluginInSettings() {
+function registerPluginInSettings(dryRun = false) {
   const dir = settingsDir();
   const file = join(dir, 'settings.json');
 
@@ -74,6 +92,15 @@ function registerPluginInSettings() {
   const already = settings.enabledPlugins[PLUGIN_REF] === true;
   settings.enabledPlugins[PLUGIN_REF] = true;
 
+  if (dryRun) {
+    console.log(`[dry-run] would register mixdog in ${file}`);
+    console.log(`[dry-run]   marketplace "${MARKETPLACE}" → github:${REPO}`);
+    console.log(
+      `[dry-run]   enabled plugin "${PLUGIN_REF}"${already ? ' (was already enabled)' : ''}`,
+    );
+    return;
+  }
+
   // Back up an existing file before the first write; create the dir otherwise.
   if (existsSync(file)) {
     const stamp = new Date().toISOString().replace(/[:.]/g, '-');
@@ -91,22 +118,179 @@ function registerPluginInSettings() {
   console.log(`\nNext: restart Claude Code (or run /reload-plugins). mixdog loads automatically.`);
 }
 
-async function main() {
-  registerPluginInSettings();
+const CLAUDE_SETUP_GUIDANCE =
+  'Install Claude Code first: https://code.claude.com/docs/en/setup';
+
+function officialClaudeInstallerCommandDescription() {
+  if (process.platform === 'win32') {
+    return 'powershell -NoProfile -Command "irm https://claude.ai/install.ps1 | iex"';
+  }
+  return 'bash -c "curl -fsSL https://claude.ai/install.sh | bash"';
+}
+
+function runOfficialClaudeInstaller() {
+  if (process.platform === 'win32') {
+    spawnSync(
+      'powershell.exe',
+      ['-NoProfile', '-Command', 'irm https://claude.ai/install.ps1 | iex'],
+      { stdio: 'inherit', windowsHide: true },
+    );
+  } else {
+    spawnSync('bash', ['-c', 'curl -fsSL https://claude.ai/install.sh | bash'], {
+      stdio: 'inherit',
+    });
+  }
+}
+
+function askInstallClaude() {
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(
+      'Claude Code CLI not found. Install it now with the official installer? (y/N) ',
+      (answer) => {
+        rl.close();
+        const a = answer.trim().toLowerCase();
+        resolve(a === 'y' || a === 'yes');
+      },
+    );
+  });
+}
+
+async function ensureClaudeInstalled(dryRun = false) {
+  const claudePath = resolveClaudeExecutable();
+  if (claudePath) {
+    if (dryRun) console.log(`[dry-run] Claude Code detected at ${claudePath}`);
+    return;
+  }
+
+  if (dryRun) {
+    const cmd = officialClaudeInstallerCommandDescription();
+    console.log(
+      `[dry-run] Claude Code NOT found — would prompt to install via the official installer (${cmd})`,
+    );
+    return;
+  }
+
+  const interactive = process.stdin.isTTY && !process.env.CI;
+
+  if (!interactive) {
+    console.log(CLAUDE_SETUP_GUIDANCE);
+    return;
+  }
+
+  const yes = await askInstallClaude();
+  if (yes) {
+    runOfficialClaudeInstaller();
+    if (resolveClaudeExecutable()) {
+      console.log('✓ Claude Code detected.');
+      return;
+    }
+    console.log(
+      "✓ Claude Code installed — open a NEW terminal so 'claude' is on PATH, then start Claude Code (mixdog is being registered now).",
+    );
+    return;
+  }
+
+  console.log(CLAUDE_SETUP_GUIDANCE);
+}
+
+const WIZARD_STEP_LABELS = [
+  'Address form',
+  'Discord bot token',
+  'Voice transcription',
+  'Webhook receiver',
+  'Provider API keys',
+  'Model presets',
+  'Role → preset mapping',
+  'Search backend',
+  'Explorer maintenance preset',
+];
+
+function logDryRunWizard() {
+  console.log('[dry-run] would run the setup wizard (9 steps):');
+  for (let i = 0; i < WIZARD_STEP_LABELS.length; i += 1) {
+    console.log(`[dry-run]   ${i + 1}. ${WIZARD_STEP_LABELS[i]}`);
+  }
+}
+
+export async function runInstall() {
+  const dryRun =
+    process.argv.includes('--dry-run') || process.env.MIXDOG_SETUP_DRY_RUN === '1';
+
+  if (dryRun) {
+    console.log('[dry-run] mixdog install preview — no files, prompts, or installs');
+  }
+
+  await ensureClaudeInstalled(dryRun);
+  registerPluginInSettings(dryRun);
 
   // npx / node setup/install.mjs runs outside Claude Code — config.mjs needs a data dir.
-  process.env.CLAUDE_PLUGIN_DATA = join(
-    homedir(),
-    '.claude',
-    'plugins',
-    'data',
-    'mixdog-trib-plugin',
-  );
+  const pluginData = process.env.CLAUDE_PLUGIN_DATA;
+  const dataDir =
+    pluginData && String(pluginData).trim() ? String(pluginData).trim() : defaultPluginDataDir();
+  if (!dryRun && (!pluginData || !String(pluginData).trim())) {
+    process.env.CLAUDE_PLUGIN_DATA = defaultPluginDataDir();
+  }
+
+  if (dryRun) {
+    logDryRunWizard();
+  } else {
+    const { runSetupWizard } = await import('./wizard.mjs');
+    await runSetupWizard();
+  }
+
+  await prewarmRuntimeDepsBestEffort(dryRun, dataDir);
+
+  if (!dryRun) maybeStarNudge();
+}
+
+async function prewarmRuntimeDepsBestEffort(dryRun = false, dataDirOverride = null) {
+  const dataDir = dataDirOverride || process.env.CLAUDE_PLUGIN_DATA || defaultPluginDataDir();
+  if (dryRun) {
+    console.log(
+      `[dry-run] would prewarm runtime deps (bun install into ${join(dataDir, '.deps')})`,
+    );
+    return;
+  }
+
+  const spinner = createSpinner('Installing runtime dependencies…');
+  try {
+    const pluginRoot = join(dirname(fileURLToPath(import.meta.url)), '..');
+    mkdirSync(dataDir, { recursive: true });
+
+    const { resolveBun, installBunViaNpm } = await import('../scripts/resolve-bun.mjs');
+    const { ensureRuntimeDeps, resolveNmWithRequiredDeps } = await import('../scripts/ensure-deps.mjs');
 
-  const { runSetupWizard } = await import('./wizard.mjs');
-  await runSetupWizard();
+    let bunPath = resolveBun(pluginRoot);
+    if (!bunPath) {
+      installBunViaNpm(pluginRoot, { fatal: false });
+      bunPath = resolveBun(pluginRoot);
+    }
+    if (!bunPath) {
+      spinner.stop('bun unavailable — will install on first launch', false);
+      return;
+    }
+    const seedNm = resolveNmWithRequiredDeps(pluginRoot) || undefined;
 
-  maybeStarNudge();
+    const result = ensureRuntimeDeps({
+      dataDir,
+      pluginRoot,
+      bunPath,
+      seedNm,
+      logPrefix: '[setup]',
+      installStdio: 'pipe',
+    });
+    if (result?.satisfied) {
+      spinner.stop('prewarmed (first launch should skip bun install)', true);
+    } else {
+      spinner.stop(`will install on first launch (${result?.reason || 'prewarm did not complete'})`, false);
+    }
+  } catch (err) {
+    spinner.stop(
+      `prewarm skipped — ${err?.message || 'first MCP launch may run bun install'}`,
+      false,
+    );
+  }
 }
 
 // Non-blocking, opt-in star nudge. Only on a real interactive terminal — never
@@ -134,7 +318,21 @@ function openRepo() {
   }
 }
 
-main().catch((err) => {
-  console.error(err?.stack || err?.message || String(err));
-  process.exit(1);
-});
+function isInstallerEntry() {
+  const entry = process.argv[1];
+  if (!entry) return false;
+  try {
+    const self = realpathSync(fileURLToPath(import.meta.url));
+    const invoked = realpathSync(entry);
+    return self === invoked;
+  } catch {
+    return false;
+  }
+}
+
+if (isInstallerEntry()) {
+  runInstall().catch((err) => {
+    console.error(err?.stack || err?.message || String(err));
+    process.exit(1);
+  });
+}

package/setup/locate-claude.mjs

@@ -0,0 +1,38 @@
+// locate-claude.mjs — shared PATH scan for the Claude Code CLI executable.
+
+import { execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+export function resolveClaudeExecutable() {
+  const win32 = process.platform === 'win32';
+  try {
+    const cmd = win32 ? 'where' : 'which';
+    const out = execFileSync(cmd, ['claude'], { encoding: 'utf8', windowsHide: true }).trim();
+    const first = out.split(/\r?\n/).map((l) => l.trim()).find(Boolean);
+    if (first && existsSync(first)) return first;
+  } catch { /* PATH scan */ }
+
+  const pathSep = win32 ? ';' : ':';
+  const dirs = String(process.env.PATH || '').split(pathSep).filter(Boolean);
+  const pathext = win32
+    ? String(process.env.PATHEXT || '.EXE;.CMD;.BAT').split(';').map((e) => e.toLowerCase())
+    : [''];
+  const bases = win32 ? ['claude'] : ['claude'];
+  for (const dir of dirs) {
+    for (const base of bases) {
+      if (win32) {
+        for (const ext of pathext) {
+          const candidate = join(dir, base + ext);
+          if (existsSync(candidate)) return candidate;
+        }
+        const bare = join(dir, base);
+        if (existsSync(bare)) return bare;
+      } else {
+        const candidate = join(dir, base);
+        if (existsSync(candidate)) return candidate;
+      }
+    }
+  }
+  return null;
+}