vercel 51.2.1 → 51.4.0

package/dist/chunks/inspect-HUJLUQAV.js

@@ -0,0 +1,353 @@
+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 {
+  emitAlertsScopeError
+} from "./chunk-7ZDERWUW.js";
+import {
+  handleValidationError,
+  outputError,
+  validateAllProjectMutualExclusivity
+} from "./chunk-HTOH3MSD.js";
+import {
+  getScope
+} from "./chunk-L2JUC7NX.js";
+import {
+  validateJsonOutput
+} from "./chunk-XPKWKPWA.js";
+import {
+  inspectSubcommand
+} from "./chunk-TAOVG4PS.js";
+import "./chunk-DVQ4SIWF.js";
+import {
+  AGENT_REASON
+} from "./chunk-E3NE4SKN.js";
+import {
+  getLinkedProject,
+  getProjectByNameOrId
+} from "./chunk-537JTK2U.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 {
+  ProjectNotFound,
+  isAPIError,
+  packageName
+} from "./chunk-ECRBC4HL.js";
+import {
+  output_manager_default
+} from "./chunk-ZQKJVHXY.js";
+import {
+  require_source
+} from "./chunk-S7KYDPEM.js";
+import {
+  __toESM
+} from "./chunk-TZ2YI2VH.js";
+
+// src/commands/alerts/inspect.ts
+var import_chalk = __toESM(require_source(), 1);
+async function resolveInspectScope(client, flags, jsonOutput) {
+  const mutual = validateAllProjectMutualExclusivity(
+    flags["--all"],
+    flags["--project"]
+  );
+  if (!mutual.valid) {
+    outputAgentError(
+      client,
+      {
+        status: "error",
+        reason: AGENT_REASON.INVALID_ARGUMENTS,
+        message: mutual.message,
+        next: [
+          {
+            command: buildCommandWithGlobalFlags(
+              client.argv,
+              "alerts inspect <groupId> --help"
+            ),
+            when: "Use either `--project` or `--all`, not both"
+          }
+        ]
+      },
+      1
+    );
+    return handleValidationError(mutual, jsonOutput, client);
+  }
+  if (flags["--all"]) {
+    const { team } = await getScope(client);
+    if (!team) {
+      const msg = "No team context found. Run `vercel switch` to select a team, or use `vercel link`.";
+      return emitAlertsScopeError(client, jsonOutput, "NO_TEAM", msg, {
+        reason: AGENT_REASON.MISSING_SCOPE,
+        next: [
+          {
+            command: buildCommandWithGlobalFlags(client.argv, "whoami"),
+            when: "See current user and team"
+          },
+          {
+            command: buildCommandWithGlobalFlags(client.argv, "teams switch"),
+            when: "Switch to a team that owns the project"
+          }
+        ]
+      });
+    }
+    return { teamId: team.id };
+  }
+  if (flags["--project"]) {
+    const { team } = await getScope(client);
+    if (!team) {
+      const msg = "No team context found. Run `vercel switch` to select a team.";
+      return emitAlertsScopeError(client, jsonOutput, "NO_TEAM", msg, {
+        reason: AGENT_REASON.MISSING_SCOPE,
+        next: [
+          {
+            command: buildCommandWithGlobalFlags(client.argv, "whoami"),
+            when: "See current user and team"
+          },
+          {
+            command: buildCommandWithGlobalFlags(client.argv, "teams switch"),
+            when: "Switch to a team that owns the project"
+          }
+        ]
+      });
+    }
+    try {
+      const p = await getProjectByNameOrId(client, flags["--project"], team.id);
+      if (p instanceof ProjectNotFound) {
+        const msg = `Project "${flags["--project"]}" was not found.`;
+        return emitAlertsScopeError(
+          client,
+          jsonOutput,
+          "PROJECT_NOT_FOUND",
+          msg,
+          {
+            reason: AGENT_REASON.NOT_FOUND,
+            next: [
+              {
+                command: buildCommandWithGlobalFlags(
+                  client.argv,
+                  "alerts inspect <groupId> --project <name_or_id>"
+                ),
+                when: "Retry with a valid project (replace placeholders)"
+              }
+            ]
+          }
+        );
+      }
+      return { teamId: team.id, projectId: p.id };
+    } catch (err) {
+      if (isAPIError(err)) {
+        const msg = err.serverMessage || (err.status === 403 ? `You do not have permission to access project "${flags["--project"]}" in team "${team.slug}".` : `API error (${err.status}).`);
+        const reason = err.status === 401 ? "not_authorized" : err.status === 403 ? "forbidden" : AGENT_REASON.API_ERROR;
+        return emitAlertsScopeError(
+          client,
+          jsonOutput,
+          err.code || "API_ERROR",
+          msg,
+          {
+            reason,
+            next: [
+              {
+                command: buildCommandWithGlobalFlags(
+                  client.argv,
+                  "alerts inspect <groupId> --project <name_or_id>"
+                ),
+                when: "Retry with a project you can access"
+              }
+            ]
+          }
+        );
+      }
+      throw err;
+    }
+  }
+  const linked = await getLinkedProject(client);
+  if (linked.status === "error") {
+    return linked.exitCode;
+  }
+  if (linked.status === "not_linked") {
+    const msg = "No linked project. Run `vercel link` or pass --project <name> or --all.";
+    return emitAlertsScopeError(client, jsonOutput, "NOT_LINKED", msg, {
+      reason: AGENT_REASON.NOT_LINKED,
+      next: [
+        {
+          command: buildCommandWithGlobalFlags(client.argv, "link"),
+          when: "Link this directory to a Vercel project"
+        },
+        {
+          command: buildCommandWithGlobalFlags(
+            client.argv,
+            "alerts inspect <groupId> --project <name_or_id>"
+          ),
+          when: "Inspect using an explicit project"
+        },
+        {
+          command: buildCommandWithGlobalFlags(
+            client.argv,
+            "alerts inspect <groupId> --all"
+          ),
+          when: "Inspect using team-wide scope"
+        }
+      ]
+    });
+  }
+  return {
+    teamId: linked.org.id,
+    projectId: linked.project.id
+  };
+}
+async function inspect(client, argv) {
+  let parsedArgs;
+  const spec = getFlagsSpecification(inspectSubcommand.options);
+  try {
+    parsedArgs = parseArguments(argv, spec);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    const projectFlagMissingArg = msg.includes("--project") && msg.includes("requires argument");
+    outputAgentError(
+      client,
+      {
+        status: "error",
+        reason: AGENT_REASON.INVALID_ARGUMENTS,
+        message: projectFlagMissingArg ? "`--project` requires a project name or id (for example `--project my-app`)." : msg,
+        next: projectFlagMissingArg ? [
+          {
+            command: buildCommandWithGlobalFlags(
+              client.argv,
+              "alerts inspect <groupId> --project <name-or-id>"
+            ),
+            when: "Re-run with placeholders replaced"
+          }
+        ] : [
+          {
+            command: buildCommandWithGlobalFlags(
+              client.argv,
+              "alerts inspect --help"
+            ),
+            when: "See valid `alerts inspect` usage"
+          }
+        ]
+      },
+      1
+    );
+    printError(e);
+    return 1;
+  }
+  const groupId = 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 (!groupId) {
+    outputAgentError(
+      client,
+      {
+        status: "error",
+        reason: AGENT_REASON.MISSING_ARGUMENTS,
+        message: `Missing group id. Example: ${packageName} alerts inspect <groupId>`,
+        next: [
+          {
+            command: buildCommandWithGlobalFlags(
+              client.argv,
+              "alerts inspect <groupId>"
+            ),
+            when: "Replace <groupId> with a group id from `vercel alerts`"
+          }
+        ]
+      },
+      1
+    );
+    return outputError(
+      client,
+      fr.jsonOutput,
+      "MISSING_ARGUMENTS",
+      "Usage: `vercel alerts inspect <groupId>`"
+    );
+  }
+  const scope = await resolveInspectScope(
+    client,
+    {
+      "--project": parsedArgs.flags["--project"],
+      "--all": parsedArgs.flags["--all"]
+    },
+    fr.jsonOutput
+  );
+  if (typeof scope === "number") {
+    return scope;
+  }
+  const query = new URLSearchParams({ teamId: scope.teamId });
+  if (scope.projectId) {
+    query.set("projectId", scope.projectId);
+  }
+  const path = `/alerts/v3/groups/${encodeURIComponent(groupId)}?${query.toString()}`;
+  output_manager_default.spinner("Fetching alert group...");
+  try {
+    const group = await client.fetch(path);
+    if (fr.jsonOutput) {
+      client.stdout.write(`${JSON.stringify({ group }, null, 2)}
+`);
+    } else {
+      output_manager_default.log(`${import_chalk.default.bold("Alert group")} ${import_chalk.default.cyan(groupId)}`);
+      client.stdout.write(`${JSON.stringify(group, null, 2)}
+`);
+    }
+    return 0;
+  } catch (err) {
+    if (isAPIError(err)) {
+      const msg = err.serverMessage || `API error (${err.status}).`;
+      const reason = err.status === 401 ? "not_authorized" : err.status === 403 ? "forbidden" : err.status === 404 ? AGENT_REASON.NOT_FOUND : err.status === 429 ? "rate_limited" : AGENT_REASON.API_ERROR;
+      outputAgentError(
+        client,
+        {
+          status: "error",
+          reason,
+          message: msg,
+          ...err.status === 401 || err.status === 403 ? {
+            hint: "Confirm team scope; use --scope <team-slug> if the group belongs to another team.",
+            next: [
+              {
+                command: buildCommandWithGlobalFlags(client.argv, "whoami"),
+                when: "See current user and team"
+              },
+              {
+                command: buildCommandWithGlobalFlags(
+                  client.argv,
+                  `alerts inspect ${groupId}`
+                ),
+                when: "Retry after fixing scope or permissions"
+              }
+            ]
+          } : {}
+        },
+        1
+      );
+      return outputError(client, fr.jsonOutput, err.code || "API_ERROR", msg);
+    }
+    throw err;
+  } finally {
+    output_manager_default.stopSpinner();
+  }
+}
+export {
+  inspect as default
+};

