vercel 56.4.1 → 57.0.0

package/dist/chunks/resolve-6ZX4RTXX.js

@@ -0,0 +1,228 @@
+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 {
+  addMessage,
+  handleCommentsParseError,
+  resolveCommentsScope,
+  threadNotFoundMessage,
+  toApiErrorParts,
+  updateThread
+} from "./chunk-LMHT3QR3.js";
+import {
+  canPrompt
+} from "./chunk-2473DUBR.js";
+import {
+  outputError
+} from "./chunk-BUZRVER7.js";
+import {
+  validateJsonOutput
+} from "./chunk-XPKWKPWA.js";
+import {
+  reopenSubcommand,
+  resolveSubcommand
+} 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/resolve.ts
+var import_chalk = __toESM(require_source(), 1);
+async function resolveThreads(client, telemetry, resolved) {
+  const subcommand = resolved ? resolveSubcommand : reopenSubcommand;
+  const verb = resolved ? "resolve" : "reopen";
+  const pastVerb = resolved ? "resolved" : "reopened";
+  let parsedArgs;
+  const flagsSpecification = getFlagsSpecification(subcommand.options);
+  try {
+    parsedArgs = parseArguments(client.argv.slice(2), flagsSpecification);
+  } catch (err) {
+    return handleCommentsParseError(err, subcommand.name);
+  }
+  const formatResult = validateJsonOutput(parsedArgs.flags);
+  if (!formatResult.valid) {
+    output_manager_default.error(formatResult.error);
+    return 1;
+  }
+  const jsonOutput = formatResult.jsonOutput;
+  const closingMessage = resolved ? parsedArgs.flags["--message"] : void 0;
+  const yes = Boolean(parsedArgs.flags["--yes"]);
+  telemetry.trackCliOptionFormat(parsedArgs.flags["--format"]);
+  telemetry.trackCliFlagYes(parsedArgs.flags["--yes"]);
+  if (resolved) {
+    telemetry.trackCliOptionMessage(closingMessage);
+  }
+  const threadInputs = parsedArgs.args.slice(2);
+  telemetry.trackCliArgumentThread(threadInputs[0]);
+  if (threadInputs.length === 0) {
+    return outputError(
+      client,
+      jsonOutput,
+      "MISSING_THREAD",
+      `Pass at least one thread ID or URL: \`vercel comments ${verb} <thread>\`.`
+    );
+  }
+  const threadIds = [];
+  let urlTeamSlug;
+  for (const input of threadInputs) {
+    const ref = parseThreadArg(input);
+    if (!ref) {
+      return outputError(
+        client,
+        jsonOutput,
+        "INVALID_THREAD",
+        `Could not extract a thread ID from "${input}".`
+      );
+    }
+    if (ref.teamSlug) {
+      if (urlTeamSlug && urlTeamSlug !== ref.teamSlug) {
+        return outputError(
+          client,
+          jsonOutput,
+          "MIXED_TEAMS",
+          `The URLs belong to different teams (${urlTeamSlug}, ${ref.teamSlug}). Run once per team.`
+        );
+      }
+      urlTeamSlug = ref.teamSlug;
+    }
+    threadIds.push(ref.id);
+  }
+  if (closingMessage !== void 0 && threadIds.length > 1) {
+    return outputError(
+      client,
+      jsonOutput,
+      "MESSAGE_WITH_MULTIPLE_THREADS",
+      "Cannot use -m with multiple threads. Resolve one thread with a closing message, or resolve multiple threads without -m."
+    );
+  }
+  const scope = await resolveCommentsScope(client, {
+    project: parsedArgs.flags["--project"],
+    requireProject: false,
+    jsonOutput,
+    urlTeamSlug
+  });
+  if (typeof scope === "number") {
+    return scope;
+  }
+  if (threadIds.length > 1 && !yes) {
+    if (!canPrompt(client) || jsonOutput) {
+      return outputError(
+        client,
+        jsonOutput,
+        "CONFIRMATION_REQUIRED",
+        `Pass --yes to ${verb} ${threadIds.length} comments non-interactively.`
+      );
+    }
+    const confirmed = await client.input.confirm(
+      `${import_chalk.default.bold(String(threadIds.length))} comments will be ${pastVerb} in team ${scope.teamSlug ?? scope.teamId}. Continue?`,
+      false
+    );
+    if (!confirmed) {
+      output_manager_default.log("Canceled.");
+      return 0;
+    }
+  }
+  telemetry.trackCliOptionProject(
+    parsedArgs.flags["--project"]
+  );
+  if (threadIds.length === 1) {
+    const threadId = threadIds[0];
+    let replied = false;
+    try {
+      if (closingMessage !== void 0) {
+        await addMessage(client, scope.teamId, threadId, {
+          markdown: closingMessage
+        });
+        replied = true;
+      }
+      const thread = await updateThread(
+        client,
+        scope.teamId,
+        threadId,
+        resolved
+      );
+      if (jsonOutput) {
+        client.stdout.write(
+          `${JSON.stringify({ thread, replied }, null, 2)}
+`
+        );
+        return 0;
+      }
+      output_manager_default.print(
+        `${import_chalk.default.green("\u2713")} ${threadId} ${pastVerb}${replied ? " (with closing reply)" : ""}
+`
+      );
+      return 0;
+    } catch (err) {
+      if (isAPIError(err)) {
+        const { code, message } = toApiErrorParts(err);
+        const friendly = err.status === 404 ? threadNotFoundMessage(threadId, scope) : message;
+        return outputError(
+          client,
+          jsonOutput,
+          code,
+          replied ? `Replied, but ${verb} failed: ${friendly} Run \`vercel comments resolve ${threadId}\` (without -m) to finish without duplicating the reply.` : friendly
+        );
+      }
+      throw err;
+    }
+  }
+  const results = [];
+  for (const threadId of threadIds) {
+    try {
+      await updateThread(client, scope.teamId, threadId, resolved);
+      results.push({ id: threadId, ok: true });
+    } catch (err) {
+      if (isAPIError(err)) {
+        const { message } = toApiErrorParts(err);
+        results.push({ id: threadId, ok: false, error: message });
+      } else {
+        throw err;
+      }
+    }
+  }
+  const failed = results.filter((result) => !result.ok);
+  if (jsonOutput) {
+    client.stdout.write(`${JSON.stringify({ results }, null, 2)}
+`);
+    return failed.length > 0 ? 1 : 0;
+  }
+  for (const result of results) {
+    if (result.ok) {
+      output_manager_default.print(`${import_chalk.default.green("\u2713")} ${result.id} ${pastVerb}
+`);
+    } else {
+      output_manager_default.print(`${import_chalk.default.yellow("!")} ${result.id} ${result.error}
+`);
+    }
+  }
+  return failed.length > 0 ? 1 : 0;
+}
+export {
+  resolveThreads as default
+};

