@vercel/cli-support 65.9.0 → 65.10.0-snapshot-c80a43d75dc7

package/dist/vc.js

@@ -34,9 +34,9 @@ try {
 } catch {}
 markStartup('launcher');
 
-// Run the one package this platform maps to: the native binary on macOS and
-// Linux x64/arm64 (downloaded once into the CLI cache when the install skipped
-// it), @vercel/cli-support everywhere else. This package's own JS CLI
+// 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 {
@@ -53,8 +53,15 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
-// Keep in sync with packages/vc-native/scripts/platforms.mjs. Windows runs
-// only the Node CLI until its native binaries are signed.
+// 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',
@@ -62,14 +69,47 @@ const NATIVE_TARGETS = [
   '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() {
-  const ldd = spawnSync('ldd', ['--version'], { encoding: 'utf8' });
-  return `${ldd.stdout ?? ''}${ldd.stderr ?? ''}`.includes('musl');
+  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 {}
+  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() {
@@ -108,11 +148,30 @@ function resolveTarget() {
     };
   }
   const pkgDir = findPackage(`@vercel/vc-native-${target}`);
+  const name = binaryName(target);
   const bin =
     pkgDir &&
-    [join(pkgDir, 'bin', 'vercel'), join(pkgDir, 'vercel')].find(existsSync);
+    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;
@@ -147,7 +206,33 @@ function wantsJsonOutput(argv) {
 // 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.
-const DOWNLOAD_RETRY_AFTER_MS = 24 * 60 * 60 * 1000;
+//
+// 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;
@@ -172,12 +257,13 @@ 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: 'target_missing' };
+    return { reason: 'not_in_node_modules' };
   }
   const cache = await nativeCacheDir(target);
   if (!cache) return { reason: 'target_missing' };
-  const bin = join(cache.dir, 'vercel');
+  const bin = join(cache.dir, binaryName(target));
   if (existsSync(bin)) return { bin, source: 'cache' };
 
   // Tests only: never reach the real registry.
@@ -185,53 +271,75 @@ async function fetchNativeBinary(target) {
     return { reason: 'target_missing' };
   }
   // Without a writable cache the binary has nowhere to go and a failure can't
-  // be recorded, so every run would try and warn again. Use the JS CLI quietly.
+  // 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' };
+    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');
-  try {
-    if (Date.now() - statSync(failedStamp).mtimeMs < DOWNLOAD_RETRY_AFTER_MS) {
-      return { reason: 'download_failed' };
-    }
-  } catch {}
+  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: await downloadNativeBinary({
-        target,
-        version: cache.version,
-        directory: cache.dir,
-        log: quiet ? undefined : line => console.error(line),
-      }),
+      bin: downloaded.bin,
       source: 'download',
+      attempts: downloaded.attempts,
     };
   } catch (error) {
     markStartup('launcher');
+    const failures = (previous?.count ?? 0) + 1;
     try {
-      writeFileSync(failedStamp, '');
+      writeFileSync(failedStamp, String(failures));
     } catch {}
     const known = error?.name === 'NativeDownloadError';
-    if (!quiet) {
+    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 (${known ? error.detail : 'unexpected error'}), so Node.js is running this command. The CLI tries again in 24 hours.`
+        `! 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 for 24 hours.
+    // 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',
@@ -244,12 +352,14 @@ async function fetchNativeBinary(target) {
   }
 }
 
-// The native binary is the default, but this release still honors an explicit
-// opt-out: VERCEL_CLI_USE_NATIVE_BINARY, then a persisted `useNativeBinary`
-// preference. Any failure to read config counts as no preference.
-async function isNativeBinaryOptedOut() {
+// 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 true;
+  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.
@@ -258,20 +368,91 @@ async function isNativeBinaryOptedOut() {
     const configDir = argDir
       ? resolve(process.cwd(), argDir)
       : config.getGlobalPathConfig();
-    return (
-      config.readGlobalConfigFlag(
-        config.getConfigFilePath(configDir),
-        'useNativeBinary'
-      ) === false
-    );
+    return config.readGlobalConfigFlag(
+      config.getConfigFilePath(configDir),
+      'useNativeBinary'
+    ) === false
+      ? 'config'
+      : false;
   } catch {
     return false;
   }
 }
 
-// When the OS cannot start the binary at all, no command code has run, so
-// Node.js can safely run the command instead.
-const NATIVE_SPAWN_FALLBACK_CODES = ['ENOENT', 'EACCES', 'ENOEXEC'];
+// 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;
+}
+
+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
@@ -279,42 +460,64 @@ const NATIVE_SPAWN_FALLBACK_CODES = ['ENOENT', 'EACCES', 'ENOEXEC'];
 const LAUNCH = Symbol.for('vercel.cli.launch');
 let launch;
 let cliSupportEntry;