package/dist/chunks/{list-SSIMVNNN.js → list-EPU4SB3E.js}

@@ -18,27 +18,30 @@ import {
 } from "./chunk-EOZFDJSY.js";
 import {
   getScope
-} from "./chunk-3FMFPD7F.js";
+} from "./chunk-L2JUC7NX.js";
 import {
   validateJsonOutput
 } from "./chunk-XPKWKPWA.js";
 import {
   activityCommand
-} from "./chunk-2IAZZEVQ.js";
+} from "./chunk-UWKTUK3W.js";
 import {
   getLinkedProject,
   getProjectByNameOrId
-} from "./chunk-7S7GE4BN.js";
+} from "./chunk-537JTK2U.js";
 import "./chunk-U3WLEFHU.js";
+import "./chunk-CGTXAXZ4.js";
 import "./chunk-CO5D46AG.js";
 import {
-  ProjectNotFound,
-  getCommandName,
   getFlagsSpecification,
-  isAPIError,
   parseArguments,
   printError
-} from "./chunk-A4NVECX5.js";
+} from "./chunk-RFMC2QXQ.js";
+import {
+  ProjectNotFound,
+  getCommandName,
+  isAPIError
+} from "./chunk-ECRBC4HL.js";
 import {
   output_manager_default
 } from "./chunk-ZQKJVHXY.js";

