vercel 51.2.0 → 51.3.0

package/dist/chunks/rm-LDXY2G45.js

@@ -0,0 +1,164 @@
+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 {
+  emitRulesArgParseError,
+  handleRulesApiError,
+  parseRulesFlagsAndScope,
+  rulesItemPath
+} from "./chunk-4ZWTYJSP.js";
+import "./chunk-NE34PEHL.js";
+import "./chunk-HTOH3MSD.js";
+import "./chunk-APGVHLAW.js";
+import {
+  validateJsonOutput
+} from "./chunk-XPKWKPWA.js";
+import {
+  rulesRmSubcommand
+} from "./chunk-DVQ4SIWF.js";
+import {
+  AGENT_REASON
+} from "./chunk-E3NE4SKN.js";
+import "./chunk-4VP55L4V.js";
+import "./chunk-U3WLEFHU.js";
+import {
+  buildCommandWithGlobalFlags,
+  buildCommandWithYes,
+  outputAgentError
+} from "./chunk-CGTXAXZ4.js";
+import "./chunk-CO5D46AG.js";
+import {
+  getFlagsSpecification,
+  parseArguments,
+  printError
+} from "./chunk-RFMC2QXQ.js";
+import {
+  isAPIError,
+  packageName
+} from "./chunk-ECRBC4HL.js";
+import {
+  output_manager_default
+} from "./chunk-ZQKJVHXY.js";
+import "./chunk-S7KYDPEM.js";
+import "./chunk-TZ2YI2VH.js";
+
+// src/commands/alerts/rules/rm.ts
+async function rm(client, argv) {
+  let parsedArgs;
+  try {
+    parsedArgs = parseArguments(
+      argv,
+      getFlagsSpecification(rulesRmSubcommand.options)
+    );
+  } catch (e) {
+    emitRulesArgParseError(
+      client,
+      e,
+      "alerts rules rm <ruleId> --project <name-or-id> --yes"
+    );
+    printError(e);
+    return 1;
+  }
+  const ruleId = parsedArgs.args[0];
+  const fr = validateJsonOutput(parsedArgs.flags);
+  if (!fr.valid) {
+    outputAgentError(
+      client,
+      {
+        status: "error",
+        reason: AGENT_REASON.INVALID_ARGUMENTS,
+        message: fr.error
+      },
+      1
+    );
+    output_manager_default.error(fr.error);
+    return 1;
+  }
+  if (!ruleId) {
+    outputAgentError(
+      client,
+      {
+        status: "error",
+        reason: AGENT_REASON.MISSING_ARGUMENTS,
+        message: `Missing rule id. Example: ${packageName} alerts rules rm <ruleId> --yes`,
+        next: [
+          {
+            command: buildCommandWithGlobalFlags(
+              client.argv,
+              "alerts rules rm <ruleId> --yes"
+            ),
+            when: "Replace <ruleId> with an id from `alerts rules ls`"
+          },
+          {
+            command: buildCommandWithGlobalFlags(
+              client.argv,
+              "alerts rules ls"
+            ),
+            when: "List rule ids in the current scope"
+          }
+        ]
+      },
+      1
+    );
+    output_manager_default.error("Usage: `vercel alerts rules rm <ruleId>`");
+    return 1;
+  }
+  const skipConfirmation = Boolean(parsedArgs.flags["--yes"]);
+  const scope = await parseRulesFlagsAndScope(
+    client,
+    {
+      "--project": parsedArgs.flags["--project"],
+      "--all": parsedArgs.flags["--all"]
+    },
+    fr.jsonOutput
+  );
+  if (typeof scope === "number") {
+    return scope;
+  }
+  if (!skipConfirmation) {
+    outputAgentError(
+      client,
+      {
+        status: "error",
+        reason: AGENT_REASON.CONFIRMATION_REQUIRED,
+        message: "Removing an alert rule requires confirmation. Re-run with --yes.",
+        next: [{ command: buildCommandWithYes(client.argv) }]
+      },
+      1
+    );
+    if (!await client.input.confirm(
+      `Delete alert rule ${ruleId}? This cannot be undone.`,
+      false
+    )) {
+      output_manager_default.log("Canceled");
+      return 0;
+    }
+  }
+  const path = rulesItemPath(scope, ruleId);
+  output_manager_default.spinner("Deleting alert rule...");
+  try {
+    await client.fetch(path, { method: "DELETE" });
+    if (fr.jsonOutput) {
+      client.stdout.write(
+        `${JSON.stringify({ ok: true, ruleId, deleted: true }, null, 2)}
+`
+      );
+    } else {
+      output_manager_default.success(`Deleted alert rule ${ruleId}`);
+    }
+    return 0;
+  } catch (err) {
+    if (isAPIError(err)) {
+      return handleRulesApiError(client, err, fr.jsonOutput);
+    }
+    throw err;
+  } finally {
+    output_manager_default.stopSpinner();
+  }
+}
+export {
+  rm as default
+};

