vercel 59.11.7 → 59.13.1

package/dist/chunks/{chunk-C762AAVU.js → chunk-66LPM47Z.js}

@@ -6,15 +6,15 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __dirname_(__filename);
 import {
   printProjectNotFoundError
-} from "./chunk-PJXMXMCO.js";
+} from "./chunk-TLPHZ7M4.js";
 import {
   detectExplicitScope
-} from "./chunk-4IVSM24H.js";
+} from "./chunk-76CB3CF2.js";
 import {
   getLinkedProject,
   param,
   resolveProjectCwd
-} from "./chunk-2TSBB22D.js";
+} from "./chunk-7F5RNOTP.js";
 import {
   buildCommandWithYes,
   outputActionRequired
@@ -91,7 +91,7 @@ async function ensureLink(commandName, client, cwd, opts = {}) {
       );
       return 1;
     }
-    const { default: setupAndLink } = await import("./setup-and-link-KXPZE32P.js");
+    const { default: setupAndLink } = await import("./setup-and-link-R5N7WJ46.js");
     link = await setupAndLink(client, cwd, opts);
     if (link.status === "not_linked") {
       return 0;

package/dist/chunks/{chunk-4IVSM24H.js → chunk-76CB3CF2.js}

@@ -14,7 +14,7 @@ import {
   getTeamByIdOrSlug,
   getUser,
   getVercelDirectory
-} from "./chunk-2TSBB22D.js";
+} from "./chunk-7F5RNOTP.js";
 import {
   InvalidToken,
   TeamDeleted

package/dist/chunks/{chunk-2TSBB22D.js → chunk-7F5RNOTP.js}

@@ -13476,7 +13476,7 @@ async function resolveProjectCwd(cwd) {
   const projectRoot = await findProjectRoot(cwd);
   if (!projectRoot || projectRoot === cwd)
     return cwd;
-  const { isExperimentalServicesEnabled, tryDetectServices } = await import("./detect-services-TESZCQWG.js");
+  const { isExperimentalServicesEnabled, tryDetectServices } = await import("./detect-services-Q2DVXVMH.js");
   const isServicesEnabled = await isExperimentalServicesEnabled(projectRoot);
   if (!isServicesEnabled) {
     return cwd;
@@ -13946,7 +13946,7 @@ async function linkFolderToProject(client, path, projectLink, projectName, orgSl
     try {
       client.cwd = path;
       const args = autoConfirm ? ["--yes"] : [];
-      const { default: pull } = await import("./pull-646WEVDE.js");
+      const { default: pull } = await import("./pull-DL72B6RW.js");
       const exitCode = await pull(client, args, "vercel-cli:link");
       if (exitCode !== 0) {
         output_manager_default.error(

package/dist/chunks/{chunk-UARGTFCT.js → chunk-7NRNFV77.js}

@@ -10,7 +10,7 @@ import {
 } from "./chunk-332LMJLZ.js";
 import {
   require_dist
-} from "./chunk-G3PXSXIB.js";
+} from "./chunk-N6HP5BLI.js";
 import {
   __commonJS,
   __toESM

package/dist/chunks/chunk-DQ23J2KG.js

@@ -0,0 +1,305 @@
+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 {
+  humanizeReference,
+  renderAlertTable
+} from "./chunk-GDOUDU6O.js";
+import {
+  formatDate
+} from "./chunk-GZLPFESR.js";
+import {
+  truncateEnd,
+  truncateMiddle
+} from "./chunk-ND5CF2H3.js";
+import {
+  printAlignedLabel
+} from "./chunk-7F5RNOTP.js";
+import {
+  buildCommandWithGlobalFlags,
+  quoteArg
+} from "./chunk-26CU4Q3C.js";
+import {
+  output_manager_default
+} from "./chunk-2JIX6UMI.js";
+import {
+  require_source
+} from "./chunk-S7KYDPEM.js";
+import {
+  __toESM
+} from "./chunk-TZ2YI2VH.js";
+
+// src/commands/alerts/rules/format.ts
+var import_chalk = __toESM(require_source(), 1);
+function formatBoolean(value) {
+  return value ? "yes" : "no";
+}
+function formatOperator(operator) {
+  return {
+    gt: ">",
+    gte: ">=",
+    lt: "<",
+    lte: "<="
+  }[operator] ?? operator;
+}
+function formatPublicRuleScope(rule) {
+  const scope = rule.ruleScope;
+  if (scope.type === "all")
+    return "all projects";
+  if (scope.type === "project")
+    return `project: ${scope.projectId}`;
+  return `${scope.type}: ${scope.projectIds.join(", ")}`;
+}
+function formatMetricSelection(metric) {
+  const modifiers = [
+    metric.per ? `per ${metric.per}` : void 0,
+    metric.normalize ? `normalize ${metric.normalize}` : void 0,
+    metric.dimensions?.length ? `dimensions ${metric.dimensions.join(", ")}` : void 0
+  ].filter(Boolean);
+  return `${metric.aggregation} ${metric.metric}${modifiers.length ? ` (${modifiers.join("; ")})` : ""}`;
+}
+function formatCustomTrigger(trigger) {
+  const minimum = trigger.minimum ? `; minimum ${trigger.minimum.output} >= ${trigger.minimum.threshold}` : "";
+  if (trigger.type === "anomaly") {
+    return `${trigger.output} anomaly at ${trigger.standardDeviations} standard deviations${minimum}`;
+  }
+  return `${trigger.output} ${formatOperator(trigger.operator)} ${trigger.threshold}${minimum}`;
+}
+function formatCustomCondition(rule) {
+  if (!rule.querySupported)
+    return "Query unavailable via API";
+  const query = rule.evaluation.query;
+  const output = query.outputs[0];
+  const selection = query.formulas?.[output] ? `${output} = ${query.formulas[output]}` : query.metrics[output] ? formatMetricSelection(query.metrics[output]) : output;
+  return `${selection}; ${formatCustomTrigger(rule.trigger)}; ${rule.evaluation.window}`;
+}
+function formatBuiltInCondition(rule) {
+  const triggers = rule.triggers.mode === "all" ? "all triggers" : rule.triggers.items.map((trigger) => humanizeReference(trigger.type)).join(", ");
+  return `${triggers}; minimum ${rule.matchMinimumSeverityLevel}`;
+}
+function formatRuleCondition(rule) {
+  return rule.type === "built-in" ? formatBuiltInCondition(rule) : formatCustomCondition(rule);
+}
+function printRules(rules) {
+  const rows = [
+    ["Name", "Rule ID", "Type", "Scope", "Condition"].map(
+      (header) => import_chalk.default.cyan(header)
+    ),
+    ...rules.map((rule) => [
+      import_chalk.default.bold(truncateEnd(rule.name, 36)),
+      import_chalk.default.dim(rule.id),
+      rule.isDefault ? `${rule.type} (default)` : rule.type,
+      truncateMiddle(formatPublicRuleScope(rule), 38),
+      truncateEnd(formatRuleCondition(rule), 72)
+    ])
+  ];
+  output_manager_default.print(`
+${renderAlertTable(rows, 2)}
+`);
+}
+function commonRows(rule) {
+  return [
+    ["Name", rule.name],
+    ["Rule ID", rule.id],
+    ["Type", rule.type],
+    ["Scope", formatPublicRuleScope(rule)],
+    ["Default", formatBoolean(rule.isDefault)],
+    ...rule.createdAt ? [["Created", formatDate(rule.createdAt)]] : [],
+    ...rule.updatedAt ? [["Updated", formatDate(rule.updatedAt)]] : []
+  ];
+}
+function notificationRows(rule) {
+  return [
+    [
+      "Team owner notifications",
+      formatBoolean(rule.notificationSettings.enableTeamOwnerNotifications)
+    ],
+    ...rule.notificationSettings.incidentIoRoutingKey ? [
+      [
+        "Incident.io routing key",
+        rule.notificationSettings.incidentIoRoutingKey
+      ]
+    ] : []
+  ];
+}
+function printBuiltInRule(rule) {
+  output_manager_default.print(`${import_chalk.default.cyan("Built-in conditions")}
+
+`);
+  if (rule.triggers.mode === "all") {
+    output_manager_default.print(
+      `${renderAlertTable(
+        [
+          ["Minimum severity", rule.matchMinimumSeverityLevel],
+          ["Triggers", "all built-in triggers"]
+        ],
+        3
+      )}
+`
+    );
+  } else {
+    output_manager_default.print(
+      `${renderAlertTable(
+        [["Minimum severity", rule.matchMinimumSeverityLevel]],
+        3
+      )}
+
+${renderAlertTable(
+        [
+          ["Trigger", "Filter"].map((header) => import_chalk.default.cyan(header)),
+          ...rule.triggers.items.map((trigger) => [
+            trigger.type,
+            trigger.filter || "-"
+          ])
+        ],
+        3
+      )}
+`
+    );
+  }
+}
+function metricRows(rule) {
+  return Object.entries(rule.evaluation.query.metrics).map(
+    ([alias, metric]) => [
+      alias,
+      metric.metric,
+      metric.aggregation,
+      [
+        metric.per ? `per ${metric.per}` : void 0,
+        metric.normalize ? `normalize ${metric.normalize}` : void 0,
+        metric.dimensions?.join(", ")
+      ].filter(Boolean).join("; ") || "-",
+      metric.filter || "-"
+    ]
+  );
+}
+function printCustomRule(rule) {
+  output_manager_default.print(`${import_chalk.default.cyan("Custom alert")}
+
+`);
+  if (!rule.querySupported) {
+    output_manager_default.print(
+      "  Query unavailable via API. You can update metadata, delete the rule, or recreate it with a supported query.\n"
+    );
+    output_manager_default.print(`
+${renderAlertTable([["Severity", rule.severity]], 3)}
+`);
+    return;
+  }
+  const query = rule.evaluation.query;
+  output_manager_default.print(
+    `${renderAlertTable(
+      [
+        ["Severity", rule.severity],
+        ["Window", rule.evaluation.window],
+        ["Output", query.outputs[0]],
+        ...query.formulas ? Object.entries(query.formulas).map(([alias, formula]) => [
+          `Formula ${alias}`,
+          formula
+        ]) : [],
+        ...query.groupBy?.length ? [["Group By", query.groupBy.join(", ")]] : [],
+        ...query.filter ? [["Query Filter", query.filter]] : []
+      ],
+      3
+    )}
+`
+  );
+  output_manager_default.print(`
+${import_chalk.default.cyan("Metrics")}
+
+`);
+  output_manager_default.print(
+    `${renderAlertTable(
+      [
+        ["Alias", "Metric", "Aggregation", "Modifiers", "Filter"].map(
+          (header) => import_chalk.default.cyan(header)
+        ),
+        ...metricRows(rule)
+      ],
+      3
+    )}
+`
+  );
+  output_manager_default.print(`
+${import_chalk.default.cyan("Trigger")}
+
+`);
+  output_manager_default.print(
+    `${renderAlertTable(
+      [
+        ["Type", rule.trigger.type],
+        ["Output", rule.trigger.output],
+        ...rule.trigger.type === "threshold" ? [
+          ["Operator", rule.trigger.operator],
+          ["Threshold", String(rule.trigger.threshold)]
+        ] : [["Standard Deviations", String(rule.trigger.standardDeviations)]],
+        ...rule.trigger.minimum ? [
+          ["Minimum Output", rule.trigger.minimum.output],
+          ["Minimum Threshold", String(rule.trigger.minimum.threshold)]
+        ] : []
+      ],
+      3
+    )}
+`
+  );
+}
+function printRule(rule) {
+  output_manager_default.print(
+    `
+${import_chalk.default.bold("Alert rule")} ${import_chalk.default.cyan(rule.id)}
+${renderAlertTable(
+      commonRows(rule),
+      3
+    )}
+
+${import_chalk.default.cyan("Notifications")}
+
+${renderAlertTable(
+      notificationRows(rule),
+      3
+    )}
+
+`
+  );
+  if (rule.type === "built-in")
+    printBuiltInRule(rule);
+  else
+    printCustomRule(rule);
+}
+function printRulePreview(rule) {
+  printAlignedLabel("Name", rule.name);
+  printAlignedLabel("Rule ID", rule.id);
+  printAlignedLabel("Type", rule.type);
+  printAlignedLabel("Scope", formatPublicRuleScope(rule));
+}
+function printRuleDeletionReceipt(ruleId) {
+  output_manager_default.print("\n");
+  printAlignedLabel("Deleted", ruleId, { gutter: "\u2713" });
+}
+function printRuleMutationReceipt(action, rule, argv) {
+  output_manager_default.print("\n");
+  printAlignedLabel(action, rule.name, { gutter: "\u2713" });
+  printAlignedLabel("Rule ID", rule.id);
+  printAlignedLabel("Type", rule.type);
+  printAlignedLabel("Scope", formatPublicRuleScope(rule));
+  if (action !== "Deleted") {
+    printAlignedLabel(
+      "Inspect",
+      buildCommandWithGlobalFlags(
+        argv,
+        `alerts rules inspect ${quoteArg(rule.id)}`
+      )
+    );
+  }
+}
+
+export {
+  printRules,
+  printRule,
+  printRulePreview,
+  printRuleDeletionReceipt,
+  printRuleMutationReceipt
+};

package/dist/chunks/{chunk-XM3LOQIX.js → chunk-EDMW7SBH.js}

@@ -13,68 +13,76 @@ import {
 } from "./chunk-Q2DGFCO7.js";
 
 // src/commands/alerts/rules/command.ts
-var scopeOptions = [
-  {
-    ...projectOption,
-    shorthand: "p",
-    description: "Project scope (overrides linked project). Requires team context."
-  },
-  {
-    name: "all",
-    shorthand: "a",
-    type: Boolean,
-    deprecated: false,
-    description: "Team-wide rules only (omit project filter; ignore linked project)."
-  }
-];
-var addScopeOptions = [
-  {
-    ...scopeOptions[0],
-    description: "Target project when the body omits projectId; built-in rules otherwise remain team-wide."
-  },
-  scopeOptions[1]
+var projectScopeOption = {
+  ...projectOption,
+  shorthand: "p",
+  description: "Use a project by name or ID"
+};
+var listAllOption = {
+  name: "all",
+  shorthand: "a",
+  type: Boolean,
+  deprecated: false,
+  description: "List all accessible rules in the selected team"
+};
+var mutationAllOption = {
+  ...listAllOption,
+  description: "Apply the rule to all projects in the selected team"
+};
+var deprecatedItemScopeOptions = [
+  { ...projectScopeOption, deprecated: true },
+  { ...listAllOption, deprecated: true }
 ];
+var bodyOption = {
+  name: "body",
+  shorthand: null,
+  type: String,
+  argument: "PATH",
+  deprecated: false,
+  description: "Read the alert rule body from a JSON file"
+};
 var rulesLsSubcommand = {
   name: "ls",
   aliases: ["list"],
-  description: "List alert rules for the current scope",
+  description: "List alert rules for a project or team",
   arguments: [],
   options: [
-    ...scopeOptions,
+    projectScopeOption,
+    listAllOption,
     {
       name: "type",
       shorthand: null,
       type: [String],
       argument: "TYPE",
       deprecated: false,
-      description: "Filter by alert type. Repeatable and comma-separated (for example --type custom_alert)."
+      description: "Filter by rule type: built-in or custom"
     },
     formatOption,
     jsonOption
   ],
   examples: [
     {
-      name: "List rules for the linked project",
+      name: "List rules affecting the linked project",
       value: `${packageName} alerts rules ls`
     },
     {
-      name: "List team-wide rules",
+      name: "List all rules in the selected team",
       value: `${packageName} alerts rules ls --all`
     },
     {
-      name: "List custom alert rules",
-      value: `${packageName} alerts rules ls --type custom_alert`
+      name: "List custom rules for a project",
+      value: `${packageName} alerts rules ls --project my-app --type custom`
     },
     {
-      name: "JSON output",
-      value: `${packageName} alerts rules ls --json`
+      name: "Write JSON output",
+      value: `${packageName} alerts rules ls --all --json`
     }
   ]
 };
 var rulesSchemaSubcommand = {
   name: "schema",
   aliases: [],
-  description: "Show alert rule body schema and examples by alert type",
+  description: "Show alert rule request fields and examples",
   arguments: [],
   options: [
     {
@@ -83,7 +91,7 @@ var rulesSchemaSubcommand = {
       type: String,
       argument: "TYPE",
       deprecated: false,
-      description: "Alert rule type to describe: usage_anomaly, error_anomaly, or custom_alert."
+      description: "Rule type to describe: built-in or custom"
     },
     formatOption
   ],
@@ -93,62 +101,51 @@ var rulesSchemaSubcommand = {
       value: `${packageName} alerts rules schema`
     },
     {
-      name: "Show error anomaly rule schema",
-      value: `${packageName} alerts rules schema --type error_anomaly`
-    },
-    {
-      name: "Show custom alert rule schema",
-      value: `${packageName} alerts rules schema --type custom_alert`
+      name: "Show the built-in rule schema",
+      value: `${packageName} alerts rules schema --type built-in`
     },
     {
-      name: "Schema as JSON",
-      value: `${packageName} alerts rules schema --type custom_alert --format json`
+      name: "Show the custom rule schema as JSON",
+      value: `${packageName} alerts rules schema --type custom --format json`
     }
   ]
 };
 var rulesAddSubcommand = {
   name: "add",
   aliases: ["create"],
-  description: "Create an alert rule from a JSON body file",
+  description: "Create an alert rule from a JSON body",
   arguments: [],
   options: [
-    ...addScopeOptions,
+    projectScopeOption,
+    mutationAllOption,
     formatOption,
     jsonOption,
-    {
-      name: "body",
-      shorthand: null,
-      type: String,
-      argument: "PATH",
-      deprecated: false,
-      description: "Path to JSON for the new rule. Do not include id or teamId; the API assigns them."
-    }
+    bodyOption
   ],
   examples: [
     {
-      name: "Create from file",
-      value: `${packageName} alerts rules add --body ./rule.json`
+      name: "Create a project-scoped rule",
+      value: `${packageName} alerts rules add --project my-app --body ./rule.json`
+    },
+    {
+      name: "Create a team-wide built-in rule",
+      value: `${packageName} alerts rules add --all --body ./rule.json`
     }
   ]
 };
 var rulesInspectSubcommand = {
   name: "inspect",
   aliases: ["get"],
-  description: "Show one alert rule by id",
-  arguments: [
-    {
-      name: "ruleId",
-      required: true
-    }
-  ],
-  options: [...scopeOptions, formatOption, jsonOption],
+  description: "Show one alert rule by ID",
+  arguments: [{ name: "ruleId", required: true }],
+  options: [...deprecatedItemScopeOptions, formatOption, jsonOption],
   examples: [
     {
       name: "Inspect a rule",
       value: `${packageName} alerts rules inspect ar_abc123`
     },
     {
-      name: "JSON output",
+      name: "Write JSON output",
       value: `${packageName} alerts rules inspect ar_abc123 --json`
     }
   ]
@@ -157,20 +154,15 @@ var rulesRmSubcommand = {
   name: "rm",
   aliases: ["remove", "delete"],
   description: "Delete an alert rule",
-  arguments: [
-    {
-      name: "ruleId",
-      required: true
-    }
-  ],
-  options: [...scopeOptions, formatOption, jsonOption, yesOption],
+  arguments: [{ name: "ruleId", required: true }],
+  options: [...deprecatedItemScopeOptions, formatOption, jsonOption, yesOption],
   examples: [
     {
       name: "Delete with confirmation",
       value: `${packageName} alerts rules rm ar_abc123`
     },
     {
-      name: "Delete without prompt",
+      name: "Delete without a prompt",
       value: `${packageName} alerts rules rm ar_abc123 --yes`
     }
   ]
@@ -178,37 +170,33 @@ var rulesRmSubcommand = {
 var rulesUpdateSubcommand = {
   name: "update",
   aliases: ["patch"],
-  description: "Patch an alert rule from a JSON body file",
-  arguments: [
-    {
-      name: "ruleId",
-      required: true
-    }
-  ],
+  description: "Patch an alert rule or change its scope",
+  arguments: [{ name: "ruleId", required: true }],
   options: [
-    ...scopeOptions,
+    projectScopeOption,
+    mutationAllOption,
     formatOption,
     jsonOption,
     {
-      name: "body",
-      shorthand: null,
-      type: String,
-      argument: "PATH",
-      deprecated: false,
-      description: "Path to partial JSON. Omitted fields remain unchanged; null clears supported optional fields."
+      ...bodyOption,
+      description: "Read the partial update body from a JSON file"
     }
   ],
   examples: [
     {
-      name: "Update from file",
+      name: "Update fields from a file",
       value: `${packageName} alerts rules update ar_abc123 --body ./patch.json`
+    },
+    {
+      name: "Move a rule to a project",
+      value: `${packageName} alerts rules update ar_abc123 --project my-app`
     }
   ]
 };
 var rulesAggregateCommand = {
   name: "rules",
   aliases: [],
-  description: "Create, list, update, or delete alert notification rules (dashboard parity).",
+  description: "Create, inspect, list, update, and delete alert rules",
   arguments: [],
   subcommands: [
     rulesLsSubcommand,
@@ -221,20 +209,16 @@ var rulesAggregateCommand = {
   options: [],
   examples: [
     {
-      name: "List rules",
+      name: "List rules for the linked project",
       value: `${packageName} alerts rules ls`
     },
     {
-      name: "List custom alert rules",
-      value: `${packageName} alerts rules ls --type custom_alert`
-    },
-    {
-      name: "Show schema for a rule type",
-      value: `${packageName} alerts rules schema --type custom_alert`
+      name: "Show the custom rule schema",
+      value: `${packageName} alerts rules schema --type custom`
     },
     {
       name: "Add a rule",
-      value: `${packageName} alerts rules add --body ./rule.json`
+      value: `${packageName} alerts rules add --project my-app --body ./rule.json`
     },
     {
       name: "Inspect a rule",

package/dist/chunks/{chunk-Z7JWYFOY.js → chunk-EEV2LKFC.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-57RHXXXG.js";
 import {
   VERCEL_DIR
-} from "./chunk-2TSBB22D.js";
+} from "./chunk-7F5RNOTP.js";
 import {
   ConflictingConfigFiles,
   DeprecatedNowJson,