vercel 59.11.2 → 59.12.0

package/dist/chunks/{chunk-FRAXI2WT.js → chunk-HD4DR3DA.js}

@@ -7,7 +7,7 @@ const __dirname = __dirname_(__filename);
 import {
   getResolvedOrderMetadata,
   getRollupColumnName
-} from "./chunk-ASBP32T6.js";
+} from "./chunk-7MRDIPJY.js";
 import {
   formatGranularity
 } from "./chunk-5AJPMLDV.js";
@@ -16,7 +16,7 @@ import {
 } from "./chunk-A3NYPUKZ.js";
 import {
   ellipsizeMiddle
-} from "./chunk-XRWOTCDO.js";
+} from "./chunk-ND5CF2H3.js";
 import {
   elapsed
 } from "./chunk-VXYGCOKL.js";
@@ -25,7 +25,7 @@ import {
 } from "./chunk-GGP5R3FU.js";
 import {
   table
-} from "./chunk-RKDCNQ4S.js";
+} from "./chunk-NW34PW6V.js";
 import {
   require_source
 } from "./chunk-S7KYDPEM.js";
@@ -813,5 +813,6 @@ export {
   toGranularityMsFromDuration,
   isCanonicalAggregation,
   getDefaultCustomMetricAggregation,
+  generateSparkline,
   formatText
 };

package/dist/chunks/{chunk-DWIC7MRV.js → chunk-HKHXKSXQ.js}

@@ -6,7 +6,7 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __dirname_(__filename);
 import {
   rulesAggregateCommand
-} from "./chunk-XM3LOQIX.js";
+} from "./chunk-EDMW7SBH.js";
 import {
   formatOption,
   jsonOption,

package/dist/chunks/{chunk-6JPVTPTU.js → chunk-HM24ZWQL.js}

@@ -7,13 +7,13 @@ const __dirname = __dirname_(__filename);
 import {
   formatErrorJson,
   handleApiError
-} from "./chunk-ASBP32T6.js";
+} from "./chunk-7MRDIPJY.js";
 import {
   isAPIError
-} from "./chunk-BMKU5KEL.js";
+} from "./chunk-CV5YC2EN.js";
 import {
   output_manager_default
-} from "./chunk-QFAS4OVW.js";
+} from "./chunk-2JIX6UMI.js";
 
 // src/commands/metrics/schema-api.ts
 var OBSERVABILITY_METRICS_PATH = "/metrics/v1";
