@anton.andrusenko/shopify-mcp-admin 0.6.0 → 0.8.0

package/dist/index.js

@@ -917,9 +917,351 @@ var PRODUCTS_QUERY = `
     }
   }
 `;
+var STORE_LIMITS_QUERY = `
+  query ShopResourceLimits {
+    shop {
+      resourceLimits {
+        maxProductVariants
+        maxProductOptions
+        locationLimit
+        redirectLimitReached
+      }
+    }
+  }
+`;
+var STORE_FEATURES_QUERY = `
+  query ShopFeatures {
+    shop {
+      features {
+        giftCards
+        reports
+        storefront
+        bundles {
+          eligibleForBundles
+        }
+        sellsSubscriptions
+      }
+    }
+  }
+`;
+var STORE_CURRENCIES_QUERY = `
+  query ShopCurrencies {
+    shop {
+      currencyCode
+      enabledPresentmentCurrencies
+      currencyFormats {
+        moneyFormat
+        moneyWithCurrencyFormat
+      }
+    }
+  }
+`;
+var STORE_SHIPPING_QUERY = `
+  query ShopShipping {
+    shop {
+      shipsToCountries
+      countriesInShippingZones {
+        countryCodes
+      }
+    }
+  }
+`;
+var STORE_DOMAIN_QUERY = `
+  query ShopDomain {
+    shop {
+      primaryDomain {
+        host
+        url
+        sslEnabled
+      }
+    }
+  }
+`;
+var STORE_TAXES_QUERY = `
+  query ShopTaxes {
+    shop {
+      taxesIncluded
+      taxShipping
+    }
+  }
+`;
+var STORE_POLICIES_QUERY = `
+  query ShopPolicies {
+    shop {
+      shopPolicies {
+        title
+        type
+        url
+      }
+    }
+  }
+`;
+var STORE_ALERTS_QUERY = `
+  query ShopAlerts {
+    shop {
+      alerts {
+        action {
+          title
+          url
+        }
+        description
+      }
+      setupRequired
+    }
+  }
+`;
 
-// src/shopify/store-info.ts
+// src/shopify/store-info-extended.ts
 var DEFAULT_CACHE_TTL_MS = 5 * 60 * 1e3;
