@vercel/cli-support 0.0.0 → 65.4.0

package/dist/runtime-assets/node-preloads/next-dev-websocket.cjs

@@ -0,0 +1,220 @@
+'use strict';
+
+const http = require('node:http');
+const { AsyncLocalStorage } = require('node:async_hooks');
+
+const REQUEST_CONTEXT_SYMBOL = Symbol.for('@vercel/request-context');
+const PATCHED_SYMBOL = Symbol.for('@vercel/next-dev-websocket-shim/patched');
+const UPGRADE_LISTENER_SYMBOL = Symbol.for(
+  '@vercel/next-dev-websocket-shim/upgrade-listener'
+);
+
+if (!globalThis[PATCHED_SYMBOL]) {
+  globalThis[PATCHED_SYMBOL] = true;
+
+  const requestContext = new AsyncLocalStorage();
+  const previousRequestContext = globalThis[REQUEST_CONTEXT_SYMBOL];
+
+  Object.defineProperty(globalThis, REQUEST_CONTEXT_SYMBOL, {
+    enumerable: false,
+    configurable: true,
+    value: {
+      get: () => requestContext.getStore() ?? previousRequestContext?.get?.(),
+    },
+  });
+
+  const originalEmit = http.Server.prototype.emit;
+  const originalListen = http.Server.prototype.listen;
+
+  http.Server.prototype.listen = function listen(...args) {
+    if (!this[UPGRADE_LISTENER_SYMBOL]) {
+      this[UPGRADE_LISTENER_SYMBOL] = true;
+      this.on('upgrade', noop);
+    }
+
+    return originalListen.apply(this, args);
+  };
+
+  http.Server.prototype.emit = function emit(
+    event,
+    req,
+    socket,
+    head,
+    ...args
+  ) {
+    if (
+      event !== 'upgrade' ||
+      !isWebSocketUpgrade(req) ||
+      isNextInternalUpgrade(req)
+    ) {
+      return originalEmit.call(this, event, req, socket, head, ...args);
+    }
+
+    const requestListeners = this.listeners('request');
+    if (requestListeners.length === 0) {
+      return originalEmit.call(this, event, req, socket, head, ...args);
+    }
+
+    const response = new http.ServerResponse(req);
+
+    return emitWebSocketRequest({
+      server: this,
+      req,
+      response,
+      socket,
+      head: head || Buffer.alloc(0),
+      requestContext,
+      originalEmit,
+    });
+  };
+}
+
+function emitWebSocketRequest({
+  server,
+  req,
+  response,
+  socket,
+  head,
+  requestContext,
+  originalEmit,
+}) {
+  socket.setTimeout(0);
+  socket.setNoDelay(true);
+
+  if (typeof response.assignSocket === 'function' && !response.socket) {
+    response.assignSocket(socket);
+  }
+
+  const abortController = new AbortController();
+  let consumed = false;
+  response.once('finish', () => {
+    if (!consumed) {
+      socket.end();
+    }
+  });
+
+  const context = {
+    waitUntil: promiseOrFunc => {
+      const promise =
+        typeof promiseOrFunc === 'function' ? promiseOrFunc() : promiseOrFunc;
+      Promise.resolve(promise).catch(() => {});
+    },
+    headers: Object.fromEntries(
+      Object.entries(req.headers).map(([key, value]) => [
+        key,
+        Array.isArray(value) ? value.join(',') : value,
+      ])
+    ),
+    method: req.method || 'GET',
+    url: new URL(req.url || '/', getRequestOrigin(req)).toString(),
+    signal: abortController.signal,
+    upgradeWebSocket: () => {
+      if (consumed) {
+        throw new Error(
+          'ctx.upgradeWebSocket() can only be called once per request'
+        );
+      }
+      consumed = true;
+
+      const closeResponse = createResponseCloseEmitter(response);
+      if (typeof response.detachSocket === 'function') {
+        response.detachSocket(socket);
+      }
+      suppressFrameworkResponse(response);
+      preserveAsyncContextOnSocket(socket, requestContext);
+
+      socket.once('close', () => {
+        requestContext.run(context, () => {
+          req.emit('aborted');
+          abortController.abort();
+        });
+
+        // Next dev treats ServerResponse "close" as the end of its request
+        // lifecycle. Let ws emit its user-facing "close" event first so those
+        // callbacks can register after() work before Next drains that work.
+        setImmediate(() => requestContext.run(context, closeResponse));
+      });
+      socket.once('error', noop);
+
+      return { req, socket, head };
+    },
+  };
+
+  requestContext.run(context, () => {
+    try {
+      originalEmit.call(server, 'request', req, response);
+    } catch (error) {
+      socket.destroy(error);
+    }
+  });
+
+  return true;
+}
+
+function isWebSocketUpgrade(req) {
+  const connection = req?.headers?.connection;
+  const upgrade = req?.headers?.upgrade;
+  return (
+    typeof connection === 'string' &&
+    connection
+      .split(',')
+      .some(token => token.trim().toLowerCase() === 'upgrade') &&
+    typeof upgrade === 'string' &&
+    upgrade.split(',').some(token => token.trim().toLowerCase() === 'websocket')
+  );
+}
+
+function isNextInternalUpgrade(req) {
+  const pathname = new URL(req?.url || '/', 'http://localhost').pathname;
+  return pathname.includes('/_next/') || pathname.startsWith('/__nextjs');
+}
+
+function suppressFrameworkResponse(response) {
+  response.writeHead = function writeHead() {
+    return this;
+  };
+  response.write = function write() {
+    return true;
+  };
+  response.end = function end() {
+    return this;
+  };
+}
+
+function createResponseCloseEmitter(response) {
+  let closed = false;
+  response.once('close', () => {
+    closed = true;
+  });
+
+  return () => {
+    if (closed) {
+      return;
+    }
+    closed = true;
+    // Frameworks like Next.js use ServerResponse "close" as their request
+    // lifecycle hook. Upgraded requests detach the socket, so bridge that
+    // hook to the WebSocket close.
+    response.emit('close');
+  };
+}
+
+function preserveAsyncContextOnSocket(socket, requestContext) {
+  const store = requestContext.getStore();
+  const runInSnapshot =
+    typeof AsyncLocalStorage.snapshot === 'function'
+      ? AsyncLocalStorage.snapshot()
+      : callback => requestContext.run(store, callback);
+  const originalEmit = socket.emit;
+  socket.emit = function emit(...args) {
+    return runInSnapshot(() => originalEmit.apply(this, args));
+  };
+}
+
+function getRequestOrigin(req) {
+  const host = req.headers.host || 'localhost';
+  const proto = req.socket?.encrypted ? 'https' : 'http';
+  return `${proto}://${host}`;
+}
+
+function noop() {}

