vercel 56.4.1 → 57.0.0

package/dist/chunks/ls-RHEQ6YQB.js

@@ -0,0 +1,188 @@
+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 {
+  formatCustomAlertMetric,
+  formatCustomAlertTrigger,
+  formatRuleScope,
+  isCustomAlertRule,
+  parseCustomAlertQuery,
+  renderAlertTable
+} from "./chunk-3PGXYIKC.js";
+import {
+  emitRulesArgParseError,
+  handleRulesApiError,
+  parseRulesFlagsAndScope,
+  rulesCollectionPath
+} from "./chunk-MAHINYBW.js";
+import "./chunk-T4NODP6Y.js";
+import {
+  formatGranularity
+} from "./chunk-5AJPMLDV.js";
+import "./chunk-A3NYPUKZ.js";
+import {
+  normalizeRepeatableStringFilters
+} from "./chunk-BUZRVER7.js";
+import "./chunk-FGDKMNEN.js";
+import {
+  truncateEnd
+} from "./chunk-OF2GNB42.js";
+import {
+  validateJsonOutput
+} from "./chunk-XPKWKPWA.js";
+import {
+  rulesLsSubcommand
+} from "./chunk-KCF6S3XF.js";
+import "./chunk-NZRWTCRM.js";
+import "./chunk-TBR2Q37Y.js";
+import "./chunk-ECCWJHC6.js";
+import {
+  AGENT_REASON,
+  outputAgentError
+} from "./chunk-UDWRZXIT.js";
+import {
+  parseArguments,
+  printError
+} from "./chunk-SZXT3PDQ.js";
+import {
+  getFlagsSpecification,
+  isAPIError
+} from "./chunk-KSSNLCL4.js";
+import "./chunk-P4QNYOFB.js";
+import "./chunk-52QYYTM5.js";
+import {
+  output_manager_default
+} from "./chunk-OX7KI3LF.js";
+import "./chunk-GGP5R3FU.js";
+import {
+  require_source
+} from "./chunk-S7KYDPEM.js";
+import {
+  __toESM
+} from "./chunk-TZ2YI2VH.js";
+
+// src/commands/alerts/rules/ls.ts
+var import_chalk = __toESM(require_source(), 1);
+function getCustomAlertRuleDetails(rule) {
+  const customAlert = rule.customAlert;
+  if (!isCustomAlertRule(rule) || !customAlert) {
+    return "";
+  }
+  const metric = formatCustomAlertMetric(customAlert);
+  const trigger = formatCustomAlertTrigger(customAlert);
+  const min = typeof customAlert.minThreshold === "number" ? `min ${customAlert.minThreshold}` : void 0;
+  const granularity = formatGranularity(
+    parseCustomAlertQuery(customAlert.queryJsonString).granularity
+  );
+  const interval = granularity ? `every ${granularity}` : void 0;
+  return [metric, trigger, min, interval].filter(Boolean).join("; ");
+}
+function ruleMatchesTypes(rule, types) {
+  if (types.length === 0) {
+    return true;
+  }
+  return rule.alertTypes?.some((alertType) => types.includes(alertType.type)) || types.includes("custom_alert") && isCustomAlertRule(rule);
+}
+function getRuleScope(rule) {
+  return formatRuleScope(rule.projectId, {
+    projectIdMaxLength: 24,
+    filterMaxLength: 24
+  });
+}
+function printRules(rules) {
+  const showDetails = rules.some((rule) => getCustomAlertRuleDetails(rule));
+  const headers = [
+    "Name",
+    "Rule id",
+    "Scope",
+    ...showDetails ? ["Details"] : []
+  ].map((h) => import_chalk.default.cyan(h));
+  const rows = [
+    headers,
+    ...rules.map((rule) => {
+      const row = [
+        import_chalk.default.bold(truncateEnd(rule.name || "-", 44)),
+        import_chalk.default.dim(rule.id || "-"),
+        getRuleScope(rule)
+      ];
+      if (showDetails) {
+        row.push(truncateEnd(getCustomAlertRuleDetails(rule) || "-", 72));
+      }
+      return row;
+    })
+  ];
+  output_manager_default.print(`
+${renderAlertTable(rows, 2)}
+`);
+}
+async function ls(client, argv) {
+  let parsedArgs;
+  try {
+    parsedArgs = parseArguments(
+      argv,
+      getFlagsSpecification(rulesLsSubcommand.options)
+    );
+  } catch (e) {
+    emitRulesArgParseError(client, e, "alerts rules ls --project <name-or-id>");
+    printError(e);
+    return 1;
+  }
+  const flags = parsedArgs.flags;
+  const fr = validateJsonOutput(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;
+  }
+  const scope = await parseRulesFlagsAndScope(
+    client,
+    {
+      "--project": flags["--project"],
+      "--all": flags["--all"]
+    },
+    fr.jsonOutput,
+    "alerts rules ls"
+  );
+  if (typeof scope === "number") {
+    return scope;
+  }
+  const path = rulesCollectionPath(scope);
+  output_manager_default.spinner("Fetching alert rules...");
+  try {
+    const rules = await client.fetch(path);
+    const types = normalizeRepeatableStringFilters(flags["--type"]);
+    const filteredRules = rules.filter((rule) => ruleMatchesTypes(rule, types));
+    if (fr.jsonOutput) {
+      client.stdout.write(
+        `${JSON.stringify({ rules: filteredRules }, null, 2)}
+`
+      );
+    } else if (filteredRules.length === 0) {
+      output_manager_default.log("No alert rules found for this scope.");
+    } else {
+      printRules(filteredRules);
+    }
+    return 0;
+  } catch (err) {
+    if (isAPIError(err)) {
+      return handleRulesApiError(client, err, fr.jsonOutput);
+    }
+    throw err;
+  } finally {
+    output_manager_default.stopSpinner();
+  }
+}
+export {
+  ls as default
+};