package/dist/chunks/{restore-YK5DGGRX.js → restore-NEHI5B5P.js}

@@ -19,7 +19,7 @@ import {
   requireProjectContext,
   validateRequiredArguments,
   withGlobalFlags
-} from "./chunk-GKVAAY2A.js";
+} from "./chunk-555WJSO5.js";
 import {
   restoreSubcommand
 } from "./chunk-VZSZBD4V.js";
@@ -27,11 +27,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/{rm-O474MI5C.js → rm-22B22E47.js}

@@ -13,19 +13,19 @@ import {
   requireVcrRepositoryAndImageId,
   resolveVcrScope,
   validateVcrJsonOutput
-} from "./chunk-NLRIKNPX.js";
+} from "./chunk-GP5VCTEU.js";
 import "./chunk-BUZRVER7.js";
 import "./chunk-XPKWKPWA.js";
 import {
   imageRmSubcommand
 } from "./chunk-FYQPTH5C.js";
-import "./chunk-GLAHGVBS.js";
+import "./chunk-TBR2Q37Y.js";
+import "./chunk-ECCWJHC6.js";
 import {
   AGENT_REASON,
   buildCommandWithYes,
   outputAgentError
 } from "./chunk-UDWRZXIT.js";
-import "./chunk-ECCWJHC6.js";
 import {
   parseArguments,
   printError

package/dist/chunks/{rm-LK6P7XTA.js → rm-E5ZVLAKO.js}

@@ -13,7 +13,7 @@ import {
   requireVcrRepository,
   resolveVcrScope,
   validateVcrJsonOutput
-} from "./chunk-NLRIKNPX.js";
+} from "./chunk-GP5VCTEU.js";
 import "./chunk-BUZRVER7.js";
 import "./chunk-XPKWKPWA.js";
 import {
@@ -21,13 +21,13 @@ import {
 } from "./chunk-3VS4DTAU.js";
 import "./chunk-GIL3VAUR.js";
 import "./chunk-FYQPTH5C.js";
-import "./chunk-GLAHGVBS.js";
+import "./chunk-TBR2Q37Y.js";
+import "./chunk-ECCWJHC6.js";
 import {
   AGENT_REASON,
   buildCommandWithYes,
   outputAgentError
 } from "./chunk-UDWRZXIT.js";
-import "./chunk-ECCWJHC6.js";
 import {
   parseArguments,
   printError

package/dist/chunks/{rm-FRZMXB2W.js → rm-FR6KE744.js}

@@ -9,23 +9,23 @@ import {
   handleRulesApiError,
   parseRulesFlagsAndScope,
   rulesItemPath
-} from "./chunk-A4XB42AB.js";
-import "./chunk-XFGY3JAX.js";
+} from "./chunk-MAHINYBW.js";
+import "./chunk-T4NODP6Y.js";
 import "./chunk-BUZRVER7.js";
 import {
   validateJsonOutput
 } from "./chunk-XPKWKPWA.js";
 import {
   rulesRmSubcommand
-} from "./chunk-STJJ3DFO.js";
-import "./chunk-GLAHGVBS.js";
+} from "./chunk-KCF6S3XF.js";
+import "./chunk-TBR2Q37Y.js";
+import "./chunk-ECCWJHC6.js";
 import {
   AGENT_REASON,
   buildCommandWithGlobalFlags,
   buildCommandWithYes,
   outputAgentError
 } from "./chunk-UDWRZXIT.js";