package/dist/chunks/rule-inspect-THIN6POX.js

@@ -0,0 +1,142 @@
+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 {
+  emitRulesArgParseError,
+  handleRulesApiError,
+  parseRulesFlagsAndScope,
+  rulesItemPath
+} from "./chunk-4ZWTYJSP.js";
+import "./chunk-NE34PEHL.js";
+import "./chunk-HTOH3MSD.js";
+import "./chunk-APGVHLAW.js";
+import {
+  validateJsonOutput
+} from "./chunk-XPKWKPWA.js";
+import {
+  rulesInspectSubcommand
+} from "./chunk-DVQ4SIWF.js";
+import {
+  AGENT_REASON
+} from "./chunk-E3NE4SKN.js";
+import "./chunk-4VP55L4V.js";
+import "./chunk-U3WLEFHU.js";
+import {
+  buildCommandWithGlobalFlags,
+  outputAgentError
+} from "./chunk-CGTXAXZ4.js";
+import "./chunk-CO5D46AG.js";
+import {
+  getFlagsSpecification,
+  parseArguments,
+  printError
+} from "./chunk-RFMC2QXQ.js";
+import {
+  isAPIError,
+  packageName
+} from "./chunk-ECRBC4HL.js";
+import {
+  output_manager_default
+} from "./chunk-ZQKJVHXY.js";
+import "./chunk-S7KYDPEM.js";
+import "./chunk-TZ2YI2VH.js";
+
+// src/commands/alerts/rules/rule-inspect.ts
+async function ruleInspect(client, argv) {
+  let parsedArgs;
+  try {
+    parsedArgs = parseArguments(
+      argv,
+      getFlagsSpecification(rulesInspectSubcommand.options)
+    );
+  } catch (e) {
+    emitRulesArgParseError(
+      client,
+      e,
+      "alerts rules inspect <ruleId> --project <name-or-id>"
+    );
+    printError(e);
+    return 1;
+  }
+  const ruleId = parsedArgs.args[0];
+  const fr = validateJsonOutput(parsedArgs.flags);
+  if (!fr.valid) {
+    outputAgentError(
+      client,
+      {
+        status: "error",
+        reason: AGENT_REASON.INVALID_ARGUMENTS,
+        message: fr.error
+      },
+      1
+    );
+    output_manager_default.error(fr.error);
+    return 1;
+  }
+  if (!ruleId) {
+    outputAgentError(
+      client,
+      {
+        status: "error",
+        reason: AGENT_REASON.MISSING_ARGUMENTS,
+        message: `Missing rule id. Example: ${packageName} alerts rules inspect <ruleId>`,
+        next: [
+          {
+            command: buildCommandWithGlobalFlags(
+              client.argv,
+              "alerts rules inspect <ruleId>"
+            ),
+            when: "Replace <ruleId> with an id from `alerts rules ls`"
+          },
+          {
+            command: buildCommandWithGlobalFlags(
+              client.argv,
+              "alerts rules ls"
+            ),
+            when: "List rule ids in the current scope"
+          }
+        ]
+      },
+      1
+    );
+    output_manager_default.error("Usage: `vercel alerts rules inspect <ruleId>`");
+    return 1;
+  }
+  const scope = await parseRulesFlagsAndScope(
+    client,
+    {
+      "--project": parsedArgs.flags["--project"],
+      "--all": parsedArgs.flags["--all"]
+    },
+    fr.jsonOutput
+  );
+  if (typeof scope === "number") {
+    return scope;
+  }
+  const path = rulesItemPath(scope, ruleId);
+  output_manager_default.spinner("Fetching alert rule...");
+  try {
+    const rule = await client.fetch(path);
+    if (fr.jsonOutput) {
+      client.stdout.write(`${JSON.stringify({ rule }, null, 2)}
+`);
+    } else {
+      client.stdout.write(`${JSON.stringify(rule, null, 2)}
+`);
+    }
+    return 0;
+  } catch (err) {
+    if (isAPIError(err)) {
+      return handleRulesApiError(client, err, fr.jsonOutput);
+    }
+    throw err;
+  } finally {
+    output_manager_default.stopSpinner();
+  }
+}
+export {
+  ruleInspect as default
+};

