vercel
Version:
The command-line interface for Vercel
1,801 lines (1,763 loc) • 1.53 MB
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 {
indent_default
} from "./chunks/chunk-A3NYPUKZ.js";
import {
RoutesAddTelemetryClient,
RoutesTelemetryClient
} from "./chunks/chunk-MUBKPS2Z.js";
import {
ALL_ACTION_CHOICES,
MAX_CONDITIONS,
MAX_DESCRIPTION_LENGTH,
MAX_NAME_LENGTH,
REDIRECT_STATUS_CODES,
VALID_SYNTAXES,
collectActionDetails,
collectHeadersAndTransforms,
collectInteractiveConditions,
convertRouteToCurrentRoute,
extractTransformFlags,
generateRoute,
generatedRouteToAddInput,
parseConditions,
populateRouteEnv,
printGeneratedRoutePreview,
runInteractiveEditLoop,
stripQuotes,
validateActionFlags
} from "./chunks/chunk-IIZO5JJ2.js";
import {
getRouteVersions
} from "./chunks/chunk-AHU7WNL2.js";
import {
TRANSFORM_TYPE_LABELS,
ensureProjectLink,
findVersionById,
formatCondition,
formatTransform,
getRouteTypeLabel,
getRoutes,
getSrcSyntaxLabel,
offerAutoPromote,
parsePosition,
parseSubcommandArgs,
withGlobalFlags
} from "./chunks/chunk-XNUHSM7I.js";
import {
normalizeRepeatableStringFilters
} from "./chunks/chunk-HTOH3MSD.js";
import {
OpenApiCache,
api,
box,
did_you_mean_default,
executeUpgrade,
login,
resolveOpenApiTagForProjectsCli,
resolveOpenApiTagForTeamsCli,
tryOpenApiFallback
} from "./chunks/chunk-J3BCJYPE.js";
import {
getUpdateCommand,
isGlobal
} from "./chunks/chunk-FUBTAFL2.js";
import {
Now,
collectContactInformation,
createCertForCns,
displayBuildLogs,
displayRuntimeLogs,
extractDomain,
getDomain,
getDomainByName,
getDomainPrice,
getDomainStatus,
isDeploying,
isWildcardAlias,
pollForOrder,
printDeploymentStatus,
purchaseDomain,
require_cjs,
require_format,
require_jsonlines,
setupDomain
} from "./chunks/chunk-V6RCNEUA.js";
import {
processRevocationResponse,
readLocalConfig,
require_open,
revocationRequest,
sleep,
writeToAuthConfigFile,
writeToConfigFile
} from "./chunks/chunk-F2UPASLT.js";
import "./chunks/chunk-V5P25P7F.js";
import {
getCustomEnvironments,
getInvalidSubcommand,
pickCustomEnvironment,
readStandardInput,
require_dist as require_dist4
} from "./chunks/chunk-C5YP6KFI.js";
import {
formatTable
} from "./chunks/chunk-2DFWEDF7.js";
import "./chunks/chunk-LOS7HHU3.js";
import {
isValidName
} from "./chunks/chunk-Y4JJYHUG.js";
import {
getCommandFlags
} from "./chunks/chunk-EOZFDJSY.js";
import {
getDeployment,
mapCertError,
toHost
} from "./chunks/chunk-NYJXGEIR.js";
import {
formatEnvironment,
validateLsArgs
} from "./chunks/chunk-PPIAHRII.js";
import {
validateJsonOutput
} from "./chunks/chunk-XPKWKPWA.js";
import {
getSubcommand as getSubcommand4
} from "./chunks/chunk-YPQSDAEW.js";
import {
ADDON_LABELS,
CREDIT_TYPE_LABELS,
SUPPORTED_ADDON_ALIASES,
SUPPORTED_CREDIT_TYPES,
abortSubcommand,
acceptTermsSubcommand,
accessGroupsSubcommand,
accessSummarySubcommand,
addStoreSubcommand,
addSubcommand,
addSubcommand10,
addSubcommand11,
addSubcommand2,
addSubcommand3,
addSubcommand4,
addSubcommand5,
addSubcommand6,
addSubcommand8 as addSubcommand7,
addSubcommand9 as addSubcommand8,
addToGroupSubcommand,
addonSubcommand,
agentCommand,
aiGatewayCommand,
aliasCommand,
apiKeysSubcommand,
approveSubcommand,
archiveSubcommand,
attachSubcommand,
attackModeDisableSubcommand,
attackModeEnableSubcommand,
attackModeSubcommand,
balanceSubcommand,
bisectCommand,
blobCommand,
buyCommand,
buySubcommand,
cacheCommand,
certsCommand,
checksAddFlags,
checksRemoveFlags,
checksSubcommand,
completeSubcommand,
configureSubcommand,
connectSubcommand,
connexCommand,
contractCommand,
copySubcommand,
createGroupSubcommand,
createStoreSubcommand,
createSubcommand,
createSubcommand2,
createSubcommand3,
createSubcommand4,
createSubcommand5,
createThresholdSubcommand,
creditsSubcommand,
cronsCommand,
curlCommand,
dangerouslyDeleteSubcommand,
delSubcommand,
deleteGroupSubcommand,
deleteStoreSubcommand,
deployHooksCommand,
detachSubcommand,
diffSubcommand,
disableSubcommand,
disableSubcommand2,
disableSubcommand3 as disableSubcommand4,
discardSubcommand,
disconnectSubcommand,
disconnectSubcommand2,
discoverSubcommand,
dismissSubcommand,
dnsCommand,
domainSubcommand,
domainsCommand,
edgeConfigCommand,
emptyStoreSubcommand,
enableSubcommand,
enableSubcommand2,
enableSubcommand3 as enableSubcommand4,
fetchSubcommand,
firewallCommand,
flagsCommand,
flushSubcommand,
getCommandAliases,
getStoreInfoSubcommand,
getStoreSubcommand,
getSubcommand,
getSubcommand2,
getSubcommand3,
gitCommand,
guidanceCommand,
guideSubcommand,
httpstatCommand,
importSubcommand,
initCommand,
inspectCommand,
inspectGroupSubcommand,
inspectSubcommand as inspectSubcommand2,
inspectSubcommand2 as inspectSubcommand3,
inspectSubcommand3 as inspectSubcommand4,
installCommand,
installSubcommand,
installationsSubcommand,
integrationCommand,
integrationResourceCommand,
invalidateSubcommand,
inviteSubcommand,
ipBlocksBlockSubcommand,
ipBlocksListSubcommand,
ipBlocksSubcommand,
ipBlocksUnblockSubcommand,
issueSubcommand,
itemsSubcommand,
listRequestsSubcommand,
listStoresSubcommand,
listSubcommand as listSubcommand2,
listSubcommand10,
listSubcommand11,
listSubcommand12,
listSubcommand13,
listSubcommand14 as listSubcommand15,
listSubcommand15 as listSubcommand16,
listSubcommand16 as listSubcommand17,
listSubcommand17 as listSubcommand18,
listSubcommand18 as listSubcommand19,
listSubcommand3,
listSubcommand4,
listSubcommand5,
listSubcommand6,
listSubcommand7,
listSubcommand8,
listSubcommand9,
listVersionsSubcommand,
logoutCommand,
logsCommand,
mcpCommand,
membersSubcommand,
membersSubcommand2,
microfrontendsCommand,
moveSubcommand,
oauthAppsCommand,
openCommand,
openSubcommand,
openSubcommand2,
openSubcommand3,
overrideSubcommand,
overviewSubcommand,
prepareSubcommand,
priceSubcommand,
proSubcommand,
projectCommand,
promoteCommand,
promoteSubcommand,
protectionSubcommand,
publishSubcommand,
pullSubcommand,
purgeSubcommand,
putSubcommand,
redeployCommand,
redirectsCommand,
registerSubcommand,
removeCommand,
removeFromGroupSubcommand,
removeStoreSubcommand,
removeSubcommand,
removeSubcommand10,
removeSubcommand11,
removeSubcommand12,
removeSubcommand13,
removeSubcommand14,
removeSubcommand15,
removeSubcommand2,
removeSubcommand3,
removeSubcommand4,
removeSubcommand5,
removeSubcommand6,
removeSubcommand7,
removeSubcommand8,
removeSubcommand9,
renameSubcommand,
requestSubcommand,
restoreSubcommand,
rollbackCommand,
rollingReleaseCommand,
rolloutSubcommand,
rulesAddSubcommand as rulesAddSubcommand2,
rulesDisableSubcommand,
rulesEditSubcommand,
rulesEnableSubcommand,
rulesInspectSubcommand as rulesInspectSubcommand2,
rulesListSubcommand,
rulesRemoveSubcommand,
rulesReorderSubcommand,
rulesSubcommand,
runSubcommand,
sdkKeysAddSubcommand,
sdkKeysListSubcommand,
sdkKeysRemoveSubcommand,
sdkKeysSubcommand,
setSubcommand,
setSubcommand2,
skillsCommand,
speedInsightsSubcommand,
ssoSubcommand,
startSubcommand,
statusSubcommand,
statusSubcommand2,
statusSubcommand3,
statusSubcommand4,
switchSubcommand,
systemBypassAddSubcommand,
systemBypassListSubcommand,
systemBypassRemoveSubcommand,
systemBypassSubcommand,
systemMitigationsPauseSubcommand,
systemMitigationsResumeSubcommand,
systemMitigationsSubcommand,
targetCommand,
teamsCommand,
telemetryCommand,
tokenSubcommand,
tokenSubcommand2,
tokensCommand,
tokensSubcommand,
transferInSubcommand,
updateSubcommand,
updateSubcommand2,
updateSubcommand3,
upgradeCommand,
uploadSubcommand,
usageCommand,
v0Subcommand,
webAnalyticsSubcommand,
webhooksCommand,
whoamiCommand
} from "./chunks/chunk-UVFXUXOZ.js";
import {
metricsCommand,
schemaSubcommand
} from "./chunks/chunk-IFATV36R.js";
import {
addSubcommand as addSubcommand9,
deleteSubcommand,
disableSubcommand as disableSubcommand3,
discardSubcommand as discardSubcommand2,
editSubcommand,
enableSubcommand as enableSubcommand3,
exportSubcommand,
inspectSubcommand as inspectSubcommand5,
listSubcommand as listSubcommand14,
listVersionsSubcommand as listVersionsSubcommand2,
publishSubcommand as publishSubcommand2,
reorderSubcommand,
restoreSubcommand as restoreSubcommand2,
routesCommand
} from "./chunks/chunk-JFVGRFME.js";
import {
alertsCommand,
inspectSubcommand,
listSubcommand
} from "./chunks/chunk-TZMIHH5D.js";
import {
rulesAddSubcommand,
rulesAggregateCommand,
rulesInspectSubcommand,
rulesLsSubcommand,
rulesRmSubcommand,
rulesUpdateSubcommand
} from "./chunks/chunk-XVAEOG4L.js";
import "./chunks/chunk-ZAAKSLHC.js";
import {
activityCommand,
typesSubcommand
} from "./chunks/chunk-CQANJIEC.js";
import {
detectExplicitScope,
getScope
} from "./chunks/chunk-KWDV5FZH.js";
import "./chunks/chunk-4PSOOFYO.js";
import {
main
} from "./chunks/chunk-FXOKKAK2.js";
import {
AGENT_ACTION,
AGENT_REASON,
AGENT_STATUS
} from "./chunks/chunk-E3NE4SKN.js";
import "./chunks/chunk-LVUE7LLE.js";
import {
ua_default
} from "./chunks/chunk-76ZNZKIN.js";
import {
require_execa
} from "./chunks/chunk-N733ZD4W.js";
import {
ensureLink
} from "./chunks/chunk-N4WFAZKO.js";
import "./chunks/chunk-UTXSTM52.js";
import "./chunks/chunk-4VPRHRPA.js";
import {
autoInstallVercelPlugin
} from "./chunks/chunk-ZKKIBUCU.js";
import {
help
} from "./chunks/chunk-MMF4BVAP.js";
import {
STANDARD_ENVIRONMENTS,
VERCEL_CONFIG_EXTENSIONS,
checkExistsAndConnect,
createEnvObject,
createGitMeta,
createProject,
disconnectGitProvider,
envPullCommandLogic,
envTargetChoices,
formatProject,
getLinkFromDir,
getLinkedProject,
getProjectByNameOrId,
getProjectLink,
getTeamById,
getTeams,
getUser,
getVercelDirectory,
humanizePath,
isValidEnvTarget,
isVercelTomlEnabled,
list,
param,
parseGitConfig,
parseRepoUrl,
pluckRemoteUrls,
printAlignedLabel,
printRemoteUrls,
pull,
readJSONFile,
require_dist as require_dist2,
require_dist3,
require_fast_deep_equal,
require_frameworks,
require_lib,
require_pluralize,
require_tar_fs,
resolveProjectCwd,
selectAndParseRemoteUrl,
selectOrg
} from "./chunks/chunk-X775BOSL.js";
import {
TelemetryClient
} from "./chunks/chunk-4OEA5ILS.js";
import {
argvHasNonInteractive,
buildCommandWithGlobalFlags,
buildCommandWithYes,
buildIntegrationCommandTailFromArgv,
exitWithNonInteractiveError,
getGlobalFlagsFromArgv,
openUrlInBrowserCommand,
outputActionRequired,
outputAgentError,
shouldEmitNonInteractiveCommandError
} from "./chunks/chunk-ULXHXZCZ.js";
import {
elapsed,
require_ms,
stamp_default
} from "./chunks/chunk-CO5D46AG.js";
import {
require_lib as require_lib3
} from "./chunks/chunk-N2T234LO.js";
import {
table
} from "./chunks/chunk-DKD6GTQT.js";
import {
GLOBAL_CLI_FLAG_NAMES,
getCommandNameWithGlobalFlags,
getFlagsSpecification,
getGlobalFlagsOnlyFromArgs,
getSameSubcommandSuggestionFlags,
globalCliFlagTakesValue,
parseArguments,
printError
} from "./chunks/chunk-4GQQJY5Y.js";
import {
APIError,
AliasInUse,
CertConfigurationError,
CertError,
CertMissing,
CertNotFound,
CertOrderNotFound,
CertsPermissionDenied,
DNSConflictingRecord,
DNSInvalidPort,
DNSInvalidType,
DNSPermissionDenied,
DeploymentFailedAliasImpossible,
DeploymentNotFound,
DeploymentNotReady,
DeploymentPermissionDenied,
DomainAlreadyExists,
DomainExternal,
DomainMoveConflict,
DomainNotAvailable,
DomainNotFound,
DomainNotVerified,
DomainPaymentError,
DomainPermissionDenied,
DomainPurchasePending,
DomainRemovalConflict,
InvalidAlias,
InvalidAliasInConfig,
InvalidDeploymentId,
InvalidDomain,
InvalidMoveDestination,
LinkRequiredError,
NoAliasInConfig,
NowError,
ProjectNotFound,
SourceNotFound,
TLDNotSupportedViaCLI,
TooManyRequests,
UnexpectedDomainPurchaseError,
UnexpectedDomainTransferError,
UnsupportedTLD,
UserAborted,
cmd,
code,
getCommandName,
getCommandNamePlain,
isAPIError,
packageName,
require_bytes,
require_lib as require_lib2,
stripSensitiveAuthArgs
} from "./chunks/chunk-UGXBNJMO.js";
import {
pkg_default
} from "./chunks/chunk-P4QNYOFB.js";
import {
emoji,
eraseLines,
link_default,
output_manager_default,
prependEmoji,
require_dist
} from "./chunks/chunk-ZQKJVHXY.js";
import {
require_source
} from "./chunks/chunk-S7KYDPEM.js";
import {
__require,
__toESM
} from "./chunks/chunk-TZ2YI2VH.js";
// src/util/telemetry/commands/agent/index.ts
var AgentTelemetryClient = class extends TelemetryClient {
trackCliArgumentInit(value) {
if (value) {
this.trackCliArgument({
arg: "init",
value
});
}
}
trackCliFlagYes(value) {
if (value) {
this.trackCliFlag("yes");
}
}
};
// src/commands/agent/init.ts
var import_chalk = __toESM(require_source(), 1);
import { readFile, writeFile } from "fs/promises";
import { join } from "path";
import { KNOWN_AGENTS } from "@vercel/detect-agent";
var BEST_PRACTICES_START = "<!-- VERCEL BEST PRACTICES START -->";
var BEST_PRACTICES_END = "<!-- VERCEL BEST PRACTICES END -->";
var BEST_PRACTICES_BODY = `## Best practices for developing on Vercel
These defaults are optimized for AI coding agents (and humans) working on apps that deploy to Vercel.
- Treat Vercel Functions as stateless + ephemeral (no durable RAM/FS, no background daemons), use Blob or marketplace integrations for preserving state
- Edge Functions (standalone) are deprecated; prefer Vercel Functions
- Don't start new projects on Vercel KV/Postgres (both discontinued); use Marketplace Redis/Postgres instead
- Store secrets in Vercel Env Variables; not in git or \`NEXT_PUBLIC_*\`
- Provision Marketplace native integrations with \`vercel integration add\` (CI/agent-friendly)
- Sync env + project settings with \`vercel env pull\` / \`vercel pull\` when you need local/offline parity
- Use \`waitUntil\` for post-response work; avoid the deprecated Function \`context\` parameter
- Set Function regions near your primary data source; avoid cross-region DB/service roundtrips
- Tune Fluid Compute knobs (e.g., \`maxDuration\`, memory/CPU) for long I/O-heavy calls (LLMs, APIs)
- Use Runtime Cache for fast **regional** caching + tag invalidation (don't treat it as global KV)
- Use Cron Jobs for schedules; cron runs in UTC and triggers your production URL via HTTP GET
- Use Vercel Blob for uploads/media; Use Edge Config for small, globally-read config
- If Enable Deployment Protection is enabled, use a bypass secret to directly access them
- Add OpenTelemetry via \`@vercel/otel\` on Node; don't expect OTEL support on the Edge runtime
- Enable Web Analytics + Speed Insights early
- Use AI Gateway for model routing, set AI_GATEWAY_API_KEY, using a model string (e.g. 'anthropic/claude-sonnet-4.6'), Gateway is already default in AI SDK
needed. Always curl https://ai-gateway.vercel.sh/v1/models first; never trust model IDs from memory
- For durable agent loops or untrusted code: use Workflow (pause/resume/state) + Sandbox; use Vercel MCP for secure infra access`;
var BEST_PRACTICES_CONTENT = `${BEST_PRACTICES_START}
${BEST_PRACTICES_BODY}
${BEST_PRACTICES_END}
`;
function getTargetFile(agentName) {
if (agentName === KNOWN_AGENTS.CLAUDE) {
return "CLAUDE.md";
}
return "AGENTS.md";
}
async function agentInit(client, yes) {
const targetFile = getTargetFile(client.agentName);
const filePath = join(client.cwd, targetFile);
let existing = null;
try {
existing = await readFile(filePath, "utf-8");
} catch {
}
const hasMarkers = existing !== null && existing.includes(BEST_PRACTICES_START) && existing.includes(BEST_PRACTICES_END);
const action = hasMarkers ? "update" : existing !== null ? "append" : "create";
const promptMessage = hasMarkers ? `We're going to update Vercel best practices in your ${import_chalk.default.bold(targetFile)}. Proceed?` : `We're going to add Vercel best practices to your ${import_chalk.default.bold(targetFile)}. Proceed?`;
if (!yes && client.stdin.isTTY) {
const confirmed = await client.input.confirm(promptMessage, true);
if (!confirmed) {
output_manager_default.log("Canceled");
return 0;
}
} else if (!yes && !client.stdin.isTTY) {
output_manager_default.error(
"Missing required flag --yes. Use --yes to skip confirmation, or run interactively in a terminal."
);
return 1;
}
output_manager_default.spinner(`Writing Vercel best practices to ${targetFile}`);
try {
if (action === "update") {
const startIdx = existing.indexOf(BEST_PRACTICES_START);
const endIdx = existing.indexOf(BEST_PRACTICES_END) + BEST_PRACTICES_END.length;
const trailingNewline = existing[endIdx] === "\n" ? 1 : 0;
const updated = existing.slice(0, startIdx) + BEST_PRACTICES_CONTENT + existing.slice(endIdx + trailingNewline);
await writeFile(filePath, updated, "utf-8");
output_manager_default.stopSpinner();
output_manager_default.success(
`Updated Vercel best practices in ${import_chalk.default.bold(targetFile)}`
);
} else if (action === "append") {
const separator = existing.endsWith("\n") ? "\n" : "\n\n";
await writeFile(
filePath,
existing + separator + BEST_PRACTICES_CONTENT,
"utf-8"
);
output_manager_default.stopSpinner();
output_manager_default.success(
`Appended Vercel best practices to ${import_chalk.default.bold(targetFile)}`
);
} else {
await writeFile(filePath, BEST_PRACTICES_CONTENT, "utf-8");
output_manager_default.stopSpinner();
output_manager_default.success(
`Created ${import_chalk.default.bold(targetFile)} with Vercel best practices`
);
}
} catch (error) {
output_manager_default.stopSpinner();
printError(error);
return 1;
}
output_manager_default.log(import_chalk.default.dim("Run vercel deploy to ship your project"));
return 0;
}
// src/commands/agent/index.ts
async function agent(client) {
let parsedArgs;
const flagsSpecification = getFlagsSpecification(agentCommand.options);
const telemetry2 = new AgentTelemetryClient({
opts: {
store: client.telemetryEventStore
}
});
try {
parsedArgs = parseArguments(client.argv.slice(2), flagsSpecification);
} catch (error) {
printError(error);
return 1;
}
if (parsedArgs.flags["--help"]) {
telemetry2.trackCliFlagHelp("agent");
output_manager_default.print(help(agentCommand, { columns: client.stderr.columns }));
return 2;
}
const subcommand = parsedArgs.args[1];
telemetry2.trackCliArgumentInit(subcommand);
if (!subcommand || subcommand === "init") {
const yes = parsedArgs.flags["--yes"] ?? false;
telemetry2.trackCliFlagYes(yes);
try {
return await agentInit(client, yes);
} catch (error) {
printError(error);
return 1;
}
}
output_manager_default.error(`Unknown subcommand: ${subcommand}`);
output_manager_default.print(help(agentCommand, { columns: client.stderr.columns }));
return 1;
}
// src/util/telemetry/commands/activity/index.ts
var ActivityTelemetryClient = class extends TelemetryClient {
trackCliSubcommandLs(v) {
if (v) {
this.trackCliSubcommand({
subcommand: "ls",
value: v
});
}
}
trackCliSubcommandTypes(v) {
if (v) {
this.trackCliSubcommand({
subcommand: "types",
value: v
});
}
}
trackCliOptionType(v) {
if (v && v.length > 0) {
this.trackCliOption({
option: "type",
value: v.join(",")
});
}
}
trackCliOptionSince(v) {
if (v) {
this.trackCliOption({
option: "since",
value: this.redactedValue
});
}
}
trackCliOptionUntil(v) {
if (v) {
this.trackCliOption({
option: "until",
value: this.redactedValue
});
}
}
trackCliOptionProject(v) {
if (v) {
this.trackCliOption({
option: "project",
value: this.redactedValue
});
}
}
trackCliFlagAll(v) {
if (v) {
this.trackCliFlag("all");
}
}
trackCliOptionLimit(v) {
if (typeof v === "number") {
this.trackCliOption({
option: "limit",
value: this.redactedValue
});
}
}
trackCliOptionNext(v) {
if (typeof v === "number") {
this.trackCliOption({
option: "next",
value: this.redactedValue
});
}
}
};
// src/commands/activity/index.ts
var COMMAND_CONFIG = {
types: getCommandAliases(typesSubcommand)
};
async function activity(client) {
const telemetry2 = new ActivityTelemetryClient({
opts: {
store: client.telemetryEventStore
}
});
let parsedArgs;
const flagsSpecification = getFlagsSpecification(activityCommand.options);
try {
parsedArgs = parseArguments(client.argv.slice(2), flagsSpecification, {
permissive: true
});
} catch (err) {
printError(err);
return 1;
}
const { subcommand, subcommandOriginal } = getSubcommand4(
parsedArgs.args.slice(1),
COMMAND_CONFIG
);
const needHelp = parsedArgs.flags["--help"];
if (!subcommand && needHelp) {
telemetry2.trackCliFlagHelp("activity", subcommand);
output_manager_default.print(help(activityCommand, { columns: client.stderr.columns }));
return 0;
}
function printSubcommandHelp(command) {
output_manager_default.print(
help(command, { parent: activityCommand, columns: client.stderr.columns })
);
}
switch (subcommand) {
case "types": {
if (needHelp) {
telemetry2.trackCliFlagHelp("activity", subcommandOriginal);
printSubcommandHelp(typesSubcommand);
return 0;
}
telemetry2.trackCliSubcommandTypes(subcommandOriginal);
const typesFn = (await import("./chunks/types-QAT6PCGL.js")).default;
return typesFn(client, telemetry2);
}
default: {
if (needHelp) {
telemetry2.trackCliFlagHelp("activity", subcommandOriginal);
output_manager_default.print(help(activityCommand, { columns: client.stderr.columns }));
return 0;
}
telemetry2.trackCliSubcommandLs(subcommandOriginal);
const listFn = (await import("./chunks/list-GEI7DMTS.js")).default;
return listFn(client, telemetry2);
}
}
}
// src/commands/ai-gateway/api-keys-create.ts
var import_chalk2 = __toESM(require_source(), 1);
// src/util/ai-gateway/create-api-key.ts
async function createApiKey(client, payload) {
return await client.fetch("/v1/api-keys", {
method: "POST",
body: {
purpose: "ai-gateway",
...payload
}
});
}
// src/util/telemetry/commands/ai-gateway/api-keys-create.ts
var AiGatewayApiKeysCreateTelemetryClient = class extends TelemetryClient {
trackCliOptionName(name) {
if (name) {
this.trackCliOption({
option: "name",
value: this.redactedValue
});
}
}
trackCliOptionBudget(budget) {
if (budget !== void 0) {
this.trackCliOption({
option: "budget",
value: this.redactedValue
});
}
}
trackCliOptionRefreshPeriod(refreshPeriod) {
if (refreshPeriod) {
this.trackCliOption({
option: "refresh-period",
value: refreshPeriod
});
}
}
trackCliFlagIncludeByok(includeByok) {
if (includeByok) {
this.trackCliFlag("include-byok");
}
}
};
// src/commands/ai-gateway/api-keys-create.ts
var VALID_REFRESH_PERIODS = ["daily", "weekly", "monthly", "none"];
async function create(client, argv) {
const telemetry2 = new AiGatewayApiKeysCreateTelemetryClient({
opts: {
store: client.telemetryEventStore
}
});
let parsedArgs;
const flagsSpecification = getFlagsSpecification(createSubcommand.options);
try {
parsedArgs = parseArguments(argv, flagsSpecification);
} catch (error) {
printError(error);
return 1;
}
const { flags: opts } = parsedArgs;
const name = opts["--name"];
const budget = opts["--budget"];
const refreshPeriod = opts["--refresh-period"];
const includeByok = opts["--include-byok"];
telemetry2.trackCliOptionName(name);
telemetry2.trackCliOptionBudget(budget);
telemetry2.trackCliOptionRefreshPeriod(refreshPeriod);
telemetry2.trackCliFlagIncludeByok(includeByok);
if (budget !== void 0 && budget < 1) {
const message = "Budget must be a positive number in dollars (minimum 1).";
outputAgentError(
client,
{
status: AGENT_STATUS.ERROR,
reason: AGENT_REASON.INVALID_BUDGET,
message,
next: [
{
command: getCommandNamePlain(
"ai-gateway api-keys create --budget 500"
)
}
]
},
1
);
output_manager_default.error(message);
return 1;
}
if (refreshPeriod && !VALID_REFRESH_PERIODS.includes(
refreshPeriod
)) {
const message = `Invalid refresh period "${refreshPeriod}". Must be one of: ${VALID_REFRESH_PERIODS.join(", ")}.`;
outputAgentError(
client,
{
status: AGENT_STATUS.ERROR,
reason: AGENT_REASON.INVALID_REFRESH_PERIOD,
message,
next: [
{
command: getCommandNamePlain(
"ai-gateway api-keys create --refresh-period monthly"
)
}
]
},
1
);
output_manager_default.error(message);
return 1;
}
const effectiveRefreshPeriod = refreshPeriod && refreshPeriod !== "none" ? refreshPeriod : void 0;
const aiGatewayQuota = budget !== void 0 || effectiveRefreshPeriod || includeByok ? {
...budget !== void 0 && { limitAmount: budget },
...effectiveRefreshPeriod && {
refreshPeriod: effectiveRefreshPeriod
},
...includeByok && { includeByokInQuota: true }
} : void 0;
if (!client.config.currentTeam) {
if (!client.stdin.isTTY) {
output_manager_default.error(
"No team selected. Use `vercel --scope <team-slug> ai-gateway api-keys create` or run `vercel switch` first."
);
return 1;
}
const org = await selectOrg(client, "Which team should own this API key?");
if (org.type === "team") {
client.config.currentTeam = org.id;
}
}
const createStamp = stamp_default();
output_manager_default.spinner("Creating API key");
try {
const result = await createApiKey(client, {
name,
aiGatewayQuota
});
output_manager_default.stopSpinner();
client.stdout.write(`${result.apiKeyString}
`);
output_manager_default.success(
`API key ${import_chalk2.default.bold(result.apiKey.name)} (${result.apiKey.id}) created ${createStamp()}`
);
return 0;
} catch (err) {
output_manager_default.stopSpinner();
if (isAPIError(err)) {
output_manager_default.error(err.message);
return 1;
}
throw err;
}
}
// src/util/telemetry/commands/ai-gateway/api-keys.ts
var AiGatewayApiKeysTelemetryClient = class extends TelemetryClient {
trackCliSubcommandCreate(actual) {
this.trackCliSubcommand({
subcommand: "create",
value: actual
});
}
};
// src/commands/ai-gateway/api-keys.ts
var COMMAND_CONFIG2 = {
create: getCommandAliases(createSubcommand)
};
async function apiKeys(client) {
const telemetry2 = new AiGatewayApiKeysTelemetryClient({
opts: {
store: client.telemetryEventStore
}
});
const flagsSpecification = getFlagsSpecification(apiKeysSubcommand.options);
let parsedArgs;
try {
parsedArgs = parseArguments(client.argv.slice(2), flagsSpecification, {
permissive: true
});
} catch (err) {
printError(err);
return 1;
}
const subArgs = parsedArgs.args.slice(2);
const { subcommand, args, subcommandOriginal } = getSubcommand4(
subArgs,
COMMAND_CONFIG2
);
const needHelp = parsedArgs.flags["--help"];
if (!subcommand && needHelp) {
telemetry2.trackCliFlagHelp("ai-gateway api-keys", subcommand);
output_manager_default.print(help(apiKeysSubcommand, { columns: client.stderr.columns }));
return 2;
}
function printHelp(command) {
output_manager_default.print(
help(command, {
parent: apiKeysSubcommand,
columns: client.stderr.columns
})
);
}
switch (subcommand) {
case "create":
if (needHelp) {
telemetry2.trackCliFlagHelp("ai-gateway api-keys", subcommandOriginal);
printHelp(createSubcommand);
return 2;
}
telemetry2.trackCliSubcommandCreate(subcommandOriginal);
return create(client, args);
default:
output_manager_default.error(getInvalidSubcommand(COMMAND_CONFIG2));
output_manager_default.print(help(apiKeysSubcommand, { columns: client.stderr.columns }));
return 2;
}
}
// src/util/telemetry/commands/ai-gateway/index.ts
var AiGatewayTelemetryClient = class extends TelemetryClient {
trackCliSubcommandApiKeys(actual) {
this.trackCliSubcommand({
subcommand: "api-keys",
value: actual
});
}
};
// src/commands/ai-gateway/index.ts
var COMMAND_CONFIG3 = {
"api-keys": getCommandAliases(apiKeysSubcommand)
};
async function main2(client) {
let parsedArgs;
const flagsSpecification = getFlagsSpecification(aiGatewayCommand.options);
try {
parsedArgs = parseArguments(client.argv.slice(2), flagsSpecification, {
permissive: true
});
} catch (error) {
printError(error);
return 1;
}
const telemetry2 = new AiGatewayTelemetryClient({
opts: {
store: client.telemetryEventStore
}
});
const { subcommand, subcommandOriginal } = getSubcommand4(
parsedArgs.args.slice(1),
COMMAND_CONFIG3
);
const needHelp = parsedArgs.flags["--help"];
if (!subcommand && needHelp) {
telemetry2.trackCliFlagHelp("ai-gateway");
output_manager_default.print(help(aiGatewayCommand, { columns: client.stderr.columns }));
return 2;
}
switch (subcommand) {
case "api-keys":
telemetry2.trackCliSubcommandApiKeys(subcommandOriginal);
return apiKeys(client);
default:
if (needHelp) {
telemetry2.trackCliFlagHelp("ai-gateway", subcommandOriginal);
output_manager_default.print(
help(aiGatewayCommand, { columns: client.stderr.columns })
);
return 2;
}
output_manager_default.error(
"Please specify a subcommand. Run `vercel ai-gateway --help` for usage information."
);
return 1;
}
}
// src/util/telemetry/commands/alerts/index.ts
var AlertsTelemetryClient = class extends TelemetryClient {
trackCliSubcommandLs(v) {
if (v) {
this.trackCliSubcommand({
subcommand: "ls",
value: v
});
}
}
trackCliSubcommandInspect(actual) {
this.trackCliSubcommand({
subcommand: "inspect",
value: actual
});
}
trackCliSubcommandRules(actual) {
this.trackCliSubcommand({
subcommand: "rules",
value: actual
});
}
trackCliOptionType(v) {
if (v && v.length > 0) {
this.trackCliOption({
option: "type",
value: v.join(",")
});
}
}
trackCliOptionSince(v) {
if (v) {
this.trackCliOption({
option: "since",
value: this.redactedValue
});
}
}
trackCliOptionUntil(v) {
if (v) {
this.trackCliOption({
option: "until",
value: this.redactedValue
});
}
}
trackCliOptionProject(v) {
if (v) {
this.trackCliOption({
option: "project",
value: this.redactedValue
});
}
}
trackCliFlagAll(v) {
if (v) {
this.trackCliFlag("all");
}
}
trackCliFlagAi(v) {
if (v) {
this.trackCliFlag("ai");
}
}
trackCliOptionLimit(v) {
if (typeof v === "number") {
this.trackCliOption({
option: "limit",
value: this.redactedValue
});
}
}
};
// src/commands/alerts/index.ts
var COMMAND_CONFIG4 = {
inspect: getCommandAliases(inspectSubcommand),
ls: getCommandAliases(listSubcommand),
rules: ["rules"]
};
async function alerts(client) {
const telemetry2 = new AlertsTelemetryClient({
opts: {
store: client.telemetryEventStore
}
});
let parsedArgs;
const flagsSpecification = getFlagsSpecification(alertsCommand.options);
try {
parsedArgs = parseArguments(client.argv.slice(2), flagsSpecification, {
permissive: true
});
} catch (err) {
const msg = err instanceof Error ? err.message : String(err);
const projectFlagMissingArg = msg.includes("--project") && msg.includes("requires argument");
if (shouldEmitNonInteractiveCommandError(client)) {
outputAgentError(
client,
{
status: "error",
reason: AGENT_REASON.INVALID_ARGUMENTS,
message: projectFlagMissingArg ? "`--project` requires a project name or id (for example `--project my-app`)." : msg,
next: projectFlagMissingArg ? [
{
command: buildCommandWithGlobalFlags(
client.argv,
"alerts --project <name-or-id>"
),
when: "Re-run with a project name or id (replace placeholder)"
},
{
command: buildCommandWithGlobalFlags(
client.argv,
"alerts --help"
),
when: "See all `alerts` flags and examples"
}
] : [
{
command: buildCommandWithGlobalFlags(
client.argv,
"alerts --help"
),
when: "See valid flags and examples"
}
]
},
1
);
}
printError(err);
return 1;
}
const { subcommand, args, subcommandOriginal } = getSubcommand4(
parsedArgs.args.slice(1),
COMMAND_CONFIG4
);
const needHelp = parsedArgs.flags["--help"];
function printHelp(command) {
output_manager_default.print(
help(command, { parent: alertsCommand, columns: client.stderr.columns })
);
}
if (needHelp) {
if (subcommand === "inspect") {
telemetry2.trackCliFlagHelp("alerts", "inspect");
printHelp(inspectSubcommand);
return 0;
}
if (subcommand === "rules") {
telemetry2.trackCliFlagHelp("alerts", "rules");
const nested = args[0];
if (nested === "ls" || nested === "list") {
printHelp(rulesLsSubcommand);
return 0;
}
if (nested === "add" || nested === "create") {
printHelp(rulesAddSubcommand);
return 0;
}
if (nested === "inspect" || nested === "get") {
printHelp(rulesInspectSubcommand);
return 0;
}
if (nested === "rm" || nested === "remove" || nested === "delete") {
printHelp(rulesRmSubcommand);
return 0;
}
if (nested === "update" || nested === "patch") {
printHelp(rulesUpdateSubcommand);
return 0;
}
output_manager_default.print(
help(rulesAggregateCommand, {
parent: alertsCommand,
columns: client.stderr.columns
})
);
return 0;
}
telemetry2.trackCliFlagHelp("alerts", subcommandOriginal);
output_manager_default.print(help(alertsCommand, { columns: client.stderr.columns }));
return 0;
}
switch (subcommand) {
case "inspect": {
telemetry2.trackCliSubcommandInspect(subcommandOriginal);
const inspectFn = (await import("./chunks/inspect-SF355FJC.js")).default;
return inspectFn(client, args);
}
case "rules": {
telemetry2.trackCliSubcommandRules(args[0] ?? "ls");
const rulesFn = (await import("./chunks/rules-KRCW5RQK.js")).default;
return rulesFn(client, args);
}
default: {
telemetry2.trackCliSubcommandLs(subcommandOriginal);
const listFn = (await import("./chunks/list-ZGR3WI5L.js")).default;
return listFn(client, telemetry2);
}
}
}
// src/commands/alias/ls.ts
var import_chalk3 = __toESM(require_source(), 1);
var import_ms = __toESM(require_ms(), 1);
// src/util/alias/get-aliases.ts
async function getAliases(client, deploymentId, next, limit = 20) {
let aliasUrl = `/v3/now/aliases?limit=${limit}`;
if (next) {
aliasUrl += `&until=${next}`;
}
const to = deploymentId ? `/now/deployments/${deploymentId}/aliases` : aliasUrl;
try {
const payload = await client.fetch(to);
return payload;
} catch (err) {
if (isAPIError(err)) {
const contextName = await getScope(client).then(
(scope) => scope.contextName
);
if (err.status === 404) {
throw new DeploymentNotFound({
id: deploymentId,
context: contextName
});
}
if (err.status === 403 && deploymentId) {
throw new DeploymentPermissionDenied(deploymentId, contextName);
}
if (err.status === 400 && err.message.includes("`id`") && deploymentId) {
throw new InvalidDeploymentId(deploymentId);
}
}
throw err;
}
}
// src/util/get-pagination-opts.ts
function getPaginationOpts(opts) {
const { "--next": nextTimestamp, "--limit": limit } = opts;
if (typeof nextTimestamp !== void 0 && Number.isNaN(nextTimestamp)) {
throw new Error("Please provide a number for option --next");
}
if (typeof limit === "number" && (!Number.isInteger(limit) || limit > 100 || limit < 1)) {
throw new Error(
"Please provide an integer from 1 to 100 for option --limit"
);
}
return [nextTimestamp, limit];
}
// src/util/telemetry/commands/alias/list.ts
var AliasListTelemetryClient = class extends TelemetryClient {
trackCliOptionLimit(limit) {
if (limit) {
this.trackCliOption({
option: "limit",
value: String(limit)
});
}
}
trackCliOptionNext(next) {
if (next) {
this.trackCliOption({
option: "next",
value: this.redactedValue
});
}
}
};
// src/commands/alias/ls.ts
async function ls(client, argv) {
let parsedArguments;
const flagsSpecification = getFlagsSpecification(listSubcommand2.options);
try {
parsedArguments = parseArguments(argv, flagsSpecification);
} catch (err) {
printError(err);
return 1;
}
const { args, flags: opts } = parsedArguments;
const validationResult = validateLsArgs({
commandName: "alias ls",
args
});
if (validationResult !== 0) {
return validationResult;
}
const { contextName } = await getScope(client);
const telemetryClient = new AliasListTelemetryClient({
opts: {
store: client.telemetryEventStore
}
});
let paginationOptions;
const formatResult = validateJsonOutput(opts);
if (!formatResult.valid) {
output_manager_default.error(formatResult.error);
return 1;
}
const asJson = formatResult.jsonOutput;
try {
paginationOptions = getPaginationOpts(opts);
const [next, limit] = paginationOptions;
telemetryClient.trackCliOptionNext(next);
telemetryClient.trackCliOptionLimit(limit);
telemetryClient.trackCliOptionFormat(opts["--format"]);
} catch (err) {
output_manager_default.prettyError(err);
return 1;
}
const lsStamp = stamp_default();
output_manager_default.spinner(`Fetching aliases under ${import_chalk3.default.bold(contextName)}`);
const { aliases, pagination } = await getAliases(
client,
void 0,
...paginationOptions
);
if (asJson) {
output_manager_default.stopSpinner();
const jsonOutput = {
aliases: aliases.map((a) => ({
alias: a.alias,
deploymentId: a.deploymentId,
url: a.deployment?.url ?? null,
createdAt: a.createdAt
})),
pagination
};
client.stdout.write(`${JSON.stringify(jsonOutput, null, 2)}
`);
} else {
output_manager_default.log(`aliases found under ${import_chalk3.default.bold(contextName)} ${lsStamp()}`);
client.stdout.write(printAliasTable(aliases));
if (pagination.count === 20) {
const flags = getCommandFlags(opts, ["_", "--next", "--format"]);
output_manager_default.log(
`To display the next page run ${getCommandName(
`alias ls${flags} --next ${pagination.next}`
)}`
);
}
}
return 0;
}
function printAliasTable(aliases) {
return `${table(
[
["source", "url", "age"].map((header) => import_chalk3.default.gray(header)),
...aliases.map((a) => [
// for legacy reasons, we might have situations
// where the deployment was deleted and the alias
// not collected appropriately, and we need to handle it
a.deployment?.url ? a.deployment.url : import_chalk3.default.gray("\u2013"),
a.alias,
(0, import_ms.default)(Date.now() - a.createdAt)
])
],
{ align: ["l", "l", "r"], hsep: 4 }
).replace(/^/gm, " ")}
`;
}
// src/commands/alias/rm.ts
var import_chalk4 = __toESM(require_source(), 1);
var import_ms2 = __toESM(require_ms(), 1);
// src/util/alias/remove-alias-by-id.ts
async function removeAliasById(client, id) {
return client.fetch(`/now/aliases/${id}`, {
method: "DELETE"
});
}
// src/util/alias/find-alias-by-alias-or-id.ts
async function findAliasByAliasOrId(client, aliasOrId) {
return client.fetch(
`/now/aliases/${encodeURIComponent(getSafeAlias(aliasOrId))}`
);
}
function getSafeAlias(alias2) {
return alias2.replace(/^https:\/\//i, "").replace(/^\.+/, "").replace(/\.+$/, "").toLowerCase();
}
// src/util/telemetry/commands/alias/remove.ts
var AliasRemoveTelemetryClient = class extends TelemetryClient {
trackCliArgumentAlias(alias2) {
if (alias2) {
this.trackCliArgument({
arg: "alias",
value: this.redactedValue
});
}
}
trackCliFlagYes(yes) {
if (yes) {
this.trackCliFlag("yes");
}
}
};
// src/commands/alias/rm.ts
async function rm(client, argv) {
let parsedArguments;
const flagsSpecification = getFlagsSpecification(removeSubcommand.options);
try {
parsedArguments = parseArguments(argv, flagsSpecification);
} catch (err) {
printError(err);
return 1;
}
const { args, flags: opts } = parsedArguments;
const { contextName } = await getScope(client);
const telemetryClient = new AliasRemoveTelemetryClient({
opts: {
store: client.telemetryEventStore
}
});
telemetryClient.trackCliFlagYes(opts["--yes"]);
const [aliasOrId] = args;
telemetryClient.trackCliArgumentAlias(aliasOrId);
if (args.length !== 1) {
output_manager_default.error(
`Invalid number of arguments. Usage: ${import_chalk4.default.cyan(
`${getCommandName("alias rm <alias>")}`
)}`
);
return 1;
}
if (!aliasOrId) {
output_manager_default.error(`${getCommandName("alias rm <alias>")} expects one argument`);
return 1;
}
if (!isValidName(aliasOrId)) {
output_manager_default.error(`The provided argument "${aliasOrId}" is not a valid alias`);
return 1;
}
const alias2 = await findAliasByAliasOrId(client, aliasOrId);
if (!alias2) {
output_manager_default.error(
`Alias not found by "${aliasOrId}" under ${import_chalk4.default.bold(contextName)}`
);
output_manager_default.log(`Run ${getCommandName("alias ls")} to see your aliases.`);
return 1;
}
const removeStamp = stamp_default();
if (!opts["--yes"] && !await confirmAliasRemove(client, alias2)) {
output_manager_default.log("Canceled");
return 0;
}
await removeAliasById(client, alias2.uid);
output_manager_default.success(`Alias ${import_chalk4.default.bold(alias2.alias)} removed ${removeStamp()}`);
return 0;
}
async function confirmAliasRemove(client, alias2) {
const srcUrl = alias2.deployment ? import_chalk4.default.underline(alias2.deployment.url) : null;
const tbl = table(
[
[
...srcUrl ? [srcUrl] : [],
import_chalk4.default.underline(alias2.alias),
import_chalk4.default.gray(`${(0, import_ms2.default)(Date.now() - alias2.createdAt)} ago`)
]
],
{ hsep: 4 }
);
output_manager_default.log("The following alias will be removed permanently");
output_manager_default.print(` ${tbl}
`);
return client.input.confirm(import_chalk4.default.red("Are you sure?"), false);
}
// src/commands/alias/set.ts
var import_chalk8 = __toESM(require_source(), 1);
// src/util/certs/get-wildcard-cns-for-alias.ts
var import_tldts = __toESM(require_cjs(), 1);
function getWildcardCNSForAlias(alias2) {
if (isWildcardAlias(alias2)) {
return [extractDomain(alias2), alias2];
}
const parsedDomain = (0, import_tldts.parse)(alias2);
const { domain: domain2, subdomain } = parsedDomain;
if (!domain2) {
throw new InvalidDomain(alias2);
}
const secondLevel = subdomain && subdomain.includes(".") ? subdomain.split(".").slice(1).join(".") : null;
const root = secondLevel ? `${secondLevel}.${domain2}` : domain2;
return [root, `*.${root}`];
}
// src/util/output/join-words.ts
function joinWords(words = []) {
if (words.length === 0) {
return "";
}
if (words.length === 1) {
return words[0];
}
const last = words[words.length - 1];
const rest = words.slice(0, words.length - 1);
return `${rest.join(", ")} and ${last}`;
}
// src/util/certs/create-cert-for-alias.ts
async function createCertificateForAlias(client, context, alias2, shouldBeWildcard) {
output_manager_default.spinner(`Generating a certificate\u2026`);
const cns = shouldBeWildcard ? getWildcardCNSForAlias(alias2) : [alias2];
const certStamp = stamp_default();
const cert = await createCertForCns(client, cns, context);
if (cert instanceof NowError) {
output_manager_default.stopSpinner();
return cert;
}
output_manager_default.log(
`Certificate for ${joinWords(cert.cns)} (${cert.uid}) created ${certStamp()}`
);
return cert;
}
// src/util/alias/create-alias.ts
async function createAlias(client, contextName, idOrUrl, alias2, externalDomain) {
output_manager_default.spinner(`Creating alias`);
const result = await performCreateAlias(client, contextName, idOrUrl, alias2);
output_manager_default.stopSpinner();
if (result instanceof CertMissing) {
const cert = await createCertificateForAlias(
client,
contextName,
alias2,
!externalDomain
);
if (cert instanceof Error) {
return cert;
}
output_manager_default.spinner(`Creating alias`);
const secondTry = await performCreateAlias(
client,
contextName,
idOrUrl,
alias2
);
output_manager_default.stopSpinner();
return secondTry;
}
return result;
}
async function performCreateAlias(client, contextName, idOrUrl, alias2) {
try {
return await client.fetch(
`/now/deployments/${encodeURIComponent(idOrUrl)}/aliases`,
{
method: "POST",
body: { alias: alias2 }
}
);
} catch (err) {
if (isAPIError(err)) {
if (err.code === "cert_missing" || err.code === "cert_expired") {
return new CertMissing(alias2);
}
if (err.status === 409) {
return { uid: err.uid, alias: err.alias };
}
if (err.code === "deployment_not_found" || err.code === "not_found") {
return new DeploymentNotFound({
context: contextName,
id: idOrUrl
});
}
if (err.code === "gone") {
return new DeploymentFailedAliasImpossible();
}
if (err.code === "invalid_alias") {
return new InvalidAlias(alias2);
}
if (err.code === "deployment_not_ready") {
return new DeploymentNotReady({
url: idOrUrl
});
}
if (err.status === 403) {
if (err.code === "alias_in_use") {
return new AliasInUse(alias2);
}
if (err.code === "forbidden") {
return new DomainPermissionDenied(alias2, contextName);
}
}
}
throw err;
}
}
// src/util/domains/is-domain-external.ts
function isDomainExternal(domain2) {
return domain2.serviceType !== "zeit.world";
}
// src/util/alias/assign-alias.ts
async function assignAlias(client, idOrUrl, alias2, contextName) {
let externalDomain = false;
if (alias2.indexOf(".") !== -1 && !alias2.endsWith(".now.sh") && !alias2.endsWith(".vercel.app")) {
const result = await setupDomain(client, alias2, contextName);
if (result instanceof Error) {
return result;
}
externalDomain = isDomainExternal(result);
}
const record = await createAlias(
client,
contextName,
idOrUrl,
alias2,
externalDomain
);
return record;
}
// src/util/alias/get-deployment-by-alias.ts
var import_chalk5 = __toESM(require_source(), 1);
import path from "path";
// src/util/deploy/get-deployments-by-appname.ts
async function fetchDeploymentsByAppName(client, appName) {
const { deployments } = await client.fetch(
`/v3/now/deployments?app=${encodeURIComponent(appName)}`
);
return deployments;
}
// src/util/alias/get-deployment-by-alias.ts
async function getAppLastDeployment(client, appName, user, contextName) {
output_manager_default.debug(`Looking for deployments matching app ${appName}`);
const deployments = await fetchDeploymentsByAppName(client, appName);
const deploymentItem = deployments.sort((a, b) => b.created - a.created).filter((