-import "./chunk-ECCWJHC6.js";
 import {
   parseArguments,
   printError
@@ -112,7 +112,8 @@ async function rm(client, argv) {
       "--project": parsedArgs.flags["--project"],
       "--all": parsedArgs.flags["--all"]
     },
-    fr.jsonOutput
+    fr.jsonOutput,
+    `alerts rules rm ${ruleId}`
   );
   if (typeof scope === "number") {
     return scope;

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

@@ -0,0 +1,283 @@
+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,
+  humanizeReference,
+  isCustomAlertRule,
+  parseCustomAlertQuery,
+  renderAlertTable
+} from "./chunk-3PGXYIKC.js";
+import {
+  emitRulesArgParseError,
+  handleRulesApiError,
+  parseRulesFlagsAndScope,
+  rulesItemPath
+} from "./chunk-MAHINYBW.js";
+import "./chunk-T4NODP6Y.js";
+import {
+  formatDate
+} from "./chunk-GZLPFESR.js";
+import {
+  formatGranularity
+} from "./chunk-5AJPMLDV.js";
+import "./chunk-A3NYPUKZ.js";
+import "./chunk-BUZRVER7.js";
+import "./chunk-FGDKMNEN.js";
+import "./chunk-PRWJUY5U.js";
+import {
+  truncateMiddle
+} from "./chunk-OF2GNB42.js";
+import {
+  validateJsonOutput
+} from "./chunk-XPKWKPWA.js";
+import {
+  rulesInspectSubcommand
+} from "./chunk-KCF6S3XF.js";
+import "./chunk-NZRWTCRM.js";
+import "./chunk-TBR2Q37Y.js";
+import "./chunk-ECCWJHC6.js";
+import {
+  AGENT_REASON,
+  buildCommandWithGlobalFlags,
+  outputAgentError
+} from "./chunk-UDWRZXIT.js";
+import {
+  parseArguments,
+  printError
+} from "./chunk-SZXT3PDQ.js";
+import {
+  getFlagsSpecification,
+  isAPIError,
+  packageName
+} 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/rule-inspect.ts
+var import_chalk = __toESM(require_source(), 1);
+function formatBoolean(value) {
+  if (value === void 0) {
+    return "-";
+  }
+  return value ? "yes" : "no";
+}
+function getAlertTypeRows(rule) {
+  const types = rule.alertTypes?.map((alertType) => alertType.type) ?? (rule.customAlert ? ["custom_alert"] : []);
+  if (types.length === 0) {
+    return [];
+  }
+  const uniqueTypes = [...new Set(types)];
+  return [
+    [
+      uniqueTypes.length === 1 ? "Type" : "Types",
+      uniqueTypes.map((value) => humanizeReference(value)).join(", ")
+    ]
+  ];
+}
+function getNotificationRows(rule) {
+  const rows = [];
+  if (rule.autosubscribeOwnersInKnock !== void 0) {
+    rows.push([
+      "Auto-subscribe owners",
+      formatBoolean(rule.autosubscribeOwnersInKnock)
+    ]);
+  }
+  if (rule.autosubscribeProjectAdminsInKnock !== void 0) {
+    rows.push([
+      "Auto-subscribe project admins",
+      formatBoolean(rule.autosubscribeProjectAdminsInKnock)
+    ]);
+  }
+  const slackChannels = /* @__PURE__ */ new Set();
+  const webhooks = /* @__PURE__ */ new Set();
+  for (const notification of rule.notifications ?? []) {
+    for (const channel of notification.slack ?? []) {
+      slackChannels.add(channel);
+    }
+    for (const webhook of notification.webhooks ?? []) {
+      webhooks.add(webhook);
+    }
+  }
+  if (slackChannels.size > 0) {
+    rows.push(["Slack", [...slackChannels].join(", ")]);
+  }
+  if (webhooks.size > 0) {
+    rows.push(["Webhooks", [...webhooks].join(", ")]);
+  }
+  return rows;
+}
+function getCustomAlertRows(customAlert) {
+  const query = parseCustomAlertQuery(customAlert.queryJsonString);
+  const granularity = formatGranularity(query.granularity);
+  const groupBy = query.groupBy ?? [];
+  const rows = [
+    ["Title", customAlert.title || "-"],
+    ["Metric", formatCustomAlertMetric(customAlert) || "-"],
+    ["Trigger", formatCustomAlertTrigger(customAlert) || "-"],
+    ...typeof customAlert.minThreshold === "number" ? [["Minimum", String(customAlert.minThreshold)]] : [],
+    ...query.event ? [["Event", humanizeReference(query.event)]] : [],
+    ...groupBy.length > 0 ? [
+      [
+        "Group By",
+        groupBy.map((value) => humanizeReference(value)).join(", ")
+      ]
+    ] : [],
+    ...granularity ? [["Granularity", granularity]] : [],
+    ...customAlert.createdAt ? [["Created At", formatDate(customAlert.createdAt)]] : []
+  ];
+  return rows.map(([label, value]) => [label, truncateMiddle(value, 96)]);
+}
+function printRule(rule, ruleId) {
+  const summaryRows = [
+    ["Name", rule.name || "-"],
+    ...rule.action === "exclude" ? [["Action", rule.action]] : [],
+    ["Scope", formatRuleScope(rule.projectId)],
+    ...getAlertTypeRows(rule),
+    ...rule.sensitivityLevel !== void 0 ? [["Sensitivity", String(rule.sensitivityLevel)]] : [],
+    ...rule.isDefault !== void 0 ? [["Default", formatBoolean(rule.isDefault)]] : [],
+    ...rule.owner ? [["Owner", rule.owner]] : [],
+    ...rule.teamId ? [["Team id", rule.teamId]] : [],
+    ...rule.lastEditedByUserId ? [["Last Edited By", rule.lastEditedByUserId]] : [],
+    ...rule.odataFilters ? [["OData Filters", rule.odataFilters]] : []
+  ];
+  const sections = [
+    "",
+    `${import_chalk.default.bold("Alert rule")} ${import_chalk.default.cyan(rule.id || ruleId)}`,
+    renderAlertTable(summaryRows, 3)
+  ];
+  const notificationRows = getNotificationRows(rule);
+  if (notificationRows.length > 0) {
+    sections.push(
+      "",
+      import_chalk.default.cyan("Notifications"),
+      renderAlertTable(notificationRows, 3)
+    );
+  }
+  if (rule.customAlert) {
+    sections.push(
+      "",
+      import_chalk.default.cyan("Custom Alert"),
+      renderAlertTable(getCustomAlertRows(rule.customAlert), 3)
+    );
+  } else if (isCustomAlertRule(rule)) {
+    sections.push(
+      "",
+      import_chalk.default.cyan("Custom Alert"),
+      "  No custom alert definition returned."
+    );
+  }
+  output_manager_default.print(`${sections.join("\n")}
+`);
+}
+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,
+    `alerts rules inspect ${ruleId}`
+  );
+  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);
+    output_manager_default.stopSpinner();
+    if (fr.jsonOutput) {
+      client.stdout.write(`${JSON.stringify({ rule }, null, 2)}
+`);
+    } else {
+      printRule(rule, ruleId);
+    }
+    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-MZ2MP6KJ.js → rules-EYGXEI2Z.js}

