@vercel/cli-support 0.0.0 → 65.3.1

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,393 @@
+#!/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 {}
+
+// Spawn the installed native binary for explicit opt-ins, macOS machines, or
+// internal automatic enrollment. Explicit opt-outs always override defaults.
+import { spawnSync } from 'node:child_process';
+import { existsSync, 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.
+const NATIVE_TARGETS = [
+  'darwin-arm64',
+  'darwin-x64',
+  'linux-arm64',
+  'linux-arm64-musl',
+  'linux-x64',
+  'linux-x64-musl',
+  'win32-arm64',
+  'win32-x64',
+];
+
+// 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 nativeTarget() {
+  const target = `${process.platform}-${process.arch}`;
+  return process.platform === 'linux' && isMusl() ? `${target}-musl` : target;
+}
+
+function resolveNative() {
+  // Already running inside the native binary — never trampoline again.
+  if (process.env.VERCEL_VC_NATIVE === '1') return null;
+  const pkgName = `@vercel/vc-native-${nativeTarget()}`;
+  const binName = process.platform === 'win32' ? 'vercel.exe' : 'vercel';
+  // Walk up from this install's own tree looking for a sibling native
+  // package. `require.resolve()` is not used because it falls back to
+  // NODE_PATH and the global folders even when `paths` is given.
+  let dir = __dirname;
+  while (true) {
+    const pkgDir = join(dir, 'node_modules', pkgName);
+    if (existsSync(join(pkgDir, 'package.json'))) {
+      const a = join(pkgDir, 'bin', binName);
+      if (existsSync(a)) return a;
+      const b = join(pkgDir, binName);
+      if (existsSync(b)) return b;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+function nativeUnavailableMessage() {
+  const target = nativeTarget();
+  if (NATIVE_TARGETS.includes(target)) {
+    return (
+      `The native Vercel CLI package @vercel/vc-native-${target} is not installed. ` +
+      'Reinstall vercel without omitting optional dependencies (for example, npm i -g vercel@latest).'
+    );
+  }
+  return (
+    `Vercel CLI does not provide a native binary for ${target}. ` +
+    'Install the JavaScript CLI instead (for example, npm i -g @vercel/cli-support).'
+  );
+}
+
+// Operating systems without a native package get the same version's JS CLI
+// from @vercel/cli-support. Like resolveNative(), only search this install's
+// tree.
+function resolveCliSupport() {
+  let dir = __dirname;
+  while (true) {
+    const entry = join(
+      dir,
+      'node_modules',
+      '@vercel',
+      'cli-support',
+      'dist',
+      'index.js'
+    );
+    if (existsSync(entry)) return entry;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+async function importJsCli() {
+  try {
+    return await import('./index.js');
+  } catch (error) {
+    const cliSupport =
+      process.env.VERCEL_VC_NATIVE !== '1' &&
+      error?.code === 'ERR_MODULE_NOT_FOUND' &&
+      resolveCliSupport();
+    if (!cliSupport) throw error;
+    return import(pathToFileURL(cliSupport).href);
+  }
+}
+
+// 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;
+}
+
+// Any failure to read config counts as "not opted in".
+async function isNativeBinaryOptedIn() {
+  const envOverride = process.env.VERCEL_CLI_USE_NATIVE_BINARY;
+  if (envOverride === '1' || envOverride === 'true') return true;
+  if (envOverride === '0' || envOverride === 'false') 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();
+    const configPath = config.getConfigFilePath(configDir);
+    const preference = config.readGlobalConfigFlag(
+      configPath,
+      'useNativeBinary'
+    );
+    if (typeof preference === 'boolean') return preference;
+    // All macOS machines are opted in unless they explicitly opt out above.
+    if (process.platform === 'darwin') return true;
+    return (
+      config.readGlobalConfigFlag(configPath, 'nativeBinaryAutoOptIn') === true
+    );
+  } catch {
+    return false;
+  }
+}
+
+// Keep the opt-out escape hatch in Node even when the native binary cannot
+// start. The full CLI parser still validates the command and its arguments.
+const disableBinary = process.argv.slice(2).includes('--disable-binary');
+const nativeBin = resolveNative();
+const bin = disableBinary ? null : nativeBin;
+
+// Internal worker arguments intentionally trampoline too. The packaged native
+// binary sets VERCEL_VC_NATIVE=1 in pkg.js and re-enters this file, where
+// resolveNative() returns null and the worker branch below handles the request.
+if (bin && (await isNativeBinaryOptedIn())) {
+  process.env.VERCEL_VC_NATIVE = '1';
+  // Do not fall through to JS on spawn/loader failures — surface them so
+  // native binary issues (e.g. glibc mismatch) are visible.
+  const r = spawnSync(bin, process.argv.slice(2), {
+    stdio: 'inherit',
+    windowsHide: true,
+    env: {
+      ...process.env,
+      // 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: bin,
+    },
+  });
+  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);
+}
+
+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);
+}
+
+// Linux and Windows on anything but x64/arm64 have no native binary, and will
+// lose the JS CLI from `vercel` itself in a future release.
+async function warnDeprecatedArch() {
+  if (
+    !['linux', 'win32'].includes(process.platform) ||
+    ['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. ` +
+      'npm i -g @vercel/cli-support will keep working.'
+  );
+  if (target === 'win32-ia32') {
+    console.error(
+      '  If this is a 64-bit PC, install 64-bit Node.js and reinstall vercel instead.'
+    );
+  }
+  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 importJsCli();
+} catch (error) {
+  // Without a native binary the JS CLI is the only option; if its
+  // dependencies are not installed either, name the missing package.
+  if (
+    !nativeBin &&
+    process.env.VERCEL_VC_NATIVE !== '1' &&
+    error?.code === 'ERR_MODULE_NOT_FOUND'
+  ) {
+    console.error(`Error: ${nativeUnavailableMessage()}`);
+    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.3.1";
+export const buildLabel = "";