+var ALERTS_CACHE_TTL_MS = 60 * 1e3;
+var _cachedStoreLimits = null;
+var _limitsTimestamp = 0;
+var _cachedStoreFeatures = null;
+var _featuresTimestamp = 0;
+var _cachedStoreCurrencies = null;
+var _currenciesTimestamp = 0;
+var _cachedStoreShipping = null;
+var _shippingTimestamp = 0;
+var _cachedStoreDomain = null;
+var _domainTimestamp = 0;
+var _cachedStoreTaxes = null;
+var _taxesTimestamp = 0;
+var _cachedStorePolicies = null;
+var _policiesTimestamp = 0;
+var _cachedStoreAlerts = null;
+var _alertsTimestamp = 0;
+async function getStoreLimits() {
+  const now = Date.now();
+  const config = getConfig();
+  const ttl = config.STORE_INFO_CACHE_TTL_MS ?? DEFAULT_CACHE_TTL_MS;
+  if (_cachedStoreLimits && now - _limitsTimestamp < ttl) {
+    log.debug("Returning cached store limits");
+    return _cachedStoreLimits;
+  }
+  log.debug("Fetching fresh store limits from Shopify");
+  const client = await getShopifyClient();
+  const response = await withRateLimit(
+    () => client.graphql.request(STORE_LIMITS_QUERY),
+    "getStoreLimits"
+  );
+  if (response.errors && response.errors.length > 0) {
+    const errorMessages = response.errors.map((e) => e.message).join(", ");
+    throw new Error(`GraphQL errors: ${errorMessages}`);
+  }
+  if (!response.data?.shop?.resourceLimits) {
+    throw new Error("Invalid response: missing shop.resourceLimits data");
+  }
+  _cachedStoreLimits = response.data.shop.resourceLimits;
+  _limitsTimestamp = now;
+  return _cachedStoreLimits;
+}
+async function getStoreFeatures() {
+  const now = Date.now();
+  const config = getConfig();
+  const ttl = config.STORE_INFO_CACHE_TTL_MS ?? DEFAULT_CACHE_TTL_MS;
+  if (_cachedStoreFeatures && now - _featuresTimestamp < ttl) {
+    log.debug("Returning cached store features");
+    return _cachedStoreFeatures;
+  }
+  log.debug("Fetching fresh store features from Shopify");
+  const client = await getShopifyClient();
+  const response = await withRateLimit(
+    () => client.graphql.request(STORE_FEATURES_QUERY),
+    "getStoreFeatures"
+  );
+  if (response.errors && response.errors.length > 0) {
+    const errorMessages = response.errors.map((e) => e.message).join(", ");
+    throw new Error(`GraphQL errors: ${errorMessages}`);
+  }
+  if (!response.data?.shop?.features) {
+    throw new Error("Invalid response: missing shop.features data");
+  }
+  _cachedStoreFeatures = response.data.shop.features;
+  _featuresTimestamp = now;
+  return _cachedStoreFeatures;
+}
+async function getStoreCurrencies() {
+  const now = Date.now();
+  const config = getConfig();
+  const ttl = config.STORE_INFO_CACHE_TTL_MS ?? DEFAULT_CACHE_TTL_MS;
+  if (_cachedStoreCurrencies && now - _currenciesTimestamp < ttl) {
+    log.debug("Returning cached store currencies");
+    return _cachedStoreCurrencies;
+  }
+  log.debug("Fetching fresh store currencies from Shopify");
+  const client = await getShopifyClient();
+  const response = await withRateLimit(
+    () => client.graphql.request(STORE_CURRENCIES_QUERY),
+    "getStoreCurrencies"
+  );
+  if (response.errors && response.errors.length > 0) {
+    const errorMessages = response.errors.map((e) => e.message).join(", ");
+    throw new Error(`GraphQL errors: ${errorMessages}`);
+  }
+  if (!response.data?.shop) {
+    throw new Error("Invalid response: missing shop data");
+  }
+  const { currencyCode, enabledPresentmentCurrencies, currencyFormats } = response.data.shop;
+  _cachedStoreCurrencies = {
+    currencyCode,
+    enabledPresentmentCurrencies,
+    currencyFormats
+  };
+  _currenciesTimestamp = now;
+  return _cachedStoreCurrencies;
+}
+async function getStoreShipping() {
+  const now = Date.now();
+  const config = getConfig();
+  const ttl = config.STORE_INFO_CACHE_TTL_MS ?? DEFAULT_CACHE_TTL_MS;
+  if (_cachedStoreShipping && now - _shippingTimestamp < ttl) {
+    log.debug("Returning cached store shipping");
+    return _cachedStoreShipping;
+  }
+  log.debug("Fetching fresh store shipping from Shopify");
+  const client = await getShopifyClient();
+  const response = await withRateLimit(
+    () => client.graphql.request(STORE_SHIPPING_QUERY),
+    "getStoreShipping"
+  );
+  if (response.errors && response.errors.length > 0) {
+    const errorMessages = response.errors.map((e) => e.message).join(", ");
+    throw new Error(`GraphQL errors: ${errorMessages}`);
+  }
+  if (!response.data?.shop) {
+    throw new Error("Invalid response: missing shop data");
+  }
+  _cachedStoreShipping = {
+    shipsToCountries: response.data.shop.shipsToCountries,
+    countriesInShippingZones: response.data.shop.countriesInShippingZones
+  };
+  _shippingTimestamp = now;
+  return _cachedStoreShipping;
+}
+async function getStoreDomain() {
+  const now = Date.now();
+  const config = getConfig();
+  const ttl = config.STORE_INFO_CACHE_TTL_MS ?? DEFAULT_CACHE_TTL_MS;
+  if (_cachedStoreDomain && now - _domainTimestamp < ttl) {
+    log.debug("Returning cached store domain");
+    return _cachedStoreDomain;
+  }
+  log.debug("Fetching fresh store domain from Shopify");
+  const client = await getShopifyClient();
+  const response = await withRateLimit(
+    () => client.graphql.request(STORE_DOMAIN_QUERY),
+    "getStoreDomain"
+  );
+  if (response.errors && response.errors.length > 0) {
+    const errorMessages = response.errors.map((e) => e.message).join(", ");
+    throw new Error(`GraphQL errors: ${errorMessages}`);
+  }
+  if (!response.data?.shop?.primaryDomain) {
+    throw new Error("Invalid response: missing shop.primaryDomain data");
+  }
+  _cachedStoreDomain = {
+    primaryDomain: response.data.shop.primaryDomain
+  };
+  _domainTimestamp = now;
+  return _cachedStoreDomain;
+}
+async function getStoreTaxes() {
+  const now = Date.now();
+  const config = getConfig();
+  const ttl = config.STORE_INFO_CACHE_TTL_MS ?? DEFAULT_CACHE_TTL_MS;
+  if (_cachedStoreTaxes && now - _taxesTimestamp < ttl) {
+    log.debug("Returning cached store taxes");
+    return _cachedStoreTaxes;
+  }
+  log.debug("Fetching fresh store taxes from Shopify");
+  const client = await getShopifyClient();
+  const response = await withRateLimit(
+    () => client.graphql.request(STORE_TAXES_QUERY),
+    "getStoreTaxes"
+  );
+  if (response.errors && response.errors.length > 0) {
+    const errorMessages = response.errors.map((e) => e.message).join(", ");
+    throw new Error(`GraphQL errors: ${errorMessages}`);
+  }
+  if (response.data?.shop === void 0 || response.data?.shop === null) {
+    throw new Error("Invalid response: missing shop data");
+  }
+  _cachedStoreTaxes = {
+    taxesIncluded: response.data.shop.taxesIncluded,
+    taxShipping: response.data.shop.taxShipping
+  };
+  _taxesTimestamp = now;
+  return _cachedStoreTaxes;
+}
+async function getStorePolicies() {
+  const now = Date.now();
+  const config = getConfig();
+  const ttl = config.STORE_INFO_CACHE_TTL_MS ?? DEFAULT_CACHE_TTL_MS;
+  if (_cachedStorePolicies && now - _policiesTimestamp < ttl) {
+    log.debug("Returning cached store policies");
+    return _cachedStorePolicies;
+  }
+  try {
+    log.debug("Fetching fresh store policies from Shopify");
+    const client = await getShopifyClient();
+    const response = await withRateLimit(
+      () => client.graphql.request(STORE_POLICIES_QUERY),
+      "getStorePolicies"
+    );
+    if (response.errors && response.errors.length > 0) {
+      const errorMessages = response.errors.map((e) => e.message).join(", ");
+      if (errorMessages.toLowerCase().includes("access denied") || errorMessages.toLowerCase().includes("unauthorized")) {
+        log.debug("read_legal_policies scope not available, returning empty policies");
+        _cachedStorePolicies = { shopPolicies: [] };
+        _policiesTimestamp = now;
+        return _cachedStorePolicies;
+      }
+      throw new Error(`GraphQL errors: ${errorMessages}`);
+    }
+    const policies = response.data?.shop?.shopPolicies ?? [];
+    _cachedStorePolicies = { shopPolicies: policies };
+    _policiesTimestamp = now;
+    return _cachedStorePolicies;
+  } catch (error) {
+    if (error instanceof Error && (error.message.toLowerCase().includes("access denied") || error.message.toLowerCase().includes("unauthorized"))) {
+      log.debug("read_legal_policies scope not available, returning empty policies");
+      _cachedStorePolicies = { shopPolicies: [] };
+      _policiesTimestamp = now;
+      return _cachedStorePolicies;
+    }
+    throw error;
+  }
+}
+async function getStoreAlerts() {
+  const now = Date.now();
+  const ttl = ALERTS_CACHE_TTL_MS;
+  if (_cachedStoreAlerts && now - _alertsTimestamp < ttl) {
+    log.debug("Returning cached store alerts");
+    return _cachedStoreAlerts;
+  }
+  log.debug("Fetching fresh store alerts from Shopify");
+  const client = await getShopifyClient();
+  const response = await withRateLimit(
+    () => client.graphql.request(STORE_ALERTS_QUERY),
+    "getStoreAlerts"
+  );
+  if (response.errors && response.errors.length > 0) {
+    const errorMessages = response.errors.map((e) => e.message).join(", ");
+    throw new Error(`GraphQL errors: ${errorMessages}`);
+  }
+  if (response.data?.shop === void 0 || response.data?.shop === null) {
+    throw new Error("Invalid response: missing shop data");
+  }
+  _cachedStoreAlerts = {
+    alerts: response.data.shop.alerts ?? [],
+    setupRequired: response.data.shop.setupRequired
+  };
+  _alertsTimestamp = now;
+  return _cachedStoreAlerts;
+}
+
+// src/shopify/store-info.ts
+var DEFAULT_CACHE_TTL_MS2 = 5 * 60 * 1e3;
 var _cachedStoreInfo = null;
 var _cacheTimestamp = 0;
 function transformShopResponse(shop) {
@@ -939,7 +1281,7 @@ function transformShopResponse(shop) {
 async function getStoreInfo() {
   const now = Date.now();
   const config = getConfig();
-  const ttl = config.STORE_INFO_CACHE_TTL_MS ?? DEFAULT_CACHE_TTL_MS;
+  const ttl = config.STORE_INFO_CACHE_TTL_MS ?? DEFAULT_CACHE_TTL_MS2;
   if (_cachedStoreInfo && now - _cacheTimestamp < ttl) {
     log.debug("Returning cached store info");
     return _cachedStoreInfo;
@@ -1009,54 +1351,358 @@ function createServer() {
   const server = new McpServer(
     // Server info (sent to clients in initialize response)
     {
-      name: SERVER_NAME,
-      version: getServerVersion()
+      name: SERVER_NAME,
+      version: getServerVersion()
+    },
+    // Server options (capabilities for handler enforcement)
+    {
+      capabilities: {
+        tools: {},
+        // Enable tools capability (AC-2.1.4)
+        resources: {},
+        // Enable resources capability (AC-2.1.4)
+        logging: {}
+        // Enable logging capability (AC-9.5.1.2)
+      },
+      instructions: SERVER_INSTRUCTIONS
+      // Provide Shopify context to AI agents (AC-9.5.1.1)
+    }
+  );
+  return server;
+}
+function registerResources(server) {
+  server.resource(
+    "store-info",
+    "shopify://store/info",
+    {
+      description: "Basic information about the connected Shopify store including name, domain, plan, currency, and timezone. Use this to understand the store context before performing operations.",
+      mimeType: "application/json"
+    },
+    async () => {
+      try {
+        const storeInfo = await getStoreInfo();
+        return {
+          contents: [
+            {
+              uri: "shopify://store/info",
+              mimeType: "application/json",
+              text: JSON.stringify(storeInfo, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        log.error("Failed to fetch store info", error instanceof Error ? error : void 0);
+        return {
+          contents: [
+            {
+              uri: "shopify://store/info",
+              mimeType: "application/json",
+              text: JSON.stringify({
+                error: "Failed to fetch store information",
+                message: sanitizeLogMessage(
+                  error instanceof Error ? error.message : "Unknown error"
+                )
+              })
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.resource(
+    "store-limits",
+    "shopify://store/limits",
+    {
+      description: "Resource limits for the Shopify store including max product variants, max product options, location limit, and redirect limit status. Use this to validate operations against store constraints.",
+      mimeType: "application/json"
+    },
+    async () => {
+      try {
+        const limits = await getStoreLimits();
+        return {
+          contents: [
+            {
+              uri: "shopify://store/limits",
+              mimeType: "application/json",
+              text: JSON.stringify(limits, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        log.error("Failed to fetch store limits", error instanceof Error ? error : void 0);
+        return {
+          contents: [
+            {
+              uri: "shopify://store/limits",
+              mimeType: "application/json",
+              text: JSON.stringify({
+                error: "Failed to fetch store limits",
+                message: sanitizeLogMessage(
+                  error instanceof Error ? error.message : "Unknown error"
+                )
+              })
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.resource(
+    "store-features",
+    "shopify://store/features",
+    {
+      description: "Feature flags for the Shopify store including gift cards, reports, storefront, bundles eligibility, and subscriptions. Use this to determine available store capabilities.",
+      mimeType: "application/json"
+    },
+    async () => {
+      try {
+        const features = await getStoreFeatures();
+        return {
+          contents: [
+            {
+              uri: "shopify://store/features",
+              mimeType: "application/json",
+              text: JSON.stringify(features, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        log.error("Failed to fetch store features", error instanceof Error ? error : void 0);
+        return {
+          contents: [
+            {
+              uri: "shopify://store/features",
+              mimeType: "application/json",
+              text: JSON.stringify({
+                error: "Failed to fetch store features",
+                message: sanitizeLogMessage(
+                  error instanceof Error ? error.message : "Unknown error"
+                )
+              })
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.resource(
+    "store-currencies",
+    "shopify://store/currencies",
+    {
+      description: "Currency configuration for the Shopify store including base currency, enabled presentment currencies, and money format patterns. Use this to understand multi-currency setup.",
+      mimeType: "application/json"
+    },
+    async () => {
+      try {
+        const currencies = await getStoreCurrencies();
+        return {
+          contents: [
+            {
+              uri: "shopify://store/currencies",
+              mimeType: "application/json",
+              text: JSON.stringify(currencies, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        log.error("Failed to fetch store currencies", error instanceof Error ? error : void 0);
+        return {
+          contents: [
+            {
+              uri: "shopify://store/currencies",
+              mimeType: "application/json",
+              text: JSON.stringify({
+                error: "Failed to fetch store currencies",
+                message: sanitizeLogMessage(
+                  error instanceof Error ? error.message : "Unknown error"
+                )
+              })
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.resource(
+    "store-shipping",
+    "shopify://store/shipping",
+    {
+      description: "Shipping configuration for the Shopify store including ships-to countries and countries with configured shipping zones. Use this to understand international shipping capabilities.",
+      mimeType: "application/json"
+    },
+    async () => {
+      try {
+        const shipping = await getStoreShipping();
+        return {
+          contents: [
+            {
+              uri: "shopify://store/shipping",
+              mimeType: "application/json",
+              text: JSON.stringify(shipping, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        log.error("Failed to fetch store shipping", error instanceof Error ? error : void 0);
+        return {
+          contents: [
+            {
+              uri: "shopify://store/shipping",
+              mimeType: "application/json",
+              text: JSON.stringify({
+                error: "Failed to fetch store shipping",
+                message: sanitizeLogMessage(
+                  error instanceof Error ? error.message : "Unknown error"
+                )
+              })
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.resource(
+    "store-domain",
+    "shopify://store/domain",
+    {
+      description: "Primary domain configuration for the Shopify store including hostname, URL, and SSL status. Use this to construct proper URLs and understand store identity.",
+      mimeType: "application/json"
+    },
+    async () => {
+      try {
+        const domain = await getStoreDomain();
+        return {
+          contents: [
+            {
+              uri: "shopify://store/domain",
+              mimeType: "application/json",
+              text: JSON.stringify(domain, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        log.error("Failed to fetch store domain", error instanceof Error ? error : void 0);
+        return {
+          contents: [
+            {
+              uri: "shopify://store/domain",
+              mimeType: "application/json",
+              text: JSON.stringify({
+                error: "Failed to fetch store domain",
+                message: sanitizeLogMessage(
+                  error instanceof Error ? error.message : "Unknown error"
+                )
+              })
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.resource(
+    "store-taxes",
+    "shopify://store/taxes",
+    {
+      description: "Tax configuration for the Shopify store including whether taxes are included in prices and tax shipping settings. Use this to understand pricing structure for tax calculations.",
+      mimeType: "application/json"
+    },
+    async () => {
+      try {
+        const taxes = await getStoreTaxes();
+        return {
+          contents: [
+            {
+              uri: "shopify://store/taxes",
+              mimeType: "application/json",
+              text: JSON.stringify(taxes, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        log.error("Failed to fetch store taxes", error instanceof Error ? error : void 0);
+        return {
+          contents: [
+            {
+              uri: "shopify://store/taxes",
+              mimeType: "application/json",
+              text: JSON.stringify({
+                error: "Failed to fetch store taxes",
+                message: sanitizeLogMessage(
+                  error instanceof Error ? error.message : "Unknown error"
+                )
+              })
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.resource(
+    "store-policies",
+    "shopify://store/policies",
+    {
+      description: "Legal policies for the Shopify store (privacy policy, terms of service, refund policy). Returns empty array if read_legal_policies scope is not available. Use this to reference store policies in customer communications.",
+      mimeType: "application/json"
     },
-    // Server options (capabilities for handler enforcement)
-    {
-      capabilities: {
-        tools: {},
-        // Enable tools capability (AC-2.1.4)
-        resources: {},
-        // Enable resources capability (AC-2.1.4)
-        logging: {}
-        // Enable logging capability (AC-9.5.1.2)
-      },
-      instructions: SERVER_INSTRUCTIONS
-      // Provide Shopify context to AI agents (AC-9.5.1.1)
+    async () => {
+      try {
+        const policies = await getStorePolicies();
+        return {
+          contents: [
+            {
+              uri: "shopify://store/policies",
+              mimeType: "application/json",
+              text: JSON.stringify(policies, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        log.error("Failed to fetch store policies", error instanceof Error ? error : void 0);
+        return {
+          contents: [
+            {
+              uri: "shopify://store/policies",
+              mimeType: "application/json",
+              text: JSON.stringify({
+                error: "Failed to fetch store policies",
+                message: sanitizeLogMessage(
+                  error instanceof Error ? error.message : "Unknown error"
+                )
+              })
+            }
+          ]
+        };
+      }
     }
   );
-  return server;
-}
-function registerResources(server) {
   server.resource(
-    "store-info",
-    "shopify://store/info",
+    "store-alerts",
+    "shopify://store/alerts",
     {
-      description: "Basic information about the connected Shopify store including name, domain, plan, currency, and timezone. Use this to understand the store context before performing operations.",
+      description: "Active admin alerts and setup requirements for the Shopify store. Use this to proactively identify issues needing merchant attention.",
       mimeType: "application/json"
     },
     async () => {
       try {
-        const storeInfo = await getStoreInfo();
+        const alerts = await getStoreAlerts();
         return {
           contents: [
             {
-              uri: "shopify://store/info",
+              uri: "shopify://store/alerts",
               mimeType: "application/json",
-              text: JSON.stringify(storeInfo, null, 2)
+              text: JSON.stringify(alerts, null, 2)
             }
           ]
         };
       } catch (error) {
-        log.error("Failed to fetch store info", error instanceof Error ? error : void 0);
+        log.error("Failed to fetch store alerts", error instanceof Error ? error : void 0);
         return {
           contents: [
             {
-              uri: "shopify://store/info",
+              uri: "shopify://store/alerts",
               mimeType: "application/json",
               text: JSON.stringify({
-                error: "Failed to fetch store information",
+                error: "Failed to fetch store alerts",
                 message: sanitizeLogMessage(
                   error instanceof Error ? error.message : "Unknown error"
                 )
@@ -2451,7 +3097,7 @@ function wrapToolHandler(toolName, schema, handler) {
   };
 }
 function registerTool(definition, handler, options = {}) {
-  const { name, title, description, inputSchema: inputSchema71, annotations } = definition;
+  const { name, title, description, inputSchema: inputSchema80, annotations } = definition;
   try {
     if (!options.skipNameValidation) {
       validateToolName(name);
@@ -2459,8 +3105,8 @@ function registerTool(definition, handler, options = {}) {
     if (registeredTools.has(name)) {
       throw new Error(`Tool "${name}" is already registered. Tool names must be unique.`);
     }
-    const jsonSchema = convertZodToJsonSchema(inputSchema71);
-    const wrappedHandler = wrapToolHandler(name, inputSchema71, handler);
+    const jsonSchema = convertZodToJsonSchema(inputSchema80);
+    const wrappedHandler = wrapToolHandler(name, inputSchema80, handler);
     const finalAnnotations = {
       ...deriveDefaultAnnotations(name),
       ...annotations,
@@ -2472,7 +3118,7 @@ function registerTool(definition, handler, options = {}) {
       title,
       description,
       inputSchema: jsonSchema,
-      zodSchema: inputSchema71,
+      zodSchema: inputSchema80,
       handler: wrappedHandler,
       annotations: finalAnnotations
     };
@@ -2648,6 +3294,28 @@ var PRODUCT_VARIANTS_BULK_UPDATE_MUTATION = `
     }
   }
 `;
+var PRODUCT_VARIANTS_BULK_CREATE_MUTATION = `
+  mutation ProductVariantsBulkCreate($productId: ID!, $variants: [ProductVariantsBulkInput!]!) {
+    productVariantsBulkCreate(productId: $productId, variants: $variants) {
+      product {
+        id
+      }
+      productVariants {
+        id
+        title
+        price
+        compareAtPrice
+        sku
+        barcode
+        inventoryQuantity
+      }
+      userErrors {
+        field
+        message
+      }
+    }
+  }
+`;
 var PRODUCT_SET_MEDIA_MUTATION = `
   mutation ProductSetMedia($input: ProductSetInput!) {
     productSet(input: $input) {
@@ -2781,26 +3449,6 @@ function buildProductCreateVariables(input) {
   if (input.handle !== void 0) {
     productData.handle = input.handle;
   }
-  if (input.variants && input.variants.length > 0) {
-    productData.variants = input.variants.map((variant) => {
-      const variantInput = {
-        price: variant.price
-      };
-      if (variant.compareAtPrice !== void 0) {
-        variantInput.compareAtPrice = variant.compareAtPrice;
-      }
-      if (variant.sku !== void 0) {
-        variantInput.sku = variant.sku;
-      }
-      if (variant.barcode !== void 0) {
-        variantInput.barcode = variant.barcode;
-      }
-      if (variant.options !== void 0 && variant.options.length > 0) {
-        variantInput.options = variant.options;
-      }
-      return variantInput;
-    });
-  }
   let media;
   if (input.images && input.images.length > 0) {
     media = input.images.map((image) => ({
@@ -2811,6 +3459,65 @@ function buildProductCreateVariables(input) {
   }
   return { product: productData, media };
 }
+async function createProductVariants(productId, variants) {
+  const client = await getShopifyClient();
+  const variantInputs = variants.map((variant) => {
+    const variantInput = {
+      price: variant.price
+    };
+    if (variant.compareAtPrice !== void 0) {
+      variantInput.compareAtPrice = variant.compareAtPrice;
+    }
+    if (variant.sku !== void 0) {
+      variantInput.sku = variant.sku;
+    }
+    if (variant.barcode !== void 0) {
+      variantInput.barcode = variant.barcode;
+    }
+    if (variant.options !== void 0 && variant.options.length > 0) {
+      variantInput.optionValues = variant.options.map((optionValue) => ({
+        name: optionValue,
+        optionName: optionValue
+        // Use the option value as the option name for simple cases
+      }));
+    }
+    return variantInput;
+  });
+  log.debug(`Creating ${variants.length} variants for product: ${productId}`);
+  const response = await withRateLimit(
+    () => client.graphql.request(
+      PRODUCT_VARIANTS_BULK_CREATE_MUTATION,
+      {
+        variables: { productId, variants: variantInputs }
+      }
+    ),
+    "create-product-variants"
+  );
+  if (response.errors && response.errors.length > 0) {
+    const errorMessage = response.errors.map((e) => e.message).join(", ");
+    throw new Error(`GraphQL error: ${errorMessage}`);
+  }
+  const result = response.data?.productVariantsBulkCreate;
+  if (!result) {
+    throw new Error("No response data from productVariantsBulkCreate mutation");
+  }
+  if (result.userErrors && result.userErrors.length > 0) {
+    throw new ShopifyUserErrorException(result.userErrors);
+  }
+  if (!result.productVariants || result.productVariants.length === 0) {
+    throw new Error("No variants were created");
+  }
+  log.debug(`Created ${result.productVariants.length} variants`);
+  return result.productVariants.map((variant) => ({
+    id: variant.id,
+    title: variant.title,
+    price: variant.price,
+    compareAtPrice: variant.compareAtPrice,
+    sku: variant.sku,
+    barcode: variant.barcode,
+    inventoryQuantity: variant.inventoryQuantity
+  }));
+}
 async function createProduct(input) {
   const client = await getShopifyClient();
   const variables = buildProductCreateVariables(input);
@@ -2836,7 +3543,23 @@ async function createProduct(input) {
     throw new Error("Product was not created (no product in response)");
   }
   log.debug(`Created product: ${result.product.id}`);
-  return transformProductToOutput(result.product);
+  let productOutput = transformProductToOutput(result.product);
+  if (input.variants && input.variants.length > 0) {
+    try {
+      const createdVariants = await createProductVariants(result.product.id, input.variants);
+      productOutput = {
+        ...productOutput,
+        variants: createdVariants
+      };
+      log.debug(`Created ${createdVariants.length} variants for product: ${result.product.id}`);
+    } catch (variantError) {
+      log.warn(
+        `Product created but variant creation failed: ${variantError instanceof Error ? variantError.message : "Unknown error"}`
+      );
+      log.warn("Variants can be added using update-product-variant tool");
+    }
+  }
+  return productOutput;
 }
 async function getProduct(id) {
   const client = await getShopifyClient();
@@ -5540,10 +6263,10 @@ var inputSchema8 = z10.object({
   // Variants
   variants: z10.array(
     z10.object({
-      price: z10.string().describe('Variant price as decimal string. Example: "29.99"'),
-      compareAtPrice: z10.string().optional().describe('Original price for sale display. Example: "39.99"'),
+      price: z10.union([z10.string(), z10.number()]).transform((val) => typeof val === "number" ? String(val) : val).describe('Variant price as decimal string. Example: "29.99"'),
+      compareAtPrice: z10.union([z10.string(), z10.number()]).optional().transform((val) => typeof val === "number" ? String(val) : val).describe('Original price for sale display. Example: "39.99"'),
       sku: z10.string().optional().describe('Stock keeping unit. Example: "SHIRT-001-RED-M"'),
-      barcode: z10.string().optional().describe("Barcode (UPC, EAN, etc.)"),
+      barcode: z10.union([z10.string(), z10.number()]).optional().transform((val) => typeof val === "number" ? String(val) : val).describe("Barcode (UPC, EAN, etc.)"),
       inventoryQuantity: z10.number().int().min(0).optional().describe("Initial inventory quantity (note: may require separate inventory API)"),
       options: z10.array(z10.string()).optional().describe('Variant options. Example: ["Red", "Medium"]')
     })
@@ -10300,11 +11023,11 @@ var inputSchema44 = z46.object({
   id: variantIdSchema.describe(
     'Shopify variant GID (e.g., "gid://shopify/ProductVariant/456"). Required. Use get-product to find variant IDs for a product.'
   ),
-  price: z46.string().optional().describe('New variant price as decimal string (e.g., "29.99")'),
-  compareAtPrice: z46.string().nullable().optional().describe(
+  price: z46.union([z46.string(), z46.number()]).optional().transform((val) => typeof val === "number" ? String(val) : val).describe('New variant price as decimal string (e.g., "29.99")'),
+  compareAtPrice: z46.union([z46.string(), z46.number()]).nullable().optional().transform((val) => typeof val === "number" ? String(val) : val).describe(
     'Original price for sale display (e.g., "39.99"). When set higher than price, Shopify shows strikethrough pricing. Set to null to remove the compare at price.'
   ),
-  barcode: z46.string().nullable().optional().describe("Barcode (UPC, EAN, ISBN, etc.). Set to null to remove.")
+  barcode: z46.union([z46.string(), z46.number()]).nullable().optional().transform((val) => typeof val === "number" ? String(val) : val).describe("Barcode (UPC, EAN, ISBN, etc.). Set to null to remove.")
 }).refine(
   (data) => {
     const { productId: _productId, id: _id, ...updateFields } = data;
@@ -12483,6 +13206,358 @@ function registerSubmitRedirectImportTool() {
   );
 }
 
+// src/tools/get-store-alerts.ts
+import { z as z73 } from "zod";
+var inputSchema71 = z73.object({});
+var outputSchema71 = z73.object({
+  alerts: z73.array(
+    z73.object({
+      action: z73.object({
+        title: z73.string().describe('The text for the button in the alert (e.g., "Add credit card")'),
+        url: z73.string().describe("The target URL that the button links to")
+      }).describe("Action to resolve the alert"),
+      description: z73.string().describe("Human-readable alert description")
+    })
+  ).describe("Array of active admin alerts"),
+  setupRequired: z73.boolean().describe("Whether store setup is incomplete")
+});
+async function handleGetStoreAlerts(context, _params) {
+  log.debug(`Getting store alerts for shop: ${context.shopDomain}`);
+  return await getStoreAlerts();
+}
+function registerGetStoreAlertsTool() {
+  registerContextAwareTool(
+    {
+      name: "get-store-alerts",
+      title: "Get Store Alerts",
+      description: "Get active admin alerts and setup requirements for the connected Shopify store. **Prerequisites:** None. **Use this** to proactively identify issues needing merchant attention.",
+      inputSchema: inputSchema71,
+      outputSchema: outputSchema71,
+      category: "store",
+      relationships: {
+        relatedTools: ["get-store-info", "list-low-inventory"],
+        followUps: []
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    handleGetStoreAlerts
+  );
+}
+
+// src/tools/get-store-currencies.ts
+import { z as z74 } from "zod";
+var inputSchema72 = z74.object({});
+var outputSchema72 = z74.object({
+  currencyCode: z74.string().describe("Base currency code (e.g., USD)"),
+  enabledPresentmentCurrencies: z74.array(z74.string()).describe("Enabled multi-currency codes"),
+  currencyFormats: z74.object({
+    moneyFormat: z74.string().describe("Money format pattern (e.g., ${{amount}})"),
+    moneyWithCurrencyFormat: z74.string().describe("Money with currency format (e.g., ${{amount}} USD)")
+  }).describe("Currency format patterns")
+});
+async function handleGetStoreCurrencies(context, _params) {
+  log.debug(`Getting store currencies for shop: ${context.shopDomain}`);
+  return await getStoreCurrencies();
+}
+function registerGetStoreCurrenciesTool() {
+  registerContextAwareTool(
+    {
+      name: "get-store-currencies",
+      title: "Get Store Currencies",
+      description: "Get currency configuration for the connected Shopify store including base currency, enabled presentment currencies, and money format patterns. **Prerequisites:** None. **Use this** to understand multi-currency setup.",
+      inputSchema: inputSchema72,
+      outputSchema: outputSchema72,
+      category: "store",
+      relationships: {
+        relatedTools: ["get-store-info", "get-store-limits"],
+        followUps: ["list-markets", "list-products"]
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    handleGetStoreCurrencies
+  );
+}
+
+// src/tools/get-store-domain.ts
+import { z as z75 } from "zod";
+var inputSchema73 = z75.object({});
+var outputSchema73 = z75.object({
+  primaryDomain: z75.object({
+    host: z75.string().describe('Domain hostname (e.g., "mystore.com")'),
+    url: z75.string().describe('Full domain URL (e.g., "https://mystore.com")'),
+    sslEnabled: z75.boolean().describe("Whether SSL is enabled")
+  })
+});
+async function handleGetStoreDomain(context, _params) {
+  log.debug(`Getting store domain for shop: ${context.shopDomain}`);
+  return await getStoreDomain();
+}
+function registerGetStoreDomainTool() {
+  registerContextAwareTool(
+    {
+      name: "get-store-domain",
+      title: "Get Store Domain",
+      description: "Get primary domain configuration for the connected Shopify store including hostname, URL, and SSL status. **Prerequisites:** None. **Use this** to construct proper URLs and understand store identity.",
+      inputSchema: inputSchema73,
+      outputSchema: outputSchema73,
+      category: "store",
+      relationships: {
+        relatedTools: ["get-store-info", "get-store-shipping"],
+        followUps: ["create-redirect"]
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    handleGetStoreDomain
+  );
+}
+
+// src/tools/get-store-features.ts
+import { z as z76 } from "zod";
+var inputSchema74 = z76.object({});
+var outputSchema74 = z76.object({
+  giftCards: z76.boolean().describe("Gift cards enabled"),
+  reports: z76.boolean().describe("Reports enabled"),
+  storefront: z76.boolean().describe("Storefront enabled"),
+  bundles: z76.object({
+    eligibleForBundles: z76.boolean().describe("Whether store is eligible for bundles")
+  }).describe("Bundles feature configuration"),
+  sellsSubscriptions: z76.boolean().describe("Subscriptions enabled")
+});
+async function handleGetStoreFeatures(context, _params) {
+  log.debug(`Getting store features for shop: ${context.shopDomain}`);
+  return await getStoreFeatures();
+}
+function registerGetStoreFeaturesTool() {
+  registerContextAwareTool(
+    {
+      name: "get-store-features",
+      title: "Get Store Features",
+      description: "Get feature flags for the connected Shopify store including gift cards, reports, storefront, bundles eligibility, and subscriptions. **Prerequisites:** None. **Use this** to determine available store capabilities.",
+      inputSchema: inputSchema74,
+      outputSchema: outputSchema74,
+      category: "store",
+      relationships: {
+        relatedTools: ["get-store-info", "get-store-limits"],
+        followUps: ["list-products", "list-collections"]
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    handleGetStoreFeatures
+  );
+}
+
+// src/tools/get-store-info.ts
+import { z as z77 } from "zod";
+var inputSchema75 = z77.object({});
+var outputSchema75 = z77.object({
+  name: z77.string().describe("Store name"),
+  domain: z77.string().describe("Store domain (without .myshopify.com)"),
+  myshopifyDomain: z77.string().describe("Full myshopify.com domain"),
+  plan: z77.object({
+    displayName: z77.string().describe("Current plan name"),
+    partnerDevelopment: z77.boolean().describe("Whether partner development store")
+  }).describe("Store plan details"),
+  currencyCode: z77.string().describe("Store currency code (e.g., USD, EUR)"),
+  timezone: z77.string().describe("Store IANA timezone"),
+  contactEmail: z77.string().describe("Store contact email")
+});
+async function handleGetStoreInfo(context, _params) {
+  log.debug(`Getting store info for shop: ${context.shopDomain}`);
+  return await getStoreInfo();
+}
+function registerGetStoreInfoTool() {
+  registerContextAwareTool(
+    {
+      name: "get-store-info",
+      title: "Get Store Info",
+      description: "Get basic information about the connected Shopify store including name, domain, plan, currency, timezone, and contact email. **Prerequisites:** None. **Use this** to understand store context before performing operations.",
+      inputSchema: inputSchema75,
+      outputSchema: outputSchema75,
+      category: "store",
+      relationships: {
+        relatedTools: [],
+        followUps: ["list-products", "list-collections"]
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    handleGetStoreInfo
+  );
+}
+
+// src/tools/get-store-limits.ts
+import { z as z78 } from "zod";
+var inputSchema76 = z78.object({});
+var outputSchema76 = z78.object({
+  maxProductVariants: z78.number().describe("Maximum variants per product"),
+  maxProductOptions: z78.number().describe("Maximum product options"),
+  locationLimit: z78.number().describe("Maximum locations"),
+  redirectLimitReached: z78.boolean().describe("Whether redirect limit is reached")
+});
+async function handleGetStoreLimits(context, _params) {
+  log.debug(`Getting store limits for shop: ${context.shopDomain}`);
+  return await getStoreLimits();
+}
+function registerGetStoreLimitsTool() {
+  registerContextAwareTool(
+    {
+      name: "get-store-limits",
+      title: "Get Store Limits",
+      description: "Get resource limits for the connected Shopify store including max product variants, max product options, location limit, and redirect limit status. **Prerequisites:** None. **Use this** to validate operations against store constraints.",
+      inputSchema: inputSchema76,
+      outputSchema: outputSchema76,
+      category: "store",
+      relationships: {
+        relatedTools: ["get-store-info", "get-store-features"],
+        followUps: ["list-products", "create-product"]
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    handleGetStoreLimits
+  );
+}
+
+// src/tools/get-store-policies.ts
+import { z as z79 } from "zod";
+var inputSchema77 = z79.object({});
+var outputSchema77 = z79.object({
+  shopPolicies: z79.array(
+    z79.object({
+      title: z79.string().describe('Policy title (e.g., "Privacy Policy")'),
+      type: z79.string().describe('Policy type (e.g., "PRIVACY_POLICY")'),
+      url: z79.string().describe("Full URL to the policy page")
+    })
+  ).describe("Array of store policy items (empty if scope unavailable)")
+});
+async function handleGetStorePolicies(context, _params) {
+  log.debug(`Getting store policies for shop: ${context.shopDomain}`);
+  return await getStorePolicies();
+}
+function registerGetStorePoliciesTool() {
+  registerContextAwareTool(
+    {
+      name: "get-store-policies",
+      title: "Get Store Policies",
+      description: "Get legal policies for the connected Shopify store (privacy policy, terms of service, refund policy). Returns empty array if read_legal_policies scope is not available. **Prerequisites:** None. **Use this** to reference store policies in customer communications.",
+      inputSchema: inputSchema77,
+      outputSchema: outputSchema77,
+      category: "store",
+      relationships: {
+        relatedTools: ["get-store-info", "get-store-domain"],
+        followUps: []
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    handleGetStorePolicies
+  );
+}
+
+// src/tools/get-store-shipping.ts
+import { z as z80 } from "zod";
+var inputSchema78 = z80.object({});
+var outputSchema78 = z80.object({
+  shipsToCountries: z80.array(z80.string()).describe("Countries the store ships to"),
+  countriesInShippingZones: z80.object({
+    countryCodes: z80.array(z80.string()).describe("Countries with configured shipping zones")
+  })
+});
+async function handleGetStoreShipping(context, _params) {
+  log.debug(`Getting store shipping for shop: ${context.shopDomain}`);
+  return await getStoreShipping();
+}
+function registerGetStoreShippingTool() {
+  registerContextAwareTool(
+    {
+      name: "get-store-shipping",
+      title: "Get Store Shipping",
+      description: "Get shipping configuration for the connected Shopify store including ships-to countries and countries with configured shipping zones. **Prerequisites:** None. **Use this** to understand international shipping capabilities.",
+      inputSchema: inputSchema78,
+      outputSchema: outputSchema78,
+      category: "store",
+      relationships: {
+        relatedTools: ["get-store-info", "get-store-domain", "list-markets"],
+        followUps: ["get-store-domain"]
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    handleGetStoreShipping
+  );
+}
+
+// src/tools/get-store-taxes.ts
+import { z as z81 } from "zod";
+var inputSchema79 = z81.object({});
+var outputSchema79 = z81.object({
+  taxesIncluded: z81.boolean().describe("Whether taxes are included in product prices"),
+  taxShipping: z81.boolean().describe("Whether shipping is taxed")
+});
+async function handleGetStoreTaxes(context, _params) {
+  log.debug(`Getting store taxes for shop: ${context.shopDomain}`);
+  return await getStoreTaxes();
+}
+function registerGetStoreTaxesTool() {
+  registerContextAwareTool(
+    {
+      name: "get-store-taxes",
+      title: "Get Store Taxes",
+      description: "Get tax configuration for the connected Shopify store including whether taxes are included in prices and tax shipping settings. **Prerequisites:** None. **Use this** to understand pricing structure for tax calculations.",
+      inputSchema: inputSchema79,
+      outputSchema: outputSchema79,
+      category: "store",
+      relationships: {
+        relatedTools: ["get-store-info", "get-store-currencies"],
+        followUps: []
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    handleGetStoreTaxes
+  );
+}
+
 // src/tools/index.ts
 function setupToolHandlers(server) {
   server.server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -12609,6 +13684,15 @@ function registerAllTools(server) {
   registerBulkDeleteRedirectsBySearchTool();
   registerImportRedirectsTool();
   registerSubmitRedirectImportTool();
+  registerGetStoreInfoTool();
+  registerGetStoreLimitsTool();
+  registerGetStoreFeaturesTool();
+  registerGetStoreCurrenciesTool();
+  registerGetStoreShippingTool();
+  registerGetStoreDomainTool();
+  registerGetStoreTaxesTool();
+  registerGetStorePoliciesTool();
+  registerGetStoreAlertsTool();
   const toolCount = getRegisteredTools().length;
   log.debug(`Tool registration complete: ${toolCount} tools registered`);
 }