@@ -29,8 +29,8 @@ var RULES_CONFIG = {
   update: ["update", "patch"]
 };
 async function rules(client, argv) {
-  if (argv.length === 0 || argv[0].startsWith("-")) {
-    const lsFn = (await import("./ls-MB74DIQV.js")).default;
+  if (argv.length === 0 || argv[0]?.startsWith("-")) {
+    const lsFn = (await import("./ls-RHEQ6YQB.js")).default;
     return lsFn(client, argv);
   }
   const { subcommand, args, subcommandOriginal } = getSubcommand(
@@ -63,15 +63,15 @@ async function rules(client, argv) {
   }
   switch (subcommand) {
     case "ls":
-      return (await import("./ls-MB74DIQV.js")).default(client, args);
+      return (await import("./ls-RHEQ6YQB.js")).default(client, args);
     case "add":
-      return (await import("./add-L3Z6PL54.js")).default(client, args);
+      return (await import("./add-7M577U56.js")).default(client, args);
     case "inspect":
-      return (await import("./rule-inspect-YEZGYINZ.js")).default(client, args);
+      return (await import("./rule-inspect-DMP2CKJQ.js")).default(client, args);
     case "rm":
-      return (await import("./rm-FRZMXB2W.js")).default(client, args);
+      return (await import("./rm-FR6KE744.js")).default(client, args);
     case "update":
-      return (await import("./update-W3CWQB2F.js")).default(client, args);
+      return (await import("./update-QH4DQMZV.js")).default(client, args);
     default:
       output_manager_default.error(`Unhandled rules subcommand: ${String(subcommandOriginal)}`);
       return 1;

package/dist/chunks/{schema-FR6CCQIZ.js → schema-2IIWOBSQ.js}

@@ -7,11 +7,13 @@ const __dirname = __dirname_(__filename);
 import {
   fetchMetricDetailOrExit,
   fetchMetricListOrExit
-} from "./chunk-6RTK6BWX.js";
+} from "./chunk-YA3WQFLY.js";
+import {
+  formatErrorJson
+} from "./chunk-NM43FFV6.js";
 import {
-  formatErrorJson,
   indent_default
-} from "./chunk-Z7NPYIZ6.js";
+} from "./chunk-A3NYPUKZ.js";
 import {
   formatTable
 } from "./chunk-ZVLPUREX.js";
@@ -25,9 +27,9 @@ import "./chunk-NZRWTCRM.js";
 import {
   getScope,
   require_pluralize
-} from "./chunk-GLAHGVBS.js";
-import "./chunk-UDWRZXIT.js";
+} from "./chunk-TBR2Q37Y.js";
 import "./chunk-ECCWJHC6.js";
+import "./chunk-UDWRZXIT.js";
 import {
   parseArguments,
   printError

package/dist/chunks/{tags-AKRTKFRV.js → tags-ZDVYRHAY.js}

@@ -52,9 +52,9 @@ async function tags(client, argv, telemetry) {
   }
   switch (subcommand) {
     case "ls":
-      return (await import("./ls-YDUYTLXW.js")).default(client, args, telemetry);
+      return (await import("./ls-CG6A7UXF.js")).default(client, args, telemetry);
     case "inspect":
-      return (await import("./inspect-4JD2QN67.js")).default(client, args, telemetry);
+      return (await import("./inspect-UM3LDRPV.js")).default(client, args, telemetry);
     default:
       output_manager_default.error(`Unhandled tags subcommand: ${subcommand}`);
       return 1;