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

package/README.md

@@ -1,6 +1,6 @@
 # @anton.andrusenko/shopify-mcp-admin
 
-> 🛍️ **MCP Server for Shopify Admin API** — Enable AI agents to manage Shopify stores with 71 powerful tools
+> 🛍️ **MCP Server for Shopify Admin API** — Enable AI agents to manage Shopify stores with 79 powerful tools
 
 [![npm version](https://badge.fury.io/js/@anton.andrusenko%2Fshopify-mcp-admin.svg)](https://www.npmjs.com/package/@anton.andrusenko/shopify-mcp-admin)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
@@ -11,7 +11,7 @@
 
 ## ✨ Features
 
-- 🛠️ **71 MCP Tools** — Complete store management: products, inventory, collections, pages, blogs, redirects, metafields, markets, locales & translations
+- 🛠️ **79 MCP Tools** — Complete store management: products, inventory, collections, pages, blogs, redirects, metafields, markets, locales & translations
 - 🤖 **AI-Optimized** — Tool descriptions and error messages designed for LLM comprehension
 - 🔌 **Dual Transport** — STDIO for Claude Desktop, HTTP for ChatGPT/OpenAI
 - ⚡ **Rate Limiting** — Automatic retry with exponential backoff for Shopify API limits
@@ -250,14 +250,60 @@ Each tool can be converted to OpenAI function format:
 
 ## 🛠️ Available Tools
 
-@anton.andrusenko/shopify-mcp-admin provides **71 tools** organized into 16 categories:
+@anton.andrusenko/shopify-mcp-admin provides **79 tools** organized into 16 categories:
 
 <details>
-<summary><strong>🏪 Store Info (1 tool)</strong></summary>
+<summary><strong>🏪 Store Info (9 tools)</strong></summary>
 
 | Tool | Description |
 |------|-------------|
 | `get-store-info` | Get basic store information (name, domain, plan, currency, timezone, email) |
+| `get-store-limits` | Get store resource limits (max variants, max options, location limit) |
+| `get-store-features` | Get feature flags (gift cards, reports, storefront, bundles, subscriptions) |
+| `get-store-currencies` | Get multi-currency configuration (base currency, presentment currencies, formats) |
+| `get-store-shipping` | Get shipping configuration (ships-to countries, countries in shipping zones) |
+| `get-store-domain` | Get primary domain configuration (hostname, URL, SSL status) |
+| `get-store-taxes` | Get tax configuration (taxes included in prices, tax shipping) |
+| `get-store-policies` | Get legal policies (privacy, terms of service, refund policy) |
+| `get-store-alerts` | Get admin alerts and setup requirements |
+
+#### Example: Get Store Limits
+
+```json
+{
+  "maxProductVariants": 2000,
+  "maxProductOptions": 3,
+  "locationLimit": 1000,
+  "redirectLimitReached": false
+}
+```
+
+#### Example: Get Store Features
+
+```json
+{
+  "giftCards": true,
+  "reports": true,
+  "storefront": true,
+  "bundles": {
+    "eligibleForBundles": true
+  },
+  "sellsSubscriptions": false
+}
+```
+
+#### Example: Get Store Currencies
+
+```json
+{
+  "currencyCode": "USD",
+  "enabledPresentmentCurrencies": ["USD", "EUR", "GBP", "CAD"],
+  "currencyFormats": {
+    "moneyFormat": "${{amount}}",
+    "moneyWithCurrencyFormat": "${{amount}} USD"
+  }
+}
+```
 
 </details>
 
@@ -497,13 +543,38 @@ npm run inspect:config
 
 MCP Inspector opens a web UI at `http://localhost:6274` where you can:
 
-- 📋 Browse all 71 registered tools with schemas
+- 📋 Browse all 79 registered tools with schemas
+- 📊 Access 9 MCP resources for store context
 - ▶️ Execute tools interactively and view results
 - 🔍 Inspect JSON-RPC protocol messages
 - 📊 Monitor server events in real-time
 
 > **Tip:** Use `npm run inspect:dev` during development for instant feedback without rebuilding.
 
+---
+
+## 📊 MCP Resources
+
+The MCP server exposes comprehensive store context information via MCP resources. These are read-only data sources that AI agents can query for context.
+
+### Extended Store Resources
+
+| Resource URI | Description |
+|--------------|-------------|
+| `shopify://store/info` | Basic store info (name, domain, plan, currency, timezone) |
+| `shopify://store/limits` | Resource limits (max variants, max options, location limit) |
+| `shopify://store/features` | Feature flags (gift cards, reports, storefront, bundles) |
+| `shopify://store/currencies` | Multi-currency configuration (base currency, presentment currencies) |
+| `shopify://store/shipping` | Shipping configuration (ships-to countries, shipping zones) |
+| `shopify://store/domain` | Primary domain configuration (hostname, URL, SSL status) |
+| `shopify://store/taxes` | Tax configuration (taxes included, tax shipping) |
+| `shopify://store/policies` | Legal policies (privacy, terms of service, refund) |
+| `shopify://store/alerts` | Admin alerts and setup requirements |
+
+> **Note:** For MCP clients that don't support resources (e.g., Claude Desktop), equivalent tools are available. See **Store Info Tools** below.
+
+---
+
 ### FAQ
 
 **Q: Can I connect to multiple stores?**  

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"
     },
-    // Server options (capabilities for handler enforcement)
+    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",
     {
-      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)
+      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"
+                )
+              })
+            }
+          ]
+        };
+      }
     }
   );