@@ -57,7 +57,7 @@ async function fetchMetricCatalog(client, accountId, kind, search, activeSince)
     }
     const response = await client.fetch(
       `${OBSERVABILITY_METRICS_PATH}?${searchParams}`,
-      { accountId }
+      { accountId, bailOn429: true }
     );
     metrics.push(
       ...response.metrics.map((metric) => ({

package/dist/chunks/chunk-HR2MP4XF.js

@@ -0,0 +1,324 @@
+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 {
+  emitAlertsScopeError,
+  resolveAlertsScope
+} from "./chunk-3BB2HOO2.js";
+import {
+  handleValidationError,
+  validateAllProjectMutualExclusivity
+} from "./chunk-KFWQ3EFH.js";
+import {
+  isJSONObject
+} from "./chunk-WT2Y7FRD.js";
+import {
+  AGENT_REASON
+} from "./chunk-VUS2JQB2.js";
+import {
+  getScope
+} from "./chunk-ABSZNJQO.js";
+import {
+  getProjectByNameOrId
+} from "./chunk-MADFAH3O.js";
+import {
+  buildCommandWithGlobalFlags,
+  outputAgentError
+} from "./chunk-26CU4Q3C.js";
+import {
+  ProjectNotFound,
+  isAPIError
+} from "./chunk-CV5YC2EN.js";
+import {
+  output_manager_default
+} from "./chunk-2JIX6UMI.js";
+
+// src/commands/alerts/rules/parse-scope.ts
+async function resolveRulesTeam(client, jsonOutput) {
+  const { team } = await getScope(client, { resolveLocalScope: true });
+  if (team) {
+    return { teamId: team.id };
+  }
+  const message = "No team context found. Run `vercel switch` to select a team, use `--scope <team>`, or link a team project.";
+  return emitAlertsScopeError(client, jsonOutput, "NO_TEAM", message, {
+    reason: AGENT_REASON.MISSING_SCOPE,
+    hint: "Alert rules belong to a team. Select the team before retrying.",
+    next: [
+      {
+        command: buildCommandWithGlobalFlags(client.argv, "teams switch"),
+        when: "Select a team"
+      },
+      {
+        command: buildCommandWithGlobalFlags(client.argv, "whoami"),
+        when: "Inspect the current scope"
+      }
+    ]
+  });
+}
+async function resolveRulesProject(client, projectNameOrId, jsonOutput, command) {
+  const teamScope = await resolveRulesTeam(client, jsonOutput);
+  if (typeof teamScope === "number") {
+    return teamScope;
+  }
+  try {
+    const project = await getProjectByNameOrId(
+      client,
+      projectNameOrId,
+      teamScope.teamId
+    );
+    if (project instanceof ProjectNotFound) {
+      return emitAlertsScopeError(
+        client,
+        jsonOutput,
+        "PROJECT_NOT_FOUND",
+        `Project "${projectNameOrId}" was not found in the selected team.`,
+        {
+          reason: AGENT_REASON.NOT_FOUND,
+          next: [
+            {
+              command: buildCommandWithGlobalFlags(
+                client.argv,
+                `${command} --project <name_or_id>`
+              ),
+              when: "Retry with a valid project"
+            }
+          ]
+        }
+      );
+    }
+    return {
+      ...teamScope,
+      projectId: project.id,
+      projectName: project.name
+    };
+  } catch (error) {
+    if (!isAPIError(error)) {
+      throw error;
+    }
+    return emitAlertsScopeError(
+      client,
+      jsonOutput,
+      error.code || "API_ERROR",
+      error.serverMessage || `API error (${error.status}).`,
+      {
+        reason: error.status === 401 ? "not_authorized" : error.status === 403 ? "forbidden" : AGENT_REASON.API_ERROR
+      }
+    );
+  }
+}
+async function parseRulesFlagsAndScope(client, flags, jsonOutput, command = "alerts rules ls") {
+  const mutual = validateAllProjectMutualExclusivity(
+    flags["--all"],
+    flags["--project"]
+  );
+  if (!mutual.valid) {
+    outputAgentError(
+      client,
+      {
+        status: "error",
+        reason: AGENT_REASON.INVALID_ARGUMENTS,
+        message: mutual.message,
+        next: [
+          {
+            command: buildCommandWithGlobalFlags(
+              client.argv,
+              "alerts rules --help"
+            ),
+            when: "Use either `--project` or `--all`, not both"
+          }
+        ]
+      },
+      1
+    );
+    return handleValidationError(mutual, jsonOutput, client);
+  }
+  if (flags["--all"]) {
+    return resolveRulesTeam(client, jsonOutput);
+  }
+  if (flags["--project"]) {
+    return resolveRulesProject(client, flags["--project"], jsonOutput, command);
+  }
+  const linkedScope = await resolveAlertsScope(client, {
+    jsonOutput,
+    command
+  });
+  if (typeof linkedScope === "number")
+    return linkedScope;
+  const teamScope = await resolveRulesTeam(client, jsonOutput);
+  if (typeof teamScope === "number")
+    return teamScope;
+  return linkedScope.teamId === teamScope.teamId ? linkedScope : teamScope;
+}
+
+// src/commands/alerts/rules/util.ts
+import { readFileSync } from "fs";
+import { resolve } from "path";
+function rulesCollectionPath(teamId, options = {}) {
+  const query = new URLSearchParams({ teamId });
+  if (options.limit !== void 0)
+    query.set("limit", String(options.limit));
+  if (options.cursor)
+    query.set("cursor", options.cursor);
+  if (options.projectId)
+    query.set("projectId", options.projectId);
+  if (options.type)
+    query.set("type", options.type);
+  return `/alerts/v3/alert-rules?${query.toString()}`;
+}
+function rulesItemPath(teamId, ruleId) {
+  const query = new URLSearchParams({ teamId });
+  return `/alerts/v3/alert-rules/${encodeURIComponent(ruleId)}?${query.toString()}`;
+}
+function rulesSchemaPath(teamId, type) {
+  const query = new URLSearchParams({ teamId });
+  if (type)
+    query.set("type", type);
+  return `/alerts/v3/alert-rules/schema?${query.toString()}`;
+}
+async function fetchRule(client, scope, ruleId) {
+  const response = await client.fetch(
+    rulesItemPath(scope.teamId, ruleId)
+  );
+  return response.rule;
+}
+function getIssues(error) {
+  if (!Array.isArray(error.issues))
+    return [];
+  return error.issues.filter(
+    (issue) => isJSONObject(issue) && typeof issue.path === "string" && typeof issue.message === "string"
+  );
+}
+function outputRulesError(client, jsonOutput, code, message, options = {}) {
+  const issues = options.issues ?? [];
+  const issueSummary = issues.slice(0, 5).map((issue) => `${issue.path || "body"}: ${issue.message}`).join("; ");
+  outputAgentError(
+    client,
+    {
+      status: "error",
+      reason: options.reason ?? AGENT_REASON.INVALID_ARGUMENTS,
+      message,
+      hint: options.hint ?? (issueSummary || void 0)
+    },
+    1
+  );
+  if (jsonOutput) {
+    client.stdout.write(
+      `${JSON.stringify(
+        { error: { code, message, ...issues.length ? { issues } : {} } },
+        null,
+        2
+      )}
+`
+    );
+  } else {
+    output_manager_default.fatal(
+      [
+        message,
+        ...issues.map((issue) => `  ${issue.path}: ${issue.message}`)
+      ].join("\n")
+    );
+  }
+  return 1;
+}
+function handleRulesApiError(client, err, jsonOutput) {
+  const message = err.status === 401 ? "You do not have access to alert rules in this team. Ensure your role can manage Alert Rules, or pass --token and --scope." : err.status === 403 ? err.serverMessage || "You do not have permission to manage alert rules in this team." : err.status >= 500 ? `The alert rules endpoint failed (${err.status}). Re-run with --debug and share the x-vercel-id from the failed request.` : err.serverMessage || `API error (${err.status}).`;
+  return outputRulesError(
+    client,
+    jsonOutput,
+    err.code || "API_ERROR",
+    message,
+    {
+      reason: err.status === 401 ? "not_authorized" : err.status === 403 ? "forbidden" : err.status === 404 ? AGENT_REASON.NOT_FOUND : err.status === 429 ? "rate_limited" : AGENT_REASON.API_ERROR,
+      issues: getIssues(err),
+      hint: err.status === 401 || err.status === 403 ? "Confirm the team with `vercel whoami`; use --scope <team-slug> if the rule belongs to another team." : void 0
+    }
+  );
+}
+var LEGACY_BODY_FIELDS = ["alertTypes", "customAlert", "queryJsonString"];
+function readRuleBody(client, bodyPath, jsonOutput) {
+  let raw;
+  try {
+    raw = readFileSync(resolve(client.cwd, bodyPath), "utf8");
+  } catch {
+    return outputRulesError(
+      client,
+      jsonOutput,
+      "INVALID_ARGUMENTS",
+      `Could not read --body file: ${bodyPath}`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return outputRulesError(
+      client,
+      jsonOutput,
+      "INVALID_ARGUMENTS",
+      "Invalid JSON in --body file."
+    );
+  }
+  if (!isJSONObject(parsed)) {
+    return outputRulesError(
+      client,
+      jsonOutput,
+      "INVALID_ARGUMENTS",
+      "The --body file must contain a JSON object."
+    );
+  }
+  if (LEGACY_BODY_FIELDS.some((field) => Object.hasOwn(parsed, field))) {
+    return outputRulesError(
+      client,
+      jsonOutput,
+      "LEGACY_ALERT_RULE_BODY",
+      "This body uses the previous alert-rules shape. Rewrite it using the built-in or custom schema.",
+      {
+        hint: "Run `vercel alerts rules schema --type built-in` or `vercel alerts rules schema --type custom` for examples."
+      }
+    );
+  }
+  return parsed;
+}
+function getBodyType(body) {
+  return body.type === "built-in" || body.type === "custom" ? body.type : void 0;
+}
+function emitRulesArgParseError(client, err, recoverWithProjectFlag) {
+  const message = err instanceof Error ? err.message : String(err);
+  const projectFlagMissingArg = message.includes("--project") && message.includes("requires argument");
+  outputAgentError(
+    client,
+    {
+      status: "error",
+      reason: AGENT_REASON.INVALID_ARGUMENTS,
+      message: projectFlagMissingArg ? "`--project` requires a project name or id (for example `--project my-app`)." : message,
+      next: [
+        {
+          command: buildCommandWithGlobalFlags(
+            client.argv,
+            projectFlagMissingArg ? recoverWithProjectFlag : "alerts rules --help"
+          ),
+          when: projectFlagMissingArg ? "Retry with a project name or id" : "See valid `alerts rules` subcommands"
+        }
+      ]
+    },
+    1
+  );
+}
+
+export {
+  resolveRulesTeam,
+  resolveRulesProject,
+  parseRulesFlagsAndScope,
+  rulesCollectionPath,
+  rulesItemPath,
+  rulesSchemaPath,
+  fetchRule,
+  outputRulesError,
+  handleRulesApiError,
+  readRuleBody,
+  getBodyType,
+  emitRulesArgParseError
+};