vercel 59.14.0 → 59.15.0

package/dist/chunks/chunk-4KD5BYHB.js

@@ -1,127 +0,0 @@
-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 {
-  formatOption,
-  jsonOption,
-  limitOption,
-  nextOption,
-  packageName,
-  projectOption
-} from "./chunk-Q2DGFCO7.js";
-
-// src/commands/activity/command.ts
-var typesSubcommand = {
-  name: "types",
-  aliases: [],
-  description: "List available event types with descriptions.",
-  arguments: [],
-  options: [formatOption, jsonOption],
-  examples: [
-    {
-      name: "List all event types",
-      value: `${packageName} activity types`
-    },
-    {
-      name: "Output JSON",
-      value: `${packageName} activity types --json`
-    }
-  ]
-};
-var activityCommand = {
-  name: "activity",
-  aliases: [],
-  description: "List user activity events.",
-  arguments: [],
-  subcommands: [
-    // Hidden placeholder so the help synopsis renders [command] as optional
-    // (help.ts treats `command` as required unless a subcommand has `default: true`)
-    {
-      name: "ls",
-      aliases: ["list"],
-      description: "",
-      default: true,
-      hidden: true,
-      arguments: [],
-      options: [],
-      examples: []
-    },
-    typesSubcommand
-  ],
-  options: [
-    {
-      name: "type",
-      shorthand: null,
-      type: [String],
-      argument: "TYPE",
-      deprecated: false,
-      description: "Filter by event type. Repeatable and comma-separated (e.g. --type deployment --type project-created or --type deployment,project-created)."
-    },
-    {
-      name: "since",
-      shorthand: null,
-      type: String,
-      argument: "DATE",
-      deprecated: false,
-      description: "Show events after this date (ISO 8601 or relative: 1d, 7d, 30d)."
-    },
-    {
-      name: "until",
-      shorthand: null,
-      type: String,
-      argument: "DATE",
-      deprecated: false,
-      description: "Show events before this date (ISO 8601 or relative)."
-    },
-    {
-      ...projectOption,
-      shorthand: "p",
-      description: "Filter by project (overrides auto-detected linked project)."
-    },
-    {
-      name: "all",
-      shorthand: "a",
-      type: Boolean,
-      deprecated: false,
-      description: "Show all team events (ignore linked project auto-scoping)."
-    },
-    limitOption,
-    nextOption,
-    formatOption,
-    jsonOption
-  ],
-  examples: [
-    {
-      name: "List events for the linked project",
-      value: `${packageName} activity`
-    },
-    {
-      name: "Filter events by multiple types",
-      value: `${packageName} activity --type deployment --type project-created --since 7d`
-    },
-    {
-      name: "Filter events by comma-separated types",
-      value: `${packageName} activity --type deployment,project-created --since 7d`
-    },
-    {
-      name: "List all team events",
-      value: `${packageName} activity --all --since 30d`
-    },
-    {
-      name: "Output JSON",
-      value: `${packageName} activity --json | jq '.events[]'`
-    },
-    {
-      name: "List activity event types",
-      value: `${packageName} activity types`
-    }
-  ]
-};
-
-export {
-  typesSubcommand,
-  activityCommand
-};

package/dist/chunks/chunk-4TUMNBEE.js

