vercel 59.11.2 → 59.12.0

package/dist/chunks/chunk-PEC3CQSK.js

@@ -0,0 +1,90 @@
+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 {
+  __commonJS
+} from "./chunk-TZ2YI2VH.js";
+
+// ../../node_modules/.pnpm/wrappy@1.0.2/node_modules/wrappy/wrappy.js
+var require_wrappy = __commonJS({
+  "../../node_modules/.pnpm/wrappy@1.0.2/node_modules/wrappy/wrappy.js"(exports, module) {
+    module.exports = wrappy;
+    function wrappy(fn, cb) {
+      if (fn && cb)
+        return wrappy(fn)(cb);
+      if (typeof fn !== "function")
+        throw new TypeError("need wrapper function");
+      Object.keys(fn).forEach(function(k) {
+        wrapper[k] = fn[k];
+      });
+      return wrapper;
+      function wrapper() {
+        var args = new Array(arguments.length);
+        for (var i = 0; i < args.length; i++) {
+          args[i] = arguments[i];
+        }
+        var ret = fn.apply(this, args);
+        var cb2 = args[args.length - 1];
+        if (typeof ret === "function" && ret !== cb2) {
+          Object.keys(cb2).forEach(function(k) {
+            ret[k] = cb2[k];
+          });
+        }
+        return ret;
+      }
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/once@1.4.0/node_modules/once/once.js
+var require_once = __commonJS({
+  "../../node_modules/.pnpm/once@1.4.0/node_modules/once/once.js"(exports, module) {
+    var wrappy = require_wrappy();
+    module.exports = wrappy(once);
+    module.exports.strict = wrappy(onceStrict);
+    once.proto = once(function() {
+      Object.defineProperty(Function.prototype, "once", {
+        value: function() {
+          return once(this);
+        },
+        configurable: true
+      });
+      Object.defineProperty(Function.prototype, "onceStrict", {
+        value: function() {
+          return onceStrict(this);
+        },
+        configurable: true
+      });
+    });
+    function once(fn) {
+      var f = function() {
+        if (f.called)
+          return f.value;
+        f.called = true;
+        return f.value = fn.apply(this, arguments);
+      };
+      f.called = false;
+      return f;
+    }
+    function onceStrict(fn) {
+      var f = function() {
+        if (f.called)
+          throw new Error(f.onceError);
+        f.called = true;
+        return f.value = fn.apply(this, arguments);
+      };
+      var name = fn.name || "Function wrapped with `once`";
+      f.onceError = name + " shouldn't be called more than once";
+      f.called = false;
+      return f;
+    }
+  }
+});
+
+export {
+  require_wrappy,
+  require_once
+};

package/dist/chunks/{chunk-KJBZ5ZST.js → chunk-PIMIVJYK.js}

@@ -86,6 +86,7 @@ var help = () => `
       rr | rolling-release [cmd]       Manage rolling releases for gradual traffic shifting
       sandbox                          Interact with Vercel Sandbox
       skills               [query]     Discover agent skills relevant to your project
+      storage              [cmd]       Connect and manage storage resources for your Projects
       target               [cmd]       Manage custom environments for your Project
       teams                            Manages your teams
       telemetry            [cmd]       Enable or disable telemetry collection

package/dist/chunks/chunk-PNGVSHR3.js

@@ -0,0 +1,40 @@
+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 {
+  output_manager_default
+} from "./chunk-2JIX6UMI.js";
+import {
+  require_source
+} from "./chunk-S7KYDPEM.js";
+import {
+  __toESM
+} from "./chunk-TZ2YI2VH.js";
+
+// src/util/projects/format-project.ts
+var import_chalk = __toESM(require_source(), 1);
+function formatProject(orgSlug, projectSlug, options) {
+  const orgProjectSlug = `${orgSlug}/${projectSlug}`;
+  const projectUrl = `https://vercel.com/${orgProjectSlug}`;
+  const projectSlugLink = output_manager_default.link(import_chalk.default.bold(orgProjectSlug), projectUrl, {
+    fallback: () => import_chalk.default.bold(orgProjectSlug),
+    color: false,
+    ...options
+  });
+  return projectSlugLink;
+}
+
+// src/util/target/standard-environments.ts
+var STANDARD_ENVIRONMENTS = [
+  "production",
+  "preview",
+  "development"
+];
+
+export {
+  formatProject,
+  STANDARD_ENVIRONMENTS
+};

package/dist/chunks/chunk-PP5GKSIX.js

@@ -0,0 +1,137 @@
+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 {
+  printProjectNotFoundError
+} from "./chunk-ELZ6WQQA.js";
+import {
+  detectExplicitScope
+} from "./chunk-ABSZNJQO.js";
+import {
+  getLinkedProject,
+  param,
+  resolveProjectCwd
+} from "./chunk-MADFAH3O.js";
+import {
+  buildCommandWithYes,
+  outputActionRequired
+} from "./chunk-26CU4Q3C.js";
+import {
+  getCommandName,
+  getCommandNamePlain
+} from "./chunk-Q2DGFCO7.js";
+import {
+  output_manager_default
+} from "./chunk-2JIX6UMI.js";
+
+// src/util/parse-env.ts
+var parseEnv = (env) => {
+  if (!env) {
+    return {};
+  }
+  if (typeof env === "string") {
+    env = [env];
+  }
+  if (Array.isArray(env)) {
+    const startingDict = {};
+    return env.reduce((o, e) => {
+      let key;
+      let value;
+      const equalsSign = e.indexOf("=");
+      if (equalsSign === -1) {
+        key = e;
+      } else {
+        key = e.slice(0, equalsSign);
+        value = e.slice(equalsSign + 1);
+      }
+      o[key] = value;
+      return o;
+    }, startingDict);
+  }
+  return env;
+};
+
+// src/util/link/ensure-link.ts
+async function ensureLink(commandName, client, cwd, opts = {}) {
+  cwd = await resolveProjectCwd(cwd);
+  let link = opts.link;
+  const nonInteractive = opts.nonInteractive ?? client.nonInteractive ?? false;
+  opts.nonInteractive = nonInteractive;
+  if (!link) {
+    if (opts.forceDelete) {
+      link = { status: "not_linked", org: null, project: null };
+    } else {
+      link = await getLinkedProject(client, {
+        cwd,
+        projectName: opts.projectName,
+        projectNameIsExplicit: Boolean(opts.projectName && opts.failIfNotFound),
+        scopeIsExplicit: detectExplicitScope(client),
+        allowOwnerLookupFallback: opts.allowOwnerLookupFallback,
+        skipRemoteLookup: opts.skipRemoteLookup
+      });
+    }
+    opts.link = link;
+  }
+  if (link.status === "linked" && opts.forceDelete || link.status === "not_linked") {
+    if (link.status === "not_linked" && opts.failIfNotFound && opts.projectName) {
+      await printProjectNotFoundError(
+        client,
+        opts.projectName,
+        commandName,
+        link.orgId
+      );
+      return 1;
+    }
+    if (link.status === "not_linked" && opts.requireExistingLink) {
+      output_manager_default.error(
+        `Project is not linked. Run ${getCommandName("link")} first.`
+      );
+      return 1;
+    }
+    const { default: setupAndLink } = await import("./setup-and-link-DRYXQOH4.js");
+    link = await setupAndLink(client, cwd, opts);
+    if (link.status === "not_linked") {
+      return 0;
+    }
+  }
+  if (link.status === "error") {
+    if (link.reason === "HEADLESS") {
+      if (nonInteractive) {
+        outputActionRequired(
+          client,
+          {
+            status: "action_required",
+            reason: "confirmation_required",
+            message: `Command ${getCommandNamePlain(commandName)} requires confirmation. Use option --yes to confirm.`,
+            next: [
+              {
+                command: buildCommandWithYes(client.argv),
+                when: "Confirm and run"
+              }
+            ]
+          },
+          link.exitCode
+        );
+      } else {
+        output_manager_default.error(
+          `Command ${getCommandName(
+            commandName
+          )} requires confirmation. Use option ${param("--yes")} to confirm.`
+        );
+      }
+    }
+    if (nonInteractive) {
+      process.exit(link.exitCode);
+    }
+    return link.exitCode;
+  }
+  return link;
+}
+
+export {
+  parseEnv,
+  ensureLink
+};

package/dist/chunks/chunk-QB2UHSUB.js

@@ -0,0 +1,58 @@
+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 {
+  parseArguments
+} from "./chunk-57RHXXXG.js";
+import {
+  VERCEL_DIR
+} from "./chunk-MADFAH3O.js";
+import {
+  ConflictingConfigFiles,
+  DeprecatedNowJson,
+  InvalidLocalConfig
+} from "./chunk-CV5YC2EN.js";
+
+// src/util/config/local-path.ts
+import path from "path";
+import { existsSync } from "fs";
+function getLocalPathConfig(prefix) {
+  const argv = parseArguments(process.argv.slice(2), {}, { permissive: true });
+  const customPath = argv.flags["--local-config"];
+  if (customPath) {
+    if (typeof customPath !== "string") {
+      throw new InvalidLocalConfig(customPath);
+    }
+    return path.resolve(process.cwd(), customPath);
+  }
+  const vercelConfigPath = path.join(prefix, "vercel.json");
+  const vercelTomlPath = path.join(prefix, "vercel.toml");
+  const nowConfigPath = path.join(prefix, "now.json");
+  const vercelConfigExists = existsSync(vercelConfigPath);
+  const vercelTomlExists = existsSync(vercelTomlPath);
+  const nowConfigExists = existsSync(nowConfigPath);
+  const foundConfigs = [];
+  if (vercelConfigExists)
+    foundConfigs.push(vercelConfigPath);
+  if (vercelTomlExists)
+    foundConfigs.push(vercelTomlPath);
+  if (nowConfigExists) {
+    throw new DeprecatedNowJson(nowConfigPath);
+  }
+  if (foundConfigs.length > 1) {
+    throw new ConflictingConfigFiles(foundConfigs);
+  }
+  const compiledConfigPath = path.join(prefix, VERCEL_DIR, "vercel.json");
+  const compiledConfigExists = existsSync(compiledConfigPath);
+  if (compiledConfigExists) {
+    return compiledConfigPath;
+  }
+  return vercelConfigPath;
+}
+
+export {
+  getLocalPathConfig
+};

package/dist/chunks/chunk-QIUK4Z7Q.js

@@ -0,0 +1,79 @@
+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 {
+  AGENT_REASON
+} from "./chunk-VUS2JQB2.js";
+import {
+  getProjectByNameOrId
+} from "./chunk-MADFAH3O.js";
+import {
+  ProjectNotFound
+} from "./chunk-CV5YC2EN.js";
+
+// src/commands/traces/scope-resolver.ts
+var MISSING_BOTH_MESSAGE = "No linked project found. Run `vercel link`, pass --cwd to a linked dir, or use --scope <team> and --project <name>.";
+async function resolveScope({
+  client,
+  flags = {},
+  linkedProject
+}) {
+  const flagScope = flags.scope?.trim() || void 0;
+  const flagProject = flags.project?.trim() || void 0;
+  if (linkedProject.status === "linked") {
+    if (!flagScope && !flagProject) {
+      return {
+        teamId: linkedProject.org.id,
+        projectId: linkedProject.project.id
+      };
+    }
+    const teamId = flagScope ? client.config.currentTeam : linkedProject.org.id;
+    if (!teamId) {
+      return {
+        reason: AGENT_REASON.NOT_FOUND,
+        message: `Team not found: ${flagScope}`
+      };
+    }
+    const project = await getProjectByNameOrId(
+      client,
+      flagProject ?? linkedProject.project.id,
+      teamId
+    );
+    if (project instanceof ProjectNotFound) {
+      return {
+        reason: AGENT_REASON.NOT_FOUND,
+        message: `Project not found: ${flagProject}`
+      };
+    }
+    return {
+      teamId,
+      projectId: project.id
+    };
+  }
+  if (flagScope && flagProject) {
+    const teamId = client.config.currentTeam;
+    if (!teamId) {
+      return {
+        reason: AGENT_REASON.NOT_FOUND,
+        message: `Team not found: ${flagScope}`
+      };
+    }
+    const project = await getProjectByNameOrId(client, flagProject, teamId);
+    if (project instanceof ProjectNotFound) {
+      return {
+        reason: AGENT_REASON.NOT_FOUND,
+        message: `Project not found: ${flagProject}`
+      };
+    }
+    return { teamId, projectId: project.id };
+  }
+  return { reason: AGENT_REASON.NOT_LINKED, message: MISSING_BOTH_MESSAGE };
+}
+
+export {
+  MISSING_BOTH_MESSAGE,
+  resolveScope
+};

package/dist/chunks/chunk-RN6V5ODW.js

@@ -0,0 +1,114 @@
+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 {
+  CertConfigurationError,
+  CertError,
+  DeploymentNotFound,
+  DeploymentPermissionDenied,
+  DomainNotFound,
+  InvalidDeploymentId,
+  TooManyRequests,
+  isAPIError
+} from "./chunk-CV5YC2EN.js";
+import {
+  output_manager_default
+} from "./chunk-2JIX6UMI.js";
+
+// src/util/parse-target.ts
+function parseTarget({
+  flagName,
+  flags
+}) {
+  const targetFlagName = `--${flagName}`;
+  const targetFlagValue = flags[targetFlagName];
+  const prodFlagValue = flags["--prod"];
+  if (prodFlagValue && targetFlagValue) {
+    output_manager_default.warn(
+      `Both \`--prod\` and \`${targetFlagName}\` detected. Ignoring \`--prod\`.`
+    );
+  }
+  if (typeof targetFlagValue === "string") {
+    output_manager_default.debug(`Setting target to ${targetFlagValue}`);
+    return targetFlagValue;
+  }
+  if (prodFlagValue) {
+    output_manager_default.debug("Setting target to production");
+    return "production";
+  }
+  return void 0;
+}
+
+// src/util/to-host.ts
+function toHost(url) {
+  return url.replace(/^(?:.*?\/\/)?([^/]+).*/, "$1");
+}
+
+// src/util/certs/map-cert-error.ts
+function mapCertError(error, cns) {
+  const errorCode = error.code;
+  if (errorCode === "too_many_requests") {
+    const retryAfter = typeof error.retryAfterMs === "number" ? error.retryAfterMs : 0;
+    return new TooManyRequests("certificates", retryAfter);
+  }
+  if (errorCode === "not_found") {
+    return new DomainNotFound(error.domain);
+  }
+  if (errorCode === "configuration_error") {
+    return new CertConfigurationError({
+      cns: cns || error.cns || [],
+      message: error.message,
+      external: error.external,
+      helpUrl: error.helpUrl,
+      type: error.statusCode === 449 ? "http-01" : "dns-01"
+    });
+  }
+  if (errorCode === "bad_domains" || errorCode === "challenge_still_pending" || errorCode === "common_name_domain_name_mismatch" || errorCode === "conflicting_caa_record" || errorCode === "domain_not_verified" || errorCode === "invalid_cn" || errorCode === "invalid_domain" || errorCode === "rate_limited" || errorCode === "should_share_root_domain" || errorCode === "unauthorized_request_error" || errorCode === "unsupported_challenge_priority" || errorCode === "wildcard_not_allowed" || errorCode === "validation_running" || errorCode === "dns_error" || errorCode === "challenge_error" || errorCode === "txt_record_not_found") {
+    return new CertError({
+      cns: cns || error.cns || [],
+      code: errorCode,
+      message: error.message,
+      helpUrl: error.helpUrl
+    });
+  }
+  return null;
+}
+
+// src/util/get-deployment.ts
+async function getDeployment(client, contextName, hostOrId) {
+  if (hostOrId.includes(".")) {
+    hostOrId = toHost(hostOrId);
+  }
+  try {
+    return await client.fetch(
+      `/v13/deployments/${encodeURIComponent(hostOrId)}`
+    );
+  } catch (err) {
+    if (isAPIError(err)) {
+      if (err.status === 404) {
+        throw new DeploymentNotFound({ id: hostOrId, context: contextName });
+      }
+      if (err.status === 403) {
+        throw new DeploymentPermissionDenied(hostOrId, contextName);
+      }
+      if (err.status === 400 && err.message.includes("`id`")) {
+        throw new InvalidDeploymentId(hostOrId);
+      }
+      const certError = mapCertError(err);
+      if (certError) {
+        throw certError;
+      }
+    }
+    throw err;
+  }
+}
+
+export {
+  parseTarget,
+  mapCertError,
+  toHost,
+  getDeployment
+};