package/dist/chunks/{list-VFPV4TUW.js → list-RMA56KYZ.js}

@@ -4,6 +4,9 @@ import { dirname as __dirname_ } from 'node:path';
 const require = __createRequire(import.meta.url);
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __dirname_(__filename);
+import {
+  resolveAlertsScope
+} from "./chunk-7ZDERWUW.js";
 import {
   handleValidationError,
   normalizeRepeatableStringFilters,
@@ -13,33 +16,38 @@ import {
   validateTimeBound,
   validateTimeOrder
 } from "./chunk-HTOH3MSD.js";
-import {
-  getScope
-} from "./chunk-3FMFPD7F.js";
+import "./chunk-L2JUC7NX.js";
 import {
   validateJsonOutput
 } from "./chunk-XPKWKPWA.js";
 import {
   alertsCommand
-} from "./chunk-WXNT7WJO.js";
+} from "./chunk-TAOVG4PS.js";
+import "./chunk-DVQ4SIWF.js";
 import {
-  table
-} from "./chunk-4YZKA4FN.js";
+  AGENT_REASON
+} from "./chunk-E3NE4SKN.js";
 import {
-  getLinkedProject,
-  getProjectByNameOrId
-} from "./chunk-7S7GE4BN.js";
+  table
+} from "./chunk-GE6G37P4.js";
+import "./chunk-537JTK2U.js";
 import "./chunk-U3WLEFHU.js";
