vercel 59.11.7 → 59.12.0

package/dist/chunks/{add-KSJQYR5C.js → add-OO3JGLZW.js}

@@ -17,7 +17,7 @@ import {
   emitVcrArgParseError,
   resolveVcrScope,
   validateVcrJsonOutput
-} from "./chunk-FVNJTRCE.js";
+} from "./chunk-EOLGLGXJ.js";
 import "./chunk-TO7QZGYK.js";
 import {
   outputError
@@ -33,7 +33,7 @@ import "./chunk-GGP5R3FU.js";
 import {
   AGENT_REASON
 } from "./chunk-VUS2JQB2.js";
-import "./chunk-4IVSM24H.js";
+import "./chunk-ABSZNJQO.js";
 import "./chunk-XNIZGCN5.js";
 import {
   printError
@@ -41,7 +41,7 @@ import {
 import {
   parseArguments
 } from "./chunk-57RHXXXG.js";
-import "./chunk-2TSBB22D.js";
+import "./chunk-MADFAH3O.js";
 import "./chunk-G5FBSUL4.js";
 import {
   buildCommandWithGlobalFlags,

package/dist/chunks/{add-WU2QYHYL.js → add-RTXDASSS.js}

@@ -9,7 +9,7 @@ import {
   handleVcrApiError,
   resolveVcrScope,
   validateVcrJsonOutput
-} from "./chunk-FVNJTRCE.js";
+} from "./chunk-EOLGLGXJ.js";
 import "./chunk-TO7QZGYK.js";
 import {
   outputError
@@ -28,7 +28,7 @@ import "./chunk-GGP5R3FU.js";
 import {
   AGENT_REASON
 } from "./chunk-VUS2JQB2.js";
-import "./chunk-4IVSM24H.js";
+import "./chunk-ABSZNJQO.js";
 import "./chunk-XNIZGCN5.js";
 import {
   printError
@@ -36,7 +36,7 @@ import {
 import {
   parseArguments
 } from "./chunk-57RHXXXG.js";
-import "./chunk-2TSBB22D.js";
+import "./chunk-MADFAH3O.js";
 import "./chunk-G5FBSUL4.js";
 import {
   buildCommandWithGlobalFlags,

package/dist/chunks/add-XGO6LHMD.js

@@ -0,0 +1,221 @@
+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 {
+  printRuleMutationReceipt
+} from "./chunk-2NIDTSQJ.js";
+import "./chunk-GDOUDU6O.js";
+import {
+  emitRulesArgParseError,
+  getBodyType,
+  handleRulesApiError,
+  outputRulesError,
+  readRuleBody,
+  resolveRulesProject,
+  resolveRulesTeam,
+  rulesCollectionPath
+} from "./chunk-HR2MP4XF.js";
+import "./chunk-3BB2HOO2.js";
+import "./chunk-GZLPFESR.js";
+import "./chunk-A3NYPUKZ.js";
+import "./chunk-KFWQ3EFH.js";
+import "./chunk-FGDKMNEN.js";
+import "./chunk-PRWJUY5U.js";
+import "./chunk-WT2Y7FRD.js";
+import "./chunk-AINIBIP4.js";
+import "./chunk-QB2UHSUB.js";
+import "./chunk-ND5CF2H3.js";
+import {
+  validateJsonOutput
+} from "./chunk-KXDWXXJH.js";
+import "./chunk-V4RMJKQP.js";
+import {
+  rulesAddSubcommand
+} from "./chunk-EDMW7SBH.js";
+import "./chunk-WT6C2ALC.js";
+import "./chunk-P7VSBDR4.js";
+import "./chunk-YPMFZRTN.js";
+import "./chunk-ZDU2NODC.js";
+import "./chunk-PEC3CQSK.js";
+import "./chunk-GGP5R3FU.js";
+import "./chunk-VUS2JQB2.js";
+import "./chunk-KAF4WFF3.js";
+import "./chunk-HRXRELD3.js";
+import "./chunk-B5XLQKHI.js";
+import "./chunk-ABSZNJQO.js";
+import "./chunk-XNIZGCN5.js";
+import "./chunk-NW34PW6V.js";
+import {
+  printError
+} from "./chunk-3VM7HWF6.js";
+import {
+  parseArguments
+} from "./chunk-57RHXXXG.js";
+import "./chunk-MADFAH3O.js";
+import "./chunk-G5FBSUL4.js";
+import "./chunk-26CU4Q3C.js";
+import "./chunk-XPJLPUKO.js";
+import {
+  isAPIError
+} from "./chunk-CV5YC2EN.js";
+import {
+  getFlagsSpecification
+} from "./chunk-Q2DGFCO7.js";
+import {
+  output_manager_default
+} from "./chunk-2JIX6UMI.js";
+import "./chunk-P4QNYOFB.js";
+import "./chunk-ZW6HETRE.js";
+import "./chunk-S7KYDPEM.js";
+import "./chunk-TZ2YI2VH.js";
+
+// src/commands/alerts/rules/add.ts
+function applyScopeFlag(client, body, type, scope, flags, jsonOutput) {
+  if (Object.hasOwn(body, "ruleScope")) {
+    if (flags["--project"] || flags["--all"]) {
+      return outputRulesError(
+        client,
+        jsonOutput,
+        "SCOPE_CONFLICT",
+        "Specify rule scope either in the body or with --project/--all, not both."
+      );
+    }
+    return void 0;
+  }
+  if (flags["--project"]) {
+    body.ruleScope = type === "custom" ? { type: "project", projectId: scope.projectId } : { type: "include", projectIds: [scope.projectId] };
+    return void 0;
+  }
+  if (flags["--all"]) {
+    if (type === "custom") {
+      return outputRulesError(
+        client,
+        jsonOutput,
+        "INVALID_SCOPE",
+        "Custom alert rules must target one project. Use --project <name-or-id>."
+      );
+    }
+    body.ruleScope = { type: "all" };
+    return void 0;
+  }
+  return outputRulesError(
+    client,
+    jsonOutput,
+    "MISSING_SCOPE",
+    "Missing rule scope. Add ruleScope to the body, or pass --project or --all."
+  );
+}
+async function resolveCreateScope(client, flags, jsonOutput) {
+  if (flags["--project"] && flags["--all"]) {
+    return outputRulesError(
+      client,
+      jsonOutput,
+      "MUTUAL_EXCLUSIVITY",
+      "Cannot specify both --all and --project. Use one or the other."
+    );
+  }
+  return flags["--project"] ? resolveRulesProject(
+    client,
+    flags["--project"],
+    jsonOutput,
+    "alerts rules add"
+  ) : resolveRulesTeam(client, jsonOutput);
+}
+async function add(client, argv) {
+  let parsedArgs;
+  try {
+    parsedArgs = parseArguments(
+      argv,
+      getFlagsSpecification(rulesAddSubcommand.options)
+    );
+  } catch (error) {
+    emitRulesArgParseError(
+      client,
+      error,
+      "alerts rules add --project <name-or-id> --body <path>"
+    );
+    printError(error);
+    return 1;
+  }
+  const flags = parsedArgs.flags;
+  const format = validateJsonOutput(flags);
+  if (!format.valid) {
+    return outputRulesError(client, false, "INVALID_ARGUMENTS", format.error);
+  }
+  if (!flags["--body"]) {
+    return outputRulesError(
+      client,
+      format.jsonOutput,
+      "MISSING_ARGUMENTS",
+      "Missing required flag: --body <PATH>."
+    );
+  }
+  const body = readRuleBody(client, flags["--body"], format.jsonOutput);
+  if (typeof body === "number")
+    return body;
+  const type = getBodyType(body);
+  if (!type) {
+    return outputRulesError(
+      client,
+      format.jsonOutput,
+      "INVALID_RULE_TYPE",
+      "Create body must set type to built-in or custom."
+    );
+  }
+  if (Object.hasOwn(body, "ruleScope") && (flags["--project"] || flags["--all"])) {
+    return outputRulesError(
+      client,
+      format.jsonOutput,
+      "SCOPE_CONFLICT",
+      "Specify rule scope either in the body or with --project/--all, not both."
+    );
+  }
+  if (type === "custom" && flags["--all"]) {
+    return outputRulesError(
+      client,
+      format.jsonOutput,
+      "INVALID_SCOPE",
+      "Custom alert rules must target one project. Use --project <name-or-id>."
+    );
+  }
+  const scope = await resolveCreateScope(client, flags, format.jsonOutput);
+  if (typeof scope === "number")
+    return scope;
+  const scopeError = applyScopeFlag(
+    client,
+    body,
+    type,
+    scope,
+    flags,
+    format.jsonOutput
+  );
+  if (scopeError !== void 0)
+    return scopeError;
+  output_manager_default.spinner("Creating alert rule\u2026");
+  try {
+    const response = await client.fetch(
+      rulesCollectionPath(scope.teamId),
+      { method: "POST", body }
+    );
+    if (format.jsonOutput) {
+      client.stdout.write(`${JSON.stringify(response, null, 2)}
+`);
+    } else {
+      printRuleMutationReceipt("Created", response.rule, client.argv);
+    }
+    return 0;
+  } catch (error) {
+    if (isAPIError(error)) {
+      return handleRulesApiError(client, error, format.jsonOutput);
+    }
+    throw error;
+  } finally {
+    output_manager_default.stopSpinner();
+  }
+}
+export {
+  add as default
+};

package/dist/chunks/{build-F3J6FLPD.js → build-JINV2UD4.js}

@@ -23,7 +23,7 @@ import {
   runEngine,
   splitPassthrough,
   validateVcrChoice
-} from "./chunk-FVNJTRCE.js";
+} from "./chunk-EOLGLGXJ.js";
 import "./chunk-TO7QZGYK.js";
 import {
   outputError
@@ -42,7 +42,7 @@ import "./chunk-GGP5R3FU.js";
 import {
   AGENT_REASON
 } from "./chunk-VUS2JQB2.js";
-import "./chunk-4IVSM24H.js";
+import "./chunk-ABSZNJQO.js";
 import "./chunk-XNIZGCN5.js";
 import {
   printError
@@ -50,7 +50,7 @@ import {
 import {
   parseArguments
 } from "./chunk-57RHXXXG.js";
-import "./chunk-2TSBB22D.js";
+import "./chunk-MADFAH3O.js";
 import "./chunk-G5FBSUL4.js";
 import {
   buildCommandWithGlobalFlags,

package/dist/chunks/chunk-2NIDTSQJ.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-MADFAH3O.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-SHFNEZVI.js → chunk-32XSMM3W.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-6E6KPBXY.js";
 import {
   require_lib
-} from "./chunk-2TSBB22D.js";
+} from "./chunk-MADFAH3O.js";
 import {
   CantParseJSONFile
 } from "./chunk-CV5YC2EN.js";

package/dist/chunks/{chunk-N4QHMXOO.js → chunk-3BB2HOO2.js}

@@ -12,11 +12,11 @@ import {
 } from "./chunk-VUS2JQB2.js";
 import {
   getScope
-} from "./chunk-4IVSM24H.js";
+} from "./chunk-ABSZNJQO.js";
 import {
   getLinkedProject,
   getProjectByNameOrId
-} from "./chunk-2TSBB22D.js";
+} from "./chunk-MADFAH3O.js";
 import {
   buildCommandWithGlobalFlags,
   outputAgentError
@@ -158,5 +158,6 @@ async function resolveAlertsScope(client, opts) {
 }
 
 export {
+  emitAlertsScopeError,
   resolveAlertsScope
 };

package/dist/chunks/{chunk-DSTNNQVV.js → chunk-3F25W3GA.js}

@@ -6,20 +6,20 @@ const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __dirname_(__filename);
 import {
   MISSING_BOTH_MESSAGE
-} from "./chunk-5GGUB4EO.js";
+} from "./chunk-QIUK4Z7Q.js";
 import {
   RULE_ENVIRONMENTS
 } from "./chunk-GY5I4AYD.js";
 import {
   resolveProjectContext
-} from "./chunk-7KROIXQM.js";
+} from "./chunk-X6TGUHFD.js";
 import {
   AGENT_REASON,
   AGENT_STATUS
 } from "./chunk-VUS2JQB2.js";
 import {
   detectExplicitScope
-} from "./chunk-4IVSM24H.js";
+} from "./chunk-ABSZNJQO.js";
 import {
   printError
 } from "./chunk-3VM7HWF6.js";

package/dist/chunks/{chunk-OIH6FP5Y.js → chunk-4TUMNBEE.js}

@@ -100,7 +100,7 @@ var metricsCommand = {
       type: [String],
       deprecated: false,
       get description() {
-        return process.env.FF_METRICS ? "KQL filter expression (repeatable, ANDed together)" : "OData filter expression (repeatable, ANDed together)";
+        return process.env.FF_LEGACY_METRICS ? "OData filter expression (repeatable, ANDed together)" : "KQL filter expression (repeatable, ANDed together)";
       },
       argument: "EXPR"
     },
@@ -158,7 +158,7 @@ var metricsCommand = {
     jsonOption
   ],
   get examples() {
-    const canonical = Boolean(process.env.FF_METRICS);
+    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";

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

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