package/dist/vc.js

@@ -0,0 +1,404 @@
+#!/usr/bin/env node
+/* biome-ignore-all lint/suspicious/noConsole: CLI entry point */
+// 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.
+const entryAt = performance.now();
+try {
+  const { enableCompileCache } = await import('node:module');
+  if (enableCompileCache) {
+    enableCompileCache();
+  }
+} catch {}
+
+// Run the one package this platform maps to: the native binary on macOS and
+// Linux x64/arm64, @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 { existsSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+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.
+const NATIVE_TARGETS = [
+  'darwin-arm64',
+  'darwin-x64',
+  'linux-arm64',
+  'linux-arm64-musl',
+  'linux-x64',
+  'linux-x64-musl',
+];
+
+// 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.
+function isMusl() {
+  const ldd = spawnSync('ldd', ['--version'], { encoding: 'utf8' });
+  return `${ldd.stdout ?? ''}${ldd.stderr ?? ''}`.includes('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 bin =
+    pkgDir &&
+    [join(pkgDir, 'bin', 'vercel'), join(pkgDir, 'vercel')].find(existsSync);
+  return { target, bin };
+}
+
+// This file also ships in @vercel/cli-support, which is its own JS CLI.
+function isCliSupport() {
+  try {
+    const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json')));
+    return pkg.name === '@vercel/cli-support';
+  } catch {
+    return false;
+  }
+}
+
+// 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() {
+  const envOverride = process.env.VERCEL_CLI_USE_NATIVE_BINARY;
+  if (envOverride === '0' || envOverride === 'false') return true;
+  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
+    );
+  } 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'];
+
+// 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.
+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;
+  }
+} else {
+  const resolved = resolveTarget();
+  if (resolved.bin && (await isNativeBinaryOptedOut())) {
+    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.
+    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,
+      },
+    });
+    // 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.signal) {
+        try {
+          process.kill(process.pid, r.signal);
+        } catch {}
+      }
+      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 };
+  } else if (resolved.entry || isCliSupport()) {
+    launch = { runtime: 'cli-support' };
+  } else {
+    launch = {
+      runtime: 'dist',
+      target: resolved.target,
+      reason: 'target_missing',
+    };
+  }
+  globalThis[LAUNCH] = launch;
+  cliSupportEntry = resolved.entry;
+}
+
+if (process.argv[2] === '--internal-build-worker') {
+  const {
+    applyInternalBuildRequest,
+    InternalBuildWorkerReport,
+    preloadInternalBuild,
+    waitForInternalBuildRequest,
+  } = await import('./internal-build-worker.js');
+  const report = new InternalBuildWorkerReport({ entryAt });
+  // Only module loading belongs here: argv, env, and cwd still belong to the
+  // prewarm process until the build request is applied.
+  const handoff = await waitForInternalBuildRequest(
+    process.argv.slice(2),
+    () =>
+      preloadInternalBuild(
+        () => import('./commands/build/index.js'),
+        () => import('./internal-build.js'),
+        report
+      ),
+    { report }
+  );
+  globalThis[Symbol.for('vercel.cli.fatal-error-handler')] = error =>
+    handoff.error(error);
+
+  try {
+    // The caller must provide the complete environment for a non-interactive
+    // build-container invocation before normal CLI initialization starts.
+    applyInternalBuildRequest(handoff.request);
+    const { runInternalBuild } = await import('./internal-build.js');
+    let exitCode = await runInternalBuild();
+    if (exitCode === undefined) {
+      // Importing index.js starts the full CLI with the applied request.
+      const { cliPromise } = await import('./index.js');
+      exitCode = await cliPromise;
+    }
+    await handoff.complete(exitCode ?? 0);
+  } catch (error) {
+    await handoff.error(error);
+    process.exitCode = 1;
+  }
+
+  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;
+  }
+  const argv = process.argv.slice(2);
+  const formatIndex = argv.indexOf('--format');
+  if (
+    argv.some(arg =>
+      [
+        '--non-interactive',
+        '--non-interactive=true',
+        '--json',
+        '--format=json',
+      ].includes(arg)
+    ) ||
+    (formatIndex !== -1 && argv[formatIndex + 1] === 'json')
+  ) {
+    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.`
+  );
+  if (stamp) {
+    try {
+      writeFileSync(stamp, '');
+    } catch {}
+  }
+}
+
+await warnDeprecatedArch();
+
+// Fast path for --version to avoid loading the entire CLI
+if (
+  process.argv.length === 3 &&
+  (process.argv[2] === '--version' || process.argv[2] === '-v')
+) {
+  const { version, buildLabel } = await import('./version.mjs');
+  const labels = [];
+  if (process.env.VERCEL_VC_NATIVE === '1') labels.push('native');
+  // Optional build metadata stamped by CI (e.g. "pr-115 abc1234").
+  if (buildLabel) labels.push(buildLabel);
+  const suffix = labels.length > 0 ? ` (${labels.join(', ')})` : '';
+  console.error(`Vercel CLI ${version}${suffix}`);
+  console.log(version);
+  process.exit(0);
+}
+
+// Fast path for --help to avoid loading the entire CLI. The build generates
+// root-help-commands.mjs from the command registry; without it, fall through
+// to the full CLI, which renders the same help from the registry.
+if (
+  process.argv.length === 3 &&
+  (process.argv[2] === '--help' || process.argv[2] === '-h')
+) {
+  let rootHelp;
+  try {
+    const { version } = await import('./version.mjs');
+    const { help } = await import('./help.js');
+    const { rootHelpCommands } = await import('./root-help-commands.mjs');
+    rootHelp = {
+      version,
+      text: help(rootHelpCommands, process.stdout.columns),
+    };
+  } catch {
+    rootHelp = undefined;
+  }
+  if (rootHelp) {
+    console.error(`Vercel CLI ${rootHelp.version}`);
+    process.stdout.write(rootHelp.text);
+    process.exit(0);
+  }
+}
+
+try {
+  await (cliSupportEntry
+    ? import(pathToFileURL(cliSupportEntry).href)
+    : 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.
+  if (
+    error?.name !== 'ArgError' ||
+    ![
+      'ARG_UNKNOWN_OPTION',
+      'ARG_MISSING_REQUIRED_LONGARG',
+      'ARG_MISSING_REQUIRED_SHORTARG',
+    ].includes(error.code)
+  ) {
+    throw error;
+  }
+  let nonInteractive = false;
+  for (const arg of process.argv.slice(2)) {
+    if (arg === '--') break;
+    if (arg === '--non-interactive' || arg === '--non-interactive=true') {
+      nonInteractive = true;
+    } else if (arg === '--non-interactive=false') {
+      nonInteractive = false;
+    }
+  }
+  if (nonInteractive) {
+    console.log(
+      JSON.stringify(
+        {
+          status: 'error',
+          reason: 'invalid_arguments',
+          message: error.message,
+        },
+        null,
+        2
+      )
+    );
+  } else {
+    console.error(`✗ ${error.message}`);
+  }
+  // A usage error, like every other unknown or incomplete option.
+  process.exit(2);
+}

package/dist/version.mjs

@@ -0,0 +1,2 @@
+export const version = "65.4.0";
+export const buildLabel = "";