+import {
+  buildCommandWithGlobalFlags,
+  outputAgentError,
+  shouldEmitNonInteractiveCommandError
+} from "./chunk-CGTXAXZ4.js";
 import {
   require_ms
 } from "./chunk-CO5D46AG.js";
 import {
-  ProjectNotFound,
   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";
@@ -55,6 +63,29 @@ var import_ms = __toESM(require_ms(), 1);
 var import_chalk = __toESM(require_source(), 1);
 function handleApiError(err, jsonOutput, client) {
   const message = err.status === 401 || err.status === 403 ? "You do not have access to alerts in this scope. Pass --token <TOKEN> and --scope <team-slug> with Alerts read access." : err.status >= 500 ? `The alerts endpoint failed on the server (${err.status}). Re-run with --debug and share the x-vercel-id from the failed request.` : err.serverMessage || `API error (${err.status}).`;
+  const reason = err.status === 401 ? "not_authorized" : err.status === 403 ? "forbidden" : err.status === 404 ? AGENT_REASON.NOT_FOUND : err.status === 429 ? "rate_limited" : AGENT_REASON.API_ERROR;
+  outputAgentError(
+    client,
+    {
+      status: "error",
+      reason,
+      message,
+      ...err.status === 401 || err.status === 403 ? {
+        hint: "Confirm team scope; use --scope <team-slug> if alerts belong to another team.",
+        next: [
+          {
+            command: buildCommandWithGlobalFlags(client.argv, "whoami"),
+            when: "See current user and team"
+          },
+          {
+            command: buildCommandWithGlobalFlags(client.argv, "alerts"),
+            when: "Retry listing alerts after fixing scope or permissions"
+          }
+        ]
+      } : {}
+    },
+    1
+  );
   return outputError(client, jsonOutput, err.code || "API_ERROR", message);
 }
 function getDefaultRange() {
@@ -62,70 +93,6 @@ function getDefaultRange() {
   const from = new Date(to.getTime() - 24 * 60 * 60 * 1e3);
   return { from: from.toISOString(), to: to.toISOString() };
 }
-async function resolveScope(client, opts) {
-  if (opts.all || opts.project) {
-    const { team } = await getScope(client);
-    if (!team) {
-      return outputError(
-        client,
-        opts.jsonOutput,
-        "NO_TEAM",
-        "No team context found. Run `vercel switch` to select a team, or use `vercel link` in a project directory."
-      );
-    }
-    if (opts.all) {
-      return {
-        teamId: team.id
-      };
-    }
-    let projectResult;
-    try {
-      projectResult = await getProjectByNameOrId(
-        client,
-        opts.project,
-        team.id
-      );
-    } catch (err) {
-      if (isAPIError(err)) {
-        return outputError(
-          client,
-          opts.jsonOutput,
-          err.code || "API_ERROR",
-          err.serverMessage || (err.status === 403 ? `You do not have permission to access project "${opts.project}" in team "${team.slug}".` : `API error (${err.status}).`)
-        );
-      }
-      throw err;
-    }
-    if (projectResult instanceof ProjectNotFound) {
-      return outputError(
-        client,
-        opts.jsonOutput,
-        "PROJECT_NOT_FOUND",
-        `Project "${opts.project}" was not found in team "${team.slug}".`
-      );
-    }
-    return {
-      teamId: team.id,
-      projectId: projectResult.id
-    };
-  }
-  const linkedProject = await getLinkedProject(client);
-  if (linkedProject.status === "error") {
-    return linkedProject.exitCode;
-  }
-  if (linkedProject.status === "not_linked") {
-    return outputError(
-      client,
-      opts.jsonOutput,
-      "NOT_LINKED",
-      "No linked project found. Run `vercel link` to link a project, or use --project <name> or --all."
-    );
-  }
-  return {
-    teamId: linkedProject.org.id,
-    projectId: linkedProject.project.id
-  };
-}
 function getGroupTitle(group) {
   return group.ai?.title || "Alert group";
 }
@@ -191,18 +158,44 @@ function getResolvedAt(group) {
 function getAlertsCount(group) {
   return String(group.alerts?.length ?? 0);
 }
+function validationFailureForAgents(client, result, jsonOutput) {
+  if (shouldEmitNonInteractiveCommandError(client)) {
+    outputAgentError(
+      client,
+      {
+        status: "error",
+        reason: AGENT_REASON.INVALID_ARGUMENTS,
+        message: result.message,
+        next: [
+          {
+            command: buildCommandWithGlobalFlags(client.argv, "alerts --help"),
+            when: "See valid `alerts` list flags and examples"
+          }
+        ]
+      },
+      1
+    );
+  }
+  return handleValidationError(result, jsonOutput, client);
+}
 function printGroups(groups) {
   if (groups.length === 0) {
     output_manager_default.log("No alerts found.");
     return;
   }
-  const headers = ["Title", "Started At", "Type", "Status", "Alerts"].map(
-    (h) => import_chalk.default.cyan(h)
-  );
+  const headers = [
+    "Title",
+    "Group id",
+    "Started At",
+    "Type",
+    "Status",
+    "Alerts"
+  ].map((h) => import_chalk.default.cyan(h));
   const rows = [
     headers,
     ...groups.map((group) => [
       import_chalk.default.bold(getGroupTitle(group)),
+      import_chalk.default.dim(group.id || "-"),
       getStartedAt(group),
       group.type || "-",
       getStatus(group),
@@ -252,6 +245,43 @@ function parseFlags(client) {
     const parsedArgs = parseArguments(client.argv.slice(2), flagsSpecification);
     return parsedArgs.flags;
   } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const projectFlagMissingArg = msg.includes("--project") && msg.includes("requires argument");
+    if (shouldEmitNonInteractiveCommandError(client)) {
+      outputAgentError(
+        client,
+        {
+          status: "error",
+          reason: AGENT_REASON.INVALID_ARGUMENTS,
+          message: projectFlagMissingArg ? "`--project` requires a project name or id (for example `--project my-app`)." : msg,
+          next: projectFlagMissingArg ? [
+            {
+              command: buildCommandWithGlobalFlags(
+                client.argv,
+                "alerts --project <name-or-id>"
+              ),
+              when: "Re-run with a project name or id (replace placeholder)"
+            },
+            {
+              command: buildCommandWithGlobalFlags(
+                client.argv,
+                "alerts --help"
+              ),
+              when: "See all `alerts` flags and examples"
+            }
+          ] : [
+            {
+              command: buildCommandWithGlobalFlags(
+                client.argv,
+                "alerts --help"
+              ),
+              when: "See valid flags and examples"
+            }
+          ]
+        },
+        1
+      );
+    }
     printError(err);
     return 1;
   }
@@ -264,29 +294,29 @@ function resolveValidatedInputs(flags, client, jsonOutput) {
     max: 100
   });
   if (!limitResult.valid) {
-    return handleValidationError(limitResult, jsonOutput, client);
+    return validationFailureForAgents(client, limitResult, jsonOutput);
   }
   const mutualResult = validateAllProjectMutualExclusivity(
     flags["--all"],
     flags["--project"]
   );
   if (!mutualResult.valid) {
-    return handleValidationError(mutualResult, jsonOutput, client);
+    return validationFailureForAgents(client, mutualResult, jsonOutput);
   }
   const sinceResult = validateTimeBound(flags["--since"]);
   if (!sinceResult.valid) {
-    return handleValidationError(sinceResult, jsonOutput, client);
+    return validationFailureForAgents(client, sinceResult, jsonOutput);
   }
   const untilResult = validateTimeBound(flags["--until"]);
   if (!untilResult.valid) {
-    return handleValidationError(untilResult, jsonOutput, client);
+    return validationFailureForAgents(client, untilResult, jsonOutput);
   }
   const timeOrderResult = validateTimeOrder(
     sinceResult.value,
     untilResult.value
   );
   if (!timeOrderResult.valid) {
-    return handleValidationError(timeOrderResult, jsonOutput, client);
+    return validationFailureForAgents(client, timeOrderResult, jsonOutput);
   }
   return {
     limit: limitResult.value,
@@ -338,7 +368,7 @@ async function list(client, telemetry) {
   if (typeof validatedInputs === "number") {
     return validatedInputs;
   }
-  const scope = await resolveScope(client, {
+  const scope = await resolveAlertsScope(client, {
     project: flags["--project"],
     all: flags["--all"],
     jsonOutput