vercel 54.18.7 → 54.19.0

package/dist/chunks/chunk-VGIMO3ZK.js

@@ -0,0 +1,17 @@
+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);
+
+// src/util/get-invalid-subcommand.ts
+function getInvalidSubcommand(config) {
+  return `Please specify a valid subcommand: ${Object.keys(config).join(
+    " | "
+  )}`;
+}
+
+export {
+  getInvalidSubcommand
+};

package/dist/chunks/{chunk-AXFSALI3.js → chunk-WFXGLPSI.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 {
+  vcrCommand
+} from "./chunk-KXGWAWRV.js";
 import {
   metricsCommand
 } from "./chunk-MAJWH2PD.js";
@@ -5512,7 +5515,7 @@ var integrationResourceCommand = {
 // src/commands/integration/command.ts
 var addSubcommand7 = {
   name: "add",
-  aliases: [],
+  aliases: ["install"],
   description: "Installs a marketplace integration",
   arguments: [
     {
@@ -9478,6 +9481,7 @@ var commandsStructs = [
   upgradeCommand,
   webhooksCommand,
   usageCommand,
+  vcrCommand,
   whoamiCommand,
   // added because we don't have a full help command
   { name: "help", aliases: [] }

package/dist/chunks/chunk-ZVDYGXRA.js

@@ -0,0 +1,363 @@
+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 {
+  outputError
+} from "./chunk-E2ENQE2W.js";
+import {
+  validateJsonOutput
+} from "./chunk-XPKWKPWA.js";
+import {
+  AGENT_REASON
+} from "./chunk-QH7WYDEP.js";
+import {
+  getScope
+} from "./chunk-P726GMBL.js";
+import {
+  getLinkedProject,
+  getProjectByNameOrId
+} from "./chunk-RB7WQKNC.js";
+import {
+  buildCommandWithGlobalFlags,
+  outputAgentError
+} from "./chunk-IZOHLD5D.js";
+import {
+  ProjectNotFound,
+  isAPIError,
+  packageName
+} from "./chunk-P6AK7SVK.js";
+import {
+  output_manager_default
+} from "./chunk-OX7KI3LF.js";
+
+// src/commands/vcr/utils/resolve-vcr-scope.ts
+function emitVcrScopeError(client, jsonOutput, code, message, agent) {
+  outputAgentError(
+    client,
+    {
+      status: "error",
+      reason: agent.reason,
+      message,
+      hint: agent.hint,
+      next: agent.next
+    },
+    1
+  );
+  return outputError(client, jsonOutput, code, message);
+}
+async function resolveVcrScope(client, opts) {
+  if (opts.project) {
+    const { team } = await getScope(client);
+    if (!team) {
+      const msg = "No team context found. Run `vercel switch` to select a team, or use `vercel link` in a project directory.";
+      return emitVcrScopeError(client, opts.jsonOutput, "NO_TEAM", msg, {
+        reason: AGENT_REASON.MISSING_SCOPE,
+        hint: "Select a team scope before using --project with vcr.",
+        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"
+          }
+        ]
+      });
+    }
+    let projectResult;
+    try {
+      projectResult = await getProjectByNameOrId(client, opts.project, team.id);
+    } catch (err) {
+      if (isAPIError(err)) {
+        const msg = err.serverMessage || (err.status === 403 ? `You do not have permission to access project "${opts.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 emitVcrScopeError(
+          client,
+          opts.jsonOutput,
+          err.code || "API_ERROR",
+          msg,
+          {
+            reason,
+            next: [
+              {
+                command: buildCommandWithGlobalFlags(
+                  client.argv,
+                  "vcr ls --project <name_or_id>"
+                ),
+                when: "Retry with a project you can access (replace <name_or_id>)"
+              }
+            ]
+          }
+        );
+      }
+      throw err;
+    }
+    if (projectResult instanceof ProjectNotFound) {
+      const msg = `Project "${opts.project}" was not found in team "${team.slug}".`;
+      return emitVcrScopeError(
+        client,
+        opts.jsonOutput,
+        "PROJECT_NOT_FOUND",
+        msg,
+        {
+          reason: AGENT_REASON.NOT_FOUND,
+          next: [
+            {
+              command: buildCommandWithGlobalFlags(client.argv, "project ls"),
+              when: "List projects in the current team to pick a name"
+            }
+          ]
+        }
+      );
+    }
+    return {
+      teamId: team.id,
+      teamSlug: team.slug,
+      projectId: projectResult.id,
+      projectName: projectResult.name
+    };
+  }
+  const linkedProject = await getLinkedProject(client);
+  if (linkedProject.status === "error") {
+    return linkedProject.exitCode;
+  }
+  if (linkedProject.status === "not_linked") {
+    const msg = "No linked project found. Run `vercel link` to link a project, or pass --project <name>.";
+    return emitVcrScopeError(client, opts.jsonOutput, "NOT_LINKED", msg, {
+      reason: AGENT_REASON.NOT_LINKED,
+      hint: "Agents should pass --project when no .vercel link exists in --cwd.",
+      next: [
+        {
+          command: buildCommandWithGlobalFlags(client.argv, "link"),
+          when: "Link this directory to a Vercel project"
+        },
+        {
+          command: buildCommandWithGlobalFlags(
+            client.argv,
+            "vcr ls --project <name_or_id>"
+          ),
+          when: "List repositories for a project without linking (replace <name_or_id>)"
+        }
+      ]
+    });
+  }
+  return {
+    teamId: linkedProject.org.id,
+    teamSlug: linkedProject.org.slug,
+    projectId: linkedProject.project.id,
+    projectName: linkedProject.project.name
+  };
+}
+
+// src/commands/vcr/utils/validators.ts
+function validateVcrJsonOutput(client, 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;
+  }
+  return { jsonOutput: fr.jsonOutput };
+}
+function validateVcrChoice(client, flag, value, choices, jsonOutput) {
+  if (value === void 0 || choices.includes(value)) {
+    return void 0;
+  }
+  const message = `Invalid value for ${flag}: "${value}". Must be one of: ${choices.join(", ")}.`;
+  outputAgentError(
+    client,
+    {
+      status: "error",
+      reason: AGENT_REASON.INVALID_ARGUMENTS,
+      message
+    },
+    1
+  );
+  return outputError(client, jsonOutput, "INVALID_ARGUMENTS", message);
+}
+function requireVcrRepository(client, repository, jsonOutput, usage) {
+  if (repository) {
+    return void 0;
+  }
+  outputAgentError(
+    client,
+    {
+      status: "error",
+      reason: AGENT_REASON.MISSING_ARGUMENTS,
+      message: `Missing repository. Example: ${packageName} ${usage}`,
+      next: [
+        {
+          command: buildCommandWithGlobalFlags(client.argv, "vcr ls"),
+          when: "List repositories to pick a name or id"
+        }
+      ]
+    },
+    1
+  );
+  return outputError(
+    client,
+    jsonOutput,
+    "MISSING_ARGUMENTS",
+    `Usage: \`vercel ${usage}\``
+  );
+}
+function requireVcrRepositoryAndTag(client, repository, tag, jsonOutput, usage) {
+  if (repository && tag) {
+    return void 0;
+  }
+  outputAgentError(
+    client,
+    {
+      status: "error",
+      reason: AGENT_REASON.MISSING_ARGUMENTS,
+      message: `Missing arguments. Example: ${packageName} ${usage}`,
+      next: [
+        {
+          command: buildCommandWithGlobalFlags(
+            client.argv,
+            "vcr tag ls <repository>"
+          ),
+          when: "List tags to pick a tag (replace <repository>)"
+        }
+      ]
+    },
+    1
+  );
+  return outputError(
+    client,
+    jsonOutput,
+    "MISSING_ARGUMENTS",
+    `Usage: \`vercel ${usage}\``
+  );
+}
+function requireVcrRepositoryAndImageId(client, repository, imageId, jsonOutput, usage) {
+  if (repository && imageId) {
+    return void 0;
+  }
+  outputAgentError(
+    client,
+    {
+      status: "error",
+      reason: AGENT_REASON.MISSING_ARGUMENTS,
+      message: `Missing arguments. Example: ${packageName} ${usage}`,
+      next: [
+        {
+          command: buildCommandWithGlobalFlags(
+            client.argv,
+            "vcr image ls <repository>"
+          ),
+          when: "List images to pick an image id (replace <repository>)"
+        }
+      ]
+    },
+    1
+  );
+  return outputError(
+    client,
+    jsonOutput,
+    "MISSING_ARGUMENTS",
+    `Usage: \`vercel ${usage}\``
+  );
+}
+
+// src/commands/vcr/utils/errors.ts
+var NOT_AUTHORIZED_MESSAGE = "You do not have access to the container registry in this scope. Ensure your role can manage the project, or pass --token and --scope.";
+var NOT_AUTHORIZED_HINT = "Confirm team scope with whoami; use --scope <team-slug> if the repository lives under another team.";
+var genericMessage = (err) => err.serverMessage || `API error (${err.status}).`;
+var STATUS_INFO = {
+  401: {
+    reason: "not_authorized",
+    message: () => NOT_AUTHORIZED_MESSAGE,
+    hint: NOT_AUTHORIZED_HINT,
+    suggestWhoami: true
+  },
+  403: {
+    reason: "forbidden",
+    message: () => NOT_AUTHORIZED_MESSAGE,
+    hint: NOT_AUTHORIZED_HINT,
+    suggestWhoami: true
+  },
+  404: { reason: AGENT_REASON.NOT_FOUND, message: genericMessage },
+  409: { reason: "conflict", message: genericMessage },
+  429: { reason: "rate_limited", message: genericMessage }
+};
+function resolveStatusInfo(err) {
+  if (STATUS_INFO[err.status]) {
+    return STATUS_INFO[err.status];
+  }
+  if (err.status >= 500) {
+    return {
+      reason: AGENT_REASON.API_ERROR,
+      message: () => `The container registry endpoint failed (${err.status}). Re-run with --debug and share the x-vercel-id from the failed request.`
+    };
+  }
+  return { reason: AGENT_REASON.API_ERROR, message: genericMessage };
+}
+function handleVcrApiError(client, err, jsonOutput, opts = {}) {
+  const info = resolveStatusInfo(err);
+  const message = info.message(err);
+  const next = [];
+  if (info.suggestWhoami) {
+    next.push({
+      command: buildCommandWithGlobalFlags(client.argv, "whoami"),
+      when: "See current user and team"
+    });
+  }
+  if (opts.retry) {
+    next.push(opts.retry);
+  }
+  outputAgentError(
+    client,
+    {
+      status: "error",
+      reason: info.reason,
+      message,
+      ...info.hint ? { hint: info.hint } : {},
+      ...next.length > 0 ? { next } : {}
+    },
+    1
+  );
+  return outputError(client, jsonOutput, err.code || "API_ERROR", message);
+}
+function emitVcrArgParseError(client, err, recoverTemplate) {
+  const msg = err instanceof Error ? err.message : String(err);
+  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: [
+        {
+          command: buildCommandWithGlobalFlags(client.argv, recoverTemplate),
+          when: projectFlagMissingArg ? "Re-run with a project name or id (replace placeholder)" : "See valid usage"
+        }
+      ]
+    },
+    1
+  );
+}
+
+export {
+  resolveVcrScope,
+  validateVcrJsonOutput,
+  validateVcrChoice,
+  requireVcrRepository,
+  requireVcrRepositoryAndTag,
+  requireVcrRepositoryAndImageId,
+  handleVcrApiError,
+  emitVcrArgParseError
+};

package/dist/chunks/{chunk-VTE7W5ZP.js → chunk-ZZIAWRCX.js}

@@ -240,13 +240,6 @@ var require_dist2 = __commonJS({
   }
 });
 
-// src/util/get-invalid-subcommand.ts
-function getInvalidSubcommand(config) {
-  return `Please specify a valid subcommand: ${Object.keys(config).join(
-    " | "
-  )}`;
-}
-
 // src/util/input/read-standard-input.ts
 async function readStandardInput(stdin) {
   return new Promise((resolve) => {
@@ -290,7 +283,6 @@ function ellipsis(str, length) {
 }
 
 export {
-  getInvalidSubcommand,
   readStandardInput,
   getCustomEnvironments,
   pickCustomEnvironment,

package/dist/chunks/image-R4JG4NX4.js

@@ -0,0 +1,73 @@
+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 {
+  getInvalidSubcommand
+} from "./chunk-VGIMO3ZK.js";
+import {
+  getSubcommand
+} from "./chunk-YPQSDAEW.js";
+import {
+  AGENT_REASON
+} from "./chunk-QH7WYDEP.js";
+import {
+  buildCommandWithGlobalFlags,
+  outputAgentError
+} from "./chunk-IZOHLD5D.js";
+import "./chunk-P6AK7SVK.js";
+import "./chunk-P4QNYOFB.js";
+import {
+  output_manager_default
+} from "./chunk-OX7KI3LF.js";
+import "./chunk-S7KYDPEM.js";
+import "./chunk-TZ2YI2VH.js";
+
+// src/commands/vcr/image/index.ts
+var IMAGE_CONFIG = {
+  ls: ["ls", "list"],
+  inspect: ["inspect", "get"],
+  rm: ["rm", "remove", "delete"]
+};
+async function image(client, argv, telemetry) {
+  const { subcommand, args } = getSubcommand(argv, IMAGE_CONFIG);
+  if (subcommand == null) {
+    const message = argv.length === 0 ? getInvalidSubcommand(IMAGE_CONFIG) : `Unknown "vcr image" subcommand "${argv[0]}".`;
+    outputAgentError(
+      client,
+      {
+        status: "error",
+        reason: AGENT_REASON.INVALID_ARGUMENTS,
+        message,
+        next: [
+          {
+            command: buildCommandWithGlobalFlags(
+              client.argv,
+              "vcr image --help"
+            ),
+            when: "Show valid image subcommands"
+          }
+        ]
+      },
+      1
+    );
+    output_manager_default.error(`${message} Run \`vercel vcr image --help\`.`);
+    return 1;
+  }
+  switch (subcommand) {
+    case "ls":
+      return (await import("./ls-ZDMXBOJF.js")).default(client, args, telemetry);
+    case "inspect":
+      return (await import("./inspect-RTJALSXC.js")).default(client, args, telemetry);
+    case "rm":
+      return (await import("./rm-ZJQ5DOAW.js")).default(client, args, telemetry);
+    default:
+      output_manager_default.error(`Unhandled image subcommand: ${subcommand}`);
+      return 1;
+  }
+}
+export {
+  image as default
+};

package/dist/chunks/inspect-57BITHYZ.js

@@ -0,0 +1,136 @@
+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 {
+  formatRelativeTime
+} from "./chunk-I3HGCZ4E.js";
+import {
+  repositoryPath
+} from "./chunk-4QVAYRYH.js";
+import {
+  emitVcrArgParseError,
+  handleVcrApiError,
+  requireVcrRepository,
+  resolveVcrScope,
+  validateVcrJsonOutput
+} from "./chunk-ZVDYGXRA.js";
+import "./chunk-E2ENQE2W.js";
+import "./chunk-XPKWKPWA.js";
+import {
+  inspectSubcommand
+} from "./chunk-KXGWAWRV.js";
+import "./chunk-RY3AVR6E.js";
+import "./chunk-AUECDTMX.js";
+import "./chunk-QH7WYDEP.js";
+import "./chunk-P726GMBL.js";
+import "./chunk-RB7WQKNC.js";
+import "./chunk-IZOHLD5D.js";
+import "./chunk-ECCWJHC6.js";
+import {
+  getFlagsSpecification,
+  parseArguments,
+  printError
+} from "./chunk-EJ6GQI6F.js";
+import {
+  isAPIError
+} from "./chunk-P6AK7SVK.js";
+import "./chunk-P4QNYOFB.js";
+import "./chunk-2RVK3DDN.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/vcr/inspect.ts
+var import_chalk = __toESM(require_source(), 1);
+function printRepository(repository) {
+  output_manager_default.print("\n");
+  output_manager_default.print(`  ${import_chalk.default.cyan("Name")}			${repository.name}
+`);
+  output_manager_default.print(`  ${import_chalk.default.cyan("ID")}			${repository.id}
+`);
+  output_manager_default.print(`  ${import_chalk.default.cyan("Project ID")}		${repository.projectId}
+`);
+  output_manager_default.print(
+    `  ${import_chalk.default.cyan("Created")}		${formatRelativeTime(repository.createdAt)}
+`
+  );
+  output_manager_default.print(
+    `  ${import_chalk.default.cyan("Updated")}		${formatRelativeTime(repository.updatedAt)}
+`
+  );
+  output_manager_default.print("\n");
+}
+async function inspect(client, argv, telemetry) {
+  let parsedArgs;
+  try {
+    parsedArgs = parseArguments(
+      argv,
+      getFlagsSpecification(inspectSubcommand.options)
+    );
+  } catch (err) {
+    emitVcrArgParseError(
+      client,
+      err,
+      "vcr inspect <repository> --project <name-or-id>"
+    );
+    printError(err);
+    return 1;
+  }
+  const fr = validateVcrJsonOutput(client, parsedArgs.flags);
+  if (typeof fr === "number") {
+    return fr;
+  }
+  const repository = parsedArgs.args[0];
+  const project = parsedArgs.flags["--project"];
+  telemetry.trackCliOptionProject(project);
+  telemetry.trackCliOptionFormat(parsedArgs.flags["--format"]);
+  const missingRepository = requireVcrRepository(
+    client,
+    repository,
+    fr.jsonOutput,
+    "vcr inspect <repository>"
+  );
+  if (typeof missingRepository === "number") {
+    return missingRepository;
+  }
+  const scope = await resolveVcrScope(client, {
+    project,
+    jsonOutput: fr.jsonOutput
+  });
+  if (typeof scope === "number") {
+    return scope;
+  }
+  const path = repositoryPath(scope, repository);
+  output_manager_default.spinner("Fetching repository...");
+  try {
+    const result = await client.fetch(path);
+    if (fr.jsonOutput) {
+      client.stdout.write(`${JSON.stringify(result.repository, null, 2)}
+`);
+    } else {
+      output_manager_default.log(`${import_chalk.default.bold("Repository")} ${import_chalk.default.cyan(repository)}`);
+      printRepository(result.repository);
+    }
+    return 0;
+  } catch (err) {
+    if (isAPIError(err)) {
+      return handleVcrApiError(client, err, fr.jsonOutput);
+    }
+    throw err;
+  } finally {
+    output_manager_default.stopSpinner();
+  }
+}
+export {
+  inspect as default
+};