package/dist/chunks/open-E3XADEMX.js

@@ -0,0 +1,106 @@
+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 {
+  parseThreadArg
+} from "./chunk-E336ZXPP.js";
+import {
+  getThread,
+  handleCommentsParseError,
+  resolveCommentsScope,
+  threadNotFoundMessage,
+  toApiErrorParts
+} from "./chunk-LMHT3QR3.js";
+import {
+  outputError
+} from "./chunk-BUZRVER7.js";
+import {
+  openSubcommand
+} from "./chunk-FHEMFAHB.js";
+import {
+  require_open
+} from "./chunk-TBR2Q37Y.js";
+import "./chunk-ECCWJHC6.js";
+import "./chunk-UDWRZXIT.js";
+import {
+  parseArguments
+} from "./chunk-SZXT3PDQ.js";
+import {
+  getFlagsSpecification,
+  isAPIError
+} from "./chunk-KSSNLCL4.js";
+import "./chunk-P4QNYOFB.js";
+import "./chunk-52QYYTM5.js";
+import {
+  output_manager_default
+} from "./chunk-OX7KI3LF.js";
+import "./chunk-GGP5R3FU.js";
+import "./chunk-S7KYDPEM.js";
+import {
+  __toESM
+} from "./chunk-TZ2YI2VH.js";
+
+// src/commands/comments/open.ts
+var import_open = __toESM(require_open(), 1);
+async function openThread(client, telemetry) {
+  let parsedArgs;
+  const flagsSpecification = getFlagsSpecification(openSubcommand.options);
+  try {
+    parsedArgs = parseArguments(client.argv.slice(2), flagsSpecification);
+  } catch (err) {
+    return handleCommentsParseError(err, "open");
+  }
+  const threadInput = parsedArgs.args[2];
+  telemetry.trackCliArgumentThread(threadInput);
+  if (!threadInput) {
+    output_manager_default.error("Pass a thread ID or URL: `vercel comments open <thread>`.");
+    return 1;
+  }
+  const threadRef = parseThreadArg(threadInput);
+  if (!threadRef) {
+    output_manager_default.error(
+      `Could not extract a thread ID from "${threadInput}". Pass the thread ID or its vercel.com URL.`
+    );
+    return 1;
+  }
+  const threadId = threadRef.id;
+  telemetry.trackCliOptionProject(parsedArgs.flags["--project"]);
+  const scope = await resolveCommentsScope(client, {
+    project: parsedArgs.flags["--project"],
+    requireProject: false,
+    jsonOutput: false,
+    urlTeamSlug: threadRef.teamSlug
+  });
+  if (typeof scope === "number") {
+    return scope;
+  }
+  let webUrl;
+  try {
+    const thread = await getThread(client, scope.teamId, threadId);
+    webUrl = thread.webUrl;
+  } catch (err) {
+    if (isAPIError(err)) {
+      const { code, message } = toApiErrorParts(err);
+      return outputError(
+        client,
+        false,
+        code,
+        err.status === 404 ? threadNotFoundMessage(threadId, scope) : message
+      );
+    }
+    throw err;
+  }
+  if (!webUrl) {
+    output_manager_default.error(`The API returned no web URL for ${threadId}.`);
+    return 1;
+  }
+  output_manager_default.log(`Opening ${webUrl}`);
+  await (0, import_open.default)(webUrl);
+  return 0;
+}
+export {
+  openThread as default
+};

