@vercel/cli-support 65.11.0 → 65.12.0-snapshot-801db9d533c3

package/dist/vc.js

@@ -1,645 +1,67 @@
 #!/usr/bin/env node
 /* biome-ignore-all lint/suspicious/noConsole: CLI entry point */
+// The JS CLI's entry point (dist/vc.js). @vercel/cli-support ships it, and the
+// vercel launcher (src/launcher.js) imports it when the native binary can't
+// run. The native binary's pkg.js enters it too, and a repository checkout
+// runs it directly.
+//
 // This shim defers loading the real module until the compile cache is enabled.
 // https://nodejs.org/api/module.html#moduleenablecompilecachecachedir
 // enableCompileCache was added in Node.js 22.8.0, so we need to handle older versions.
+import { sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
 const entryAt = performance.now();
-Reflect.set(globalThis, Symbol.for('vercel.cli.entry-at'), entryAt);
-const startupTimings = process.env.VERCEL_TELEMETRY_DISABLED
-  ? undefined
-  : {
-      marks: [
-        {
-          phase: 'compile_cache',
-          timestamp: Number(process.hrtime.bigint() / BigInt(1000)),
-        },
-      ],
-    };
-Reflect.set(
-  globalThis,
-  Symbol.for('vercel.cli.startup-timings'),
-  startupTimings
-);
+// The launcher sets these when it imports this file, so its own startup time
+// counts too.
+const ENTRY_AT = Symbol.for('vercel.cli.entry-at');
+const STARTUP_TIMINGS = Symbol.for('vercel.cli.startup-timings');
+const launched = ENTRY_AT in globalThis;
+if (!launched) Reflect.set(globalThis, ENTRY_AT, entryAt);
+const startupTimings = launched
+  ? globalThis[STARTUP_TIMINGS]
+  : process.env.VERCEL_TELEMETRY_DISABLED
+    ? undefined
+    : {
+        marks: [
+          {
+            phase: 'compile_cache',
+            timestamp: Number(process.hrtime.bigint() / BigInt(1000)),
+          },
+        ],
+      };
+if (!launched) Reflect.set(globalThis, STARTUP_TIMINGS, startupTimings);
 function markStartup(phase) {
   startupTimings?.marks.push({
     phase,
     timestamp: Number(process.hrtime.bigint() / BigInt(1000)),
   });
 }
-try {
-  const { enableCompileCache } = await import('node:module');
-  if (enableCompileCache) {
-    enableCompileCache();
-  }
-} catch {}
-markStartup('launcher');
-
-// Run the one package this platform maps to: the native binary on macOS, Linux
-// and Windows x64/arm64 (downloaded once into the CLI cache when the install
-// skipped it), @vercel/cli-support everywhere else. This package's own JS CLI
-// (./index.js) is only a fallback, recorded in telemetry.
-import { spawnSync } from 'node:child_process';
-import {
-  accessSync,
-  constants as fsConstants,
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  statSync,
-  writeFileSync,
-} from 'node:fs';
-import { dirname, join, resolve, sep } from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-// Whether this package still ships its own JS CLI (dist/index.js), the fallback
-// when the native binary can't run. Without it, every fallback below becomes an
-// error with a fix instead, so dropping dist/index.js from the package needs no
-// launcher change.
-const jsCliAvailable = existsSync(join(__dirname, 'index.js'));
-// At most one launcher warning per run.
-let warnedThisRun = false;
-
-// Keep in sync with packages/vc-native/scripts/platforms.mjs.
-const NATIVE_TARGETS = [
-  'darwin-arm64',
-  'darwin-x64',
-  'linux-arm64',
-  'linux-arm64-musl',
-  'linux-x64',
-  'linux-x64-musl',
-  'win32-arm64',
-  'win32-x64',
-];
-
-function isWindowsTarget(target) {
-  return target.startsWith('win32-');
-}
-
-function binaryName(target) {
-  return isWindowsTarget(target) ? 'vercel.exe' : 'vercel';
-}
-
-// musl's `ldd` names itself. npm and pnpm skip the other libc's package via
-// its `libc` field, but Yarn classic installs both, so the launcher must pick
-// one.
-// Detected the way npm does (npm-install-checks), so the launcher picks the
-// package npm installed: the ldd script names its libc, and Node's report
-// covers systems without ldd, such as minimal container images.
-let musl;
-function isMusl() {
-  if (musl !== undefined) return musl;
-  try {
-    const ldd = readFileSync('/usr/bin/ldd', 'utf8');
-    if (ldd.includes('musl')) return (musl = true);
-    if (ldd.includes('GNU C Library')) return (musl = false);
-  } catch {}
+if (!launched) {
   try {
-    const excludeNetwork = process.report.excludeNetwork;
-    process.report.excludeNetwork = true;
-    const report = process.report.getReport();
-    process.report.excludeNetwork = excludeNetwork;
-    musl =
-      !report.header?.glibcVersionRuntime &&
-      Array.isArray(report.sharedObjects) &&
-      report.sharedObjects.some(
-        file => file.includes('libc.musl-') || file.includes('ld-musl-')
-      );
-  } catch {
-    musl = false;
-  }
-  return musl;
-}
-
-function platformTarget() {
-  const target = `${process.platform}-${process.arch}`;
-  return process.platform === 'linux' && isMusl() ? `${target}-musl` : target;
-}
-
-// Walk up from this install's own tree. `require.resolve()` is not used
-// because it falls back to NODE_PATH and the global folders even when `paths`
-// is given.
-function findPackage(name) {
-  let dir = __dirname;
-  while (true) {
-    const pkgDir = join(dir, 'node_modules', name);
-    if (existsSync(join(pkgDir, 'package.json'))) return pkgDir;
-    const parent = dirname(dir);
-    if (parent === dir) return null;
-    dir = parent;
-  }
-}
-
-// The package this platform maps to: a native target or `cli-support`.
-function mappedTarget() {
-  const target = platformTarget();
-  return NATIVE_TARGETS.includes(target) ? target : 'cli-support';
-}
-
-function resolveTarget() {
-  const target = mappedTarget();
-  if (target === 'cli-support') {
-    const pkgDir = findPackage('@vercel/cli-support');
-    const entry = pkgDir && join(pkgDir, 'dist', 'index.js');
-    return {
-      target: 'cli-support',
-      entry: entry && existsSync(entry) && entry,
-    };
-  }
-  const pkgDir = findPackage(`@vercel/vc-native-${target}`);
-  const name = binaryName(target);
-  const bin =
-    pkgDir &&
-    isOwnVersion(pkgDir) &&
-    [join(pkgDir, 'bin', name), join(pkgDir, name)].find(existsSync);
-  return { target, bin };
-}
-// The lookup walks up through parent node_modules, so it can reach a package
-// hoisted for another `vercel` in the same tree. Treat a different version as
-// missing, so the launcher downloads this version instead of running another.
-// Unreadable versions don't block: the optional dependency pins it exactly.
-function isOwnVersion(pkgDir) {
-  const own = readOwnPackage()?.version;
-  try {
-    const found = JSON.parse(
-      readFileSync(join(pkgDir, 'package.json'), 'utf8')
-    ).version;
-    return (
-      typeof own !== 'string' || typeof found !== 'string' || found === own
-    );
-  } catch {
-    return true;
-  }
-}
-
-// The package this launcher belongs to: `vercel` or `@vercel/cli-support`.
-let ownPackage;
-function readOwnPackage() {
-  if (ownPackage === undefined) {
-    try {
-      ownPackage = JSON.parse(
-        readFileSync(join(__dirname, '..', 'package.json'))
-      );
-    } catch {
-      ownPackage = null;
+    const { enableCompileCache } = await import('node:module');
+    if (enableCompileCache) {
+      enableCompileCache();
     }
-  }
-  return ownPackage;
-}
-
-// This file also ships in @vercel/cli-support, which is its own JS CLI.
-function isCliSupport() {
-  return readOwnPackage()?.name === '@vercel/cli-support';
-}
-
-// Flags that make stdout a JSON document, so stderr must stay quiet.
-function wantsJsonOutput(argv) {
-  const formatIndex = argv.indexOf('--format');
-  return (
-    argv.some(arg => arg === '--json' || arg === '--format=json') ||
-    (formatIndex !== -1 && argv[formatIndex + 1] === 'json')
-  );
-}
-
-// When the native package is missing (an install that skipped optional
-// dependencies, or one made before npm had the package), download the binary
-// for this exact version into the CLI cache, once. Each version has its own
-// directory, so a binary is written once and never replaced.
-//
-// After a failed attempt, wait before trying again: 15 minutes after the
-// first failure, 2 hours after the second, then a day. The `download-failed`
-// marker holds the number of failures; its age is the time since the last.
-const DOWNLOAD_RETRY_AFTER = [
-  { ms: 15 * 60 * 1000, label: '15 minutes' },
-  { ms: 2 * 60 * 60 * 1000, label: '2 hours' },
-  { ms: 24 * 60 * 60 * 1000, label: '24 hours' },
-];
-
-function retryAfter(failures) {
-  return DOWNLOAD_RETRY_AFTER[
-    Math.min(Math.max(failures, 1), DOWNLOAD_RETRY_AFTER.length) - 1
-  ];
-}
-
-/** The failures recorded in the marker, and when the last one happened. */
-function readFailedStamp(stamp) {
-  try {
-    const { mtimeMs } = statSync(stamp);
-    // Earlier releases wrote an empty marker: one failure.
-    const count = Number.parseInt(readFileSync(stamp, 'utf8'), 10);
-    return { at: mtimeMs, count: count > 0 ? count : 1 };
-  } catch {
-    return undefined;
-  }
-}
-
-async function nativeCacheDir(target) {
-  const version = readOwnPackage()?.version;
-  if (
-    typeof version !== 'string' ||
-    !/^\d+\.\d+\.\d+(?:-[\w.-]+)?(?:\+[\w.-]+)?$/.test(version)
-  ) {
-    return null;
-  }
-  try {
-    const config = await import('@vercel/cli-config/paths');
-    return {
-      version,
-      dir: join(config.getCachePath(), 'native', version, target),
-    };
-  } catch {
-    return null;
-  }
-}
-
-async function fetchNativeBinary(target) {
-  // Only an installed package uses the download. A repository checkout
-  // (packages/cli/dist/vc.js) runs its own JS CLI, so local changes and tests
-  // never run a published binary instead.
-  // Yarn PnP and Deno installs have no node_modules either.
-  if (!__dirname.split(sep).includes('node_modules')) {
-    return { reason: 'not_in_node_modules' };
-  }
-  const cache = await nativeCacheDir(target);
-  if (!cache) return { reason: 'target_missing' };
-  const bin = join(cache.dir, binaryName(target));
-  if (existsSync(bin)) return { bin, source: 'cache' };
-
-  // Tests only: never reach the real registry.
-  if (process.env.__VERCEL_NATIVE_DOWNLOAD === '0') {
-    return { reason: 'target_missing' };
-  }
-  // Without a writable cache the binary has nowhere to go and a failure can't
-  // be recorded, so don't try: the JS CLI runs with the once-a-day warning.
-  // Reported apart from target_missing: a sandbox that blocks writes to the
-  // cache directory looks like this.
-  try {
-    mkdirSync(cache.dir, { recursive: true });
-    accessSync(cache.dir, fsConstants.W_OK);
-  } catch {
-    return { reason: 'cache_unwritable', cacheDir: cache.dir };
-  }
-  // The wait only makes sense while the JS CLI can run the command meanwhile.
-  // Without it, every run tries again.
-  const failedStamp = join(cache.dir, 'download-failed');
-  const previous = readFailedStamp(failedStamp);
-  if (
-    jsCliAvailable &&
-    previous &&
-    Date.now() - previous.at < retryAfter(previous.count).ms
-  ) {
-    return { reason: 'download_failed' };
-  }
-
-  const quiet = wantsJsonOutput(process.argv.slice(2));
-  // A failed attempt shows in the JS CLI's trace as its own startup span.
-  markStartup('native_download');
-  try {
-    const { downloadNativeBinary } = await import('./native-download.js');
-    const downloaded = await downloadNativeBinary({
-      target,
-      version: cache.version,
-      directory: cache.dir,
-      log: quiet ? undefined : line => console.error(line),
-      retryTimeouts: jsCliAvailable,
-    });
-    return {
-      bin: downloaded.bin,
-      source: 'download',
-      attempts: downloaded.attempts,
-    };
-  } catch (error) {
-    markStartup('launcher');
-    const failures = (previous?.count ?? 0) + 1;
-    try {
-      writeFileSync(failedStamp, String(failures));
-    } catch {}
-    const known = error?.name === 'NativeDownloadError';
-    const detail = known ? error.detail : 'unexpected error';
-    // Without the JS CLI, the launcher reports this as an error instead.
-    if (!quiet && jsCliAvailable) {
-      console.error(
-        `! Couldn't download the Vercel CLI binary (${detail}), so Node.js is running this command. The CLI tries again in ${retryAfter(failures).label}.\n${feedbackHint()}`
-      );
-      warnedThisRun = true;
-    }
-    // Only a run that tried reports why, so telemetry can tell attempts from
-    // the runs that skip downloading while they wait.
-    return {
-      reason: 'download_failed',
-      detail,
-      kind: known ? error.kind : 'other',
-      timeout: known ? error.timeout : undefined,
-      progress: known ? error.progress : undefined,
-      downloadFailure: {
-        downloadError: known ? error.kind : 'other',
-        downloadAttempts: String(known ? error.attempts : 1),
-        downloadFailures: failures >= 3 ? '3_or_more' : String(failures),
-        ...(known && error.phase && { downloadPhase: error.phase }),
-        ...(known && error.code && { downloadCode: error.code }),
-        ...(known && error.timeout && { downloadTimeout: error.timeout }),
-        ...(known && error.progress && { downloadProgress: error.progress }),
-        ...(known &&
-          error.environment && {
-            downloadProxy: error.environment.proxy ? 'true' : 'false',
-            npmRegistry: error.environment.npmRegistry,
-            npmProxy: error.environment.npmProxy ? 'true' : 'false',
-            npmTls: error.environment.npmTls ? 'true' : 'false',
-          }),
-      },
-    };
-  }
-}
-
-// The native binary is the default, but while this package ships its JS CLI
-// it still honors an explicit opt-out: VERCEL_CLI_USE_NATIVE_BINARY, then a
-// persisted `useNativeBinary` preference. Returns where the opt-out came from
-// (`env` or `config`), or false. Any failure to read config counts as no
-// preference.
-async function nativeBinaryOptOut() {
-  const envOverride = process.env.VERCEL_CLI_USE_NATIVE_BINARY;
-  if (envOverride === '0' || envOverride === 'false') return 'env';
-  if (envOverride === '1' || envOverride === 'true') return false;
-  try {
-    // Zod-free subpath to avoid loading zod + schemas on this hot path.
-    const config = await import('@vercel/cli-config/paths');
-    const argDir = globalConfigDirFromArgv();
-    const configDir = argDir
-      ? resolve(process.cwd(), argDir)
-      : config.getGlobalPathConfig();
-    return config.readGlobalConfigFlag(
-      config.getConfigFilePath(configDir),
-      'useNativeBinary'
-    ) === false
-      ? 'config'
-      : false;
-  } catch {
-    return false;
-  }
-}
-
-// Ctrl+C (and Ctrl+Break on Windows) also reach the binary, which handles
-// them. The launcher waits for it instead of exiting: on Windows, Node.js
-// exiting would also kill the binary before it could clean up.
-const CONSOLE_SIGNALS =
-  process.platform === 'win32' ? ['SIGINT', 'SIGBREAK'] : ['SIGINT'];
-function waitForNative() {}
-
-function optOutSetting(source) {
-  return source === 'env'
-    ? `VERCEL_CLI_USE_NATIVE_BINARY=${process.env.VERCEL_CLI_USE_NATIVE_BINARY}`
-    : '"useNativeBinary": false in the Vercel CLI config';
-}
-
-// Agents can be told to report what they run into, so every JS CLI fallback
-// warning ends with the vercel feedback command on its own line, like other
-// recovery commands. It doesn't prescribe a note: <DESCRIPTION> is for whoever
-// reads it to describe what they're seeing.
-const FALLBACK_FEEDBACK =
-  "A future release of vercel removes this fallback. If this keeps happening, describe what you're seeing with:";
-
-function feedbackHint(lead = FALLBACK_FEEDBACK) {
-  return `  ${lead}\n    vercel feedback "<DESCRIPTION>"`;
-}
-
-// A warning about the JS CLI fallback, at most once a day. Agents often run
-// non-interactively and need to see it; only --json skips it.
-async function warnOncePerDay(stampName, message) {
-  if (warnedThisRun) return;
-  if (wantsJsonOutput(process.argv.slice(2))) return;
-  const dir = await stampDirectory();
-  const stamp = dir && join(dir, stampName);
-  try {
-    if (stamp && Date.now() - statSync(stamp).mtimeMs < DAY_MS) return;
   } catch {}
-  console.error(message);
-  warnedThisRun = true;
-  if (stamp) {
-    try {
-      writeFileSync(stamp, '');
-    } catch {}
-  }
-}
-
-// Where once-a-day stamps go: the global config directory, created if it's
-// missing (as on a fresh CI machine), else the CLI's cache directory. Both are
-// under the user's home, never a shared directory such as the system temp
-// directory, where another user could plant a symlink for the stamp write to
-// follow. With neither writable (a sandbox blocking writes to home), there is
-// no stamp and the warning shows on every run.
-async function stampDirectory() {
-  let config;
-  try {
-    config = await import('@vercel/cli-config/paths');
-  } catch {
-    return undefined;
-  }
-  const argDir = globalConfigDirFromArgv();
-  const candidates = [
-    () =>
-      argDir ? resolve(process.cwd(), argDir) : config.getGlobalPathConfig(),
-    () => config.getCachePath(),
-  ];
-  for (const candidate of candidates) {
-    try {
-      const dir = candidate();
-      mkdirSync(dir, { recursive: true });
-      accessSync(dir, fsConstants.W_OK);
-      return dir;
-    } catch {}
-  }
-  return undefined;
+  markStartup('launcher');
 }
 
-const DAY_MS = 24 * 60 * 60 * 1000;
-
-// Read by src/index.ts and reported in telemetry. Inside the native binary,
-// pkg.js sets it to `native` before re-entering this file with
-// VERCEL_VC_NATIVE=1.
+// Read by src/index.ts and reported in telemetry. pkg.js (the native binary)
+// and the vercel launcher set it before this file runs; otherwise this file
+// was run directly: by a process the native binary spawned, or from a
+// repository checkout.
 const LAUNCH = Symbol.for('vercel.cli.launch');
-let launch;
-let cliSupportEntry;
-// Why the JS CLI would run, for the warning or, without it, the error.
-let fallback;
-if (
-  process.env.VERCEL_VC_NATIVE === '1' &&
-  globalThis[LAUNCH]?.runtime === 'native'
-) {
-  // Inside the native binary: pkg.js set the marker and re-entered this file.
-} else if (process.env.VERCEL_VC_NATIVE === '1' && jsCliAvailable) {
-  // Not the native binary: a process it spawned (a build script, a dev
-  // command) inherited VERCEL_VC_NATIVE=1 and runs this package's JS CLI.
-  // Without the JS CLI, it resolves and runs the binary like any launch.
-  launch = {
-    runtime: 'dist',
-    target: mappedTarget(),
-    reason: 'inherited_native_env',
-  };
-  globalThis[LAUNCH] = launch;
-} else {
-  const resolved = resolveTarget();
-  let optedOut = false;
-  let missingReason = 'target_missing';
-  let downloadFailure;
-  // Never download for @vercel/cli-support (the build container runs it on
-  // Linux).
-  const nativeTarget = resolved.target !== 'cli-support' && !isCliSupport();
-  if (resolved.bin || nativeTarget) {
-    const optOut = await nativeBinaryOptOut();
-    if (optOut && jsCliAvailable) {
-      optedOut = true;
-      await warnOncePerDay(
-        '.native-opt-out-warned',
-        `! ${optOutSetting(optOut)} will stop working in a future release, which removes the Node.js CLI from the vercel package.\n${feedbackHint(
-          'If you still need the Node.js CLI, tell us why with:'
-        )}`
-      );
-    } else if (optOut) {
-      await warnOncePerDay(
-        '.native-opt-out-warned',
-        `! ${optOutSetting(optOut)} no longer applies: this version of vercel only runs the native binary.`
-      );
-    }
-  }
-  if (!resolved.bin && nativeTarget && !optedOut) {
-    const fetched = await fetchNativeBinary(resolved.target);
-    resolved.bin = fetched.bin;
-    resolved.source = fetched.source;
-    resolved.attempts = fetched.attempts;
-    missingReason = fetched.reason ?? missingReason;
-    downloadFailure = fetched.downloadFailure;
-    fallback = fetched;
-  }
-  if (optedOut) {
-    launch = { runtime: 'dist', target: resolved.target, reason: 'opt_out' };
-  } else if (resolved.bin) {
-    // Internal worker arguments intentionally trampoline too. The packaged
-    // native binary sets VERCEL_VC_NATIVE=1 in pkg.js and re-enters this file,
-    // where the worker branch below handles the request.
-    for (const signal of CONSOLE_SIGNALS) process.on(signal, waitForNative);
-    const r = spawnSync(resolved.bin, process.argv.slice(2), {
-      stdio: 'inherit',
-      windowsHide: true,
-      env: {
-        ...process.env,
-        VERCEL_VC_NATIVE: '1',
-        // Upgrades belong to the vercel package, not its native runtime
-        // dependency. Always replace an inherited value with this launcher's
-        // own entrypoint.
-        VERCEL_CLI_PACKAGE_ENTRYPOINT: fileURLToPath(import.meta.url),
-        VERCEL_CLI_PACKAGE_EXECUTABLE: resolved.bin,
-        // Reported in telemetry. pkg.js reads it and removes it, so the
-        // binary's child processes don't inherit it.
-        ...(resolved.source && {
-          __VERCEL_CLI_NATIVE_SOURCE: resolved.source,
-        }),
-        ...(resolved.attempts && {
-          __VERCEL_CLI_NATIVE_DOWNLOAD_ATTEMPTS: String(resolved.attempts),
-        }),
-      },
-    });
-    // Restores the default handling, so re-raising a signal below terminates
-    // this process, and the JS CLI installs its own handlers if it runs.
-    for (const signal of CONSOLE_SIGNALS) process.off(signal, waitForNative);
-    // Fall back only when the binary never started, so no command code has
-    // run. spawnSync sets no timeout or output buffer here, so any error means
-    // that, such as ENOENT, EACCES or ENOEXEC, or EPERM, EFTYPE or UNKNOWN when
-    // Windows blocks the binary (AppLocker, WDAC, Smart App Control,
-    // antivirus). Never fall back on an exit status: a loader failure (e.g.
-    // glibc mismatch) and a command's own failure are indistinguishable, and
-    // retrying a command in Node.js could repeat remote mutations.
-    if (!r.error) {
-      if (r.signal) {
-        try {
-          process.kill(process.pid, r.signal);
-        } catch {}
-      }
-      process.exit(r.status ?? 1);
-    }
-    launch = {
-      runtime: 'dist',
-      target: resolved.target,
-      reason: r.error.code ?? 'UNKNOWN',
-    };
-    // `bin` marks a spawn failure, whatever its error code.
-    fallback = { bin: resolved.bin };
-  } else if (resolved.entry || isCliSupport()) {
-    launch = { runtime: 'cli-support' };
-  } else {
-    launch = {
-      runtime: 'dist',
-      target: resolved.target,
-      reason: missingReason,
-      ...downloadFailure,
-    };
-  }
-  globalThis[LAUNCH] = launch;
-  cliSupportEntry = resolved.entry;
-}
-
-// Without its JS CLI, this package can't run the command: report why and how
-// to fix it, before loading anything else.
-if (launch?.runtime === 'dist' && !jsCliAvailable) {
-  let reportLauncherFailure;
-  try {
-    ({ reportLauncherFailure } = await import('./launcher-errors.js'));
-  } catch {
-    // An incomplete package: still fail with the reason and the fix.
-    console.error(
-      `✗ Couldn't start Vercel CLI (${launch.reason}). Reinstall vercel without omitting optional dependencies.`
-    );
-    process.exit(1);
-  }
-  process.exit(
-    reportLauncherFailure({
-      reason: launch.reason,
-      target: launch.target,
-      platform: platformTarget(),
-      version: readOwnPackage()?.version,
-      detail: fallback?.detail,
-      kind: fallback?.kind,
-      timeout: fallback?.timeout,
-      progress: fallback?.progress,
-      cacheDir: fallback?.cacheDir,
-      bin: fallback?.bin,
-      json: wantsJsonOutput(process.argv.slice(2)),
-    })
-  );
-}
-
-// While it ships, the JS CLI fallback warns once a day that it's going away,
-// with the fix and the command to report it. A fresh download failure already
-// warned, and warnDeprecatedArch() covers Linux architectures without a
-// native binary.
-if (launch?.runtime === 'dist') {
-  const reinstall = 'Reinstall vercel without omitting optional dependencies.';
-  const deprecatedArch =
-    process.platform === 'linux' && !['x64', 'arm64'].includes(process.arch);
-  const platform = platformTarget();
-  let message;
-  if (launch.reason === 'target_missing' && launch.target !== 'cli-support') {
-    const pkg = `@vercel/vc-native-${launch.target}`;
-    message = `! ${pkg} isn't installed, so Node.js is running this command. ${reinstall}\n${feedbackHint()}`;
-  } else if (
-    launch.reason === 'target_missing' &&
-    !['darwin', 'linux'].includes(process.platform)
-  ) {
-    // FreeBSD and every other OS without native binaries install
-    // @vercel/cli-support, so it was skipped here, not unavailable.
-    message = `! @vercel/cli-support isn't installed, so Node.js is running this command. ${reinstall}\n${feedbackHint()}`;
-  } else if (launch.reason === 'target_missing' && !deprecatedArch) {
-    message = `! Vercel CLI has no native binary for ${platform}, so Node.js is running this command.\n${feedbackHint(
-      'A future release of vercel removes this fallback. If you need Vercel CLI on this platform, tell us with:'
-    )}`;
-  } else if (launch.reason === 'download_failed') {
-    message = `! The Vercel CLI binary for ${launch.target} couldn't be downloaded, so Node.js is running this command. Allow access to registry.npmjs.org, or ${reinstall.charAt(0).toLowerCase()}${reinstall.slice(1)}\n${feedbackHint()}`;
-  } else if (launch.reason === 'cache_unwritable') {
-    message = `! The Vercel CLI binary for ${launch.target} can't be downloaded because ${fallback?.cacheDir ?? 'the cache directory'} isn't writable, so Node.js is running this command. Make it writable, or set XDG_CACHE_HOME to a writable directory.\n${feedbackHint()}`;
-  } else if (fallback?.bin) {
-    message = `! The native Vercel CLI binary could not start (${launch.reason}), so Node.js is running this command. ${reinstall}\n${feedbackHint()}`;
-  }
-  if (message) await warnOncePerDay('.js-fallback-warned', message);
+if (globalThis[LAUNCH] === undefined) {
+  const notInNodeModules = !fileURLToPath(import.meta.url)
+    .split(sep)
+    .includes('node_modules');
+  globalThis[LAUNCH] =
+    process.env.VERCEL_VC_NATIVE === '1'
+      ? { runtime: 'cli-support', reason: 'inherited_native_env' }
+      : notInNodeModules
+        ? { runtime: 'cli-support', reason: 'not_in_node_modules' }
+        : { runtime: 'cli-support' };
 }
 
 if (process.argv[2] === '--internal-build-worker') {
@@ -689,58 +111,6 @@ if (process.argv[2] === '--internal-build-worker') {
   process.exit(process.exitCode ?? 0);
 }
 
-// Read `--global-config`/`-Q` without loading the full CLI arg parser.
-function globalConfigDirFromArgv() {
-  const argv = process.argv.slice(2);
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i];
-    if (arg === '--global-config' || arg === '-Q') {
-      return argv[i + 1];
-    }
-    if (arg.startsWith('--global-config=')) {
-      return arg.slice('--global-config='.length);
-    }
-  }
-  return undefined;
-}
-
-// Linux on anything but x64/arm64 has no native binary, and will lose the JS
-// CLI from `vercel` itself in a future release.
-async function warnDeprecatedArch() {
-  if (
-    process.platform !== 'linux' ||
-    ['x64', 'arm64'].includes(process.arch) ||
-    process.env.VERCEL_VC_NATIVE === '1'
-  ) {
-    return;
-  }
-  // Agents often run non-interactively and need to see it; only --json skips it.
-  if (wantsJsonOutput(process.argv.slice(2))) return;
-  let stamp;
-  try {
-    const config = await import('@vercel/cli-config/paths');
-    const argDir = globalConfigDirFromArgv();
-    const configDir = argDir
-      ? resolve(process.cwd(), argDir)
-      : config.getGlobalPathConfig();
-    if (existsSync(configDir)) {
-      stamp = join(configDir, '.arch-deprecation-warned');
-      if (Date.now() - statSync(stamp).mtimeMs < 24 * 60 * 60 * 1000) return;
-    }
-  } catch {}
-  const target = `${process.platform}-${process.arch}`;
-  console.error(
-    `! Support for ${target} will be removed from the vercel package in a future release.\n${feedbackHint('If you still need it, tell us with:')}`
-  );
-  if (stamp) {
-    try {
-      writeFileSync(stamp, '');
-    } catch {}
-  }
-}
-
-await warnDeprecatedArch();
-
 // Fast path for --version to avoid loading the entire CLI
 if (
   process.argv.length === 3 &&
@@ -785,26 +155,8 @@ if (
 
 markStartup('dependencies');
 try {
-  await (cliSupportEntry
-    ? import(pathToFileURL(cliSupportEntry).href)
-    : import('./index.js'));
+  await import('./index.js');
 } catch (error) {
-  // The mapped package is missing and this package's own JS CLI cannot load
-  // either, so name the package to install.
-  if (
-    launch?.reason === 'target_missing' &&
-    error?.code === 'ERR_MODULE_NOT_FOUND'
-  ) {
-    const pkg =
-      launch.target === 'cli-support'
-        ? '@vercel/cli-support'
-        : `@vercel/vc-native-${launch.target}`;
-    console.error(
-      `Error: ${pkg} is not installed. Reinstall vercel without omitting optional dependencies (for example, npm i -g vercel@latest).`
-    );
-    console.error(error.message);
-    process.exit(1);
-  }
   // Global-config paths are resolved during module initialization, before the
   // command router and its client exist. Report local parser failures without
   // dumping a stack or loading configuration again to construct the error.