shop-cli 0.1.0

package/dist/cli/verbs/products.js

@@ -0,0 +1,1257 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var products_exports = {};
+__export(products_exports, {
+  runProducts: () => runProducts
+});
+module.exports = __toCommonJS(products_exports);
+var import_errors = require("../errors");
+var import_gid = require("../gid");
+var import_input = require("../input");
+var import_output = require("../output");
+var import_computedFields = require("../output/computedFields");
+var import_router = require("../router");
+var import_select = require("../selection/select");
+var import_userErrors = require("../userErrors");
+var import_stagedUploads = require("../workflows/files/stagedUploads");
+var import_metafieldsUpsert = require("../workflows/products/metafieldsUpsert");
+var import_publishablePublish = require("../workflows/products/publishablePublish");
+var import_resolvePublicationId = require("../workflows/publications/resolvePublicationId");
+var import_shared = require("./_shared");
+const productMediaSelection = {
+  id: true,
+  mediaContentType: true,
+  status: true,
+  alt: true,
+  preview: { status: true, image: { url: true } },
+  mediaErrors: { code: true, message: true },
+  mediaWarnings: { code: true, message: true }
+};
+const productSummarySelection = {
+  id: true,
+  title: true,
+  handle: true,
+  status: true,
+  updatedAt: true
+};
+const productSummarySelectionForGet = {
+  ...productSummarySelection,
+  ...import_computedFields.computedPublicationsSelection
+};
+const productFullSelection = {
+  ...productSummarySelection,
+  createdAt: true,
+  tags: true
+};
+const productFullSelectionForGet = {
+  ...productFullSelection,
+  ...import_computedFields.computedPublicationsSelection
+};
+const getProductSelection = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "full") return productFullSelection;
+  if (view === "raw") return {};
+  return productSummarySelection;
+};
+const getProductSelectionForGet = (view) => {
+  if (view === "ids") return { id: true };
+  if (view === "full") return productFullSelectionForGet;
+  if (view === "raw") return {};
+  return productSummarySelectionForGet;
+};
+const parseTags = (tags) => {
+  if (!tags) throw new import_errors.CliError("Missing --tags", 2);
+  const parts = tags.split(",").map((t) => t.trim()).filter(Boolean);
+  if (parts.length === 0) throw new import_errors.CliError("--tags must include at least one tag", 2);
+  return parts;
+};
+const normalizeMediaContentType = (value) => {
+  if (!value) return "IMAGE";
+  const v = value.toUpperCase();
+  if (v === "IMAGE" || v === "VIDEO" || v === "MODEL_3D" || v === "EXTERNAL_VIDEO") return v;
+  throw new import_errors.CliError("--media-type must be IMAGE|VIDEO|MODEL_3D|EXTERNAL_VIDEO", 2);
+};
+const normalizeMediaId = (value) => {
+  const raw = value.trim();
+  if (!raw) throw new import_errors.CliError("Media ID cannot be empty", 2);
+  if (raw.startsWith("gid://")) return raw;
+  throw new import_errors.CliError(
+    `Numeric media ID "${raw}" is ambiguous. Use the full GID from "shop products media list" (e.g. gid://shopify/MediaImage/${raw})`,
+    2
+  );
+};
+const mediaTypeToStagedResource = (mediaType) => {
+  if (mediaType === "IMAGE") return "IMAGE";
+  if (mediaType === "VIDEO") return "VIDEO";
+  if (mediaType === "MODEL_3D") return "MODEL_3D";
+  throw new import_errors.CliError("--media-type EXTERNAL_VIDEO cannot be used with --file uploads", 2);
+};
+const stagedResourceToMediaType = (resource) => {
+  if (resource === "IMAGE") return "IMAGE";
+  if (resource === "VIDEO") return "VIDEO";
+  if (resource === "MODEL_3D") return "MODEL_3D";
+  throw new import_errors.CliError("Only IMAGE|VIDEO|MODEL_3D can be uploaded as product media", 2);
+};
+const runProducts = async ({
+  ctx,
+  verb,
+  argv
+}) => {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(
+      [
+        "Usage:",
+        "  shop products <verb> [flags]",
+        "",
+        "Verbs:",
+        "  create|get|list|count|update|delete|duplicate|set-status|archive|unarchive",
+        "  by-handle|by-identifier|operation|duplicate-job",
+        "  tags|types|vendors",
+        "  change-status|set",
+        "  join-selling-plan-groups|leave-selling-plan-groups",
+        "  option-update|options-create|options-delete|options-reorder",
+        "  combined-listing-update",
+        "  add-tags|remove-tags|set-price",
+        "  publish|unpublish|publish-all",
+        "  bundle-create|bundle-update",
+        "  metafields upsert",
+        "  media add|media upload|media list|media remove|media reorder|media update",
+        "  create-media|update-media|delete-media|reorder-media",
+        "",
+        "Common output flags:",
+        "  --view summary|ids|full|raw",
+        "  --select <path>        (repeatable; dot paths; adds to base view selection)",
+        "  --selection <graphql>  (selection override; can be @file.gql)"
+      ].join("\n")
+    );
+    return;
+  }
+  if (verb === "reorder-media") verb = "media reorder";
+  if (verb === "by-handle") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { handle: { type: "string" } } });
+    const handle = args.handle;
+    if (!handle) throw new import_errors.CliError("Missing --handle", 2);
+    const selectValues = Array.isArray(args.select) ? args.select : args.select ? [args.select] : [];
+    const selectionOverride = typeof args.selection === "string" && args.selection.length > 0;
+    const select = !selectionOverride && ctx.view !== "raw" && ctx.view !== "ids" ? Array.from(/* @__PURE__ */ new Set([...selectValues, "resourcePublicationsV2.nodes.publication.name"])) : args.select;
+    const includeValues = Array.isArray(args.include) ? args.include : args.include ? [args.include] : [];
+    const include = ctx.view === "all" ? Array.from(/* @__PURE__ */ new Set([...includeValues, "resourcePublicationsV2"])) : args.include;
+    const selection = (0, import_select.resolveSelection)({
+      resource: "products",
+      view: ctx.view,
+      baseSelection: getProductSelectionForGet(ctx.view),
+      select,
+      selection: args.selection,
+      include,
+      ensureId: ctx.quiet,
+      defaultConnectionFirst: ctx.view === "all" ? 50 : 10
+    });
+    const result = await (0, import_router.runQuery)(ctx, { productByHandle: { __args: { handle }, ...selection } });
+    if (result === void 0) return;
+    const wantsResourcePublicationsV2 = Array.isArray(args.select) && args.select.some((p) => typeof p === "string" && p.startsWith("resourcePublicationsV2"));
+    const wantsResourcePublicationsV2ViaSelection = typeof args.selection === "string" && args.selection.includes("resourcePublicationsV2");
+    const stripResourcePublicationsV2 = !(wantsResourcePublicationsV2 || wantsResourcePublicationsV2ViaSelection);
+    const withComputed = (0, import_computedFields.applyComputedFieldsToNode)(result.productByHandle, {
+      view: ctx.view,
+      stripResourcePublicationsV2
+    });
+    (0, import_output.printNode)({ node: withComputed, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "by-identifier") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { identifier: { type: "string" } } });
+    const identifier = (0, import_shared.parseJsonArg)(args.identifier, "--identifier");
+    const selectValues = Array.isArray(args.select) ? args.select : args.select ? [args.select] : [];
+    const selectionOverride = typeof args.selection === "string" && args.selection.length > 0;
+    const select = !selectionOverride && ctx.view !== "raw" && ctx.view !== "ids" ? Array.from(/* @__PURE__ */ new Set([...selectValues, "resourcePublicationsV2.nodes.publication.name"])) : args.select;
+    const includeValues = Array.isArray(args.include) ? args.include : args.include ? [args.include] : [];
+    const include = ctx.view === "all" ? Array.from(/* @__PURE__ */ new Set([...includeValues, "resourcePublicationsV2"])) : args.include;
+    const selection = (0, import_select.resolveSelection)({
+      resource: "products",
+      view: ctx.view,
+      baseSelection: getProductSelectionForGet(ctx.view),
+      select,
+      selection: args.selection,
+      include,
+      ensureId: ctx.quiet,
+      defaultConnectionFirst: ctx.view === "all" ? 50 : 10
+    });
+    const result = await (0, import_router.runQuery)(ctx, { productByIdentifier: { __args: { identifier }, ...selection } });
+    if (result === void 0) return;
+    const wantsResourcePublicationsV2 = Array.isArray(args.select) && args.select.some((p) => typeof p === "string" && p.startsWith("resourcePublicationsV2"));
+    const wantsResourcePublicationsV2ViaSelection = typeof args.selection === "string" && args.selection.includes("resourcePublicationsV2");
+    const stripResourcePublicationsV2 = !(wantsResourcePublicationsV2 || wantsResourcePublicationsV2ViaSelection);
+    const withComputed = (0, import_computedFields.applyComputedFieldsToNode)(result.productByIdentifier, {
+      view: ctx.view,
+      stripResourcePublicationsV2
+    });
+    (0, import_output.printNode)({ node: withComputed, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "duplicate-job") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = args.id;
+    if (typeof id !== "string" || !id) throw new import_errors.CliError("Missing --id", 2);
+    const selection = (0, import_select.resolveSelection)({
+      typeName: "ProductDuplicateJob",
+      view: ctx.view,
+      baseSelection: { id: true, done: true },
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, { productDuplicateJob: { __args: { id }, ...selection } });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.productDuplicateJob, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "operation") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = args.id;
+    if (typeof id !== "string" || !id) throw new import_errors.CliError("Missing --id", 2);
+    const getProductOperationSelection = (view) => {
+      if (view === "raw") return {};
+      if (view === "ids") {
+        return {
+          __typename: true,
+          on_ProductBundleOperation: { id: true },
+          on_ProductDeleteOperation: { id: true },
+          on_ProductDuplicateOperation: { id: true, newProduct: { id: true }, product: { id: true } },
+          on_ProductSetOperation: { id: true, product: { id: true } }
+        };
+      }
+      return {
+        __typename: true,
+        status: true,
+        product: { id: true, title: true, handle: true, status: true },
+        on_ProductBundleOperation: {
+          id: true,
+          status: true,
+          product: { id: true, title: true },
+          userErrors: { field: true, message: true }
+        },
+        on_ProductDeleteOperation: {
+          id: true,
+          status: true,
+          product: { id: true, title: true },
+          userErrors: { field: true, message: true }
+        },
+        on_ProductDuplicateOperation: {
+          id: true,
+          status: true,
+          product: { id: true, title: true },
+          newProduct: { id: true, title: true },
+          userErrors: { field: true, message: true }
+        },
+        on_ProductSetOperation: {
+          id: true,
+          status: true,
+          product: { id: true, title: true },
+          userErrors: { code: true, field: true, message: true }
+        }
+      };
+    };
+    const selection = (0, import_select.resolveSelection)({
+      typeName: "ProductOperation",
+      view: ctx.view,
+      baseSelection: getProductOperationSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, { productOperation: { __args: { id }, ...selection } });
+    if (result === void 0) return;
+    (0, import_output.printNode)({ node: result.productOperation, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "tags" || verb === "types" || verb === "vendors") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const first = (0, import_shared.parseFirst)(args.first);
+    const after = args.after;
+    const reverse = args.reverse;
+    const field = verb === "tags" ? "productTags" : verb === "types" ? "productTypes" : "productVendors";
+    const result = await (0, import_router.runQuery)(ctx, {
+      [field]: {
+        __args: { first, after, reverse },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: true
+      }
+    });
+    if (result === void 0) return;
+    const connection = result[field];
+    if (ctx.quiet) {
+      for (const value of connection?.nodes ?? []) {
+        if (typeof value === "string" && value) process.stdout.write(`${value}
+`);
+      }
+      return;
+    }
+    (0, import_output.printConnection)({
+      connection,
+      format: ctx.format,
+      quiet: false,
+      nextPageArgs: { base: `shop products ${verb}`, first, reverse: reverse === true }
+    });
+    return;
+  }
+  if (verb === "change-status") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const productId = (0, import_shared.requireId)(args.id, "Product");
+    const status = args.status;
+    if (!status) throw new import_errors.CliError("Missing --status (ACTIVE|DRAFT|ARCHIVED)", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      productChangeStatus: {
+        __args: { productId, status },
+        product: productSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productChangeStatus, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.productChangeStatus?.product?.id ?? "");
+    (0, import_output.printJson)(result.productChangeStatus, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "set") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        identifier: { type: "string" },
+        synchronous: { type: "string" }
+      }
+    });
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    if (!built.used) throw new import_errors.CliError("Missing --input or --set/--set-json", 2);
+    const identifier = args.identifier ? (0, import_shared.parseJsonArg)(args.identifier, "--identifier") : void 0;
+    const synchronousRaw = args.synchronous;
+    const synchronous = (() => {
+      if (synchronousRaw === void 0 || synchronousRaw === null || synchronousRaw === "") return void 0;
+      const v = String(synchronousRaw).toLowerCase();
+      if (v === "true" || v === "1") return true;
+      if (v === "false" || v === "0") return false;
+      throw new import_errors.CliError("--synchronous must be true|false", 2);
+    })();
+    const result = await (0, import_router.runMutation)(ctx, {
+      productSet: {
+        __args: {
+          input: built.input,
+          ...identifier !== void 0 ? { identifier } : {},
+          ...synchronous !== void 0 ? { synchronous } : {}
+        },
+        product: productSummarySelection,
+        productSetOperation: {
+          id: true,
+          status: true,
+          product: productSummarySelection,
+          userErrors: { code: true, field: true, message: true }
+        },
+        userErrors: { code: true, field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productSet, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) {
+      const pid = result.productSet?.product?.id;
+      const opId = result.productSet?.productSetOperation?.id;
+      return console.log(pid ?? opId ?? "");
+    }
+    (0, import_output.printJson)(result.productSet, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "join-selling-plan-groups" || verb === "leave-selling-plan-groups") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: { "group-ids": { type: "string", multiple: true } } });
+    const id = (0, import_shared.requireId)(args.id, "Product");
+    const sellingPlanGroupIds = (0, import_shared.parseIds)(args["group-ids"], "SellingPlanGroup");
+    const mutation = verb === "join-selling-plan-groups" ? "productJoinSellingPlanGroups" : "productLeaveSellingPlanGroups";
+    const result = await (0, import_router.runMutation)(ctx, {
+      [mutation]: {
+        __args: { id, sellingPlanGroupIds },
+        product: { id: true, title: true },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    const payload = result[mutation];
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(payload?.product?.id ?? "");
+    (0, import_output.printJson)(payload, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "create-media" || verb === "update-media") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "product-id": { type: "string" },
+        media: { type: "string" }
+      }
+    });
+    const productId = (0, import_shared.requireId)(args["product-id"], "Product");
+    const media = (0, import_shared.parseJsonArg)(args.media, "--media");
+    if (!Array.isArray(media)) throw new import_errors.CliError("--media must be a JSON array", 2);
+    const mutation = verb === "create-media" ? "productCreateMedia" : "productUpdateMedia";
+    const result = await (0, import_router.runMutation)(ctx, {
+      [mutation]: {
+        __args: { productId, media },
+        media: productMediaSelection,
+        mediaUserErrors: { code: true, field: true, message: true },
+        product: { id: true, title: true }
+      }
+    });
+    if (result === void 0) return;
+    const payload = result[mutation];
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(payload?.product?.id ?? "");
+    (0, import_output.printJson)(payload, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "delete-media") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "product-id": { type: "string" },
+        "media-ids": { type: "string", multiple: true }
+      }
+    });
+    const productId = (0, import_shared.requireId)(args["product-id"], "Product");
+    const mediaIds = (0, import_shared.parseStringList)(args["media-ids"], "--media-ids");
+    const result = await (0, import_router.runMutation)(ctx, {
+      productDeleteMedia: {
+        __args: { productId, mediaIds },
+        deletedMediaIds: true,
+        deletedProductImageIds: true,
+        mediaUserErrors: { code: true, field: true, message: true },
+        product: { id: true, title: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productDeleteMedia, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.productDeleteMedia?.product?.id ?? "");
+    (0, import_output.printJson)(result.productDeleteMedia, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "option-update") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "product-id": { type: "string" },
+        option: { type: "string" },
+        "option-values-to-add": { type: "string" },
+        "option-values-to-delete": { type: "string" },
+        "option-values-to-update": { type: "string" },
+        "variant-strategy": { type: "string" }
+      }
+    });
+    const productId = (0, import_shared.requireId)(args["product-id"], "Product");
+    const option = (0, import_shared.parseJsonArg)(args.option, "--option");
+    const optionValuesToAdd = args["option-values-to-add"] ? (0, import_shared.parseJsonArg)(args["option-values-to-add"], "--option-values-to-add") : void 0;
+    const optionValuesToDelete = args["option-values-to-delete"] ? (0, import_shared.parseJsonArg)(args["option-values-to-delete"], "--option-values-to-delete") : void 0;
+    const optionValuesToUpdate = args["option-values-to-update"] ? (0, import_shared.parseJsonArg)(args["option-values-to-update"], "--option-values-to-update") : void 0;
+    const variantStrategy = args["variant-strategy"];
+    const result = await (0, import_router.runMutation)(ctx, {
+      productOptionUpdate: {
+        __args: {
+          productId,
+          option,
+          ...optionValuesToAdd !== void 0 ? { optionValuesToAdd } : {},
+          ...optionValuesToDelete !== void 0 ? { optionValuesToDelete } : {},
+          ...optionValuesToUpdate !== void 0 ? { optionValuesToUpdate } : {},
+          ...variantStrategy ? { variantStrategy } : {}
+        },
+        product: productSummarySelection,
+        userErrors: { code: true, field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productOptionUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.productOptionUpdate?.product?.id ?? "");
+    (0, import_output.printJson)(result.productOptionUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "options-create") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "product-id": { type: "string" },
+        options: { type: "string" },
+        "variant-strategy": { type: "string" }
+      }
+    });
+    const productId = (0, import_shared.requireId)(args["product-id"], "Product");
+    const options = (0, import_shared.parseJsonArg)(args.options, "--options");
+    if (!Array.isArray(options)) throw new import_errors.CliError("--options must be a JSON array", 2);
+    const variantStrategy = args["variant-strategy"];
+    const result = await (0, import_router.runMutation)(ctx, {
+      productOptionsCreate: {
+        __args: {
+          productId,
+          options,
+          ...variantStrategy ? { variantStrategy } : {}
+        },
+        product: productSummarySelection,
+        userErrors: { code: true, field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productOptionsCreate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.productOptionsCreate?.product?.id ?? "");
+    (0, import_output.printJson)(result.productOptionsCreate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "options-delete") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "product-id": { type: "string" },
+        "option-ids": { type: "string", multiple: true },
+        strategy: { type: "string" }
+      }
+    });
+    const productId = (0, import_shared.requireId)(args["product-id"], "Product");
+    const options = (0, import_shared.parseStringList)(args["option-ids"], "--option-ids");
+    const strategy = args.strategy;
+    const result = await (0, import_router.runMutation)(ctx, {
+      productOptionsDelete: {
+        __args: { productId, options, ...strategy ? { strategy } : {} },
+        deletedOptionsIds: true,
+        product: productSummarySelection,
+        userErrors: { code: true, field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productOptionsDelete, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.productOptionsDelete?.product?.id ?? "");
+    (0, import_output.printJson)(result.productOptionsDelete, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "options-reorder") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "product-id": { type: "string" },
+        options: { type: "string" }
+      }
+    });
+    const productId = (0, import_shared.requireId)(args["product-id"], "Product");
+    const options = (0, import_shared.parseJsonArg)(args.options, "--options");
+    if (!Array.isArray(options)) throw new import_errors.CliError("--options must be a JSON array", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      productOptionsReorder: {
+        __args: { productId, options },
+        product: productSummarySelection,
+        userErrors: { code: true, field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productOptionsReorder, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.productOptionsReorder?.product?.id ?? "");
+    (0, import_output.printJson)(result.productOptionsReorder, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "combined-listing-update") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "parent-product-id": { type: "string" },
+        title: { type: "string" },
+        "products-added": { type: "string" },
+        "products-edited": { type: "string" },
+        "products-removed-ids": { type: "string", multiple: true },
+        "options-and-values": { type: "string" }
+      }
+    });
+    const parentProductId = (0, import_shared.requireId)(args["parent-product-id"], "Product");
+    const optionsAndValues = args["options-and-values"] ? (0, import_shared.parseJsonArg)(args["options-and-values"], "--options-and-values") : void 0;
+    const productsAdded = args["products-added"] ? (0, import_shared.parseJsonArg)(args["products-added"], "--products-added") : void 0;
+    const productsEdited = args["products-edited"] ? (0, import_shared.parseJsonArg)(args["products-edited"], "--products-edited") : void 0;
+    const productsRemovedIds = args["products-removed-ids"] ? (0, import_shared.parseIds)(args["products-removed-ids"], "Product") : void 0;
+    const title = args.title;
+    const result = await (0, import_router.runMutation)(ctx, {
+      combinedListingUpdate: {
+        __args: {
+          parentProductId,
+          ...title ? { title } : {},
+          ...optionsAndValues !== void 0 ? { optionsAndValues } : {},
+          ...productsAdded !== void 0 ? { productsAdded } : {},
+          ...productsEdited !== void 0 ? { productsEdited } : {},
+          ...productsRemovedIds !== void 0 ? { productsRemovedIds } : {}
+        },
+        product: productSummarySelection,
+        userErrors: { code: true, field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.combinedListingUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.combinedListingUpdate?.product?.id ?? "");
+    (0, import_output.printJson)(result.combinedListingUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "bundle-create" || verb === "bundle-update") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    if (!built.used) throw new import_errors.CliError("Missing --input or --set/--set-json", 2);
+    const mutation = verb === "bundle-create" ? "productBundleCreate" : "productBundleUpdate";
+    const result = await (0, import_router.runMutation)(ctx, {
+      [mutation]: {
+        __args: { input: built.input },
+        productBundleOperation: {
+          id: true,
+          status: true,
+          product: { id: true, title: true },
+          userErrors: { field: true, message: true }
+        },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    const payload = result[mutation];
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(payload?.productBundleOperation?.id ?? "");
+    (0, import_output.printJson)(payload, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "count") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        limit: { type: "string" },
+        "saved-search-id": { type: "string" }
+      }
+    });
+    const query = args.query;
+    const limitRaw = args.limit;
+    const savedSearchIdRaw = args["saved-search-id"];
+    const limit = limitRaw === void 0 || limitRaw === null || limitRaw === "" ? void 0 : Number(limitRaw);
+    if (limit !== void 0 && (!Number.isFinite(limit) || limit <= 0)) {
+      throw new import_errors.CliError("--limit must be a positive number", 2);
+    }
+    const savedSearchId = savedSearchIdRaw ? (0, import_gid.coerceGid)(String(savedSearchIdRaw), "SavedSearch") : void 0;
+    const result = await (0, import_router.runQuery)(ctx, {
+      productsCount: {
+        __args: {
+          ...query ? { query } : {},
+          ...savedSearchId ? { savedSearchId } : {},
+          ...limit !== void 0 ? { limit: Math.floor(limit) } : {}
+        },
+        count: true,
+        precision: true
+      }
+    });
+    if (result === void 0) return;
+    if (ctx.quiet) return console.log(result.productsCount?.count ?? "");
+    (0, import_output.printJson)(result.productsCount, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "publish" || verb === "unpublish") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "publication-id": { type: "string", multiple: true },
+        publication: { type: "string", multiple: true },
+        at: { type: "string" },
+        now: { type: "boolean" }
+      }
+    });
+    const publicationIds = args["publication-id"] ?? [];
+    const publicationNames = args.publication ?? [];
+    const resolvedPublicationIds = await (0, import_publishablePublish.resolvePublicationIds)({
+      ctx,
+      publicationIds,
+      publicationNames
+    });
+    if (verb === "publish") {
+      const publishDate = (0, import_publishablePublish.parsePublishDate)({ at: args.at, now: args.now });
+      const payload2 = await (0, import_publishablePublish.publishProduct)({
+        ctx,
+        id: args.id,
+        publicationIds: resolvedPublicationIds,
+        publishDate
+      });
+      if (payload2 === void 0) return;
+      if (ctx.quiet) return console.log(payload2?.publishable?.id ?? "");
+      (0, import_output.printJson)(payload2);
+      return;
+    }
+    const payload = await (0, import_publishablePublish.unpublishProduct)({
+      ctx,
+      id: args.id,
+      publicationIds: resolvedPublicationIds
+    });
+    if (payload === void 0) return;
+    if (ctx.quiet) return console.log(payload?.publishable?.id ?? "");
+    (0, import_output.printJson)(payload);
+    return;
+  }
+  if (verb === "publish-all") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        at: { type: "string" },
+        now: { type: "boolean" }
+      }
+    });
+    if (ctx.dryRun) {
+      await (0, import_resolvePublicationId.listPublications)(ctx);
+      return;
+    }
+    const publishDate = (0, import_publishablePublish.parsePublishDate)({ at: args.at, now: args.now });
+    const publications = await (0, import_resolvePublicationId.listPublications)(ctx);
+    const publicationIds = publications.map((p) => p.id).filter(Boolean);
+    if (publicationIds.length === 0) throw new import_errors.CliError("No publications found to publish to", 2);
+    const payload = await (0, import_publishablePublish.publishProduct)({
+      ctx,
+      id: args.id,
+      publicationIds,
+      publishDate
+    });
+    if (payload === void 0) return;
+    if (ctx.quiet) return console.log(payload?.publishable?.id ?? "");
+    (0, import_output.printJson)(payload);
+    return;
+  }
+  if (verb === "metafields upsert") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    if (!built.used) throw new import_errors.CliError("Missing --input or --set/--set-json", 2);
+    const result = await (0, import_metafieldsUpsert.metafieldsUpsert)({ ctx, id: args.id, input: built.input });
+    if (result === void 0) return;
+    (0, import_output.printJson)(result);
+    return;
+  }
+  if (verb === "get") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "Product");
+    const selectValues = Array.isArray(args.select) ? args.select : args.select ? [args.select] : [];
+    const selectionOverride = typeof args.selection === "string" && args.selection.length > 0;
+    const select = !selectionOverride && ctx.view !== "raw" && ctx.view !== "ids" ? Array.from(/* @__PURE__ */ new Set([...selectValues, "resourcePublicationsV2.nodes.publication.name"])) : args.select;
+    const includeValues = Array.isArray(args.include) ? args.include : args.include ? [args.include] : [];
+    const include = ctx.view === "all" ? Array.from(/* @__PURE__ */ new Set([...includeValues, "resourcePublicationsV2"])) : args.include;
+    const selection = (0, import_select.resolveSelection)({
+      resource: "products",
+      view: ctx.view,
+      baseSelection: getProductSelectionForGet(ctx.view),
+      select,
+      selection: args.selection,
+      include,
+      ensureId: ctx.quiet,
+      defaultConnectionFirst: ctx.view === "all" ? 50 : 10
+    });
+    const result = await (0, import_router.runQuery)(ctx, { product: { __args: { id }, ...selection } });
+    if (result === void 0) return;
+    const wantsResourcePublicationsV2 = Array.isArray(args.select) && args.select.some((p) => typeof p === "string" && p.startsWith("resourcePublicationsV2"));
+    const wantsResourcePublicationsV2ViaSelection = typeof args.selection === "string" && args.selection.includes("resourcePublicationsV2");
+    const stripResourcePublicationsV2 = !(wantsResourcePublicationsV2 || wantsResourcePublicationsV2ViaSelection);
+    const withComputed = (0, import_computedFields.applyComputedFieldsToNode)(result.product, {
+      view: ctx.view,
+      stripResourcePublicationsV2
+    });
+    (0, import_output.printNode)({ node: withComputed, format: ctx.format, quiet: ctx.quiet });
+    return;
+  }
+  if (verb === "list") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        published: { type: "boolean" }
+      }
+    });
+    const first = (0, import_shared.parseFirst)(args.first);
+    const after = args.after;
+    const userQuery = typeof args.query === "string" && args.query.trim() ? args.query.trim() : void 0;
+    const published = args.published === true;
+    const publishedFilter = "published_status:published";
+    const query = published && typeof userQuery === "string" && userQuery.includes(publishedFilter) ? userQuery : published ? userQuery ? `${userQuery} ${publishedFilter}` : publishedFilter : userQuery;
+    const reverse = args.reverse;
+    const sortKey = args.sort;
+    const nodeSelection = (0, import_select.resolveSelection)({
+      resource: "products",
+      view: ctx.view,
+      baseSelection: getProductSelection(ctx.view),
+      select: args.select,
+      selection: args.selection,
+      include: args.include,
+      ensureId: ctx.quiet
+    });
+    const result = await (0, import_router.runQuery)(ctx, {
+      products: {
+        __args: { first, after, query, reverse, sortKey },
+        pageInfo: { hasNextPage: true, endCursor: true },
+        nodes: nodeSelection
+      }
+    });
+    if (result === void 0) return;
+    (0, import_output.printConnection)({
+      connection: result.products,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: (0, import_shared.buildListNextPageArgs)(
+        "products",
+        { first, query: userQuery, sort: sortKey, reverse },
+        published ? [{ flag: "--published", value: true }] : void 0
+      )
+    });
+    return;
+  }
+  if (verb === "create") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    if (!built.used) throw new import_errors.CliError("Missing --input or --set/--set-json", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      productCreate: {
+        __args: { input: built.input },
+        product: productSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productCreate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.productCreate?.product?.id ?? "");
+    (0, import_output.printJson)(result.productCreate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "archive" || verb === "unarchive") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "Product");
+    const status = verb === "archive" ? "ARCHIVED" : args.status ?? "DRAFT";
+    const result = await (0, import_router.runMutation)(ctx, {
+      productUpdate: {
+        __args: { input: { id, status } },
+        product: productSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.productUpdate?.product?.id ?? "");
+    (0, import_output.printJson)(result.productUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "update") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "Product");
+    const built = (0, import_input.buildInput)({
+      inputArg: args.input,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    if (!built.used) throw new import_errors.CliError("Missing --input or --set/--set-json", 2);
+    const input = { ...built.input, id };
+    const result = await (0, import_router.runMutation)(ctx, {
+      productUpdate: {
+        __args: { input },
+        product: productSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.productUpdate?.product?.id ?? "");
+    (0, import_output.printJson)(result.productUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "delete") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "Product");
+    if (!args.yes) throw new import_errors.CliError("Refusing to delete without --yes", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      productDelete: {
+        __args: { input: { id } },
+        deletedProductId: true,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productDelete, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.productDelete?.deletedProductId ?? "");
+    (0, import_output.printJson)(result.productDelete, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "duplicate") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "Product");
+    const built = (0, import_input.buildInput)({
+      inputArg: void 0,
+      setArgs: args.set,
+      setJsonArgs: args["set-json"]
+    });
+    let newTitle = args["new-title"] ?? (built.used ? built.input?.newTitle : void 0);
+    if (!newTitle) {
+      const original = await (0, import_router.runQuery)(ctx, { product: { __args: { id }, title: true } });
+      if (original === void 0) return;
+      const title = original.product?.title;
+      if (!title) throw new import_errors.CliError("Could not resolve original product title to auto-generate newTitle", 2);
+      newTitle = `${title} (Copy)`;
+    }
+    const mutationArgs = {
+      productId: id,
+      newTitle,
+      ...built.used ? built.input : {}
+    };
+    const result = await (0, import_router.runMutation)(ctx, {
+      productDuplicate: {
+        __args: mutationArgs,
+        newProduct: productSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productDuplicate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.productDuplicate?.newProduct?.id ?? "");
+    (0, import_output.printJson)(result.productDuplicate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "set-status") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "Product");
+    const status = args.status;
+    if (!status) throw new import_errors.CliError("Missing --status (ACTIVE|DRAFT|ARCHIVED)", 2);
+    const result = await (0, import_router.runMutation)(ctx, {
+      productUpdate: {
+        __args: { input: { id, status } },
+        product: productSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.productUpdate?.product?.id ?? "");
+    (0, import_output.printJson)(result.productUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "set-price") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "variant-id": { type: "string" },
+        price: { type: "string" },
+        "compare-at-price": { type: "string" },
+        "product-id": { type: "string" }
+      }
+    });
+    const variantId = (0, import_shared.requireId)(args["variant-id"], "ProductVariant");
+    const price = args.price;
+    if (!price) throw new import_errors.CliError("Missing --price", 2);
+    const compareAtPrice = args["compare-at-price"];
+    const explicitProductId = args["product-id"];
+    let productId;
+    if (explicitProductId) {
+      productId = (0, import_gid.coerceGid)(explicitProductId, "Product");
+    } else {
+      if (ctx.dryRun) {
+        throw new import_errors.CliError(
+          "In --dry-run mode, --product-id is required because resolving a productId from a variantId requires executing a query.",
+          2
+        );
+      }
+      const resolved = await (0, import_router.runQuery)(ctx, {
+        productVariant: { __args: { id: variantId }, product: { id: true } }
+      });
+      if (resolved === void 0) return;
+      const pid = resolved.productVariant?.product?.id;
+      if (!pid) throw new import_errors.CliError("Could not resolve productId from --variant-id", 2);
+      productId = pid;
+    }
+    const result = await (0, import_router.runMutation)(ctx, {
+      productVariantsBulkUpdate: {
+        __args: {
+          productId,
+          variants: [
+            {
+              id: variantId,
+              price,
+              ...compareAtPrice ? { compareAtPrice } : {}
+            }
+          ]
+        },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({
+      payload: result.productVariantsBulkUpdate,
+      failOnUserErrors: ctx.failOnUserErrors
+    });
+    if (ctx.quiet) return console.log(variantId);
+    (0, import_output.printJson)(result.productVariantsBulkUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "add-tags" || verb === "remove-tags") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "Product");
+    const tags = parseTags(args.tags);
+    const mutationField = verb === "add-tags" ? "tagsAdd" : "tagsRemove";
+    const request = {
+      [mutationField]: {
+        __args: { id, tags },
+        node: { id: true },
+        userErrors: { field: true, message: true }
+      }
+    };
+    const result = await (0, import_router.runMutation)(ctx, request);
+    if (result === void 0) return;
+    const payload = result[mutationField];
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(payload?.node?.id ?? "");
+    (0, import_output.printJson)(payload, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "media add") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        url: { type: "string", multiple: true },
+        alt: { type: "string" },
+        "media-type": { type: "string" }
+      }
+    });
+    const id = (0, import_shared.requireId)(args.id, "Product");
+    const urls = args.url ?? [];
+    if (urls.length === 0) throw new import_errors.CliError("Missing --url (repeatable)", 2);
+    const mediaContentType = normalizeMediaContentType(args["media-type"]);
+    const alt = args.alt;
+    const media = urls.map((url) => ({
+      originalSource: url,
+      mediaContentType,
+      ...alt ? { alt } : {}
+    }));
+    const result = await (0, import_router.runMutation)(ctx, {
+      productUpdate: {
+        __args: { product: { id }, media },
+        product: productSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.productUpdate?.product?.id ?? "");
+    (0, import_output.printJson)(result.productUpdate);
+    return;
+  }
+  if (verb === "media upload") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        file: { type: "string", multiple: true },
+        alt: { type: "string" },
+        "content-type": { type: "string" },
+        "media-type": { type: "string" }
+      }
+    });
+    const id = (0, import_shared.requireId)(args.id, "Product");
+    const filePaths = args.file ?? [];
+    if (filePaths.length === 0) throw new import_errors.CliError("Missing --file (repeatable)", 2);
+    const forcedMediaType = args["media-type"];
+    const forced = forcedMediaType ? normalizeMediaContentType(forcedMediaType) : void 0;
+    const resourceOverride = forced ? mediaTypeToStagedResource(forced) : void 0;
+    const localFiles = (0, import_stagedUploads.buildLocalFilesForStagedUpload)({
+      filePaths,
+      contentType: args["content-type"],
+      resource: resourceOverride
+    });
+    const targets = await (0, import_stagedUploads.stagedUploadLocalFiles)(ctx, localFiles);
+    if (targets === void 0) return;
+    const alt = args.alt;
+    const media = targets.map((t, i) => {
+      const local = localFiles[i];
+      if (!t.resourceUrl) throw new import_errors.CliError(`Missing staged target resourceUrl for ${local.filename}`, 2);
+      return {
+        originalSource: t.resourceUrl,
+        mediaContentType: forced ?? stagedResourceToMediaType(local.resource),
+        ...alt ? { alt } : {}
+      };
+    });
+    const result = await (0, import_router.runMutation)(ctx, {
+      productUpdate: {
+        __args: { product: { id }, media },
+        product: productSummarySelection,
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.productUpdate?.product?.id ?? "");
+    (0, import_output.printJson)(result.productUpdate);
+    return;
+  }
+  if (verb === "media list") {
+    const args = (0, import_router.parseStandardArgs)({ argv, extraOptions: {} });
+    const id = (0, import_shared.requireId)(args.id, "Product");
+    const first = (0, import_shared.parseFirst)(args.first);
+    const after = args.after;
+    const result = await (0, import_router.runQuery)(ctx, {
+      product: {
+        __args: { id },
+        media: {
+          __args: { first, after },
+          pageInfo: { hasNextPage: true, endCursor: true },
+          nodes: productMediaSelection
+        }
+      }
+    });
+    if (result === void 0) return;
+    const connection = result.product?.media ?? { nodes: [], pageInfo: void 0 };
+    (0, import_output.printConnection)({
+      connection,
+      format: ctx.format,
+      quiet: ctx.quiet,
+      nextPageArgs: {
+        base: "shop products media list",
+        first,
+        extraFlags: [{ flag: "--id", value: id }]
+      }
+    });
+    return;
+  }
+  if (verb === "media remove") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "media-id": { type: "string", multiple: true }
+      }
+    });
+    const productId = (0, import_shared.requireId)(args.id, "Product");
+    const mediaIds = args["media-id"] ?? [];
+    if (mediaIds.length === 0) throw new import_errors.CliError("Missing --media-id (repeatable)", 2);
+    const files = mediaIds.map((id) => ({
+      id: normalizeMediaId(id),
+      referencesToRemove: [productId]
+    }));
+    const result = await (0, import_router.runMutation)(ctx, {
+      fileUpdate: {
+        __args: { files },
+        files: { id: true, alt: true, fileStatus: true, updatedAt: true },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.fileUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(productId);
+    (0, import_output.printJson)(result.fileUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "media update") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        "media-id": { type: "string" },
+        alt: { type: "string" }
+      }
+    });
+    const mediaIdRaw = args["media-id"];
+    if (!mediaIdRaw) throw new import_errors.CliError("Missing --media-id", 2);
+    const alt = args.alt;
+    if (alt === void 0) throw new import_errors.CliError("Missing --alt", 2);
+    const files = [{ id: normalizeMediaId(mediaIdRaw), alt }];
+    const result = await (0, import_router.runMutation)(ctx, {
+      fileUpdate: {
+        __args: { files },
+        files: { id: true, alt: true, fileStatus: true, updatedAt: true },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.fileUpdate, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(files[0].id);
+    (0, import_output.printJson)(result.fileUpdate, ctx.format !== "raw");
+    return;
+  }
+  if (verb === "media reorder") {
+    const args = (0, import_router.parseStandardArgs)({
+      argv,
+      extraOptions: {
+        moves: { type: "string" },
+        move: { type: "string", multiple: true }
+      }
+    });
+    const id = (0, import_shared.requireId)(args.id, "Product");
+    let moves = [];
+    if (args.moves) {
+      try {
+        const parsed = JSON.parse(args.moves);
+        if (!Array.isArray(parsed)) throw new import_errors.CliError("--moves must be a JSON array", 2);
+        moves = parsed;
+      } catch (err) {
+        throw new import_errors.CliError(`--moves must be valid JSON: ${err.message}`, 2);
+      }
+    } else if (args.move) {
+      const raw = args.move;
+      const parsedMoves = [];
+      for (const item of raw) {
+        const parts = item.split(":");
+        if (parts.length !== 2) throw new import_errors.CliError("--move must be <mediaId>:<newPosition>", 2);
+        const mediaId = parts[0].trim();
+        const pos = Number(parts[1].trim());
+        if (!mediaId) throw new import_errors.CliError("--move mediaId cannot be empty", 2);
+        if (!Number.isFinite(pos) || pos < 0) throw new import_errors.CliError("--move newPosition must be a non-negative number", 2);
+        parsedMoves.push({ id: normalizeMediaId(mediaId), newPosition: Math.floor(pos) });
+      }
+      moves = parsedMoves;
+    }
+    if (moves.length === 0) {
+      throw new import_errors.CliError("Missing moves: pass either --moves <json> or --move <mediaId>:<newPosition> (repeatable)", 2);
+    }
+    const normalizedMoves = moves.map((move, i) => {
+      const id2 = move?.id;
+      const newPosition = move?.newPosition;
+      if (typeof id2 !== "string" || !id2.trim()) {
+        throw new import_errors.CliError(`moves[${i}].id is required`, 2);
+      }
+      const pos = Number(newPosition);
+      if (!Number.isFinite(pos) || pos < 0) {
+        throw new import_errors.CliError(`moves[${i}].newPosition must be a non-negative number`, 2);
+      }
+      return { id: normalizeMediaId(id2), newPosition: Math.floor(pos) };
+    });
+    const result = await (0, import_router.runMutation)(ctx, {
+      productReorderMedia: {
+        __args: { id, moves: normalizedMoves },
+        job: { id: true, done: true },
+        userErrors: { field: true, message: true }
+      }
+    });
+    if (result === void 0) return;
+    (0, import_userErrors.maybeFailOnUserErrors)({ payload: result.productReorderMedia, failOnUserErrors: ctx.failOnUserErrors });
+    if (ctx.quiet) return console.log(result.productReorderMedia?.job?.id ?? "");
+    (0, import_output.printJson)(result.productReorderMedia, ctx.format !== "raw");
+    return;
+  }
+  throw new import_errors.CliError(`Unknown verb for products: ${verb}`, 2);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runProducts
+});
+//# sourceMappingURL=products.js.map