vercel
Version:
The command-line interface for Vercel
1,818 lines (1,800 loc) • 83.2 kB
JavaScript
import { createRequire as __createRequire } from 'node:module';
import { fileURLToPath as __fileURLToPath } from 'node:url';
import { dirname as __dirname_ } from 'node:path';
const require = __createRequire(import.meta.url);
const __filename = __fileURLToPath(import.meta.url);
const __dirname = __dirname_(__filename);
import {
help
} from "./chunks/chunk-JFWE5ORG.js";
import {
box,
did_you_mean_default,
executeUpgrade,
login,
matchesCliApiTag,
tryOpenApiFallback
} from "./chunks/chunk-J3BCJYPE.js";
import {
getUpdateCommand
} from "./chunks/chunk-FUBTAFL2.js";
import {
Client,
getAuthConfigFilePath,
getConfigFilePath,
getGlobalPathConfig,
readAuthConfigFile,
readConfigFile,
writeToAuthConfigFile,
writeToConfigFile
} from "./chunks/chunk-F2UPASLT.js";
import {
highlight
} from "./chunks/chunk-V5P25P7F.js";
import {
commandNames,
commands
} from "./chunks/chunk-UVFXUXOZ.js";
import "./chunks/chunk-IFATV36R.js";
import "./chunks/chunk-JFVGRFME.js";
import "./chunks/chunk-TZMIHH5D.js";
import "./chunks/chunk-XVAEOG4L.js";
import "./chunks/chunk-ZAAKSLHC.js";
import "./chunks/chunk-CQANJIEC.js";
import {
getScope
} from "./chunks/chunk-KWDV5FZH.js";
import "./chunks/chunk-4PSOOFYO.js";
import {
require_semver
} from "./chunks/chunk-IB5L4LKZ.js";
import "./chunks/chunk-76ZNZKIN.js";
import "./chunks/chunk-4VPRHRPA.js";
import "./chunks/chunk-ZKKIBUCU.js";
import "./chunks/chunk-MMF4BVAP.js";
import {
getLinkFromDir,
getTeams,
getUser,
getVercelDirectory,
humanizePath,
param,
readJSONFile,
require_dist as require_dist2,
require_lib
} from "./chunks/chunk-X775BOSL.js";
import {
TelemetryClient,
TelemetryEventStore
} from "./chunks/chunk-4OEA5ILS.js";
import "./chunks/chunk-ULXHXZCZ.js";
import "./chunks/chunk-CO5D46AG.js";
import "./chunks/chunk-N2T234LO.js";
import "./chunks/chunk-DKD6GTQT.js";
import {
getArgs,
parseArguments,
printError
} from "./chunks/chunk-4GQQJY5Y.js";
import {
APIError,
CantFindConfig,
CantParseJSONFile,
DeprecatedNowJson,
WorkingDirectoryDoesNotExist,
cmd,
getCommandName,
getTitleName
} from "./chunks/chunk-UGXBNJMO.js";
import {
pkg_default
} from "./chunks/chunk-P4QNYOFB.js";
import {
output_manager_default,
require_dist
} from "./chunks/chunk-ZQKJVHXY.js";
import {
require_source
} from "./chunks/chunk-S7KYDPEM.js";
import {
__commonJS,
__require,
__toESM
} from "./chunks/chunk-TZ2YI2VH.js";
// ../../node_modules/.pnpm/epipebomb@1.0.0/node_modules/epipebomb/epipebomb.js
var require_epipebomb = __commonJS({
"../../node_modules/.pnpm/epipebomb@1.0.0/node_modules/epipebomb/epipebomb.js"(exports, module) {
module.exports = epipeBomb;
function epipeBomb(stream, callback) {
if (stream == null)
stream = process.stdout;
if (callback == null)
callback = process.exit;
function epipeFilter(err) {
if (err.code === "EPIPE")
return callback();
if (stream.listeners("error").length <= 1) {
stream.removeAllListeners();
stream.emit("error", err);
stream.on("error", epipeFilter);
}
}
stream.on("error", epipeFilter);
}
}
});
// ../../node_modules/.pnpm/os-paths@4.4.0/node_modules/os-paths/src/lib/index.js
var require_lib2 = __commonJS({
"../../node_modules/.pnpm/os-paths@4.4.0/node_modules/os-paths/src/lib/index.js"(exports, module) {
"use strict";
var os = __require("os");
var paths = __require("path");
var isWinOS = /^win/i.test(process.platform);
function normalize_path(path2) {
return paths.normalize(paths.join(path2, "."));
}
var base = () => {
const { env } = process;
const object = {};
object.home = () => normalize_path(os.homedir ? os.homedir() : env.HOME);
object.temp = () => normalize_path(os.tmpdir ? os.tmpdir() : env.TMPDIR || env.TEMP || env.TMP);
return object;
};
var windows = () => {
const { env } = process;
const object = {};
object.home = () => normalize_path(
os.homedir ? os.homedir() : env.USERPROFILE || paths.join(env.HOMEDRIVE, env.HOMEPATH) || env.HOME
);
object.temp = () => normalize_path(
os.tmpdir ? os.tmpdir() : env.TEMP || env.TMP || paths.join(env.LOCALAPPDATA || env.SystemRoot || env.windir, "Temp")
);
return object;
};
var _OSPaths = class __OSPaths {
constructor() {
const OSPaths = function() {
return new __OSPaths();
};
this._fn = OSPaths;
const extension = isWinOS ? windows() : base();
Object.keys(extension).forEach((key) => {
this._fn[key] = extension[key];
});
return this._fn;
}
};
module.exports = new _OSPaths();
}
});
// ../../node_modules/.pnpm/xdg-portable@7.3.0/node_modules/xdg-portable/src/lib/index.js
var require_lib3 = __commonJS({
"../../node_modules/.pnpm/xdg-portable@7.3.0/node_modules/xdg-portable/src/lib/index.js"(exports, module) {
"use strict";
var path2 = __require("path");
var osPaths = require_lib2();
var linux = () => {
const object = {};
object.cache = () => process.env.XDG_CACHE_HOME || path2.join(osPaths.home() || osPaths.temp(), ".cache");
object.config = () => process.env.XDG_CONFIG_HOME || path2.join(osPaths.home() || osPaths.temp(), ".config");
object.data = () => process.env.XDG_DATA_HOME || path2.join(osPaths.home() || osPaths.temp(), ".local", "share");
object.runtime = () => process.env.XDG_RUNTIME_DIR || void 0;
object.state = () => process.env.XDG_STATE_HOME || path2.join(osPaths.home() || osPaths.temp(), ".local", "state");
return object;
};
var macos = () => {
const object = {};
object.cache = () => process.env.XDG_CACHE_HOME || path2.join(path2.join(osPaths.home() || osPaths.temp(), "Library"), "Caches");
object.config = () => process.env.XDG_CONFIG_HOME || path2.join(path2.join(osPaths.home() || osPaths.temp(), "Library"), "Preferences");
object.data = () => process.env.XDG_DATA_HOME || path2.join(path2.join(osPaths.home() || osPaths.temp(), "Library"), "Application Support");
object.runtime = () => process.env.XDG_RUNTIME_DIR || void 0;
object.state = () => process.env.XDG_STATE_HOME || path2.join(path2.join(osPaths.home() || osPaths.temp(), "Library"), "State");
return object;
};
var windows = () => {
const object = {};
object.cache = () => {
const localAppData = process.env.LOCALAPPDATA || path2.join(osPaths.home() || osPaths.temp(), "AppData", "Local");
return process.env.XDG_CACHE_HOME || path2.join(localAppData, "xdg.cache");
};
object.config = () => {
const appData = process.env.APPDATA || path2.join(osPaths.home() || osPaths.temp(), "AppData", "Roaming");
return process.env.XDG_CONFIG_HOME || path2.join(appData, "xdg.config");
};
object.data = () => {
const appData = process.env.APPDATA || path2.join(osPaths.home() || osPaths.temp(), "AppData", "Roaming");
return process.env.XDG_DATA_HOME || path2.join(appData, "xdg.data");
};
object.runtime = () => process.env.XDG_RUNTIME_DIR || void 0;
object.state = () => {
const localAppData = process.env.LOCALAPPDATA || path2.join(osPaths.home() || osPaths.temp(), "AppData", "Local");
return process.env.XDG_STATE_HOME || path2.join(localAppData, "xdg.state");
};
return object;
};
var _XDGPortable = () => {
const XDGPortable = function() {
return _XDGPortable();
};
let extension = {};
if (/^darwin$/i.test(process.platform)) {
extension = macos();
} else if (/^win/i.test(process.platform)) {
extension = windows();
} else {
extension = linux();
}
extension.configDirs = () => {
const dirs = [];
dirs.push(extension.config());
if (process.env.XDG_CONFIG_DIRS) {
dirs.push(...process.env.XDG_CONFIG_DIRS.split(path2.delimiter));
}
return dirs;
};
extension.dataDirs = () => {
const dirs = [];
dirs.push(extension.data());
if (process.env.XDG_DATA_DIRS) {
dirs.push(...process.env.XDG_DATA_DIRS.split(path2.delimiter));
}
return dirs;
};
Object.keys(extension).forEach((key) => {
XDGPortable[key] = extension[key];
});
return XDGPortable;
};
module.exports = _XDGPortable();
}
});
// ../../node_modules/.pnpm/xdg-app-paths@5.1.0/node_modules/xdg-app-paths/index.js
var require_xdg_app_paths = __commonJS({
"../../node_modules/.pnpm/xdg-app-paths@5.1.0/node_modules/xdg-app-paths/index.js"(exports, module) {
"use strict";
var path2 = __require("path");
var os = __require("os");
var xdg = require_lib3();
var isWinOS = /^win/i.test(process.platform);
function _normalizeOptions(options, isolated) {
options = options || {};
if (typeof options !== "object") {
options = { isolated: options };
}
options.isolated = options.isolated === void 0 || options.isolated === null ? isolated : options.isolated;
if (typeof options.isolated !== "boolean") {
throw new TypeError(`Expected boolean for "isolated" argument, got ${typeof options.isolated}`);
}
return options;
}
var base = (name, isolated) => {
const object = {};
object.cache = (options = { isolated: null }) => {
options = _normalizeOptions(options, isolated);
return path2.join(xdg.cache(), options.isolated ? name : "");
};
object.config = (options = { isolated: null }) => {
options = _normalizeOptions(options, isolated);
return path2.join(xdg.config(), options.isolated ? name : "");
};
object.data = (options = { isolated: null }) => {
options = _normalizeOptions(options, isolated);
return path2.join(xdg.data(), options.isolated ? name : "");
};
object.runtime = (options = { isolated: null }) => {
options = _normalizeOptions(options, isolated);
return xdg.runtime() ? path2.join(xdg.runtime(), options.isolated ? name : "") : void 0;
};
object.state = (options = { isolated: null }) => {
options = _normalizeOptions(options, isolated);
return path2.join(xdg.state(), options.isolated ? name : "");
};
object.configDirs = (options = { isolated: null }) => {
options = _normalizeOptions(options, isolated);
return xdg.configDirs().map((s) => path2.join(s, options.isolated ? name : ""));
};
object.dataDirs = (options = { isolated: null }) => {
options = _normalizeOptions(options, isolated);
return xdg.dataDirs().map((s) => path2.join(s, options.isolated ? name : ""));
};
return object;
};
var windows = (name, isolated) => {
const { env } = process;
const homedir = os.homedir();
const tmpdir = os.tmpdir();
const appData = env.APPDATA || path2.join(homedir || tmpdir, "AppData", "Roaming");
const localAppData = env.LOCALAPPDATA || path2.join(homedir || tmpdir, "AppData", "Local");
const object = {};
object.cache = (options = { isolated: null }) => {
options = _normalizeOptions(options, isolated);
return !options.isolated || env.XDG_CACHE_HOME ? path2.join(xdg.cache(), options.isolated ? name : "") : path2.join(localAppData, options.isolated ? name : "", "Cache");
};
object.config = (options = { isolated: null }) => {
options = _normalizeOptions(options, isolated);
const config2 = !options.isolated || env.XDG_CONFIG_HOME ? path2.join(xdg.config(), options.isolated ? name : "") : path2.join(appData, options.isolated ? name : "", "Config");
return config2;
};
object.data = (options = { isolated: null }) => {
options = _normalizeOptions(options, isolated);
const data = !options.isolated || env.XDG_DATA_HOME ? path2.join(xdg.data(), options.isolated ? name : "") : path2.join(appData, options.isolated ? name : "", "Data");
return data;
};
object.runtime = (options = { isolated: null }) => {
options = _normalizeOptions(options, isolated);
return xdg.runtime() ? path2.join(xdg.runtime(), options.isolated ? name : "") : void 0;
};
object.state = (options = { isolated: null }) => {
options = _normalizeOptions(options, isolated);
return !options.isolated || env.XDG_STATE_HOME ? path2.join(xdg.state(), options.isolated ? name : "") : path2.join(localAppData, options.isolated ? name : "", "State");
};
object.configDirs = (options = { isolated: null }) => {
options = _normalizeOptions(options, isolated);
const dirs = [object.config(options)];
if (env.XDG_CONFIG_DIRS) {
dirs.push(...env.XDG_CONFIG_DIRS.split(path2.delimiter).map((s) => path2.join(s, options.isolated ? name : "")));
}
return dirs;
};
object.dataDirs = (options = { isolated: null }) => {
options = _normalizeOptions(options, isolated);
const dirs = [object.data(options)];
if (env.XDG_DATA_DIRS) {
dirs.push(...env.XDG_DATA_DIRS.split(path2.delimiter).map((s) => path2.join(s, options.isolated ? name : "")));
}
return dirs;
};
return object;
};
var _XDGAppPaths = class __XDGAppPaths {
constructor(options = { name: null, suffix: null, isolated: true }) {
const XDGAppPaths2 = function(options2 = { name: null, suffix: null, isolated: true }) {
return new __XDGAppPaths(options2);
};
this._fn = XDGAppPaths2;
options = options || {};
if (typeof options !== "object") {
options = { name: options };
}
let name = options.name || "";
if (typeof name !== "string") {
throw new TypeError(`Expected string for "name" argument, got ${typeof name}`);
}
const suffix = options.suffix || "";
if (typeof suffix !== "string") {
throw new TypeError(`Expected string for "suffix" argument, got ${typeof suffix}`);
}
const isolated = options.isolated === void 0 || options.isolated === null ? true : options.isolated;
if (typeof isolated !== "boolean") {
throw new TypeError(`Expected boolean for "isolated" argument, got ${typeof isolated}`);
}
if (!name) {
name = path2.parse(process.pkg ? process.execPath : __require.main ? __require.main.filename : process.argv[0]).name;
}
if (suffix) {
name += suffix;
}
this._fn.$name = () => name;
this._fn.$isolated = () => isolated;
const extension = isWinOS ? windows(name, isolated) : base(name, isolated);
Object.keys(extension).forEach((key) => {
this._fn[key] = extension[key];
});
return this._fn;
}
};
module.exports = new _XDGAppPaths();
}
});
// ../../node_modules/.pnpm/ci-info@4.1.0/node_modules/ci-info/vendors.json
var require_vendors = __commonJS({
"../../node_modules/.pnpm/ci-info@4.1.0/node_modules/ci-info/vendors.json"(exports, module) {
module.exports = [
{
name: "Agola CI",
constant: "AGOLA",
env: "AGOLA_GIT_REF",
pr: "AGOLA_PULL_REQUEST_ID"
},
{
name: "Appcircle",
constant: "APPCIRCLE",
env: "AC_APPCIRCLE",
pr: {
env: "AC_GIT_PR",
ne: "false"
}
},
{
name: "AppVeyor",
constant: "APPVEYOR",
env: "APPVEYOR",
pr: "APPVEYOR_PULL_REQUEST_NUMBER"
},
{
name: "AWS CodeBuild",
constant: "CODEBUILD",
env: "CODEBUILD_BUILD_ARN",
pr: {
env: "CODEBUILD_WEBHOOK_EVENT",
any: [
"PULL_REQUEST_CREATED",
"PULL_REQUEST_UPDATED",
"PULL_REQUEST_REOPENED"
]
}
},
{
name: "Azure Pipelines",
constant: "AZURE_PIPELINES",
env: "TF_BUILD",
pr: {
BUILD_REASON: "PullRequest"
}
},
{
name: "Bamboo",
constant: "BAMBOO",
env: "bamboo_planKey"
},
{
name: "Bitbucket Pipelines",
constant: "BITBUCKET",
env: "BITBUCKET_COMMIT",
pr: "BITBUCKET_PR_ID"
},
{
name: "Bitrise",
constant: "BITRISE",
env: "BITRISE_IO",
pr: "BITRISE_PULL_REQUEST"
},
{
name: "Buddy",
constant: "BUDDY",
env: "BUDDY_WORKSPACE_ID",
pr: "BUDDY_EXECUTION_PULL_REQUEST_ID"
},
{
name: "Buildkite",
constant: "BUILDKITE",
env: "BUILDKITE",
pr: {
env: "BUILDKITE_PULL_REQUEST",
ne: "false"
}
},
{
name: "CircleCI",
constant: "CIRCLE",
env: "CIRCLECI",
pr: "CIRCLE_PULL_REQUEST"
},
{
name: "Cirrus CI",
constant: "CIRRUS",
env: "CIRRUS_CI",
pr: "CIRRUS_PR"
},
{
name: "Codefresh",
constant: "CODEFRESH",
env: "CF_BUILD_ID",
pr: {
any: [
"CF_PULL_REQUEST_NUMBER",
"CF_PULL_REQUEST_ID"
]
}
},
{
name: "Codemagic",
constant: "CODEMAGIC",
env: "CM_BUILD_ID",
pr: "CM_PULL_REQUEST"
},
{
name: "Codeship",
constant: "CODESHIP",
env: {
CI_NAME: "codeship"
}
},
{
name: "Drone",
constant: "DRONE",
env: "DRONE",
pr: {
DRONE_BUILD_EVENT: "pull_request"
}
},
{
name: "dsari",
constant: "DSARI",
env: "DSARI"
},
{
name: "Earthly",
constant: "EARTHLY",
env: "EARTHLY_CI"
},
{
name: "Expo Application Services",
constant: "EAS",
env: "EAS_BUILD"
},
{
name: "Gerrit",
constant: "GERRIT",
env: "GERRIT_PROJECT"
},
{
name: "Gitea Actions",
constant: "GITEA_ACTIONS",
env: "GITEA_ACTIONS"
},
{
name: "GitHub Actions",
constant: "GITHUB_ACTIONS",
env: "GITHUB_ACTIONS",
pr: {
GITHUB_EVENT_NAME: "pull_request"
}
},
{
name: "GitLab CI",
constant: "GITLAB",
env: "GITLAB_CI",
pr: "CI_MERGE_REQUEST_ID"
},
{
name: "GoCD",
constant: "GOCD",
env: "GO_PIPELINE_LABEL"
},
{
name: "Google Cloud Build",
constant: "GOOGLE_CLOUD_BUILD",
env: "BUILDER_OUTPUT"
},
{
name: "Harness CI",
constant: "HARNESS",
env: "HARNESS_BUILD_ID"
},
{
name: "Heroku",
constant: "HEROKU",
env: {
env: "NODE",
includes: "/app/.heroku/node/bin/node"
}
},
{
name: "Hudson",
constant: "HUDSON",
env: "HUDSON_URL"
},
{
name: "Jenkins",
constant: "JENKINS",
env: [
"JENKINS_URL",
"BUILD_ID"
],
pr: {
any: [
"ghprbPullId",
"CHANGE_ID"
]
}
},
{
name: "LayerCI",
constant: "LAYERCI",
env: "LAYERCI",
pr: "LAYERCI_PULL_REQUEST"
},
{
name: "Magnum CI",
constant: "MAGNUM",
env: "MAGNUM"
},
{
name: "Netlify CI",
constant: "NETLIFY",
env: "NETLIFY",
pr: {
env: "PULL_REQUEST",
ne: "false"
}
},
{
name: "Nevercode",
constant: "NEVERCODE",
env: "NEVERCODE",
pr: {
env: "NEVERCODE_PULL_REQUEST",
ne: "false"
}
},
{
name: "Prow",
constant: "PROW",
env: "PROW_JOB_ID"
},
{
name: "ReleaseHub",
constant: "RELEASEHUB",
env: "RELEASE_BUILD_ID"
},
{
name: "Render",
constant: "RENDER",
env: "RENDER",
pr: {
IS_PULL_REQUEST: "true"
}
},
{
name: "Sail CI",
constant: "SAIL",
env: "SAILCI",
pr: "SAIL_PULL_REQUEST_NUMBER"
},
{
name: "Screwdriver",
constant: "SCREWDRIVER",
env: "SCREWDRIVER",
pr: {
env: "SD_PULL_REQUEST",
ne: "false"
}
},
{
name: "Semaphore",
constant: "SEMAPHORE",
env: "SEMAPHORE",
pr: "PULL_REQUEST_NUMBER"
},
{
name: "Sourcehut",
constant: "SOURCEHUT",
env: {
CI_NAME: "sourcehut"
}
},
{
name: "Strider CD",
constant: "STRIDER",
env: "STRIDER"
},
{
name: "TaskCluster",
constant: "TASKCLUSTER",
env: [
"TASK_ID",
"RUN_ID"
]
},
{
name: "TeamCity",
constant: "TEAMCITY",
env: "TEAMCITY_VERSION"
},
{
name: "Travis CI",
constant: "TRAVIS",
env: "TRAVIS",
pr: {
env: "TRAVIS_PULL_REQUEST",
ne: "false"
}
},
{
name: "Vela",
constant: "VELA",
env: "VELA",
pr: {
VELA_PULL_REQUEST: "1"
}
},
{
name: "Vercel",
constant: "VERCEL",
env: {
any: [
"NOW_BUILDER",
"VERCEL"
]
},
pr: "VERCEL_GIT_PULL_REQUEST_ID"
},
{
name: "Visual Studio App Center",
constant: "APPCENTER",
env: "APPCENTER_BUILD_ID"
},
{
name: "Woodpecker",
constant: "WOODPECKER",
env: {
CI: "woodpecker"
},
pr: {
CI_BUILD_EVENT: "pull_request"
}
},
{
name: "Xcode Cloud",
constant: "XCODE_CLOUD",
env: "CI_XCODE_PROJECT",
pr: "CI_PULL_REQUEST_NUMBER"
},
{
name: "Xcode Server",
constant: "XCODE_SERVER",
env: "XCS"
}
];
}
});
// ../../node_modules/.pnpm/ci-info@4.1.0/node_modules/ci-info/index.js
var require_ci_info = __commonJS({
"../../node_modules/.pnpm/ci-info@4.1.0/node_modules/ci-info/index.js"(exports) {
"use strict";
var vendors = require_vendors();
var env = process.env;
Object.defineProperty(exports, "_vendors", {
value: vendors.map(function(v) {
return v.constant;
})
});
exports.name = null;
exports.isPR = null;
exports.id = null;
vendors.forEach(function(vendor) {
const envs = Array.isArray(vendor.env) ? vendor.env : [vendor.env];
const isCI = envs.every(function(obj) {
return checkEnv(obj);
});
exports[vendor.constant] = isCI;
if (!isCI) {
return;
}
exports.name = vendor.name;
exports.isPR = checkPR(vendor);
exports.id = vendor.constant;
});
exports.isCI = !!(env.CI !== "false" && // Bypass all checks if CI env is explicitly set to 'false'
(env.BUILD_ID || // Jenkins, Cloudbees
env.BUILD_NUMBER || // Jenkins, TeamCity
env.CI || // Travis CI, CircleCI, Cirrus CI, Gitlab CI, Appveyor, CodeShip, dsari
env.CI_APP_ID || // Appflow
env.CI_BUILD_ID || // Appflow
env.CI_BUILD_NUMBER || // Appflow
env.CI_NAME || // Codeship and others
env.CONTINUOUS_INTEGRATION || // Travis CI, Cirrus CI
env.RUN_ID || // TaskCluster, dsari
exports.name || false));
function checkEnv(obj) {
if (typeof obj === "string")
return !!env[obj];
if ("env" in obj) {
return env[obj.env] && env[obj.env].includes(obj.includes);
}
if ("any" in obj) {
return obj.any.some(function(k) {
return !!env[k];
});
}
return Object.keys(obj).every(function(k) {
return env[k] === obj[k];
});
}
function checkPR(vendor) {
switch (typeof vendor.pr) {
case "string":
return !!env[vendor.pr];
case "object":
if ("env" in vendor.pr) {
if ("any" in vendor.pr) {
return vendor.pr.any.some(function(key) {
return env[vendor.pr.env] === key;
});
} else {
return vendor.pr.env in env && env[vendor.pr.env] !== vendor.pr.ne;
}
} else if ("any" in vendor.pr) {
return vendor.pr.any.some(function(key) {
return !!env[key];
});
} else {
return checkEnv(vendor.pr);
}
default:
return null;
}
}
}
});
// src/index.ts
var import_error_utils3 = __toESM(require_dist(), 1);
var import_fs_extra2 = __toESM(require_lib(), 1);
var import_chalk = __toESM(require_source(), 1);
var import_epipebomb = __toESM(require_epipebomb(), 1);
import { join } from "path";
import { existsSync as existsSync2 } from "fs";
// src/util/get-latest-version/index.ts
var import_semver = __toESM(require_semver(), 1);
var import_xdg_app_paths = __toESM(require_xdg_app_paths(), 1);
var import_fs_extra = __toESM(require_lib(), 1);
import { dirname, parse as parsePath, resolve as resolvePath } from "path";
import { spawn } from "child_process";
function getLatestVersion({
cacheDir = (0, import_xdg_app_paths.default)("com.vercel.cli").cache(),
distTag = "latest",
notifyInterval = 1e3 * 60 * 60 * 24 * 3,
// 3 days
pkg,
updateCheckInterval = 1e3 * 60 * 60 * 24
// 1 day
}) {
if (!pkg || typeof pkg !== "object" || !pkg.name || typeof pkg.name !== "string") {
throw new TypeError("Expected package to be an object with a package name");
}
const cacheFile = resolvePath(
cacheDir,
"package-updates",
`${pkg.name}-${distTag}.json`
);
let cache;
try {
cache = (0, import_fs_extra.readJSONSync)(cacheFile);
} catch (err) {
if (err.code !== "ENOENT") {
output_manager_default?.debug(`Error reading latest package cache file: ${err}`);
}
}
if (!cache || !cache.expireAt || cache.expireAt <= Date.now()) {
spawnWorker({
cacheFile,
distTag,
name: pkg.name,
updateCheckInterval
});
}
if (cache) {
const shouldNotify = !cache.notifyAt || cache.notifyAt <= Date.now();
let updateAvailable = false;
if (cache.version && pkg.version) {
updateAvailable = import_semver.default.lt(pkg.version, cache.version);
}
if (shouldNotify && updateAvailable) {
cache.notifyAt = Date.now() + notifyInterval;
(0, import_fs_extra.outputJSONSync)(cacheFile, cache);
return cache.version;
}
}
}
function spawnWorker(payload) {
let dir = dirname(__filename);
let script = resolvePath(dir, "dist", "get-latest-worker.cjs");
const { root } = parsePath(dir);
while (!(0, import_fs_extra.existsSync)(script)) {
dir = dirname(dir);
if (dir === root) {
output_manager_default?.debug("Failed to find the get latest worker script!");
return;
}
script = resolvePath(dir, "dist", "get-latest-worker.cjs");
}
output_manager_default?.debug(`Spawning ${script}`);
const args = [script];
if (output_manager_default?.debugEnabled) {
args.push("--debug");
}
const worker = spawn(process.execPath, args, {
stdio: ["inherit", "inherit", "inherit", "ipc"],
windowsHide: true
});
const workerReadyTimer = setTimeout(() => worker.kill(), 2e3);
const onClose = (code) => {
output_manager_default?.debug(`Get latest worker exited (code ${code})`);
};
worker.on("close", onClose);
worker.on("error", (err) => {
output_manager_default?.log(`Failed to spawn get latest worker: ${err.stack}`);
});
worker.once("message", () => {
clearTimeout(workerReadyTimer);
worker.removeListener("close", onClose);
worker.send(payload);
worker.unref();
});
}
// src/index.ts
import { URL } from "url";
// src/util/get-sentry.ts
var sentry;
async function getSentry() {
if (!sentry) {
const [SentryModule, { SENTRY_DSN }, { default: pkg }] = await Promise.all([
import("./chunks/cjs-DV4RM7XU.js"),
import("./chunks/constants-3FSSR6E7.js"),
import("./chunks/pkg-56KRLZ5K.js")
]);
const Sentry = "init" in SentryModule ? SentryModule : SentryModule.default;
Sentry.init({
dsn: SENTRY_DSN,
release: `vercel-cli@${pkg.version}`,
environment: "stable",
autoSessionTracking: false
});
sentry = Sentry;
}
return sentry;
}
// src/util/handle-command-typo.ts
function handleCommandTypo({
command,
availableCommands,
threshold = 0.7
}) {
if (!command || command.startsWith("-")) {
return false;
}
const suggestion = did_you_mean_default(command, availableCommands, threshold);
if (suggestion) {
output_manager_default.error(
`${param(command)} is not a valid target directory or subcommand. Did you mean ${param(suggestion)}?`
);
return true;
}
return false;
}
// src/util/report-error.ts
var import_error_utils = __toESM(require_dist(), 1);
async function reportError(sentry2, client2, error) {
if (ignoreError(error)) {
return;
}
let user;
let team;
let scopeError;
try {
({ user, team } = await getScope(client2));
} catch (err) {
if ((0, import_error_utils.isError)(err)) {
scopeError = err;
}
}
sentry2.withScope((scope) => {
if (user) {
const spec = {
email: user.email,
id: user.id,
username: user.username,
name: user.name
};
scope.setUser(spec);
}
if (team) {
scope.setTag("currentTeam", team.id);
}
if (scopeError) {
scope.setExtra("scopeError", {
name: scopeError.name,
message: scopeError.message,
stack: scopeError.stack
});
}
let args;
let argsError;
try {
args = getArgs(process.argv.slice(2), {});
} catch (err) {
if ((0, import_error_utils.isError)(err)) {
argsError = err;
}
}
if (args) {
const flags = ["--env", "--build-env", "--token"];
for (const flag of flags) {
if (args[flag])
args[flag] = "REDACTED";
}
if (args._.length >= 4 && args._[0].startsWith("secret") && args._[1] === "add") {
args._[3] = "REDACTED";
}
scope.setExtra("args", args);
} else {
let msg = "Unable to parse args";
if (argsError) {
msg += `: ${argsError}`;
}
scope.setExtra("args", msg);
}
scope.setExtra("node", {
execPath: process.execPath,
version: process.version,
platform: process.platform
});
sentry2.captureException(error);
});
const sentryClient = sentry2.getCurrentHub().getClient();
if (sentryClient) {
await sentryClient.close();
}
}
function ignoreError(error) {
return (0, import_error_utils.isError)(error) && error.message.includes("uv_cwd");
}
// src/util/get-config.ts
var import_client = __toESM(require_dist2(), 1);
import path from "path";
var import_error_utils2 = __toESM(require_dist(), 1);
var config;
async function earlyGetConfig(configFile) {
if (config) {
return config;
}
let localPath;
try {
localPath = process.cwd();
} catch (err) {
if ((0, import_error_utils2.isErrnoException)(err) && err.code === "ENOENT") {
return new WorkingDirectoryDoesNotExist();
}
throw err;
}
if (configFile) {
const localFilePath = path.resolve(localPath, configFile);
output_manager_default.debug(
`Found config in provided --local-config path ${localFilePath}`
);
const localConfig = await readJSONFile(localFilePath);
if (localConfig instanceof CantParseJSONFile) {
return localConfig;
}
if (localConfig === null) {
return new CantFindConfig([humanizePath(localFilePath)]);
}
config = localConfig;
config[import_client.fileNameSymbol] = configFile;
return config;
}
const vercelFilePath = path.resolve(localPath, "vercel.json");
const nowFilePath = path.resolve(localPath, "now.json");
const [vercelConfig, nowConfig] = await Promise.all([
readJSONFile(vercelFilePath),
readJSONFile(nowFilePath)
]);
if (vercelConfig instanceof CantParseJSONFile) {
return vercelConfig;
}
if (nowConfig instanceof CantParseJSONFile) {
return nowConfig;
}
if (vercelConfig !== null) {
output_manager_default.debug(`Found config in file "${vercelFilePath}"`);
config = vercelConfig;
config[import_client.fileNameSymbol] = "vercel.json";
return config;
}
if (nowConfig !== null) {
return new DeprecatedNowJson(nowFilePath);
}
return new CantFindConfig([vercelFilePath].map(humanizePath));
}
// src/index.ts
import { defaultAuthConfig, defaultGlobalConfig } from "@vercel/cli-config";
import { Agent as HttpsAgent } from "https";
// src/util/telemetry/root.ts
var import_ci_info = __toESM(require_ci_info(), 1);
var RootTelemetryClient = class extends TelemetryClient {
trackCliExtension() {
this.trackExtension();
}
trackCliDefaultDeploy(defaultDeploy) {
if (defaultDeploy) {
this.trackDefaultDeploy();
}
}
trackCliCommandAgent(actual) {
this.trackCliCommand({
command: "agent",
value: actual
});
}
trackCliCommandAiGateway(actual) {
this.trackCliCommand({
command: "ai-gateway",
value: actual
});
}
trackCliCommandAlias(actual) {
this.trackCliCommand({
command: "alias",
value: actual
});
}
trackCliCommandActivity(actual) {
this.trackCliCommand({
command: "activity",
value: actual
});
}
trackCliCommandAlerts(actual) {
this.trackCliCommand({
command: "alerts",
value: actual
});
}
trackCliCommandApi(actual) {
this.trackCliCommand({
command: "api",
value: actual
});
}
trackCliCommandBisect(actual) {
this.trackCliCommand({
command: "bisect",
value: actual
});
}
trackCliCommandBlob(actual) {
this.trackCliCommand({
command: "blob",
value: actual
});
}
trackCliCommandBuild(actual) {
this.trackCliCommand({
command: "build",
value: actual
});
}
trackCliCommandBuy(actual) {
this.trackCliCommand({
command: "buy",
value: actual
});
}
trackCliCommandCache(actual) {
this.trackCliCommand({
command: "cache",
value: actual
});
}
trackCliCommandCerts(actual) {
this.trackCliCommand({
command: "certs",
value: actual
});
}
trackCliCommandConnex(actual) {
this.trackCliCommand({
command: "connex",
value: actual
});
}
trackCliCommandContract(actual) {
this.trackCliCommand({
command: "contract",
value: actual
});
}
trackCliCommandCrons(actual) {
this.trackCliCommand({
command: "crons",
value: actual
});
}
trackCliCommandCurl(actual) {
this.trackCliCommand({
command: "curl",
value: actual
});
}
trackCliCommandDeploy(actual) {
this.trackCliCommand({
command: "deploy",
value: actual
});
}
trackCliCommandDeployHooks(actual) {
this.trackCliCommand({
command: "deploy-hooks",
value: actual
});
}
trackCliCommandDev(actual) {
this.trackCliCommand({
command: "dev",
value: actual
});
}
trackCliCommandDomains(actual) {
this.trackCliCommand({
command: "domains",
value: actual
});
}
trackCliCommandDns(actual) {
this.trackCliCommand({
command: "dns",
value: actual
});
}
trackCliCommandEdgeConfig(actual) {
this.trackCliCommand({
command: "edge-config",
value: actual
});
}
trackCliCommandEnv(actual) {
this.trackCliCommand({
command: "env",
value: actual
});
}
trackCliCommandFirewall(actual) {
this.trackCliCommand({
command: "firewall",
value: actual
});
}
trackCliCommandFlags(actual) {
this.trackCliCommand({
command: "flags",
value: actual
});
}
trackCliCommandGit(actual) {
this.trackCliCommand({
command: "git",
value: actual
});
}
trackCliCommandGuidance(actual) {
this.trackCliCommand({
command: "guidance",
value: actual
});
}
trackCliCommandHelp(actual) {
this.trackCliCommand({
command: "help",
value: actual
});
}
trackCliCommandHttpstat(actual) {
this.trackCliCommand({
command: "httpstat",
value: actual
});
}
trackCliCommandInit(actual) {
this.trackCliCommand({
command: "init",
value: actual
});
}
trackCliCommandInspect(actual) {
this.trackCliCommand({
command: "inspect",
value: actual
});
}
trackCliCommandInstall(actual) {
this.trackCliCommand({
command: "install",
value: actual
});
}
trackCliCommandIntegration(actual) {
this.trackCliCommand({
command: "integration",
value: actual
});
}
trackCliCommandIntegrationResource(actual) {
this.trackCliCommand({
command: "integration-resource",
value: actual
});
}
trackCliCommandLink(actual) {
this.trackCliCommand({
command: "link",
value: actual
});
}
trackCliCommandList(actual) {
this.trackCliCommand({
command: "list",
value: actual
});
}
trackCliCommandLogin(actual) {
this.trackCliCommand({
command: "login",
value: actual
});
}
trackCliCommandLogout(actual) {
this.trackCliCommand({
command: "logout",
value: actual
});
}
trackCliCommandLogs(actual) {
this.trackCliCommand({
command: "logs",
value: actual
});
}
trackCliCommandMetrics(actual) {
this.trackCliCommand({
command: "metrics",
value: actual
});
}
trackCliCommandMicrofrontends(actual) {
this.trackCliCommand({
command: "microfrontends",
value: actual
});
}
trackCliCommandOauthApps(actual) {
this.trackCliCommand({
command: "oauth-apps",
value: actual
});
}
trackCliCommandOpen(actual) {
this.trackCliCommand({
command: "open",
value: actual
});
}
trackCliCommandProject(actual) {
this.trackCliCommand({
command: "project",
value: actual
});
}
trackCliCommandPromote(actual) {
this.trackCliCommand({
command: "promote",
value: actual
});
}
trackCliCommandPull(actual) {
this.trackCliCommand({
command: "pull",
value: actual
});
}
trackCliCommandRollback(actual) {
this.trackCliCommand({
command: "rollback",
value: actual
});
}
trackCliCommandRollingRelease(actual) {
this.trackCliCommand({
command: "rolling-release",
value: actual
});
}
trackCliCommandRedeploy(actual) {
this.trackCliCommand({
command: "redeploy",
value: actual
});
}
trackCliCommandRedirects(actual) {
this.trackCliCommand({
command: "redirects",
value: actual
});
}
trackCliCommandRoutes(actual) {
this.trackCliCommand({
command: "routes",
value: actual
});
}
trackCliCommandRemove(actual) {
this.trackCliCommand({
command: "remove",
value: actual
});
}
trackCliCommandSkills(actual) {
this.trackCliCommand({
command: "skills",
value: actual
});
}
trackCliCommandSandbox(actual) {
this.trackCliCommand({
command: "sandbox",
value: actual
});
}
trackCliCommandTarget(actual) {
this.trackCliCommand({
command: "target",
value: actual
});
}
trackCliCommandTeams(actual) {
this.trackCliCommand({
command: "teams",
value: actual
});
}
trackCliCommandTokens(actual) {
this.trackCliCommand({
command: "tokens",
value: actual
});
}
trackCliCommandTelemetry(actual) {
this.trackCliCommand({
command: "telemetry",
value: actual
});
}
trackCliCommandWhoami(actual) {
this.trackCliCommand({
command: "whoami",
value: actual
});
}
trackCliCommandUpgrade(actual) {
this.trackCliCommand({
command: "upgrade",
value: actual
});
}
trackCliCommandWebhooks(actual) {
this.trackCliCommand({
command: "webhooks",
value: actual
});
}
trackCliCommandUsage(actual) {
this.trackCliCommand({
command: "usage",
value: actual
});
}
trackCPUs() {
super.trackCPUs();
}
trackAgenticUse(agent) {
super.trackAgenticUse(agent);
}
trackArch() {
super.trackArch();
}
trackPlatform() {
super.trackPlatform();
}
trackCIVendorName() {
this.trackCI(import_ci_info.default.id);
}
trackStdinIsTTY(isTTY2) {
super.trackStdinIsTTY(isTTY2);
}
trackVersion(version) {
super.trackVersion(version);
}
trackProjectId(projectId) {
super.trackProjectId(projectId);
}
trackInvocationId(invocationId) {
super.trackInvocationId(invocationId);
}
trackDeviceId(deviceId) {
super.trackDeviceId(deviceId);
}
trackErrorStatus(status) {
super.trackErrorStatus(status);
}
trackErrorCode(code) {
super.trackErrorCode(code);
}
trackErrorSlug(slug) {
super.trackErrorSlug(slug);
}
trackErrorAction(action) {
super.trackErrorAction(action);
}
trackErrorServerMessage(serverMessage) {
super.trackErrorServerMessage(serverMessage);
}
trackCliOptionCwd(cwd) {
if (cwd) {
this.trackCliOption({ option: "cwd", value: this.redactedValue });
}
}
trackCliOptionLocalConfig(localConfig) {
if (localConfig) {
this.trackCliOption({
option: "local-config",
value: this.redactedValue
});
}
}
trackCliOptionGlobalConfig(globalConfig) {
if (globalConfig) {
this.trackCliOption({
option: "global-config",
value: this.redactedValue
});
}
}
trackCliOptionScope(scope) {
if (scope) {
this.trackCliOption({
option: "scope",
value: this.redactedValue
});
}
}
trackCliOptionToken(token) {
if (token) {
this.trackCliOption({
option: "token",
value: this.redactedValue
});
}
}
trackCliOptionTeam(team) {
if (team) {
this.trackCliOption({
option: "team",
value: this.redactedValue
});
}
}
trackCliOptionApi(api) {
if (api) {
this.trackCliOption({
option: "api",
value: this.redactedValue
});
}
}
trackCliFlagDebug(debug) {
if (debug) {
this.trackCliFlag("debug");
}
}
trackCliFlagNoColor(noColor) {
if (noColor) {
this.trackCliFlag("no-color");
}
}
};
// src/util/telemetry/check-status.ts
function checkTelemetryStatus({ config: config2 }) {
if (config2.telemetry) {
return;
}
if (process.env.VERCEL_TELEMETRY_DISABLED) {
return;
}
output_manager_default.note(
"The Vercel CLI now collects telemetry regarding usage of the CLI."
);
output_manager_default.log(
"This information is used to shape the CLI roadmap and prioritize features."
);
output_manager_default.log(
"You can learn more, including how to opt-out if you'd not like to participate in this program, by visiting the following URL:"
);
output_manager_default.log("https://vercel.com/docs/cli/about-telemetry");
config2.telemetry = {
enabled: true
};
writeToConfigFile(config2);
}
// src/util/guidance/check-status.ts
function checkGuidanceStatus({ config: config2 }) {
if (!process.env.FF_GUIDANCE_MODE) {
return;
}
if (process.env.CI) {
return;
}
if (process.env.VERCEL_GUIDANCE_DISABLED) {
return;
}
if (config2.guidance) {
return;
}
output_manager_default.note(
"The Vercel CLI can suggest common follow-up commands and steps to help guide new users."
);
output_manager_default.log("You can disable this feature by running:");
output_manager_default.log("vercel guidance disable");
output_manager_default.log("or by setting VERCEL_GUIDANCE_DISABLED=1");
config2.guidance = {
enabled: true
};
writeToConfigFile(config2);
}
// src/index.ts
import { determineAgent } from "@vercel/detect-agent";
import {
getPlatformEnv,
Span
} from "@vercel/build-utils";
import { mkdir, writeFile } from "fs/promises";
try {
process.cwd();
} catch (err) {
if ((0, import_error_utils3.isError)(err) && err.message.includes("uv_cwd")) {
console.error("Error: The current working directory does not exist.");
process.exit(1);
}
}
{
const SILENCED_ERRORS = [
"DeprecationWarning: The `punycode` module is deprecated. Please use a userland alternative instead."
];
const originalError = console.error;
console.error = (msg) => {
const isSilencedError = SILENCED_ERRORS.some(
(error) => typeof msg === "string" && msg.includes(error)
);
if (isSilencedError) {
return;
}
originalError(msg);
};
}
var VERCEL_DIR = getGlobalPathConfig();
var VERCEL_CONFIG_PATH = getConfigFilePath();
var VERCEL_AUTH_CONFIG_PATH = getAuthConfigFilePath();
var GLOBAL_COMMANDS = /* @__PURE__ */ new Set(["help"]);
function hasProxyConfig() {
return [
"HTTP_PROXY",
"HTTPS_PROXY",
"http_proxy",
"https_proxy",
"ALL_PROXY",
"all_proxy"
].some((v) => process.env[v]);
}
(0, import_epipebomb.default)();
var client;
var handleRejection = async (err) => {
if (err) {
if (err instanceof Error) {
await handleUnexpected(err);
} else {
output_manager_default.error(`An unexpected rejection occurred
${err}`);
await reportError(await getSentry(), client, err);
}
} else {
output_manager_default.error("An unexpected empty rejection occurred");
}
process.exit(1);
};
var handleUnexpected = async (err) => {
const { message } = err;
if (message.includes("sentry") && message.includes("ENOTFOUND")) {
output_manager_default.debug(`Sentry is not reachable: ${err}`);
return;
}
output_manager_default.error(`An unexpected error occurred!
${err.stack}`);
await reportError(await getSentry(), client, err);
process.exit(1);
};
process.on("unhandledRejection", handleRejection);
process.on("uncaughtException", handleUnexpected);
if (process.env.CLAUDECODE) {
process.stderr.write(
'<claude-code-hint v="1" type="plugin" value="vercel@claude-plugins-official" />\n'
);
}
var SHOULD_CHECK_FOR_UPDATES = !process.env.NO_UPDATE_NOTIFIER && !process.env.VERCEL;
var { isTTY } = process.stdout;
var apiUrl = "https://api.vercel.com";
var InMemoryReporter = class {
constructor() {
this.events = [];
}
report(event) {
this.events.push(event);
}
};
var main = async () => {
const traceReporter = new InMemoryReporter();
const rootSpan = new Span({ name: "vc.cli", reporter: traceReporter });
const isTelemetryFlushCommand = process.argv[2] === "telemetry" && process.argv[3] === "flush";
if (process.env.FORCE_TTY === "1") {
isTTY = true;
process.stdout.isTTY = true;
process.stdin.isTTY = true;
}
const parseInitialArgs = () => parseArguments(
process.argv,
{
"--version": Boolean,
"-v": "--version",
"--non-interactive": Boolean
},
{ permissive: true }
);
let parsedArgs;
try {
parsedArgs = parseInitialArgs();
const isDebugging = parsedArgs.flags["--debug"];
const isNoColor = parsedArgs.flags["--no-color"];
output_manager_default.initialize({
debug: isDebugging,
noColor: isNoColor
});
} catch (err) {
printError(err);
return 1;
}
const localConfigPath = parsedArgs.flags["--local-config"];
let localConfig = await earlyGetConfig(localConfigPath);
if (localConfig instanceof CantParseJSONFile) {
output_manager_default.error(`Couldn't parse JSON file ${localConfig.meta.file}.`);
return 1;
}
if (localConfig instanceof CantFindConfig) {
if (localConfigPath) {
output_manager_default.error(
`Couldn't find a project configuration file at
${localConfig.meta.paths.join(
" or\n "
)}`
);
return 1;
} else {
localConfig = void 0;
}
}
if (localConfig instanceof Error) {
output_manager_default.prettyError(localConfig);
return 1;
}
const targetOrSubcommand = parsedArgs.args[2];
const subSubCommand = parsedArgs.args[3];
const betaCommands = ["api", "crons", "curl", "webhooks"];
const msg = betaCommands.includes(targetOrSubcommand) ? `${getTitleName()} CLI ${pkg_default.version} | ${targetOrSubcommand} is in beta \u2014 https://vercel.com/feedback` : `${getTitleName()} CLI ${pkg_default.version}`;
if (process.env.VERCEL === "1") {
output_manager_default.print(`${msg}
`);
} else {
output_manager_default.debug(msg);
}
if (!targetOrSubcommand && parsedArgs.flags["--version"]) {
console.log(pkg_default.version);
return 0;
}
const bareHelpOption = !targetOrSubcommand && parsedArgs.flags["--help"];
const bareHelpSubcommand = targetOrSubcommand === "help" && !subSubCommand;
if (bareHelpOption || bareHelpSubcommand) {
output_manager_default.print(help());
return 0;
}
try {
await (0, import_fs_extra2.mkdirp)(VERCEL_DIR);
} catch (err) {
output_manager_default.error(
`An unexpected error occurred while trying to create the