-  return server;
-}
-function registerResources(server) {
   server.resource(
-    "store-info",
-    "shopify://store/info",
+    "store-policies",
+    "shopify://store/policies",
     {
-      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: "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"
     },
     async () => {
       try {
-        const storeInfo = await getStoreInfo();
+        const policies = await getStorePolicies();
         return {
           contents: [
             {
-              uri: "shopify://store/info",
+              uri: "shopify://store/policies",
               mimeType: "application/json",
-              text: JSON.stringify(storeInfo, null, 2)
+              text: JSON.stringify(policies, null, 2)
             }
           ]
         };
       } catch (error) {
-        log.error("Failed to fetch store info", error instanceof Error ? error : void 0);
+        log.error("Failed to fetch store policies", error instanceof Error ? error : void 0);
         return {
           contents: [
             {
-              uri: "shopify://store/info",
+              uri: "shopify://store/policies",
               mimeType: "application/json",
               text: JSON.stringify({
-                error: "Failed to fetch store information",
+                error: "Failed to fetch store policies",
+                message: sanitizeLogMessage(
+                  error instanceof Error ? error.message : "Unknown error"
+                )
+              })
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.resource(
+    "store-alerts",
+    "shopify://store/alerts",
+    {
+      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 alerts = await getStoreAlerts();
+        return {
+          contents: [
+            {
+              uri: "shopify://store/alerts",
+              mimeType: "application/json",
+              text: JSON.stringify(alerts, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        log.error("Failed to fetch store alerts", error instanceof Error ? error : void 0);
+        return {
+          contents: [
+            {
+              uri: "shopify://store/alerts",
+              mimeType: "application/json",
+              text: JSON.stringify({
+                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: inputSchema72, 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(inputSchema72);
-    const wrappedHandler = wrapToolHandler(name, inputSchema72, 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: inputSchema72,
+      zodSchema: inputSchema80,
       handler: wrappedHandler,
       annotations: finalAnnotations
     };
@@ -12560,20 +13206,180 @@ function registerSubmitRedirectImportTool() {
   );
 }
 
-// src/tools/get-store-info.ts
+// src/tools/get-store-alerts.ts
 import { z as z73 } from "zod";
 var inputSchema71 = z73.object({});
 var outputSchema71 = z73.object({
-  name: z73.string().describe("Store name"),
-  domain: z73.string().describe("Store domain (without .myshopify.com)"),
-  myshopifyDomain: z73.string().describe("Full myshopify.com domain"),
-  plan: z73.object({
-    displayName: z73.string().describe("Current plan name"),
-    partnerDevelopment: z73.boolean().describe("Whether partner development store")
+  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: z73.string().describe("Store currency code (e.g., USD, EUR)"),
-  timezone: z73.string().describe("Store IANA timezone"),
-  contactEmail: z73.string().describe("Store contact email")
+  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}`);
@@ -12585,8 +13391,8 @@ function registerGetStoreInfoTool() {
       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: inputSchema71,
-      outputSchema: outputSchema71,
+      inputSchema: inputSchema75,
+      outputSchema: outputSchema75,
       category: "store",
       relationships: {
         relatedTools: [],
@@ -12603,6 +13409,155 @@ function registerGetStoreInfoTool() {
   );
 }
 
+// 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 () => {
@@ -12730,6 +13685,14 @@ function registerAllTools(server) {
   registerImportRedirectsTool();
   registerSubmitRedirectImportTool();
   registerGetStoreInfoTool();
+  registerGetStoreLimitsTool();
+  registerGetStoreFeaturesTool();
+  registerGetStoreCurrenciesTool();
+  registerGetStoreShippingTool();
+  registerGetStoreDomainTool();
+  registerGetStoreTaxesTool();
+  registerGetStorePoliciesTool();
+  registerGetStoreAlertsTool();
   const toolCount = getRegisteredTools().length;
   log.debug(`Tool registration complete: ${toolCount} tools registered`);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anton.andrusenko/shopify-mcp-admin",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "MCP server for Shopify Admin API - enables AI agents to manage Shopify stores with 71 tools for products, inventory, collections, content, SEO, metafields, markets & translations",
   "type": "module",
   "main": "./dist/index.js",