@@ -1,231 +0,0 @@
-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 {
-  formatOption,
-  jsonOption,
-  packageName,
-  projectOption
-} from "./chunk-Q2DGFCO7.js";
-
-// src/commands/metrics/command.ts
-var schemaSubcommand = {
-  name: "schema",
-  aliases: [],
-  description: "List available metrics or inspect a specific metric.",
-  arguments: [{ name: "metric-or-prefix", required: false }],
-  options: [formatOption, jsonOption],
-  examples: [
-    {
-      name: "List all metrics",
-      value: `${packageName} metrics schema`
-    },
-    {
-      name: "Show metric details",
-      value: `${packageName} metrics schema vercel.function_invocation`
-    },
-    {
-      name: "Schema as JSON for agents",
-      value: `${packageName} metrics schema vercel.request.count --json`
-    }
-  ]
-};
-var metricsCommand = {
-  name: "metrics",
-  aliases: [],
-  description: "Query observability metrics for your Vercel project or team.",
-  arguments: [{ name: "metric-id", required: false }],
-  subcommands: [
-    // Hidden placeholder so the help synopsis renders [command] as optional
-    // (help.ts treats `command` as required unless a subcommand has `default: true`)
-    {
-      name: "query",
-      aliases: [],
-      description: "",
-      default: true,
-      hidden: true,
-      arguments: [],
-      options: [],
-      examples: []
-    },
-    schemaSubcommand
-  ],
-  options: [
-    {
-      name: "aggregation",
-      shorthand: "a",
-      type: String,
-      deprecated: false,
-      description: "Aggregation function (default: sum for counts/bytes/currency, avg for durations/memory/ratios)",
-      argument: "FN"
-    },
-    {
-      name: "group-by",
-      shorthand: null,
-      type: [String],
-      deprecated: false,
-      description: "Dimensions to group by (repeatable)",
-      argument: "DIM"
-    },
-    {
-      name: "limit",
-      shorthand: "l",
-      type: Number,
-      deprecated: false,
-      description: "Max groups per time bucket (default: 10)",
-      argument: "N"
-    },
-    {
-      name: "order-by",
-      shorthand: null,
-      type: String,
-      deprecated: false,
-      description: "Order grouped results by value or count (default: count, or value when count is unsupported)",
-      argument: "value|count"
-    },
-    {
-      name: "order",
-      shorthand: null,
-      type: String,
-      deprecated: false,
-      description: "Order direction for grouped results: asc or desc (default: desc)",
-      argument: "asc|desc"
-    },
-    {
-      name: "filter",
-      shorthand: "f",
-      type: [String],
-      deprecated: false,
-      get description() {
-        return process.env.FF_LEGACY_METRICS ? "OData filter expression (repeatable, ANDed together)" : "KQL filter expression (repeatable, ANDed together)";
-      },
-      argument: "EXPR"
-    },
-    {
-      name: "prod",
-      shorthand: null,
-      type: Boolean,
-      deprecated: false,
-      description: "Limit query to the production environment"
-    },
-    {
-      name: "since",
-      shorthand: "s",
-      type: String,
-      deprecated: false,
-      description: "Start time: relative (1h, 30m, 2d) or ISO date (default: 1h)",
-      argument: "TIME"
-    },
-    {
-      name: "until",
-      shorthand: "u",
-      type: String,
-      deprecated: false,
-      description: "End time (default: now)",
-      argument: "TIME"
-    },
-    {
-      name: "granularity",
-      shorthand: "g",
-      type: String,
-      deprecated: false,
-      description: "Time bucket size: 5m, 15m, 1h, 1d (default: auto)",
-      argument: "SIZE"
-    },
-    {
-      name: "bucket-timezone",
-      shorthand: null,
-      type: String,
-      deprecated: false,
-      description: "IANA timezone for calendar bucket alignment only; does not shift --since/--until or output timestamps (e.g., Europe/Paris)",
-      argument: "ZONE"
-    },
-    {
-      ...projectOption,
-      shorthand: "p"
-    },
-    {
-      name: "all",
-      shorthand: null,
-      type: Boolean,
-      deprecated: false,
-      description: "Query across all projects for the team"
-    },
-    formatOption,
-    jsonOption
-  ],
-  get examples() {
-    const canonical = !process.env.FF_LEGACY_METRICS;
-    const httpStatus = canonical ? "httpStatus" : "http_status";
-    const errorCode = canonical ? "errorCode" : "error_code";
-    const aiProvider = canonical ? "aiProvider" : "ai_provider";
-    const aiGatewayCostMetric = canonical ? "vercel.ai_gateway.request.cost" : "vercel.ai_gateway_request.cost";
-    const pageViewMetric = canonical ? "vercel.analytics.page_view.count" : "vercel.analytics_pageview.count";
-    const visitorId = canonical ? "visitorId" : "visitor_id";
-    const projectId = canonical ? "projectId" : "project_id";
-    const statusFilter = canonical ? "httpStatus >= 500" : "http_status ge 500";
-    const routeFilter = canonical ? `'route:"/api"'` : `"contains(request_path, '/api')"`;
-    return [
-      {
-        name: "5xx errors by error code in the last hour",
-        value: `${packageName} metrics vercel.function_invocation.count -f "${statusFilter}" --group-by ${errorCode} --since 1h`
-      },
-      {
-        name: "Function invocations by HTTP status code",
-        value: `${packageName} metrics vercel.function_invocation.count --group-by ${httpStatus} --since 6h`
-      },
-      {
-        name: "Function duration by route",
-        value: `${packageName} metrics vercel.function_invocation.function_duration_ms -a avg --group-by route --since 1h`
-      },
-      {
-        name: "AI Gateway costs by provider",
-        value: `${packageName} metrics ${aiGatewayCostMetric} -a sum --group-by ${aiProvider} --since 7d`
-      },
-      {
-        name: "Core Web Vitals (LCP) by route",
-        value: `${packageName} metrics vercel.speed_insights.lcp_ms -a p75 --prod --group-by route --since 7d`
-      },
-      {
-        name: "Routes with the lowest p75 LCP",
-        value: `${packageName} metrics vercel.speed_insights.lcp_ms -a p75 --prod --group-by route --since 7d --order-by value --order asc`
-      },
-      {
-        name: canonical ? "Daily pageviews" : "Daily pageviews with a Paris-aligned bucket",
-        value: canonical ? `${packageName} metrics ${pageViewMetric} --since 7d --granularity 1d` : `${packageName} metrics ${pageViewMetric} --since 7d --granularity 1d --bucket-timezone Europe/Paris`
-      },
-      {
-        name: "Visitors time series from the top 5 countries",
-        value: `${packageName} metrics ${pageViewMetric} -a unique/${visitorId} --group-by country --since 1d --granularity 1h --limit 5`
-      },
-      {
-        name: "List available metrics",
-        value: `${packageName} metrics schema`
-      },
-      {
-        name: "Function executions matching an API route",
-        value: `${packageName} metrics vercel.function_invocation.count -f ${routeFilter} --group-by route --since 1h`
-      },
-      {
-        name: "Function executions matching multiple filters",
-        value: `${packageName} metrics vercel.function_invocation.count -f "${statusFilter}" -f ${routeFilter} --since 1h`
-      },
-      {
-        name: "Show schema for a metric prefix",
-        value: `${packageName} metrics schema vercel.request`
-      },
-      {
-        name: "Team-wide function executions by project",
-        value: `${packageName} metrics --all vercel.function_invocation.count --group-by ${projectId} --since 24h`
-      }
-    ];
-  }
-};
-
-export {
-  schemaSubcommand,
-  metricsCommand
-};