package/dist/chunks/rules-4ZH7VTGC.js

@@ -0,0 +1,83 @@
+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 {
+  getSubcommand
+} from "./chunk-YPQSDAEW.js";
+import {
+  AGENT_REASON
+} from "./chunk-E3NE4SKN.js";
+import {
+  buildCommandWithGlobalFlags,
+  outputAgentError
+} from "./chunk-CGTXAXZ4.js";
+import "./chunk-ECRBC4HL.js";
+import {
+  output_manager_default
+} from "./chunk-ZQKJVHXY.js";
+import "./chunk-S7KYDPEM.js";
+import "./chunk-TZ2YI2VH.js";
+
+// src/commands/alerts/rules/index.ts
+var RULES_CONFIG = {
+  ls: ["ls", "list"],
+  add: ["add", "create"],
+  inspect: ["inspect", "get"],
+  rm: ["rm", "remove", "delete"],
+  update: ["update", "patch"]
+};
+async function rules(client, argv) {
+  if (argv.length === 0) {
+    const lsFn = (await import("./ls-TYEDISJD.js")).default;
+    return lsFn(client, []);
+  }
+  const { subcommand, args, subcommandOriginal } = getSubcommand(
+    argv,
+    RULES_CONFIG
+  );
+  if (subcommand == null) {
+    outputAgentError(
+      client,
+      {
+        status: "error",
+        reason: AGENT_REASON.INVALID_ARGUMENTS,
+        message: `Unknown "alerts rules" subcommand "${argv[0]}".`,
+        next: [
+          {
+            command: buildCommandWithGlobalFlags(
+              client.argv,
+              "alerts rules --help"
+            ),
+            when: "Show valid rules subcommands"
+          }
+        ]
+      },
+      1
+    );
+    output_manager_default.error(
+      `Unknown "alerts rules" subcommand "${argv[0]}". Run \`vercel alerts rules --help\`.`
+    );
+    return 1;
+  }
+  switch (subcommand) {
+    case "ls":
+      return (await import("./ls-TYEDISJD.js")).default(client, args);
+    case "add":
+      return (await import("./add-3MIOUOZC.js")).default(client, args);
+    case "inspect":
+      return (await import("./rule-inspect-THIN6POX.js")).default(client, args);
+    case "rm":
+      return (await import("./rm-LDXY2G45.js")).default(client, args);
+    case "update":
+      return (await import("./update-EXPUPEH6.js")).default(client, args);
+    default:
+      output_manager_default.error(`Unhandled rules subcommand: ${String(subcommandOriginal)}`);
+      return 1;
+  }
+}
+export {
+  rules as default
+};

package/dist/chunks/{schema-WBOIQRP4.js → schema-OK4OOI2N.js}

