shopq 0.1.0

package/dist/shopctl.js

@@ -0,0 +1,2264 @@
+#!/usr/bin/env node
+
+// src/graphql.ts
+var API_VERSION = "2026-01";
+
+class GraphQLError extends Error {
+  errors;
+  constructor(errors) {
+    super(errors.map((e) => e.message).join("; "));
+    this.errors = errors;
+    this.name = "GraphQLError";
+  }
+}
+
+class HttpError extends Error {
+  status;
+  body;
+  constructor(status, body) {
+    super(`HTTP ${status}: ${body}`);
+    this.status = status;
+    this.body = body;
+    this.name = "HttpError";
+  }
+}
+
+class ConfigError extends Error {
+  missing;
+  constructor(missing) {
+    super(`Missing required environment variables: ${missing.join(", ")}`);
+    this.missing = missing;
+    this.name = "ConfigError";
+  }
+}
+function resolveConfig(storeFlag) {
+  const missing = [];
+  const store = storeFlag || process.env.SHOPIFY_STORE;
+  const clientId = process.env.SHOPIFY_CLIENT_ID;
+  const clientSecret = process.env.SHOPIFY_CLIENT_SECRET;
+  if (!store)
+    missing.push("SHOPIFY_STORE");
+  if (!clientId)
+    missing.push("SHOPIFY_CLIENT_ID");
+  if (!clientSecret)
+    missing.push("SHOPIFY_CLIENT_SECRET");
+  if (missing.length > 0) {
+    throw new ConfigError(missing);
+  }
+  return { store, clientId, clientSecret };
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function exchangeToken(opts) {
+  const protocol = opts.protocol ?? "https";
+  const url = `${protocol}://${opts.store}/admin/oauth/access_token`;
+  const body = new URLSearchParams({
+    grant_type: "client_credentials",
+    client_id: opts.clientId,
+    client_secret: opts.clientSecret
+  });
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: body.toString()
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new HttpError(response.status, text);
+  }
+  const json = await response.json();
+  return {
+    accessToken: json.access_token,
+    scope: json.scope,
+    expiresIn: json.expires_in
+  };
+}
+function createClient(config) {
+  const {
+    store,
+    clientId,
+    clientSecret,
+    protocol = "https",
+    maxRetries = 5,
+    timeoutMs = 30000
+  } = config;
+  const endpoint = `${protocol}://${store}/admin/api/${API_VERSION}/graphql.json`;
+  let cachedToken = null;
+  let tokenExpiresAt = 0;
+  async function getAccessToken() {
+    if (cachedToken && Date.now() < tokenExpiresAt) {
+      return cachedToken;
+    }
+    const result = await exchangeToken({
+      store,
+      clientId,
+      clientSecret,
+      protocol
+    });
+    cachedToken = result.accessToken;
+    tokenExpiresAt = Date.now() + result.expiresIn * 1000 - 60000;
+    return cachedToken;
+  }
+  async function fetchRaw(query, variables) {
+    const accessToken = await getAccessToken();
+    const body = JSON.stringify({ query, variables });
+    for (let attempt = 0;attempt <= maxRetries; attempt++) {
+      let response;
+      try {
+        response = await fetch(endpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "X-Shopify-Access-Token": accessToken
+          },
+          body,
+          signal: AbortSignal.timeout(timeoutMs)
+        });
+      } catch (err) {
+        if (err?.name === "TimeoutError") {
+          throw new Error(`Request timed out after ${timeoutMs}ms`);
+        }
+        throw err;
+      }
+      if (response.status === 429) {
+        if (attempt === maxRetries) {
+          const text = await response.text();
+          throw new HttpError(429, text);
+        }
+        const retryAfter = response.headers.get("Retry-After");
+        const waitMs = retryAfter ? parseFloat(retryAfter) * 1000 : Math.min(1000 * 2 ** attempt, 30000);
+        await sleep(waitMs);
+        continue;
+      }
+      if (!response.ok) {
+        const text = await response.text();
+        throw new HttpError(response.status, text);
+      }
+      return await response.json();
+    }
+    throw new Error("Unexpected: exhausted retries");
+  }
+  return {
+    async query(query, variables) {
+      const json = await fetchRaw(query, variables);
+      if (json.errors && json.errors.length > 0) {
+        throw new GraphQLError(json.errors);
+      }
+      return json.data;
+    },
+    async rawQuery(query, variables) {
+      return fetchRaw(query, variables);
+    }
+  };
+}
+
+// src/helpers.ts
+import { existsSync, readFileSync } from "node:fs";
+
+// src/output.ts
+function formatOutput(data, columns, options) {
+  if (options.json) {
+    const envelope = { data };
+    if (options.pageInfo) {
+      envelope.pageInfo = options.pageInfo;
+    }
+    process.stdout.write(`${JSON.stringify(envelope, null, 2)}
+`);
+    return;
+  }
+  if (!Array.isArray(data)) {
+    for (const col of columns) {
+      if (col.key in data) {
+        const label = options.noColor ? col.header : `\x1B[1m${col.header}\x1B[0m`;
+        process.stdout.write(`${label}: ${data[col.key]}
+`);
+      }
+    }
+    return;
+  }
+  const widths = columns.map((col) => {
+    const values = data.map((row) => String(row[col.key] ?? ""));
+    return Math.max(col.header.length, ...values.map((v) => v.length));
+  });
+  const headerLine = columns.map((col, i) => {
+    const padded = col.header.padEnd(widths[i]);
+    return options.noColor ? padded : `\x1B[1m${padded}\x1B[0m`;
+  }).join("  ");
+  process.stdout.write(`${headerLine}
+`);
+  const separator = widths.map((w) => "─".repeat(w)).join("  ");
+  process.stdout.write(`${separator}
+`);
+  for (const row of data) {
+    const line = columns.map((col, i) => {
+      return String(row[col.key] ?? "").padEnd(widths[i]);
+    }).join("  ");
+    process.stdout.write(`${line}
+`);
+  }
+  if (options.pageInfo?.hasNextPage) {
+    process.stdout.write(`
+More results available. Use --cursor ${options.pageInfo.endCursor} to see next page.
+`);
+  }
+}
+function formatError(message) {
+  process.stderr.write(`Error: ${message}
+`);
+}
+
+// src/helpers.ts
+function getClient(flags) {
+  const config = resolveConfig(flags.store);
+  const protocol = process.env.SHOPIFY_PROTOCOL === "http" ? "http" : "https";
+  return createClient({ ...config, protocol });
+}
+function handleCommandError(err) {
+  if (err instanceof ConfigError) {
+    formatError(err.message);
+    process.exitCode = 1;
+    return;
+  }
+  if (err instanceof GraphQLError) {
+    formatError(err.message);
+    process.exitCode = 1;
+    return;
+  }
+  if (err instanceof Error) {
+    throw err;
+  }
+  throw new Error(String(err));
+}
+async function readFileText(path) {
+  if (!existsSync(path)) {
+    formatError(`File not found: ${path}`);
+    process.exitCode = 1;
+    return null;
+  }
+  try {
+    return readFileSync(path, "utf-8");
+  } catch (_err) {
+    formatError(`Failed to read file: ${path}`);
+    process.exitCode = 1;
+    return null;
+  }
+}
+function clampLimit(value, defaultLimit = 50) {
+  if (value === undefined)
+    return defaultLimit;
+  const n = parseInt(value, 10);
+  if (Number.isNaN(n) || n < 1) {
+    process.stderr.write(`Warning: --limit value "${value}" is invalid, using 1
+`);
+    return 1;
+  }
+  if (n > 250) {
+    process.stderr.write(`Warning: --limit value "${value}" exceeds maximum, using 250
+`);
+    return 250;
+  }
+  return n;
+}
+async function readFileJson(path) {
+  const text = await readFileText(path);
+  if (text === null)
+    return null;
+  try {
+    return JSON.parse(text);
+  } catch (_err) {
+    formatError(`Invalid JSON in file: ${path}`);
+    process.exitCode = 1;
+    return null;
+  }
+}
+
+// src/registry.ts
+var resources = new Map;
+function register(resourceName, resourceDescription, verbName, command) {
+  let resource = resources.get(resourceName);
+  if (!resource) {
+    resource = {
+      name: resourceName,
+      description: resourceDescription,
+      verbs: new Map
+    };
+    resources.set(resourceName, resource);
+  }
+  resource.verbs.set(verbName, command);
+}
+function getResource(name) {
+  return resources.get(name);
+}
+function getAllResources() {
+  return resources;
+}
+
+// src/commands/config.ts
+function maskToken(token) {
+  if (token.length <= 4)
+    return "****";
+  return `****${token.slice(-4)}`;
+}
+async function handleConfigShow(parsed) {
+  try {
+    const config = resolveConfig(parsed.flags.store);
+    const data = {
+      store: config.store,
+      apiVersion: API_VERSION,
+      clientId: maskToken(config.clientId),
+      clientSecret: maskToken(config.clientSecret)
+    };
+    const columns = [
+      { key: "store", header: "Store" },
+      { key: "apiVersion", header: "API Version" },
+      { key: "clientId", header: "Client ID" },
+      { key: "clientSecret", header: "Client Secret" }
+    ];
+    formatOutput(data, columns, {
+      json: parsed.flags.json,
+      noColor: parsed.flags.noColor
+    });
+  } catch (err) {
+    handleCommandError(err);
+  }
+}
+register("config", "Configuration management", "show", {
+  description: "Show current configuration",
+  handler: handleConfigShow
+});
+
+// src/commands/gql.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+async function handleGql(parsed) {
+  let query;
+  if (parsed.flags.file) {
+    if (!existsSync2(parsed.flags.file)) {
+      formatError(`File not found: ${parsed.flags.file}`);
+      process.exitCode = 2;
+      return;
+    }
+    query = readFileSync2(parsed.flags.file, "utf-8");
+  } else if (parsed.args[0] === "-") {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+      chunks.push(chunk);
+    query = Buffer.concat(chunks).toString("utf-8");
+  } else if (parsed.args[0]) {
+    query = parsed.args[0];
+  }
+  if (!query || query.trim() === "") {
+    formatError("No query provided. Pass an inline query, use - for stdin, or use --file <path>.");
+    process.exitCode = 2;
+    return;
+  }
+  let variables;
+  if (parsed.flags.vars) {
+    try {
+      variables = JSON.parse(parsed.flags.vars);
+    } catch {
+      formatError("Invalid JSON for --vars flag.");
+      process.exitCode = 2;
+      return;
+    }
+  }
+  let client;
+  try {
+    client = getClient(parsed.flags);
+  } catch (err) {
+    handleCommandError(err);
+    return;
+  }
+  const result = await client.rawQuery(query, variables);
+  if (result.errors && result.errors.length > 0) {
+    process.stderr.write(`${JSON.stringify(result.errors, null, 2)}
+`);
+    process.exitCode = 1;
+    return;
+  }
+  process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+}
+register("gql", "Execute raw GraphQL queries", "_default", {
+  description: "Execute a raw GraphQL query or mutation",
+  handler: handleGql
+});
+
+// src/commands/shop.ts
+var SHOP_QUERY = `{
+  shop {
+    name
+    email
+    myshopifyDomain
+    plan { displayName }
+    currencyCode
+    taxesIncluded
+    billingAddress {
+      address1
+      city
+      province
+      country
+      zip
+    }
+    enabledPresentmentCurrencies
+  }
+  productsCount { count precision }
+}`;
+function formatAddress(addr) {
+  if (!addr)
+    return "";
+  return [addr.address1, addr.city, addr.province, addr.country, addr.zip].filter(Boolean).join(", ");
+}
+async function handleShopGet(parsed) {
+  try {
+    const client = getClient(parsed.flags);
+    const result = await client.query(SHOP_QUERY);
+    const shop = result.shop;
+    const productsCount = result.productsCount;
+    if (parsed.flags.json) {
+      const data2 = {
+        name: shop.name,
+        email: shop.email,
+        domain: shop.myshopifyDomain,
+        plan: shop.plan.displayName,
+        currency: shop.currencyCode,
+        taxesIncluded: shop.taxesIncluded,
+        billingAddress: shop.billingAddress,
+        enabledPresentmentCurrencies: shop.enabledPresentmentCurrencies,
+        productsCount
+      };
+      formatOutput(data2, [], { json: true, noColor: parsed.flags.noColor });
+      return;
+    }
+    const data = {
+      name: shop.name,
+      email: shop.email,
+      domain: shop.myshopifyDomain,
+      plan: shop.plan.displayName,
+      currency: shop.currencyCode,
+      taxesIncluded: String(shop.taxesIncluded),
+      billingAddress: formatAddress(shop.billingAddress),
+      enabledPresentmentCurrencies: shop.enabledPresentmentCurrencies.join(", "),
+      productsCount: String(productsCount.count)
+    };
+    const columns = [
+      { key: "name", header: "Name" },
+      { key: "email", header: "Email" },
+      { key: "domain", header: "Domain" },
+      { key: "plan", header: "Plan" },
+      { key: "currency", header: "Currency" },
+      { key: "taxesIncluded", header: "Taxes Included" },
+      { key: "billingAddress", header: "Billing Address" },
+      { key: "enabledPresentmentCurrencies", header: "Presentment Currencies" },
+      { key: "productsCount", header: "Products Count" }
+    ];
+    formatOutput(data, columns, { json: false, noColor: parsed.flags.noColor });
+  } catch (err) {
+    handleCommandError(err);
+  }
+}
+register("shop", "Store information", "get", {
+  description: "Show store metadata",
+  handler: handleShopGet
+});
+
+// src/commands/product.ts
+var PRODUCTS_QUERY = `query ProductList($first: Int!, $after: String, $sortKey: ProductSortKeys, $query: String) {
+  products(first: $first, after: $after, sortKey: $sortKey, query: $query) {
+    edges {
+      node {
+        id
+        title
+        status
+        productType
+        vendor
+        variantsCount { count }
+        totalInventory
+      }
+    }
+    pageInfo {
+      hasNextPage
+      endCursor
+    }
+  }
+}`;
+function buildQueryFilter(flags) {
+  const parts = [];
+  if (flags.status)
+    parts.push(`status:${flags.status}`);
+  if (flags.type)
+    parts.push(`product_type:${flags.type}`);
+  if (flags.vendor)
+    parts.push(`vendor:${flags.vendor}`);
+  return parts.length > 0 ? parts.join(" ") : undefined;
+}
+async function handleProductList(parsed) {
+  try {
+    const client = getClient(parsed.flags);
+    const limit = clampLimit(parsed.flags.limit);
+    const variables = {
+      first: limit,
+      sortKey: "TITLE",
+      query: buildQueryFilter(parsed.flags)
+    };
+    if (parsed.flags.cursor) {
+      variables.after = parsed.flags.cursor;
+    }
+    const result = await client.query(PRODUCTS_QUERY, variables);
+    const products = result.products.edges.map((e) => ({
+      id: e.node.id,
+      title: e.node.title,
+      status: e.node.status,
+      productType: e.node.productType,
+      vendor: e.node.vendor,
+      variantsCount: e.node.variantsCount.count,
+      totalInventory: e.node.totalInventory
+    }));
+    const pageInfo = result.products.pageInfo;
+    if (parsed.flags.json) {
+      formatOutput(products, [], {
+        json: true,
+        noColor: parsed.flags.noColor,
+        pageInfo
+      });
+      return;
+    }
+    const columns = [
+      { key: "id", header: "ID" },
+      { key: "title", header: "Title" },
+      { key: "status", header: "Status" },
+      { key: "productType", header: "Type" },
+      { key: "vendor", header: "Vendor" },
+      { key: "variantsCount", header: "Variants" },
+      { key: "totalInventory", header: "Inventory" }
+    ];
+    formatOutput(products, columns, {
+      json: false,
+      noColor: parsed.flags.noColor,
+      pageInfo
+    });
+  } catch (err) {
+    handleCommandError(err);
+  }
+}
+var PRODUCT_GET_QUERY = `query ProductGet($id: ID!) {
+  product(id: $id) {
+    id
+    title
+    status
+    productType
+    vendor
+    tags
+    descriptionHtml
+    variants(first: 100) {
+      edges {
+        node {
+          id
+          sku
+          price
+          selectedOptions { name value }
+          inventoryQuantity
+        }
+      }
+    }
+    images(first: 20) {
+      edges {
+        node {
+          url
+          altText
+        }
+      }
+    }
+  }
+}`;
+var PRODUCT_SEARCH_QUERY = `query ProductSearch($query: String!) {
+  products(first: 10, query: $query) {
+    edges {
+      node {
+        id
+        title
+        status
+      }
+    }
+  }
+}`;
+function resolveProductId(input) {
+  if (input.startsWith("gid://")) {
+    return { type: "gid", id: input };
+  }
+  if (/^\d+$/.test(input)) {
+    return { type: "gid", id: `gid://shopify/Product/${input}` };
+  }
+  return { type: "title", title: input };
+}
+function stripHtml(html) {
+  return html.replace(/<[^>]*>/g, "").trim();
+}
+function truncate(str, max) {
+  if (str.length <= max)
+    return str;
+  return `${str.slice(0, max - 3)}...`;
+}
+async function handleProductGet(parsed) {
+  const idOrTitle = parsed.args.join(" ");
+  if (!idOrTitle) {
+    formatError("Usage: shopctl product get <id-or-title>");
+    process.exitCode = 2;
+    return;
+  }
+  try {
+    const client = getClient(parsed.flags);
+    const resolved = resolveProductId(idOrTitle);
+    if (resolved.type === "gid") {
+      const result = await client.query(PRODUCT_GET_QUERY, {
+        id: resolved.id
+      });
+      if (!result.product) {
+        formatError(`Product "${idOrTitle}" not found`);
+        process.exitCode = 1;
+        return;
+      }
+      outputProduct(result.product, parsed);
+    } else {
+      const searchResult = await client.query(PRODUCT_SEARCH_QUERY, {
+        query: `title:${resolved.title}`
+      });
+      const matches = searchResult.products.edges;
+      if (matches.length === 0) {
+        formatError(`Product "${idOrTitle}" not found`);
+        process.exitCode = 1;
+        return;
+      }
+      if (matches.length > 1) {
+        const columns = [
+          { key: "id", header: "ID" },
+          { key: "title", header: "Title" },
+          { key: "status", header: "Status" }
+        ];
+        const candidates = matches.map((e) => e.node);
+        formatOutput(candidates, columns, {
+          json: false,
+          noColor: parsed.flags.noColor
+        });
+        process.exitCode = 1;
+        return;
+      }
+      const productId = matches[0].node.id;
+      const result = await client.query(PRODUCT_GET_QUERY, {
+        id: productId
+      });
+      if (!result.product) {
+        formatError(`Product "${idOrTitle}" not found`);
+        process.exitCode = 1;
+        return;
+      }
+      outputProduct(result.product, parsed);
+    }
+  } catch (err) {
+    handleCommandError(err);
+  }
+}
+function outputProduct(product, parsed) {
+  const variants = product.variants.edges.map((e) => ({
+    sku: e.node.sku,
+    price: e.node.price,
+    options: e.node.selectedOptions.map((o) => `${o.name}: ${o.value}`).join(", "),
+    inventoryQuantity: e.node.inventoryQuantity
+  }));
+  const images = product.images.edges.map((e) => ({
+    url: e.node.url,
+    alt: e.node.altText ?? ""
+  }));
+  if (parsed.flags.json) {
+    const data = {
+      id: product.id,
+      title: product.title,
+      status: product.status,
+      productType: product.productType,
+      vendor: product.vendor,
+      tags: product.tags,
+      description: stripHtml(product.descriptionHtml),
+      variants: product.variants.edges.map((e) => ({
+        id: e.node.id,
+        sku: e.node.sku,
+        price: e.node.price,
+        options: e.node.selectedOptions,
+        inventoryQuantity: e.node.inventoryQuantity
+      })),
+      images
+    };
+    formatOutput(data, [], { json: true, noColor: parsed.flags.noColor });
+    return;
+  }
+  const plainDesc = stripHtml(product.descriptionHtml);
+  const lines = [];
+  const label = (name) => parsed.flags.noColor ? name : `\x1B[1m${name}\x1B[0m`;
+  lines.push(`${label("ID")}: ${product.id}`);
+  lines.push(`${label("Title")}: ${product.title}`);
+  lines.push(`${label("Status")}: ${product.status}`);
+  lines.push(`${label("Type")}: ${product.productType}`);
+  lines.push(`${label("Vendor")}: ${product.vendor}`);
+  lines.push(`${label("Tags")}: ${product.tags.join(", ")}`);
+  lines.push(`${label("Description")}: ${truncate(plainDesc, 80)}`);
+  lines.push("");
+  lines.push(`${label("Variants")}:`);
+  for (const v of variants) {
+    lines.push(`  SKU: ${v.sku}  Price: ${v.price}  Options: ${v.options}  Qty: ${v.inventoryQuantity}`);
+  }
+  lines.push("");
+  lines.push(`${label("Images")}:`);
+  for (const img of images) {
+    lines.push(`  ${img.url}${img.alt ? ` (${img.alt})` : ""}`);
+  }
+  process.stdout.write(`${lines.join(`
+`)}
+`);
+}
+var PRODUCT_CREATE_MUTATION = `mutation ProductCreate($input: ProductInput!) {
+  productCreate(input: $input) {
+    product { id }
+    userErrors { field message }
+  }
+}`;
+var PRODUCT_OPTIONS_CREATE_MUTATION = `mutation ProductOptionsCreate($productId: ID!, $options: [OptionCreateInput!]!) {
+  productOptionsCreate(productId: $productId, options: $options) {
+    product { id }
+    userErrors { field message }
+  }
+}`;
+var PRODUCT_VARIANTS_BULK_CREATE_MUTATION = `mutation ProductVariantsBulkCreate($productId: ID!, $variants: [ProductVariantsBulkInput!]!) {
+  productVariantsBulkCreate(productId: $productId, variants: $variants) {
+    productVariants { id }
+    userErrors { field message }
+  }
+}`;
+var PRODUCT_DELETE_MUTATION = `mutation ProductDelete($input: ProductDeleteInput!) {
+  productDelete(input: $input) {
+    deletedProductId
+    userErrors { field message }
+  }
+}`;
+async function handleProductCreate(parsed) {
+  const { flags } = parsed;
+  if (!flags.title) {
+    formatError("Missing required flag: --title");
+    process.exitCode = 2;
+    return;
+  }
+  if (flags.variants && !flags.options) {
+    formatError("--options is required when --variants is provided");
+    process.exitCode = 2;
+    return;
+  }
+  let variantsJson = null;
+  if (flags.variants) {
+    variantsJson = await readFileJson(flags.variants);
+    if (variantsJson === null)
+      return;
+  }
+  try {
+    const client = getClient(flags);
+    const status = flags.status ? flags.status.toUpperCase() : "DRAFT";
+    const input = {
+      title: flags.title,
+      status
+    };
+    if (flags.handle)
+      input.handle = flags.handle;
+    if (flags.type)
+      input.productType = flags.type;
+    if (flags.vendor)
+      input.vendor = flags.vendor;
+    if (flags.tags)
+      input.tags = flags.tags.split(",").map((t) => t.trim());
+    if (flags.description)
+      input.descriptionHtml = flags.description;
+    const createResult = await client.query(PRODUCT_CREATE_MUTATION, { input });
+    if (createResult.productCreate.userErrors.length > 0) {
+      formatError(createResult.productCreate.userErrors.map((e) => e.message).join("; "));
+      process.exitCode = 1;
+      return;
+    }
+    const productId = createResult.productCreate.product.id;
+    if (!flags.variants) {
+      const data2 = { productId };
+      if (flags.json) {
+        formatOutput(data2, [], { json: true, noColor: flags.noColor });
+      } else {
+        process.stdout.write(`Created product: ${productId}
+`);
+      }
+      return;
+    }
+    const optionNames = flags.options.split(",").map((o) => o.trim());
+    const optionsInput = optionNames.map((name) => ({
+      name,
+      values: [{ name: "Default" }]
+    }));
+    const optionsResult = await client.query(PRODUCT_OPTIONS_CREATE_MUTATION, { productId, options: optionsInput });
+    if (optionsResult.productOptionsCreate.userErrors.length > 0) {
+      await rollbackProduct(client, productId);
+      formatError(`Option creation failed, rollback performed: ${optionsResult.productOptionsCreate.userErrors.map((e) => e.message).join("; ")}`);
+      process.exitCode = 1;
+      return;
+    }
+    const variantsResult = await client.query(PRODUCT_VARIANTS_BULK_CREATE_MUTATION, {
+      productId,
+      variants: variantsJson
+    });
+    if (variantsResult.productVariantsBulkCreate.userErrors.length > 0) {
+      await rollbackProduct(client, productId);
+      formatError(`Variant creation failed, rollback performed: ${variantsResult.productVariantsBulkCreate.userErrors.map((e) => e.message).join("; ")}`);
+      process.exitCode = 1;
+      return;
+    }
+    const variantIds = (variantsResult.productVariantsBulkCreate.productVariants ?? []).map((v) => v.id);
+    const data = { productId, variantIds };
+    if (flags.json) {
+      formatOutput(data, [], { json: true, noColor: flags.noColor });
+    } else {
+      process.stdout.write(`Created product: ${productId}
+`);
+      process.stdout.write(`Created variants: ${variantIds.join(", ")}
+`);
+    }
+  } catch (err) {
+    handleCommandError(err);
+  }
+}
+async function rollbackProduct(client, productId) {
+  try {
+    await client.query(PRODUCT_DELETE_MUTATION, { input: { id: productId } });
+  } catch {}
+}
+var PRODUCT_UPDATE_MUTATION = `mutation ProductUpdate($input: ProductInput!) {
+  productUpdate(input: $input) {
+    product { id title status productType vendor }
+    userErrors { field message }
+  }
+}`;
+var UPDATE_FLAGS = [
+  "title",
+  "description",
+  "type",
+  "vendor",
+  "tags",
+  "status"
+];
+async function handleProductUpdate(parsed) {
+  const idOrTitle = parsed.args.join(" ");
+  if (!idOrTitle) {
+    formatError("Usage: shopctl product update <id-or-title> [--title ...] [--status ...] ...");
+    process.exitCode = 2;
+    return;
+  }
+  const hasUpdateFlag = UPDATE_FLAGS.some((f) => parsed.flags[f] !== undefined);
+  if (!hasUpdateFlag) {
+    formatError("Provide at least one update flag: --title, --description, --type, --vendor, --tags, --status");
+    process.exitCode = 2;
+    return;
+  }
+  try {
+    const client = getClient(parsed.flags);
+    const resolved = resolveProductId(idOrTitle);
+    let productGid;
+    if (resolved.type === "gid") {
+      productGid = resolved.id;
+    } else {
+      const searchResult = await client.query(PRODUCT_SEARCH_QUERY, {
+        query: `title:${resolved.title}`
+      });
+      const matches = searchResult.products.edges;
+      if (matches.length === 0) {
+        formatError(`Product "${idOrTitle}" not found`);
+        process.exitCode = 1;
+        return;
+      }
+      if (matches.length > 1) {
+        const columns = [
+          { key: "id", header: "ID" },
+          { key: "title", header: "Title" },
+          { key: "status", header: "Status" }
+        ];
+        formatOutput(matches.map((e) => e.node), columns, { json: false, noColor: parsed.flags.noColor });
+        process.exitCode = 1;
+        return;
+      }
+      productGid = matches[0].node.id;
+    }
+    const input = { id: productGid };
+    if (parsed.flags.title !== undefined)
+      input.title = parsed.flags.title;
+    if (parsed.flags.description !== undefined)
+      input.descriptionHtml = parsed.flags.description;
+    if (parsed.flags.type !== undefined)
+      input.productType = parsed.flags.type;
+    if (parsed.flags.vendor !== undefined)
+      input.vendor = parsed.flags.vendor;
+    if (parsed.flags.tags !== undefined)
+      input.tags = parsed.flags.tags.split(",").map((t) => t.trim());
+    if (parsed.flags.status !== undefined)
+      input.status = parsed.flags.status.toUpperCase();
+    const result = await client.query(PRODUCT_UPDATE_MUTATION, { input });
+    if (result.productUpdate.userErrors.length > 0) {
+      formatError(result.productUpdate.userErrors.map((e) => e.message).join("; "));
+      process.exitCode = 1;
+      return;
+    }
+    const product = result.productUpdate.product;
+    if (parsed.flags.json) {
+      formatOutput(product, [], { json: true, noColor: parsed.flags.noColor });
+    } else {
+      const label = (name) => parsed.flags.noColor ? name : `\x1B[1m${name}\x1B[0m`;
+      const lines = [
+        `${label("ID")}: ${product.id}`,
+        `${label("Title")}: ${product.title}`,
+        `${label("Status")}: ${product.status}`,
+        `${label("Type")}: ${product.productType}`,
+        `${label("Vendor")}: ${product.vendor}`
+      ];
+      process.stdout.write(`${lines.join(`
+`)}
+`);
+    }
+  } catch (err) {
+    handleCommandError(err);
+  }
+}
+var PRODUCT_SUMMARY_QUERY = `query ProductSummary($id: ID!) {
+  product(id: $id) {
+    id
+    title
+  }
+}`;
+async function handleProductDelete(parsed) {
+  const idOrTitle = parsed.args.join(" ");
+  if (!idOrTitle) {
+    formatError("Usage: shopctl product delete <id-or-title> [--yes]");
+    process.exitCode = 2;
+    return;
+  }
+  try {
+    const client = getClient(parsed.flags);
+    const resolved = resolveProductId(idOrTitle);
+    let productGid;
+    let productTitle;
+    if (resolved.type === "gid") {
+      const result2 = await client.query(PRODUCT_SUMMARY_QUERY, { id: resolved.id });
+      if (!result2.product) {
+        formatError(`Product "${idOrTitle}" not found`);
+        process.exitCode = 1;
+        return;
+      }
+      productGid = result2.product.id;
+      productTitle = result2.product.title;
+    } else {
+      const searchResult = await client.query(PRODUCT_SEARCH_QUERY, {
+        query: `title:${resolved.title}`
+      });
+      const matches = searchResult.products.edges;
+      if (matches.length === 0) {
+        formatError(`Product "${idOrTitle}" not found`);
+        process.exitCode = 1;
+        return;
+      }
+      if (matches.length > 1) {
+        const columns = [
+          { key: "id", header: "ID" },
+          { key: "title", header: "Title" },
+          { key: "status", header: "Status" }
+        ];
+        formatOutput(matches.map((e) => e.node), columns, { json: false, noColor: parsed.flags.noColor });
+        process.exitCode = 1;
+        return;
+      }
+      productGid = matches[0].node.id;
+      productTitle = matches[0].node.title;
+    }
+    if (!parsed.flags.yes) {
+      const data2 = { id: productGid, title: productTitle };
+      if (parsed.flags.json) {
+        formatOutput(data2, [], { json: true, noColor: parsed.flags.noColor });
+      } else {
+        process.stdout.write(`Would delete product: ${productTitle} (${productGid})
+`);
+      }
+      return;
+    }
+    const result = await client.query(PRODUCT_DELETE_MUTATION, { input: { id: productGid } });
+    if (result.productDelete.userErrors.length > 0) {
+      formatError(result.productDelete.userErrors.map((e) => e.message).join("; "));
+      process.exitCode = 1;
+      return;
+    }
+    const data = { id: productGid, title: productTitle };
+    if (parsed.flags.json) {
+      formatOutput(data, [], { json: true, noColor: parsed.flags.noColor });
+    } else {
+      process.stdout.write(`Deleted product: ${productTitle} (${productGid})
+`);
+    }
+  } catch (err) {
+    handleCommandError(err);
+  }
+}
+register("product", "Product management", "delete", {
+  description: "Delete a product by ID or title",
+  handler: handleProductDelete
+});
+register("product", "Product management", "update", {
+  description: "Update a product by ID or title",
+  handler: handleProductUpdate
+});
+register("product", "Product management", "create", {
+  description: "Create a product with optional variant support",
+  handler: handleProductCreate
+});
+register("product", "Product management", "list", {
+  description: "List products with filtering and pagination",
+  handler: handleProductList
+});
+register("product", "Product management", "get", {
+  description: "Get a single product by ID or title",
+  handler: handleProductGet
+});
+
+// src/commands/menu.ts
+var MENU_ITEMS_FRAGMENT = `
+  title
+  url
+  type
+  items {
+    title
+    url
+    type
+    items {
+      title
+      url
+      type
+      items {
+        title
+        url
+        type
+        items {
+          title
+          url
+          type
+          items {
+            title
+            url
+            type
+          }
+        }
+      }
+    }
+  }
+`;
+var MENU_BY_ID_QUERY = `query MenuGet($id: ID!) {
+  menu(id: $id) {
+    id
+    title
+    handle
+    items {
+      ${MENU_ITEMS_FRAGMENT}
+    }
+  }
+}`;
+var MENU_BY_HANDLE_QUERY = `query MenuGetByHandle($query: String!) {
+  menus(first: 1, query: $query) {
+    edges {
+      node {
+        id
+        title
+        handle
+        items {
+          ${MENU_ITEMS_FRAGMENT}
+        }
+      }
+    }
+  }
+}`;
+function resolveMenuId(input) {
+  if (input.startsWith("gid://")) {
+    return { type: "gid", id: input };
+  }
+  if (/^\d+$/.test(input)) {
+    return { type: "gid", id: `gid://shopify/Menu/${input}` };
+  }
+  return { type: "handle", handle: input };
+}
+function flattenItems(items, depth, rows) {
+  for (const item of items) {
+    rows.push({
+      indent: "  ".repeat(depth),
+      title: item.title,
+      url: item.url,
+      type: item.type
+    });
+    if (item.items && item.items.length > 0) {
+      flattenItems(item.items, depth + 1, rows);
+    }
+  }
+}
+async function handleMenuGet(parsed) {
+  const idOrHandle = parsed.args.join(" ");
+  if (!idOrHandle) {
+    formatError("Usage: shopctl menu get <id-or-handle>");
+    process.exitCode = 2;
+    return;
+  }
+  try {
+    const client = getClient(parsed.flags);
+    const resolved = resolveMenuId(idOrHandle);
+    let menu = null;
+    if (resolved.type === "gid") {
+      const result = await client.query(MENU_BY_ID_QUERY, { id: resolved.id });
+      menu = result.menu;
+    } else {
+      const result = await client.query(MENU_BY_HANDLE_QUERY, { query: `handle:${resolved.handle}` });
+      menu = result.menus.edges[0]?.node ?? null;
+    }
+    if (!menu) {
+      formatError(`Menu "${idOrHandle}" not found`);
+      process.exitCode = 1;
+      return;
+    }
+    if (parsed.flags.json) {
+      const data = {
+        id: menu.id,
+        title: menu.title,
+        handle: menu.handle,
+        itemsCount: menu.items.length,
+        items: menu.items
+      };
+      formatOutput(data, [], { json: true, noColor: parsed.flags.noColor });
+      return;
+    }
+    const label = (name) => parsed.flags.noColor ? name : `\x1B[1m${name}\x1B[0m`;
+    const lines = [];
+    lines.push(`${label("ID")}: ${menu.id}`);
+    lines.push(`${label("Title")}: ${menu.title}`);
+    lines.push(`${label("Handle")}: ${menu.handle}`);
+    lines.push(`${label("Items Count")}: ${menu.items.length}`);
+    lines.push("");
+    lines.push(`${label("Items")}:`);
+    const rows = [];
+    flattenItems(menu.items, 0, rows);
+    for (const row of rows) {
+      lines.push(`${row.indent}${row.title}  (${row.type})  ${row.url}`);
+    }
+    process.stdout.write(`${lines.join(`
+`)}
+`);
+  } catch (err) {
+    handleCommandError(err);
+  }
+}
+var MENUS_LIST_QUERY = `query MenuList {
+  menus(first: 250) {
+    edges {
+      node {
+        id
+        title
+        handle
+        items {
+          ${MENU_ITEMS_FRAGMENT}
+        }
+      }
+    }
+  }
+}`;
+async function handleMenuList(parsed) {
+  try {
+    const client = getClient(parsed.flags);
+    const result = await client.query(MENUS_LIST_QUERY, {});
+    const menus = result.menus.edges.map((e) => e.node);
+    if (parsed.flags.json) {
+      const data = menus.map((m) => ({
+        id: m.id,
+        title: m.title,
+        handle: m.handle,
+        itemCount: m.items.length,
+        items: m.items
+      }));
+      formatOutput(data, [], { json: true, noColor: parsed.flags.noColor });
+      return;
+    }
+    const label = (name) => parsed.flags.noColor ? name : `\x1B[1m${name}\x1B[0m`;
+    const lines = [];
+    for (let i = 0;i < menus.length; i++) {
+      const menu = menus[i];
+      if (i > 0)
+        lines.push("");
+      lines.push(`${label("ID")}: ${menu.id}`);
+      lines.push(`${label("Title")}: ${menu.title}`);
+      lines.push(`${label("Handle")}: ${menu.handle}`);
+      lines.push(`${label("Items Count")}: ${menu.items.length}`);
+      if (menu.items.length > 0) {
+        lines.push(`${label("Items")}:`);
+        const rows = [];
+        flattenItems(menu.items, 0, rows);
+        for (const row of rows) {
+          lines.push(`  ${row.indent}${row.title}  (${row.type})  ${row.url}`);
+        }
+      }
+    }
+    process.stdout.write(`${lines.join(`
+`)}
+`);
+  } catch (err) {
+    handleCommandError(err);
+  }
+}
+register("menu", "Navigation menu management", "get", {
+  description: "Get a single menu by ID or handle",
+  handler: handleMenuGet
+});
+register("menu", "Navigation menu management", "list", {
+  description: "List all navigation menus",
+  handler: handleMenuList
+});
+
+// src/commands/file.ts
+var VALID_TYPES = ["IMAGE", "VIDEO", "GENERIC_FILE"];
+var FILES_QUERY = `query FileList($first: Int!, $after: String, $query: String) {
+  files(first: $first, after: $after, query: $query) {
+    edges {
+      node {
+        ... on MediaImage {
+          id
+          alt
+          mediaContentType
+          fileStatus
+          image { url }
+          createdAt
+          originalSource { fileSize }
+        }
+        ... on GenericFile {
+          id
+          alt
+          mimeType
+          fileStatus
+          url
+          createdAt
+          originalFileSize
+        }
+        ... on Video {
+          id
+          alt
+          mediaContentType
+          fileStatus
+          sources { url }
+          createdAt
+          originalSource { fileSize }
+        }
+      }
+    }
+    pageInfo {
+      hasNextPage
+      endCursor
+    }
+  }
+}`;
+function extractUrl(node) {
+  if (node.image?.url)
+    return node.image.url;
+  if (node.url)
+    return node.url;
+  if (node.sources?.[0]?.url)
+    return node.sources[0].url;
+  return "";
+}
+function extractFilename(url) {
+  if (!url)
+    return "";
+  try {
+    const pathname = new URL(url).pathname;
+    return pathname.split("/").pop() ?? "";
+  } catch {
+    return url.split("/").pop() ?? "";
+  }
+}
+async function handleFileList(parsed) {
+  const { flags } = parsed;
+  if (flags.type) {
+    const typeUpper = flags.type.toUpperCase();
+    if (!VALID_TYPES.includes(typeUpper)) {
+      formatError(`Invalid --type "${flags.type}". Must be one of: ${VALID_TYPES.join(", ")}`);
+      process.exitCode = 2;
+      return;
+    }
+  }
+  try {
+    const client = getClient(flags);
+    const limit = clampLimit(flags.limit);
+    const queryParts = [];
+    if (flags.type)
+      queryParts.push(`media_type:${flags.type.toUpperCase()}`);
+    const variables = {
+      first: limit,
+      query: queryParts.length > 0 ? queryParts.join(" ") : undefined
+    };
+    if (flags.cursor) {
+      variables.after = flags.cursor;
+    }
+    const result = await client.query(FILES_QUERY, variables);
+    const files = result.files.edges.map((e) => {
+      const url = extractUrl(e.node);
+      const mediaType = e.node.mediaContentType ?? e.node.mimeType ?? "";
+      const fileSize = e.node.originalSource?.fileSize ?? (e.node.originalFileSize != null ? String(e.node.originalFileSize) : "");
+      return {
+        id: e.node.id,
+        filename: extractFilename(url),
+        url,
+        alt: e.node.alt ?? "",
+        mediaType,
+        fileSize,
+        createdAt: e.node.createdAt
+      };
+    });
+    const pageInfo = result.files.pageInfo;
+    if (flags.json) {
+      formatOutput(files, [], { json: true, noColor: flags.noColor, pageInfo });
+      return;
+    }
+    const columns = [
+      { key: "id", header: "ID" },
+      { key: "filename", header: "Filename" },
+      { key: "url", header: "URL" },
+      { key: "alt", header: "Alt" },
+      { key: "mediaType", header: "Type" },
+      { key: "fileSize", header: "Size" },
+      { key: "createdAt", header: "Created" }
+    ];
+    formatOutput(files, columns, {
+      json: false,
+      noColor: flags.noColor,
+      pageInfo
+    });
+  } catch (err) {
+    handleCommandError(err);
+  }
+}
+register("file", "File management", "list", {
+  description: "List store files with filtering and pagination",
+  handler: handleFileList
+});
+
+// src/commands/page.ts
+var PAGE_CREATE_MUTATION = `mutation PageCreate($page: PageCreateInput!) {
+  pageCreate(page: $page) {
+    page { id handle }
+    userErrors { field message }
+  }
+}`;
+async function handlePageCreate(parsed) {
+  const { flags } = parsed;
+  if (!flags.title) {
+    formatError("Missing required flag: --title");
+    process.exitCode = 2;
+    return;
+  }
+  if (flags.body && flags["body-file"]) {
+    formatError("--body and --body-file are mutually exclusive; provide only one");
+    process.exitCode = 2;
+    return;
+  }
+  try {
+    const client = getClient(flags);
+    const page = {
+      title: flags.title,
+      isPublished: flags.published === "true"
+    };
+    if (flags.handle)
+      page.handle = flags.handle;
+    if (flags.body) {
+      page.body = flags.body;
+    } else if (flags["body-file"]) {
+      const bodyContent = await readFileText(flags["body-file"]);
+      if (bodyContent === null)
+        return;
+      page.body = bodyContent;
+    }
+    const metafields = [];
+    if (flags["seo-title"]) {
+      metafields.push({
+        namespace: "global",
+        key: "title_tag",
+        type: "single_line_text_field",
+        value: flags["seo-title"]
+      });
+    }
+    if (flags["seo-desc"]) {
+      metafields.push({
+        namespace: "global",
+        key: "description_tag",
+        type: "single_line_text_field",
+        value: flags["seo-desc"]
+      });
+    }
+    if (metafields.length > 0) {
+      page.metafields = metafields;
+    }
+    const result = await client.query(PAGE_CREATE_MUTATION, { page });
+    if (result.pageCreate.userErrors.length > 0) {
+      formatError(result.pageCreate.userErrors.map((e) => e.message).join("; "));
+      process.exitCode = 1;
+      return;
+    }
+    const created = result.pageCreate.page;
+    const data = { id: created.id, handle: created.handle };
+    if (flags.json) {
+      formatOutput(data, [], { json: true, noColor: flags.noColor });
+    } else {
+      process.stdout.write(`Created page: ${created.handle} (${created.id})
+`);
+    }
+  } catch (err) {
+    handleCommandError(err);
+  }
+}
+var PAGES_QUERY = `query PageList($first: Int!, $after: String) {
+  pages(first: $first, after: $after) {
+    edges {
+      node {
+        id
+        title
+        handle
+        isPublished
+        bodySummary
+        createdAt
+        metafields(first: 10, namespace: "global") {
+          edges {
+            node {
+              namespace
+              key
+              value
+            }
+          }
+        }
+      }
+    }
+    pageInfo {
+      hasNextPage
+      endCursor
+    }
+  }
+}`;
+function extractSeo(metafields) {
+  let title = null;
+  let description = null;
+  for (const { node } of metafields.edges) {
+    if (node.namespace === "global" && node.key === "title_tag")
+      title = node.value;
+    if (node.namespace === "global" && node.key === "description_tag")
+      description = node.value;
+  }
+  return { title, description };
+}
+async function handlePageList(parsed) {
+  try {
+    const client = getClient(parsed.flags);
+    const limit = clampLimit(parsed.flags.limit);
+    const variables = { first: limit };
+    if (parsed.flags.cursor)
+      variables.after = parsed.flags.cursor;
+    const result = await client.query(PAGES_QUERY, variables);
+    const pages = result.pages.edges.map((e) => {
+      const seo = extractSeo(e.node.metafields);
+      return {
+        id: e.node.id,
+        title: e.node.title,
+        handle: e.node.handle,
+        published: e.node.isPublished,
+        bodySummary: e.node.bodySummary,
+        seo,
+        createdAt: e.node.createdAt
+      };
+    });
+    const pageInfo = result.pages.pageInfo;
+    if (parsed.flags.json) {
+      formatOutput(pages, [], {
+        json: true,
+        noColor: parsed.flags.noColor,
+        pageInfo
+      });
+      return;
+    }
+    const columns = [
+      { key: "id", header: "ID" },
+      { key: "title", header: "Title" },
+      { key: "handle", header: "Handle" },
+      { key: "published", header: "Published" },
+      { key: "seoTitle", header: "SEO Title" },
+      { key: "createdAt", header: "Created" }
+    ];
+    const tableData = pages.map((p) => ({
+      ...p,
+      seoTitle: p.seo.title ?? ""
+    }));
+    formatOutput(tableData, columns, {
+      json: false,
+      noColor: parsed.flags.noColor,
+      pageInfo
+    });
+  } catch (err) {
+    handleCommandError(err);
+  }
+}
+var PAGE_FIELDS = `
+    id
+    title
+    handle
+    isPublished
+    body
+    createdAt
+    updatedAt
+    metafields(first: 10, namespace: "global") {
+      edges {
+        node {
+          namespace
+          key
+          value
+        }
+      }
+    }`;
+var PAGE_GET_BY_ID_QUERY = `query PageGetById($id: ID!) {
+  page(id: $id) {
+    ${PAGE_FIELDS}
+  }
+}`;
+var PAGE_GET_BY_HANDLE_QUERY = `query PageGetByHandle($query: String!) {
+  pages(first: 1, query: $query) {
+    edges {
+      node {
+        ${PAGE_FIELDS}
+      }
+    }
+  }
+}`;
+function resolvePageId(input) {
+  if (input.startsWith("gid://")) {
+    return { type: "gid", id: input };
+  }
+  if (/^\d+$/.test(input)) {
+    return { type: "gid", id: `gid://shopify/Page/${input}` };
+  }
+  return { type: "handle", handle: input };
+}
+async function handlePageGet(parsed) {
+  const idOrHandle = parsed.args.join(" ");
+  if (!idOrHandle) {
+    formatError("Usage: shopctl page get <id-or-handle>");
+    process.exitCode = 2;
+    return;
+  }
+  try {
+    const client = getClient(parsed.flags);
+    const resolved = resolvePageId(idOrHandle);
+    let page = null;
+    if (resolved.type === "gid") {
+      const result = await client.query(PAGE_GET_BY_ID_QUERY, { id: resolved.id });
+      page = result.page;
+    } else {
+      const result = await client.query(PAGE_GET_BY_HANDLE_QUERY, { query: `handle:${resolved.handle}` });
+      page = result.pages.edges[0]?.node ?? null;
+    }
+    if (!page) {
+      formatError(`Page "${idOrHandle}" not found`);
+      process.exitCode = 1;
+      return;
+    }
+    const seo = extractSeo(page.metafields);
+    if (parsed.flags.json) {
+      const data = {
+        id: page.id,
+        title: page.title,
+        handle: page.handle,
+        published: page.isPublished,
+        body: page.body,
+        seo,
+        createdAt: page.createdAt,
+        updatedAt: page.updatedAt
+      };
+      formatOutput(data, [], { json: true, noColor: parsed.flags.noColor });
+      return;
+    }
+    const label = (name) => parsed.flags.noColor ? name : `\x1B[1m${name}\x1B[0m`;
+    const lines = [];
+    lines.push(`${label("ID")}: ${page.id}`);
+    lines.push(`${label("Title")}: ${page.title}`);
+    lines.push(`${label("Handle")}: ${page.handle}`);
+    lines.push(`${label("Published")}: ${page.isPublished}`);
+    lines.push(`${label("SEO Title")}: ${seo.title ?? ""}`);
+    lines.push(`${label("SEO Description")}: ${seo.description ?? ""}`);
+    lines.push(`${label("Created")}: ${page.createdAt}`);
+    lines.push(`${label("Updated")}: ${page.updatedAt}`);
+    lines.push("");
+    lines.push(`${label("Body")}:`);
+    lines.push(page.body);
+    process.stdout.write(`${lines.join(`
+`)}
+`);
+  } catch (err) {
+    handleCommandError(err);
+  }
+}
+register("page", "Page management", "get", {
+  description: "Get a single page by handle",
+  handler: handlePageGet
+});
+register("page", "Page management", "list", {
+  description: "List static store pages",
+  handler: handlePageList
+});
+register("page", "Page management", "create", {
+  description: "Create a static store page",
+  handler: handlePageCreate
+});
+var PAGE_LOOKUP_QUERY = `query PageLookup($query: String!) {
+  pages(first: 1, query: $query) {
+    edges {
+      node { id }
+    }
+  }
+}`;
+var PAGE_UPDATE_MUTATION = `mutation PageUpdate($id: ID!, $page: PageUpdateInput!) {
+  pageUpdate(id: $id, page: $page) {
+    page { id }
+    userErrors { field message }
+  }
+}`;
+async function handlePageUpdate(parsed) {
+  const { flags } = parsed;
+  const handle = parsed.args.join(" ");
+  if (!handle) {
+    formatError("Usage: shopctl page update <handle>");
+    process.exitCode = 2;
+    return;
+  }
+  if (flags.body && flags["body-file"]) {
+    formatError("--body and --body-file are mutually exclusive; provide only one");
+    process.exitCode = 2;
+    return;
+  }
+  const page = {};
+  const updatedFields = [];
+  if (flags.title) {
+    page.title = flags.title;
+    updatedFields.push("title");
+  }
+  if (flags.body) {
+    page.body = flags.body;
+    updatedFields.push("body");
+  } else if (flags["body-file"]) {
+    const bodyContent = await readFileText(flags["body-file"]);
+    if (bodyContent === null)
+      return;
+    page.body = bodyContent;
+    updatedFields.push("body");
+  }
+  const metafields = [];
+  if (flags["seo-title"]) {
+    metafields.push({
+      namespace: "global",
+      key: "title_tag",
+      type: "single_line_text_field",
+      value: flags["seo-title"]
+    });
+    updatedFields.push("seo_title");
+  }
+  if (flags["seo-desc"]) {
+    metafields.push({
+      namespace: "global",
+      key: "description_tag",
+      type: "single_line_text_field",
+      value: flags["seo-desc"]
+    });
+    updatedFields.push("seo_desc");
+  }
+  if (metafields.length > 0) {
+    page.metafields = metafields;
+  }
+  if (updatedFields.length === 0) {
+    formatError("No update flags provided; at least one of --title, --body, --body-file, --seo-title, --seo-desc is required");
+    process.exitCode = 2;
+    return;
+  }
+  try {
+    const client = getClient(flags);
+    const lookup = await client.query(PAGE_LOOKUP_QUERY, { query: `handle:${handle}` });
+    const foundPage = lookup.pages.edges[0]?.node;
+    if (!foundPage) {
+      formatError(`Page "${handle}" not found`);
+      process.exitCode = 1;
+      return;
+    }
+    const pageId = foundPage.id;
+    const result = await client.query(PAGE_UPDATE_MUTATION, { id: pageId, page });
+    if (result.pageUpdate.userErrors.length > 0) {
+      formatError(result.pageUpdate.userErrors.map((e) => e.message).join("; "));
+      process.exitCode = 1;
+      return;
+    }
+    if (flags.json) {
+      formatOutput(updatedFields, [], { json: true, noColor: flags.noColor });
+    } else {
+      process.stdout.write(`Updated fields: ${updatedFields.join(", ")}
+`);
+    }
+  } catch (err) {
+    handleCommandError(err);
+  }
+}
+register("page", "Page management", "update", {
+  description: "Update a static store page",
+  handler: handlePageUpdate
+});
+var PAGE_SUMMARY_BY_ID_QUERY = `query PageSummary($id: ID!) {
+  page(id: $id) {
+    id
+    title
+  }
+}`;
+var PAGE_SUMMARY_BY_HANDLE_QUERY = `query PageSummaryByHandle($query: String!) {
+  pages(first: 1, query: $query) {
+    edges {
+      node {
+        id
+        title
+      }
+    }
+  }
+}`;
+var PAGE_DELETE_MUTATION = `mutation PageDelete($id: ID!) {
+  pageDelete(id: $id) {
+    deletedPageId
+    userErrors { field message }
+  }
+}`;
+async function handlePageDelete(parsed) {
+  const idOrHandle = parsed.args.join(" ");
+  if (!idOrHandle) {
+    formatError("Usage: shopctl page delete <id-or-handle> [--yes]");
+    process.exitCode = 2;
+    return;
+  }
+  try {
+    const client = getClient(parsed.flags);
+    const resolved = resolvePageId(idOrHandle);
+    let pageGid;
+    let pageTitle;
+    if (resolved.type === "gid") {
+      const result2 = await client.query(PAGE_SUMMARY_BY_ID_QUERY, { id: resolved.id });
+      if (!result2.page) {
+        formatError(`Page "${idOrHandle}" not found`);
+        process.exitCode = 1;
+        return;
+      }
+      pageGid = result2.page.id;
+      pageTitle = result2.page.title;
+    } else {
+      const result2 = await client.query(PAGE_SUMMARY_BY_HANDLE_QUERY, { query: `handle:${resolved.handle}` });
+      const found = result2.pages.edges[0]?.node;
+      if (!found) {
+        formatError(`Page "${idOrHandle}" not found`);
+        process.exitCode = 1;
+        return;
+      }
+      pageGid = found.id;
+      pageTitle = found.title;
+    }
+    if (!parsed.flags.yes) {
+      const data2 = { id: pageGid, title: pageTitle };
+      if (parsed.flags.json) {
+        formatOutput(data2, [], { json: true, noColor: parsed.flags.noColor });
+      } else {
+        process.stdout.write(`Would delete page: ${pageTitle} (${pageGid})
+`);
+      }
+      return;
+    }
+    const result = await client.query(PAGE_DELETE_MUTATION, { id: pageGid });
+    if (result.pageDelete.userErrors.length > 0) {
+      formatError(result.pageDelete.userErrors.map((e) => e.message).join("; "));
+      process.exitCode = 1;
+      return;
+    }
+    const data = { id: pageGid, title: pageTitle };
+    if (parsed.flags.json) {
+      formatOutput(data, [], { json: true, noColor: parsed.flags.noColor });
+    } else {
+      process.stdout.write(`Deleted page: ${pageTitle} (${pageGid})
+`);
+    }
+  } catch (err) {
+    handleCommandError(err);
+  }
+}
+register("page", "Page management", "delete", {
+  description: "Delete a page by ID or handle",
+  handler: handlePageDelete
+});
+
+// src/commands/collection.ts
+var COLLECTION_GET_BY_ID_QUERY = `query CollectionGet($id: ID!) {
+  collection(id: $id) {
+    id
+    title
+    handle
+    descriptionHtml
+    productsCount { count precision }
+    image { url altText }
+    seo { title description }
+  }
+}`;
+var COLLECTION_GET_BY_HANDLE_QUERY = `query CollectionGetByHandle($handle: String!) {
+  collectionByHandle(handle: $handle) {
+    id
+    title
+    handle
+    descriptionHtml
+    productsCount { count precision }
+    image { url altText }
+    seo { title description }
+  }
+}`;
+function resolveCollectionInput(input) {
+  if (input.startsWith("gid://")) {
+    return { type: "gid", id: input };
+  }
+  if (/^\d+$/.test(input)) {
+    return { type: "gid", id: `gid://shopify/Collection/${input}` };
+  }
+  return { type: "handle", handle: input };
+}
+function stripHtml2(html) {
+  return html.replace(/<[^>]*>/g, "").trim();
+}
+function truncate2(str, max) {
+  if (str.length <= max)
+    return str;
+  return `${str.slice(0, max - 3)}...`;
+}
+async function handleCollectionGet(parsed) {
+  const idOrHandle = parsed.args.join(" ");
+  if (!idOrHandle) {
+    formatError("Usage: shopctl collection get <id-or-handle>");
+    process.exitCode = 2;
+    return;
+  }
+  try {
+    const client = getClient(parsed.flags);
+    const resolved = resolveCollectionInput(idOrHandle);
+    let collection = null;
+    if (resolved.type === "gid") {
+      const result = await client.query(COLLECTION_GET_BY_ID_QUERY, { id: resolved.id });
+      collection = result.collection;
+    } else {
+      const result = await client.query(COLLECTION_GET_BY_HANDLE_QUERY, { handle: resolved.handle });
+      collection = result.collectionByHandle;
+    }
+    if (!collection) {
+      formatError(`Collection "${idOrHandle}" not found`);
+      process.exitCode = 1;
+      return;
+    }
+    if (parsed.flags.json) {
+      const data = {
+        id: collection.id,
+        title: collection.title,
+        handle: collection.handle,
+        description: stripHtml2(collection.descriptionHtml),
+        productsCount: collection.productsCount,
+        image: collection.image ? { url: collection.image.url, alt: collection.image.altText ?? "" } : null,
+        seo: collection.seo
+      };
+      formatOutput(data, [], { json: true, noColor: parsed.flags.noColor });
+      return;
+    }
+    const label = (name) => parsed.flags.noColor ? name : `\x1B[1m${name}\x1B[0m`;
+    const lines = [];
+    lines.push(`${label("ID")}: ${collection.id}`);
+    lines.push(`${label("Title")}: ${collection.title}`);
+    lines.push(`${label("Handle")}: ${collection.handle}`);
+    lines.push(`${label("Products Count")}: ${collection.productsCount.count}`);
+    lines.push(`${label("Description")}: ${truncate2(stripHtml2(collection.descriptionHtml), 80)}`);
+    if (collection.image) {
+      lines.push(`${label("Image")}: ${collection.image.url}${collection.image.altText ? ` (${collection.image.altText})` : ""}`);
+    }
+    lines.push(`${label("SEO Title")}: ${collection.seo.title}`);
+    lines.push(`${label("SEO Description")}: ${collection.seo.description}`);
+    process.stdout.write(`${lines.join(`
+`)}
+`);
+  } catch (err) {
+    handleCommandError(err);
+  }
+}
+var COLLECTIONS_QUERY = `query CollectionList($first: Int!, $after: String) {
+  collections(first: $first, after: $after) {
+    edges {
+      node {
+        id
+        title
+        handle
+        descriptionHtml
+        productsCount { count precision }
+        image { url altText }
+        seo { title description }
+      }
+    }
+    pageInfo { hasNextPage endCursor }
+  }
+}`;
+async function handleCollectionList(parsed) {
+  try {
+    const client = getClient(parsed.flags);
+    const limit = clampLimit(parsed.flags.limit);
+    const variables = { first: limit };
+    if (parsed.flags.cursor) {
+      variables.after = parsed.flags.cursor;
+    }
+    const result = await client.query(COLLECTIONS_QUERY, variables);
+    const collections = result.collections.edges.map((e) => ({
+      id: e.node.id,
+      title: e.node.title,
+      handle: e.node.handle,
+      description: stripHtml2(e.node.descriptionHtml),
+      productsCount: parsed.flags.json ? e.node.productsCount : e.node.productsCount.count,
+      image: e.node.image ? { url: e.node.image.url, alt: e.node.image.altText ?? "" } : null,
+      seo: e.node.seo
+    }));
+    const pageInfo = result.collections.pageInfo;
+    if (parsed.flags.json) {
+      formatOutput(collections, [], {
+        json: true,
+        noColor: parsed.flags.noColor,
+        pageInfo
+      });
+      return;
+    }
+    const columns = [
+      { key: "id", header: "ID" },
+      { key: "title", header: "Title" },
+      { key: "handle", header: "Handle" },
+      { key: "productsCount", header: "Products" },
+      { key: "image", header: "Image", format: (v) => v ? "Yes" : "No" },
+      { key: "description", header: "Description" }
+    ];
+    formatOutput(collections, columns, {
+      json: false,
+      noColor: parsed.flags.noColor,
+      pageInfo
+    });
+  } catch (err) {
+    handleCommandError(err);
+  }
+}
+register("collection", "Collection management", "list", {
+  description: "List collections with pagination",
+  handler: handleCollectionList
+});
+register("collection", "Collection management", "get", {
+  description: "Get a single collection by ID or handle",
+  handler: handleCollectionGet
+});
+
+// src/commands/theme.ts
+var THEMES_LIST_QUERY = `query ThemeList {
+  themes(first: 250) {
+    edges {
+      node {
+        id
+        name
+        role
+        createdAt
+        updatedAt
+      }
+    }
+  }
+}`;
+function extractNumericId(gid) {
+  const match = gid.match(/(\d+)$/);
+  return match ? match[1] : gid;
+}
+async function handleThemeList(parsed) {
+  try {
+    const client = getClient(parsed.flags);
+    const result = await client.query(THEMES_LIST_QUERY, {});
+    const themes = result.themes.edges.map((e) => e.node);
+    if (parsed.flags.json) {
+      const data = themes.map((t) => ({
+        id: t.id,
+        numericId: extractNumericId(t.id),
+        name: t.name,
+        role: t.role,
+        createdAt: t.createdAt,
+        updatedAt: t.updatedAt
+      }));
+      formatOutput(data, [], { json: true, noColor: parsed.flags.noColor });
+      return;
+    }
+    const label = (name) => parsed.flags.noColor ? name : `\x1B[1m${name}\x1B[0m`;
+    const lines = [];
+    for (let i = 0;i < themes.length; i++) {
+      const theme = themes[i];
+      if (i > 0)
+        lines.push("");
+      lines.push(`${label("ID")}: ${theme.id}`);
+      lines.push(`${label("Numeric ID")}: ${extractNumericId(theme.id)}`);
+      lines.push(`${label("Name")}: ${theme.name}`);
+      lines.push(`${label("Role")}: ${theme.role}`);
+      lines.push(`${label("Created")}: ${theme.createdAt}`);
+      lines.push(`${label("Updated")}: ${theme.updatedAt}`);
+    }
+    process.stdout.write(`${lines.join(`
+`)}
+`);
+  } catch (err) {
+    handleCommandError(err);
+  }
+}
+register("theme", "Theme management", "list", {
+  description: "List all themes",
+  handler: handleThemeList
+});
+
+// src/cli.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+
+// src/help.ts
+function topLevelHelp() {
+  const lines = [
+    "Usage: shopctl <resource> <verb> [args] [flags]",
+    "",
+    "Global Flags:",
+    "  --json, -j       Output as JSON",
+    "  --help, -h       Show help",
+    "  --version, -v    Print version",
+    "  --store <url>    Store override",
+    "  --no-color       Disable colored output (also respects NO_COLOR env)",
+    ""
+  ];
+  const resources2 = getAllResources();
+  if (resources2.size > 0) {
+    lines.push("Resources:");
+    for (const [name, res] of resources2) {
+      lines.push(`  ${name.padEnd(16)} ${res.description}`);
+    }
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+function resourceHelp(resourceName) {
+  const resource = getResource(resourceName);
+  if (!resource)
+    return;
+  const lines = [
+    `Usage: shopctl ${resourceName} <verb> [args] [flags]`,
+    "",
+    `${resource.description}`,
+    "",
+    "Verbs:"
+  ];
+  for (const [verb, cmd] of resource.verbs) {
+    lines.push(`  ${verb.padEnd(16)} ${cmd.description}`);
+  }
+  lines.push("");
+  return lines.join(`
+`);
+}
+
+// src/parse.ts
+function parseArgs(argv) {
+  const flags = {
+    json: false,
+    help: false,
+    version: false,
+    noColor: "NO_COLOR" in process.env
+  };
+  const positional = [];
+  let i = 0;
+  while (i < argv.length) {
+    const arg = argv[i];
+    if (arg === "--version" || arg === "-v") {
+      flags.version = true;
+    } else if (arg === "--help" || arg === "-h") {
+      flags.help = true;
+    } else if (arg === "--json" || arg === "-j") {
+      flags.json = true;
+    } else if (arg === "--no-color") {
+      flags.noColor = true;
+    } else if (arg === "--store") {
+      i++;
+      flags.store = argv[i];
+    } else if (arg?.startsWith("--store=")) {
+      flags.store = arg.slice("--store=".length);
+    } else if (arg === "--vars") {
+      i++;
+      flags.vars = argv[i];
+    } else if (arg?.startsWith("--vars=")) {
+      flags.vars = arg.slice("--vars=".length);
+    } else if (arg === "--file") {
+      i++;
+      flags.file = argv[i];
+    } else if (arg?.startsWith("--file=")) {
+      flags.file = arg.slice("--file=".length);
+    } else if (arg === "--status") {
+      i++;
+      flags.status = argv[i];
+    } else if (arg?.startsWith("--status=")) {
+      flags.status = arg.slice("--status=".length);
+    } else if (arg === "--type") {
+      i++;
+      flags.type = argv[i];
+    } else if (arg?.startsWith("--type=")) {
+      flags.type = arg.slice("--type=".length);
+    } else if (arg === "--vendor") {
+      i++;
+      flags.vendor = argv[i];
+    } else if (arg?.startsWith("--vendor=")) {
+      flags.vendor = arg.slice("--vendor=".length);
+    } else if (arg === "--limit") {
+      i++;
+      flags.limit = argv[i];
+    } else if (arg?.startsWith("--limit=")) {
+      flags.limit = arg.slice("--limit=".length);
+    } else if (arg === "--cursor") {
+      i++;
+      flags.cursor = argv[i];
+    } else if (arg?.startsWith("--cursor=")) {
+      flags.cursor = arg.slice("--cursor=".length);
+    } else if (arg === "--title") {
+      i++;
+      flags.title = argv[i];
+    } else if (arg?.startsWith("--title=")) {
+      flags.title = arg.slice("--title=".length);
+    } else if (arg === "--handle") {
+      i++;
+      flags.handle = argv[i];
+    } else if (arg?.startsWith("--handle=")) {
+      flags.handle = arg.slice("--handle=".length);
+    } else if (arg === "--tags") {
+      i++;
+      flags.tags = argv[i];
+    } else if (arg?.startsWith("--tags=")) {
+      flags.tags = arg.slice("--tags=".length);
+    } else if (arg === "--description") {
+      i++;
+      flags.description = argv[i];
+    } else if (arg?.startsWith("--description=")) {
+      flags.description = arg.slice("--description=".length);
+    } else if (arg === "--variants") {
+      i++;
+      flags.variants = argv[i];
+    } else if (arg?.startsWith("--variants=")) {
+      flags.variants = arg.slice("--variants=".length);
+    } else if (arg === "--options") {
+      i++;
+      flags.options = argv[i];
+    } else if (arg?.startsWith("--options=")) {
+      flags.options = arg.slice("--options=".length);
+    } else if (arg === "--body") {
+      i++;
+      flags.body = argv[i];
+    } else if (arg?.startsWith("--body=")) {
+      flags.body = arg.slice("--body=".length);
+    } else if (arg === "--body-file") {
+      i++;
+      flags["body-file"] = argv[i];
+    } else if (arg?.startsWith("--body-file=")) {
+      flags["body-file"] = arg.slice("--body-file=".length);
+    } else if (arg === "--published") {
+      i++;
+      flags.published = argv[i];
+    } else if (arg?.startsWith("--published=")) {
+      flags.published = arg.slice("--published=".length);
+    } else if (arg === "--seo-title") {
+      i++;
+      flags["seo-title"] = argv[i];
+    } else if (arg?.startsWith("--seo-title=")) {
+      flags["seo-title"] = arg.slice("--seo-title=".length);
+    } else if (arg === "--seo-desc") {
+      i++;
+      flags["seo-desc"] = argv[i];
+    } else if (arg?.startsWith("--seo-desc=")) {
+      flags["seo-desc"] = arg.slice("--seo-desc=".length);
+    } else if (arg === "--yes" || arg === "-y") {
+      flags.yes = true;
+    } else if (arg) {
+      positional.push(arg);
+    }
+    i++;
+  }
+  return {
+    resource: positional[0],
+    verb: positional[1],
+    args: positional.slice(2),
+    flags
+  };
+}
+
+// src/cli.ts
+var pkgPath = new URL("../package.json", import.meta.url).pathname;
+var pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+async function run(argv) {
+  const parsed = parseArgs(argv);
+  if (parsed.flags.version) {
+    console.log(pkg.version);
+    return;
+  }
+  if (!parsed.resource || parsed.flags.help && !parsed.resource) {
+    console.log(topLevelHelp());
+    return;
+  }
+  const resource = getResource(parsed.resource);
+  if (parsed.flags.help && parsed.resource) {
+    const help = resourceHelp(parsed.resource);
+    if (help) {
+      console.log(help);
+      return;
+    }
+    process.stderr.write(`Error: unknown resource "${parsed.resource}"
+`);
+    process.exitCode = 2;
+    return;
+  }
+  if (!resource) {
+    process.stderr.write(`Error: unknown resource "${parsed.resource}"
+`);
+    process.exitCode = 2;
+    return;
+  }
+  if (!parsed.verb) {
+    const defaultCommand2 = resource.verbs.get("_default");
+    if (defaultCommand2) {
+      await defaultCommand2.handler(parsed);
+      return;
+    }
+    const help = resourceHelp(parsed.resource);
+    if (help)
+      console.log(help);
+    return;
+  }
+  const defaultCommand = resource.verbs.get("_default");
+  if (defaultCommand) {
+    parsed.args = [parsed.verb, ...parsed.args];
+    parsed.verb = undefined;
+    await defaultCommand.handler(parsed);
+    return;
+  }
+  const command = resource.verbs.get(parsed.verb);
+  if (!command) {
+    process.stderr.write(`Error: unknown verb "${parsed.verb}" for resource "${parsed.resource}"
+`);
+    process.exitCode = 2;
+    return;
+  }
+  await command.handler(parsed);
+}
+
+// bin/shopctl.ts
+await run(process.argv.slice(2));