package/dist/chunks/chunk-4WG2MYCI.js

@@ -1,163 +0,0 @@
-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 {
-  outputError
-} from "./chunk-KFWQ3EFH.js";
-import {
-  AGENT_REASON
-} from "./chunk-RNSMTWA6.js";
-import {
-  getScope
-} from "./chunk-SM3F3PYJ.js";
-import {
-  getLinkedProject,
-  getProjectByNameOrId
-} from "./chunk-AJ5HUOWB.js";
-import {
-  buildCommandWithGlobalFlags,
-  outputAgentError
-} from "./chunk-26CU4Q3C.js";
-import {
-  ProjectNotFound,
-  isAPIError
-} from "./chunk-CV5YC2EN.js";
-
-// src/commands/alerts/resolve-alerts-scope.ts
-function emitAlertsScopeError(client, jsonOutput, code, message, agent) {
-  outputAgentError(
-    client,
-    {
-      status: "error",
-      reason: agent.reason,
-      message,
-      hint: agent.hint,
-      next: agent.next
-    },
-    1
-  );
-  return outputError(client, jsonOutput, code, message);
-}
-async function resolveAlertsScope(client, opts) {
-  const command = opts.command ?? "alerts";
-  const projectCommand = `${command} --project <name_or_id>`;
-  const allCommand = `${command} --all`;
-  if (opts.all || opts.project) {
-    const { team } = await getScope(client);
-    if (!team) {
-      const msg = "No team context found. Run `vercel switch` to select a team, or use `vercel link` in a project directory.";
-      return emitAlertsScopeError(client, opts.jsonOutput, "NO_TEAM", msg, {
-        reason: AGENT_REASON.MISSING_SCOPE,
-        hint: "Select a team scope before using --project or --all with alerts.",
-        next: [
-          {
-            command: buildCommandWithGlobalFlags(client.argv, "whoami"),
-            when: "See current user and team"
-          },
-          {
-            command: buildCommandWithGlobalFlags(client.argv, "teams switch"),
-            when: "Switch to a team that owns the project"
-          }
-        ]
-      });
-    }
-    if (opts.all) {
-      return {
-        teamId: team.id
-      };
-    }
-    let projectResult;
-    try {
-      projectResult = await getProjectByNameOrId(
-        client,
-        opts.project,
-        team.id
-      );
-    } catch (err) {
-      if (isAPIError(err)) {
-        const msg = err.serverMessage || (err.status === 403 ? `You do not have permission to access project "${opts.project}" in team "${team.slug}".` : `API error (${err.status}).`);
-        const reason = err.status === 401 ? "not_authorized" : err.status === 403 ? "forbidden" : AGENT_REASON.API_ERROR;
-        return emitAlertsScopeError(
-          client,
-          opts.jsonOutput,
-          err.code || "API_ERROR",
-          msg,
-          {
-            reason,
-            next: [
-              {
-                command: buildCommandWithGlobalFlags(
-                  client.argv,
-                  projectCommand
-                ),
-                when: "Retry with a project you can access (replace <name_or_id>)"
-              }
-            ]
-          }
-        );
-      }
-      throw err;
-    }
-    if (projectResult instanceof ProjectNotFound) {
-      const msg = `Project "${opts.project}" was not found in team "${team.slug}".`;
-      return emitAlertsScopeError(
-        client,
-        opts.jsonOutput,
-        "PROJECT_NOT_FOUND",
-        msg,
-        {
-          reason: AGENT_REASON.NOT_FOUND,
-          next: [
-            {
-              command: buildCommandWithGlobalFlags(client.argv, projectCommand),
-              when: "Retry with a valid project (replace <name_or_id>)"
-            }
-          ]
-        }
-      );
-    }
-    return {
-      teamId: team.id,
-      projectId: projectResult.id,
-      projectName: projectResult.name
-    };
-  }
-  const linkedProject = await getLinkedProject(client);
-  if (linkedProject.status === "error") {
-    return linkedProject.exitCode;
-  }
-  if (linkedProject.status === "not_linked") {
-    const msg = "No linked project found. Run `vercel link` to link a project, or use --project <name> or --all.";
-    return emitAlertsScopeError(client, opts.jsonOutput, "NOT_LINKED", msg, {
-      reason: AGENT_REASON.NOT_LINKED,
-      hint: "Agents should pass --project or --all when no .vercel link exists in --cwd.",
-      next: [
-        {
-          command: buildCommandWithGlobalFlags(client.argv, "link"),
-          when: "Link this directory to a Vercel project"
-        },
-        {
-          command: buildCommandWithGlobalFlags(client.argv, projectCommand),
-          when: "Retry with an explicit project (replace <name_or_id>)"
-        },
-        {
-          command: buildCommandWithGlobalFlags(client.argv, allCommand),
-          when: "Use team-wide scope without a linked project"
-        }
-      ]
-    });
-  }
-  return {
-    teamId: linkedProject.org.id,
-    projectId: linkedProject.project.id,
-    projectName: linkedProject.project.name
-  };
-}
-
-export {
-  emitAlertsScopeError,
-  resolveAlertsScope
-};