@@ -8,33 +8,35 @@ import {
   fetchMetricDetailOrExit,
   fetchMetricListOrExit,
   formatErrorJson
-} from "./chunk-NELCIT4M.js";
+} from "./chunk-GLDQ23LD.js";
 import {
   indent_default
 } from "./chunk-A3NYPUKZ.js";
 import {
   formatTable
-} from "./chunk-L2BKVTHL.js";
+} from "./chunk-G6RXZLQ2.js";
 import {
   getScope
-} from "./chunk-7IDNCLTM.js";
+} from "./chunk-APGVHLAW.js";
 import {
   validateJsonOutput
 } from "./chunk-XPKWKPWA.js";
 import {
   schemaSubcommand
-} from "./chunk-IS2HEMF4.js";
-import "./chunk-4YZKA4FN.js";
+} from "./chunk-4RBF6ZDU.js";
+import "./chunk-GE6G37P4.js";
 import {
   require_pluralize
-} from "./chunk-V23RAVWV.js";
+} from "./chunk-4VP55L4V.js";
 import "./chunk-U3WLEFHU.js";
+import "./chunk-CGTXAXZ4.js";
 import "./chunk-CO5D46AG.js";
 import {
   getFlagsSpecification,
   parseArguments,
   printError
-} from "./chunk-A4NVECX5.js";
+} from "./chunk-RFMC2QXQ.js";
+import "./chunk-ECRBC4HL.js";
 import {
   output_manager_default
 } from "./chunk-ZQKJVHXY.js";

package/dist/chunks/{types-A4EAQ6F6.js → types-QNN5CDCB.js}

@@ -9,16 +9,18 @@ import {
 } from "./chunk-XPKWKPWA.js";
 import {
   typesSubcommand
-} from "./chunk-2IAZZEVQ.js";
+} from "./chunk-UWKTUK3W.js";
 import {
   table
-} from "./chunk-4YZKA4FN.js";
+} from "./chunk-GE6G37P4.js";
 import {
   getFlagsSpecification,
-  isAPIError,
   parseArguments,
   printError
-} from "./chunk-A4NVECX5.js";
+} from "./chunk-RFMC2QXQ.js";
+import {
+  isAPIError
+} from "./chunk-ECRBC4HL.js";
 import {
   output_manager_default
 } from "./chunk-ZQKJVHXY.js";

package/dist/chunks/update-EXPUPEH6.js