package/dist/chunks/{publish-RXFUYSW3.js → publish-Z3AQRUCS.js}

@@ -17,7 +17,7 @@ import {
   printDiffSummary,
   requireProjectContext,
   withGlobalFlags
-} from "./chunk-GKVAAY2A.js";
+} from "./chunk-555WJSO5.js";
 import {
   publishSubcommand
 } from "./chunk-VZSZBD4V.js";
@@ -25,11 +25,11 @@ import {
   stamp_default
 } from "./chunk-64IF634X.js";
 import "./chunk-VXYGCOKL.js";
-import "./chunk-GLAHGVBS.js";
+import "./chunk-TBR2Q37Y.js";
+import "./chunk-ECCWJHC6.js";
 import {
   outputAgentError
 } from "./chunk-UDWRZXIT.js";
-import "./chunk-ECCWJHC6.js";
 import "./chunk-SZXT3PDQ.js";
 import "./chunk-KSSNLCL4.js";
 import "./chunk-P4QNYOFB.js";

package/dist/chunks/{query-ILJJL3BZ.js → query-3EV66DO3.js}

@@ -7,21 +7,24 @@ const __dirname = __dirname_(__filename);
 import {
   fetchMetricDetailOrExit,
   getDefaultAggregation
-} from "./chunk-6RTK6BWX.js";
+} from "./chunk-YA3WQFLY.js";
 import {
   computeGranularity,
   formatText
-} from "./chunk-F5OMERHI.js";
+} from "./chunk-QZD5DKUR.js";
 import {
   formatErrorJson,
   formatQueryJson,
   getRollupColumnName,
   handleApiError
-} from "./chunk-Z7NPYIZ6.js";
+} from "./chunk-NM43FFV6.js";
+import "./chunk-5AJPMLDV.js";
+import "./chunk-A3NYPUKZ.js";
 import {
   resolveTimeRange,
   validateAllProjectMutualExclusivity
 } from "./chunk-BUZRVER7.js";
+import "./chunk-OF2GNB42.js";
 import {
   validateJsonOutput
 } from "./chunk-XPKWKPWA.js";
@@ -34,9 +37,9 @@ import {
   getLinkedProject,
   getProjectByNameOrId,
   getScope
-} from "./chunk-GLAHGVBS.js";
-import "./chunk-UDWRZXIT.js";
+} from "./chunk-TBR2Q37Y.js";
 import "./chunk-ECCWJHC6.js";