package/dist/chunks/chunk-57RHXXXG.js

@@ -1,150 +0,0 @@
-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 {
-  arg_common_default
-} from "./chunk-Q2DGFCO7.js";
-import {
-  __commonJS,
-  __toESM
-} from "./chunk-TZ2YI2VH.js";
-
-// ../../node_modules/.pnpm/arg@5.0.0/node_modules/arg/index.js
-var require_arg = __commonJS({
-  "../../node_modules/.pnpm/arg@5.0.0/node_modules/arg/index.js"(exports, module) {
-    var flagSymbol = Symbol("arg flag");
-    var ArgError = class _ArgError extends Error {
-      constructor(msg, code) {
-        super(msg);
-        this.name = "ArgError";
-        this.code = code;
-        Object.setPrototypeOf(this, _ArgError.prototype);
-      }
-    };
-    function arg2(opts, { argv = process.argv.slice(2), permissive = false, stopAtPositional = false } = {}) {
-      if (!opts) {
-        throw new ArgError("argument specification object is required", "ARG_CONFIG_NO_SPEC");
-      }
-      const result = { _: [] };
-      const aliases = {};
-      const handlers = {};
-      for (const key of Object.keys(opts)) {
-        if (!key) {
-          throw new ArgError("argument key cannot be an empty string", "ARG_CONFIG_EMPTY_KEY");
-        }
-        if (key[0] !== "-") {
-          throw new ArgError(`argument key must start with '-' but found: '${key}'`, "ARG_CONFIG_NONOPT_KEY");
-        }
-        if (key.length === 1) {
-          throw new ArgError(`argument key must have a name; singular '-' keys are not allowed: ${key}`, "ARG_CONFIG_NONAME_KEY");
-        }
-        if (typeof opts[key] === "string") {
-          aliases[key] = opts[key];
-          continue;
-        }
-        let type = opts[key];
-        let isFlag = false;
-        if (Array.isArray(type) && type.length === 1 && typeof type[0] === "function") {
-          const [fn] = type;
-          type = (value, name, prev = []) => {
-            prev.push(fn(value, name, prev[prev.length - 1]));
-            return prev;
-          };
-          isFlag = fn === Boolean || fn[flagSymbol] === true;
-        } else if (typeof type === "function") {
-          isFlag = type === Boolean || type[flagSymbol] === true;
-        } else {
-          throw new ArgError(`type missing or not a function or valid array type: ${key}`, "ARG_CONFIG_VAD_TYPE");
-        }
-        if (key[1] !== "-" && key.length > 2) {
-          throw new ArgError(`short argument keys (with a single hyphen) must have only one character: ${key}`, "ARG_CONFIG_SHORTOPT_TOOLONG");
-        }
-        handlers[key] = [type, isFlag];
-      }
-      for (let i = 0, len = argv.length; i < len; i++) {
-        const wholeArg = argv[i];
-        if (stopAtPositional && result._.length > 0) {
-          result._ = result._.concat(argv.slice(i));
-          break;
-        }
-        if (wholeArg === "--") {
-          result._ = result._.concat(argv.slice(i + 1));
-          break;
-        }
-        if (wholeArg.length > 1 && wholeArg[0] === "-") {
-          const separatedArguments = wholeArg[1] === "-" || wholeArg.length === 2 ? [wholeArg] : wholeArg.slice(1).split("").map((a) => `-${a}`);
-          for (let j = 0; j < separatedArguments.length; j++) {
-            const arg3 = separatedArguments[j];
-            const [originalArgName, argStr] = arg3[1] === "-" ? arg3.split(/=(.*)/, 2) : [arg3, void 0];
-            let argName = originalArgName;
-            while (argName in aliases) {
-              argName = aliases[argName];
-            }
-            if (!(argName in handlers)) {
-              if (permissive) {
-                result._.push(arg3);
-                continue;
-              } else {
-                throw new ArgError(`unknown or unexpected option: ${originalArgName}`, "ARG_UNKNOWN_OPTION");
-              }
-            }
-            const [type, isFlag] = handlers[argName];
-            if (!isFlag && j + 1 < separatedArguments.length) {
-              throw new ArgError(`option requires argument (but was followed by another short argument): ${originalArgName}`, "ARG_MISSING_REQUIRED_SHORTARG");
-            }
-            if (isFlag) {
-              result[argName] = type(true, argName, result[argName]);
-            } else if (argStr === void 0) {
-              if (argv.length < i + 2 || argv[i + 1].length > 1 && argv[i + 1][0] === "-" && !(argv[i + 1].match(/^-?\d*(\.(?=\d))?\d*$/) && (type === Number || // eslint-disable-next-line no-undef
-              typeof BigInt !== "undefined" && type === BigInt))) {
-                const extended = originalArgName === argName ? "" : ` (alias for ${argName})`;
-                throw new ArgError(`option requires argument: ${originalArgName}${extended}`, "ARG_MISSING_REQUIRED_LONGARG");
-              }
-              result[argName] = type(argv[i + 1], argName, result[argName]);
-              ++i;
-            } else {
-              result[argName] = type(argStr, argName, result[argName]);
-            }
-          }
-        } else {
-          result._.push(wholeArg);
-        }
-      }
-      return result;
-    }
-    arg2.flag = (fn) => {
-      fn[flagSymbol] = true;
-      return fn;
-    };
-    arg2.COUNT = arg2.flag((v, name, existingCount) => (existingCount || 0) + 1);
-    arg2.ArgError = ArgError;
-    module.exports = arg2;
-  }
-});
-
-// src/util/get-args.ts
-var import_arg = __toESM(require_arg(), 1);
-function getArgs(argv, argsOptions, argOptions = {}) {
-  return (0, import_arg.default)(Object.assign({}, arg_common_default(), argsOptions), {
-    ...argOptions,
-    argv
-  });
-}
-function parseArguments(args, flagsSpecification, parserOptions = {}) {
-  const { _: positional, ...rest } = (0, import_arg.default)(
-    Object.assign({}, arg_common_default(), flagsSpecification),
-    {
-      ...parserOptions,
-      argv: args
-    }
-  );
-  return { args: positional, flags: rest };
-}
-
-export {
-  getArgs,
-  parseArguments
-};

package/dist/chunks/chunk-5AJPMLDV.js

@@ -1,28 +0,0 @@
-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);
-
-// src/util/output/format-granularity.ts
-function formatGranularity(value) {
-  if (!value || typeof value !== "object") {
-    return void 0;
-  }
-  const granularity = value;
-  if (typeof granularity.minutes === "number") {
-    return `${granularity.minutes}m`;
-  }
-  if (typeof granularity.hours === "number") {
-    return `${granularity.hours}h`;
-  }
-  if (typeof granularity.days === "number") {
-    return `${granularity.days}d`;
-  }
-  return void 0;
-}
-
-export {
-  formatGranularity
-};