@@ -0,0 +1,196 @@
+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 {
+  emitRulesArgParseError,
+  handleRulesApiError,
+  parseRulesFlagsAndScope,
+  rulesItemPath
+} from "./chunk-4ZWTYJSP.js";
+import "./chunk-NE34PEHL.js";
+import "./chunk-HTOH3MSD.js";
+import "./chunk-APGVHLAW.js";
+import {
+  validateJsonOutput
+} from "./chunk-XPKWKPWA.js";
+import {
+  rulesUpdateSubcommand
+} from "./chunk-DVQ4SIWF.js";
+import {
+  AGENT_REASON
+} from "./chunk-E3NE4SKN.js";
+import "./chunk-4VP55L4V.js";
+import "./chunk-U3WLEFHU.js";
+import {
+  buildCommandWithGlobalFlags,
+  outputAgentError
+} from "./chunk-CGTXAXZ4.js";
+import "./chunk-CO5D46AG.js";
+import {
+  getFlagsSpecification,
+  parseArguments,
+  printError
+} from "./chunk-RFMC2QXQ.js";
+import {
+  isAPIError,
+  packageName
+} from "./chunk-ECRBC4HL.js";
+import {
+  output_manager_default
+} from "./chunk-ZQKJVHXY.js";
+import "./chunk-S7KYDPEM.js";
+import "./chunk-TZ2YI2VH.js";
+
+// src/commands/alerts/rules/update.ts
+import { readFileSync } from "fs";
+import { resolve } from "path";
+async function update(client, argv) {
+  let parsedArgs;
+  try {
+    parsedArgs = parseArguments(
+      argv,
+      getFlagsSpecification(rulesUpdateSubcommand.options)
+    );
+  } catch (e) {
+    emitRulesArgParseError(
+      client,
+      e,
+      "alerts rules update <ruleId> --project <name-or-id> --body <path>"
+    );
+    printError(e);
+    return 1;
+  }
+  const ruleId = parsedArgs.args[0];
+  const fr = validateJsonOutput(parsedArgs.flags);
+  if (!fr.valid) {
+    outputAgentError(
+      client,
+      {
+        status: "error",
+        reason: AGENT_REASON.INVALID_ARGUMENTS,
+        message: fr.error
+      },
+      1
+    );
+    output_manager_default.error(fr.error);
+    return 1;
+  }
+  if (!ruleId) {
+    outputAgentError(
+      client,
+      {
+        status: "error",
+        reason: AGENT_REASON.MISSING_ARGUMENTS,
+        message: `Missing rule id. Example: ${packageName} alerts rules update <ruleId> --body <file>`,
+        next: [
+          {
+            command: buildCommandWithGlobalFlags(
+              client.argv,
+              "alerts rules update <ruleId> --body <file>"
+            ),
+            when: "Replace <ruleId> and <file> with id and JSON patch path"
+          }
+        ]
+      },
+      1
+    );
+    output_manager_default.error("Usage: `vercel alerts rules update <ruleId> --body <PATH>`");
+    return 1;
+  }
+  const bodyPath = parsedArgs.flags["--body"];
+  if (!bodyPath) {
+    outputAgentError(
+      client,
+      {
+        status: "error",
+        reason: AGENT_REASON.MISSING_ARGUMENTS,
+        message: `Missing required flag --body. Example: ${packageName} alerts rules update ${ruleId} --body <file>`,
+        next: [
+          {
+            command: buildCommandWithGlobalFlags(
+              client.argv,
+              `alerts rules update ${ruleId} --body <file>`
+            ),
+            when: "Replace <file> with a path to JSON patch payload"
+          }
+        ]
+      },
+      1
+    );
+    output_manager_default.error("Missing required flag: --body <PATH> (JSON patch payload).");
+    return 1;
+  }
+  const scope = await parseRulesFlagsAndScope(
+    client,
+    {
+      "--project": parsedArgs.flags["--project"],
+      "--all": parsedArgs.flags["--all"]
+    },
+    fr.jsonOutput
+  );
+  if (typeof scope === "number") {
+    return scope;
+  }
+  let raw;
+  try {
+    raw = readFileSync(resolve(client.cwd, bodyPath), "utf8");
+  } catch {
+    outputAgentError(
+      client,
+      {
+        status: "error",
+        reason: AGENT_REASON.INVALID_ARGUMENTS,
+        message: `Could not read --body file: ${bodyPath}`
+      },
+      1
+    );
+    output_manager_default.error(`Could not read --body file: ${bodyPath}`);
+    return 1;
+  }
+  let body;
+  try {
+    body = JSON.parse(raw);
+  } catch {
+    outputAgentError(
+      client,
+      {
+        status: "error",
+        reason: AGENT_REASON.INVALID_ARGUMENTS,
+        message: "Invalid JSON in --body file."
+      },
+      1
+    );
+    output_manager_default.error("Invalid JSON in --body file.");
+    return 1;
+  }
+  delete body.id;
+  delete body.teamId;
+  const path = rulesItemPath(scope, ruleId);
+  output_manager_default.spinner("Updating alert rule...");
+  try {
+    const updated = await client.fetch(path, {
+      method: "PATCH",
+      body
+    });
+    if (fr.jsonOutput) {
+      client.stdout.write(`${JSON.stringify({ rule: updated }, null, 2)}
+`);
+    } else {
+      output_manager_default.success(`Updated alert rule ${ruleId}`);
+    }
+    return 0;
+  } catch (err) {
+    if (isAPIError(err)) {
+      return handleRulesApiError(client, err, fr.jsonOutput);
+    }
+    throw err;
+  } finally {
+    output_manager_default.stopSpinner();
+  }
+}
+export {
+  update as default
+};