-if (process.env.VERCEL_VC_NATIVE === '1') {
-  if (globalThis[LAUNCH]?.runtime !== 'native') {
-    // Not the native binary: a process it spawned (a build script, a dev
-    // command) inherited VERCEL_VC_NATIVE=1 and ran this package's JS CLI.
-    launch = {
-      runtime: 'dist',
-      target: mappedTarget(),
-      reason: 'inherited_native_env',
-    };
-    globalThis[LAUNCH] = launch;
-  }
+// 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;
-  if (resolved.bin) {
-    optedOut = await isNativeBinaryOptedOut();
-  } else if (resolved.target !== 'cli-support' && !isCliSupport()) {
-    // Never download for an opted-out user or for @vercel/cli-support (the
-    // build container runs it on Linux).
-    optedOut = await isNativeBinaryOptedOut();
-    if (!optedOut) {
-      const fetched = await fetchNativeBinary(resolved.target);
-      resolved.bin = fetched.bin;
-      resolved.source = fetched.source;
-      missingReason = fetched.reason ?? missingReason;
-      downloadFailure = fetched.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,
@@ -331,16 +534,22 @@ if (process.env.VERCEL_VC_NATIVE === '1') {
         ...(resolved.source && {
           __VERCEL_CLI_NATIVE_SOURCE: resolved.source,
         }),
+        ...(resolved.attempts && {
+          __VERCEL_CLI_NATIVE_DOWNLOAD_ATTEMPTS: String(resolved.attempts),
+        }),
       },
     });
-    // Never fall back on an exit status: a loader failure (e.g. glibc
-    // mismatch) and a command's own failure are indistinguishable, and
+    // 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 && NATIVE_SPAWN_FALLBACK_CODES.includes(r.error.code))) {
-      if (r.error) {
-        console.error(r.error.message);
-        process.exit(1);
-      }
+    if (!r.error) {
       if (r.signal) {
         try {
           process.kill(process.pid, r.signal);
@@ -348,10 +557,13 @@ if (process.env.VERCEL_VC_NATIVE === '1') {
       }
       process.exit(r.status ?? 1);
     }
-    console.error(
-      `! The native Vercel CLI binary could not start (${r.error.code}), so Node.js is running this command.`
-    );
-    launch = { runtime: 'dist', target: resolved.target, reason: r.error.code };
+    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 {
@@ -366,6 +578,70 @@ if (process.env.VERCEL_VC_NATIVE === '1') {
   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 (process.argv[2] === '--internal-build-worker') {
   const {
     applyInternalBuildRequest,
@@ -438,15 +714,8 @@ async function warnDeprecatedArch() {
   ) {
     return;
   }
-  const argv = process.argv.slice(2);
-  if (
-    argv.some(arg =>
-      ['--non-interactive', '--non-interactive=true'].includes(arg)
-    ) ||
-    wantsJsonOutput(argv)
-  ) {
-    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');
@@ -461,7 +730,7 @@ async function warnDeprecatedArch() {
   } catch {}
   const target = `${process.platform}-${process.arch}`;
   console.error(
-    `! Support for ${target} will be removed from the vercel package in a future release.`
+    `! 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 {

package/dist/version.mjs

@@ -1,2 +1,2 @@
-export const version = "65.9.0";
+export const version = "65.10.0-snapshot-c80a43d75dc7";
 export const buildLabel = "";