+import "./chunk-UDWRZXIT.js";
 import {
   parseArguments,
   printError
@@ -56,9 +59,6 @@ import "./chunk-S7KYDPEM.js";
 import "./chunk-TZ2YI2VH.js";
 
 // src/commands/metrics/validation.ts
-function validateMutualExclusivity(all, project) {
-  return validateAllProjectMutualExclusivity(all, project);
-}
 function validateRequiredMetric(metric) {
   if (metric) {
     return { valid: true, value: metric };
@@ -253,7 +253,7 @@ async function query(client, telemetry) {
     return handleValidationError(requiredMetric, jsonOutput, client);
   }
   const metric = requiredMetric.value;
-  const mutualResult = validateMutualExclusivity(all, project);
+  const mutualResult = validateAllProjectMutualExclusivity(all, project);
   if (!mutualResult.valid) {
     return handleValidationError(mutualResult, jsonOutput, client);
   }

package/dist/chunks/{reorder-GBCOPZT4.js → reorder-VA5E5ZJT.js}

@@ -16,7 +16,7 @@ import {
   resolveRoute,
   shellQuoteRouteIdentifierForSuggestion,
   withGlobalFlags
-} from "./chunk-GKVAAY2A.js";
+} from "./chunk-555WJSO5.js";
 import {
   reorderSubcommand
 } from "./chunk-VZSZBD4V.js";
@@ -24,11 +24,11 @@ import {
   stamp_default
 } from "./chunk-64IF634X.js";
 import "./chunk-VXYGCOKL.js";
-import "./chunk-GLAHGVBS.js";
+import "./chunk-TBR2Q37Y.js";
+import "./chunk-ECCWJHC6.js";
 import {
   outputAgentError
 } from "./chunk-UDWRZXIT.js";
-import "./chunk-ECCWJHC6.js";
 import "./chunk-SZXT3PDQ.js";
 import "./chunk-KSSNLCL4.js";
 import "./chunk-P4QNYOFB.js";

package/dist/chunks/reply-SNSCNKAW.js

@@ -0,0 +1,167 @@
+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 {
+  resolveMessageContent
+} from "./chunk-WR7JTCGL.js";
+import {
+  parseThreadArg
+} from "./chunk-E336ZXPP.js";
+import {
+  addMessage,
+  handleCommentsParseError,
+  resolveCommentsScope,
+  threadNotFoundMessage,
+  toApiErrorParts
+} from "./chunk-LMHT3QR3.js";
+import "./chunk-2473DUBR.js";
+import {
+  outputError
+} from "./chunk-BUZRVER7.js";
+import {
+  validateJsonOutput
+} from "./chunk-XPKWKPWA.js";
+import {
+  replySubcommand
+} from "./chunk-FHEMFAHB.js";
+import "./chunk-TBR2Q37Y.js";
+import "./chunk-ECCWJHC6.js";
+import "./chunk-UDWRZXIT.js";
+import {
+  parseArguments
+} from "./chunk-SZXT3PDQ.js";
+import {
+  getFlagsSpecification,
+  isAPIError
+} from "./chunk-KSSNLCL4.js";
+import "./chunk-P4QNYOFB.js";
+import "./chunk-52QYYTM5.js";
+import {
+  output_manager_default
+} from "./chunk-OX7KI3LF.js";
+import "./chunk-GGP5R3FU.js";
+import {
+  require_source
+} from "./chunk-S7KYDPEM.js";
+import {
+  __toESM
+} from "./chunk-TZ2YI2VH.js";
+
+// src/commands/comments/reply.ts
+var import_chalk = __toESM(require_source(), 1);
+function validateAttachments(attach) {
+  if (!attach || attach.length === 0) {
+    return void 0;
+  }
+  if (attach.length > 10) {
+    return "A message can have at most 10 attachments.";
+  }
+  for (const url of attach) {
+    if (!/^https:\/\//i.test(url)) {
+      return `Attachments must be https URLs (the API fetches them); got "${url}". Local file upload is not supported by the API.`;
+    }
+  }
+  return void 0;
+}
+async function reply(client, telemetry) {
+  let parsedArgs;
+  const flagsSpecification = getFlagsSpecification(replySubcommand.options);
+  try {
+    parsedArgs = parseArguments(client.argv.slice(2), flagsSpecification);
+  } catch (err) {
+    return handleCommentsParseError(err, "reply");
+  }
+  const formatResult = validateJsonOutput(parsedArgs.flags);
+  if (!formatResult.valid) {
+    output_manager_default.error(formatResult.error);
+    return 1;
+  }
+  const jsonOutput = formatResult.jsonOutput;
+  telemetry.trackCliOptionFormat(parsedArgs.flags["--format"]);
+  telemetry.trackCliOptionMessage(parsedArgs.flags["--message"]);
+  telemetry.trackCliOptionFile(parsedArgs.flags["--file"]);
+  telemetry.trackCliOptionAttach(parsedArgs.flags["--attach"]);
+  const threadInput = parsedArgs.args[2];
+  telemetry.trackCliArgumentThread(threadInput);
+  if (!threadInput) {
+    return outputError(
+      client,
+      jsonOutput,
+      "MISSING_THREAD",
+      "Pass a thread ID or URL: `vercel comments reply <thread> -m <text>`."
+    );
+  }
+  const threadRef = parseThreadArg(threadInput);
+  if (!threadRef) {
+    return outputError(
+      client,
+      jsonOutput,
+      "INVALID_THREAD",
+      `Could not extract a thread ID from "${threadInput}". Pass the thread ID or its vercel.com URL.`
+    );
+  }
+  const threadId = threadRef.id;
+  const attach = parsedArgs.flags["--attach"];
+  const attachError = validateAttachments(attach);
+  if (attachError) {
+    return outputError(client, jsonOutput, "INVALID_ATTACHMENT", attachError);
+  }
+  const content = await resolveMessageContent(
+    client,
+    {
+      message: parsedArgs.flags["--message"],
+      file: parsedArgs.flags["--file"],
+      hasAttachments: Boolean(attach && attach.length > 0)
+    },
+    jsonOutput
+  );
+  if (typeof content === "number") {
+    return content;
+  }
+  telemetry.trackCliOptionProject(parsedArgs.flags["--project"]);
+  const scope = await resolveCommentsScope(client, {
+    project: parsedArgs.flags["--project"],
+    requireProject: false,
+    jsonOutput,
+    urlTeamSlug: threadRef.teamSlug
+  });
+  if (typeof scope === "number") {
+    return scope;
+  }
+  if (!jsonOutput) {
+    output_manager_default.spinner("Posting reply\u2026");
+  }
+  try {
+    const message = await addMessage(client, scope.teamId, threadId, {
+      ...content !== void 0 && { markdown: content },
+      ...attach && attach.length > 0 && { attachments: attach.map((url) => ({ url })) }
+    });
+    if (jsonOutput) {
+      client.stdout.write(`${JSON.stringify(message, null, 2)}
+`);
+      return 0;
+    }
+    output_manager_default.print(`${import_chalk.default.green("\u2713")} Replied to ${threadId}
+`);
+    return 0;
+  } catch (err) {
+    if (isAPIError(err)) {
+      const { code, message } = toApiErrorParts(err);
+      return outputError(
+        client,
+        jsonOutput,
+        code,
+        err.status === 404 ? threadNotFoundMessage(threadId, scope) : message
+      );
+    }
+    throw err;
+  } finally {
+    output_manager_default.stopSpinner();
+  }
+}
+export {
+  reply as default
+};