@anton.andrusenko/shopify-mcp-admin 0.1.0 → 0.2.0

package/README.md

@@ -1,8 +1,8 @@
-# shopify-mcp-admin
+# @anton.andrusenko/shopify-mcp-admin
 
 > 🛍️ **MCP Server for Shopify Admin API** — Enable AI agents to manage Shopify stores with 40 powerful tools
 
-[![npm version](https://badge.fury.io/js/shopify-mcp-admin.svg)](https://badge.fury.io/js/shopify-mcp-admin)
+[![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)
 [![Node.js Version](https://img.shields.io/badge/node-%3E%3D20.0.0-brightgreen)](https://nodejs.org/)
 
@@ -32,10 +32,10 @@
 
 ```bash
 # Run directly with npx (recommended)
-npx shopify-mcp-admin
+npx @anton.andrusenko/shopify-mcp-admin
 
 # Or install globally
-npm install -g shopify-mcp-admin
+npm install -g @anton.andrusenko/shopify-mcp-admin
 ```
 
 ### Configuration
@@ -57,18 +57,58 @@ The AI will use the `list-products` tool to fetch your catalog.
 
 ---
 
+## 🔐 Authentication Methods
+
+shopify-mcp-admin supports two authentication methods:
+
+### Option 1: Legacy Custom App Token (Recommended for existing apps)
+
+If you have a Custom App with a static access token:
+
+```bash
+SHOPIFY_STORE_URL=mystore.myshopify.com
+SHOPIFY_ACCESS_TOKEN=shpat_xxxxx
+```
+
+### Option 2: Dev Dashboard (OAuth 2.0)
+
+If you're using Shopify's new Dev Dashboard with client credentials:
+
+```bash
+SHOPIFY_STORE_URL=mystore.myshopify.com
+SHOPIFY_CLIENT_ID=xxxxx
+SHOPIFY_CLIENT_SECRET=xxxxx
+```
+
+Tokens are automatically refreshed every 24 hours.
+
+### Which Should I Use?
+
+| Scenario | Method |
+|----------|--------|
+| Existing Custom App with static token | Legacy (Option 1) |
+| New Dev Dashboard app | Client Credentials (Option 2) |
+| Development/Partner store | Either works |
+| Production store (after Jan 2026) | Client Credentials required |
+
+---
+
 ## ⚙️ Configuration Reference
 
 | Variable | Required | Default | Description |
 |----------|----------|---------|-------------|
 | `SHOPIFY_STORE_URL` | ✅ Yes | — | Your Shopify store domain (e.g., `your-store.myshopify.com`) |
-| `SHOPIFY_ACCESS_TOKEN` | ✅ Yes | — | Admin API access token from your Custom App |
+| `SHOPIFY_ACCESS_TOKEN` | ⚡ See below | — | Admin API access token from your Custom App |
+| `SHOPIFY_CLIENT_ID` | ⚡ See below | — | Client ID from Dev Dashboard app |
+| `SHOPIFY_CLIENT_SECRET` | ⚡ See below | — | Client Secret from Dev Dashboard app |
 | `SHOPIFY_API_VERSION` | No | `2025-10` | Shopify API version |
 | `TRANSPORT` | No | `stdio` | Transport mode: `stdio` or `http` |
 | `PORT` | No | `3000` | HTTP server port (when `TRANSPORT=http`) |
 | `DEBUG` | No | — | Enable debug logging (`1` or `true`) |
 | `LOG_LEVEL` | No | `info` | Log level: `debug`, `info`, `warn`, `error` |
 
+**⚡ Authentication:** Provide EITHER `SHOPIFY_ACCESS_TOKEN` (legacy) OR both `SHOPIFY_CLIENT_ID` and `SHOPIFY_CLIENT_SECRET` (Dev Dashboard).
+
 ### Required Shopify Scopes
 
 Configure these scopes when creating your Custom App:
@@ -95,12 +135,14 @@ Edit your Claude Desktop configuration file:
 
 ### Step 2: Add the MCP Server
 
+**Option 1: Legacy Token Authentication**
+
 ```json
 {
   "mcpServers": {
     "shopify": {
       "command": "npx",
-      "args": ["shopify-mcp-admin"],
+      "args": ["@anton.andrusenko/shopify-mcp-admin"],
       "env": {
         "SHOPIFY_STORE_URL": "your-store.myshopify.com",
         "SHOPIFY_ACCESS_TOKEN": "shpat_xxxxx"
@@ -110,6 +152,24 @@ Edit your Claude Desktop configuration file:
 }
 ```
 
+**Option 2: Dev Dashboard (OAuth 2.0)**
+
+```json
+{
+  "mcpServers": {
+    "shopify": {
+      "command": "npx",
+      "args": ["@anton.andrusenko/shopify-mcp-admin"],
+      "env": {
+        "SHOPIFY_STORE_URL": "your-store.myshopify.com",
+        "SHOPIFY_CLIENT_ID": "xxxxx",
+        "SHOPIFY_CLIENT_SECRET": "xxxxx"
+      }
+    }
+  }
+}
+```
+
 ### Step 3: Restart Claude Desktop
 
 Quit and reopen Claude Desktop. You should see "shopify" in the MCP servers list.
@@ -135,7 +195,7 @@ TRANSPORT=http \
 PORT=3000 \
 SHOPIFY_STORE_URL=your-store.myshopify.com \
 SHOPIFY_ACCESS_TOKEN=shpat_xxxxx \
-npx shopify-mcp-admin
+npx @anton.andrusenko/shopify-mcp-admin
 ```
 
 ### Step 2: Test the Connection
@@ -186,7 +246,7 @@ Each tool can be converted to OpenAI function format:
 
 ## 🛠️ Available Tools
 
-shopify-mcp-admin provides **40 tools** organized into 7 categories:
+@anton.andrusenko/shopify-mcp-admin provides **40 tools** organized into 7 categories:
 
 <details>
 <summary><strong>📦 Product Management (7 tools)</strong></summary>
@@ -303,7 +363,7 @@ shopify-mcp-admin provides **40 tools** organized into 7 categories:
 | `401 Unauthorized` | Invalid access token | Regenerate token in Shopify Admin |
 | `403 Forbidden` | Missing API scopes | Add required scopes to Custom App |
 | `429 Too Many Requests` | Rate limited | Wait; shopify-mcp-admin auto-retries |
-| `ECONNREFUSED` | Server not running | Start server with `npx shopify-mcp-admin` |
+| `ECONNREFUSED` | Server not running | Start server with `npx @anton.andrusenko/shopify-mcp-admin` |
 | `Invalid store URL` | Wrong URL format | Use `store.myshopify.com` format |
 
 ### Debug Mode
@@ -312,10 +372,10 @@ Enable verbose logging to diagnose issues:
 
 ```bash
 # Option 1: DEBUG flag
-DEBUG=1 npx shopify-mcp-admin
+DEBUG=1 npx @anton.andrusenko/shopify-mcp-admin
 
 # Option 2: LOG_LEVEL
-LOG_LEVEL=debug npx shopify-mcp-admin
+LOG_LEVEL=debug npx @anton.andrusenko/shopify-mcp-admin
 ```
 
 ### FAQ

package/dist/index.js

@@ -10,8 +10,11 @@ import { z } from "zod";
 var configSchema = z.object({
   // Required - store identity
   SHOPIFY_STORE_URL: z.string().min(1, "SHOPIFY_STORE_URL is required").regex(/\.myshopify\.com$/, "Must be a valid myshopify.com domain"),
-  // Required - authentication
-  SHOPIFY_ACCESS_TOKEN: z.string().min(1, "SHOPIFY_ACCESS_TOKEN is required"),
+  // Authentication Option 1: Legacy Custom App (static token)
+  SHOPIFY_ACCESS_TOKEN: z.string().optional(),
+  // Authentication Option 2: Dev Dashboard (OAuth 2.0 client credentials)
+  SHOPIFY_CLIENT_ID: z.string().optional(),
+  SHOPIFY_CLIENT_SECRET: z.string().optional(),
   // Optional with defaults
   SHOPIFY_API_VERSION: z.string().default("2025-10"),
   DEBUG: z.string().optional(),
@@ -20,7 +23,48 @@ var configSchema = z.object({
   // Transport selection (AC-2.2.6, AC-2.2.7)
   // Default: stdio for Claude Desktop compatibility
   TRANSPORT: z.enum(["stdio", "http"]).default("stdio")
-});
+}).refine(
+  (data) => {
+    const hasLegacyAuth = !!data.SHOPIFY_ACCESS_TOKEN;
+    const hasClientId = !!data.SHOPIFY_CLIENT_ID;
+    const hasClientSecret = !!data.SHOPIFY_CLIENT_SECRET;
+    const hasClientCredentials = hasClientId && hasClientSecret;
+    return hasLegacyAuth || hasClientCredentials;
+  },
+  {
+    message: "Authentication required: Provide either SHOPIFY_ACCESS_TOKEN (legacy) OR both SHOPIFY_CLIENT_ID and SHOPIFY_CLIENT_SECRET (Dev Dashboard)"
+  }
+).refine(
+  (data) => {
+    const hasClientId = !!data.SHOPIFY_CLIENT_ID;
+    const hasClientSecret = !!data.SHOPIFY_CLIENT_SECRET;
+    if (hasClientId && !hasClientSecret) {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: "Incomplete client credentials: SHOPIFY_CLIENT_SECRET is required when SHOPIFY_CLIENT_ID is provided"
+  }
+).refine(
+  (data) => {
+    const hasClientId = !!data.SHOPIFY_CLIENT_ID;
+    const hasClientSecret = !!data.SHOPIFY_CLIENT_SECRET;
+    if (hasClientSecret && !hasClientId) {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: "Incomplete client credentials: SHOPIFY_CLIENT_ID is required when SHOPIFY_CLIENT_SECRET is provided"
+  }
+);
+function getAuthMode(config) {
+  if (config.SHOPIFY_ACCESS_TOKEN) {
+    return "token";
+  }
+  return "client_credentials";
+}
 function isDebugEnabled(debugValue) {
   if (!debugValue) return false;
   const normalized = debugValue.toLowerCase().trim();
@@ -54,8 +98,10 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 // src/utils/logger.ts
 var SANITIZATION_PATTERNS = [
   { pattern: /shpat_[a-zA-Z0-9]+/g, replacement: "[REDACTED]" },
-  { pattern: /Bearer\s+[a-zA-Z0-9]+/g, replacement: "Bearer [REDACTED]" },
-  { pattern: /access_token[=:]\s*[a-zA-Z0-9]+/gi, replacement: "access_token=[REDACTED]" }
+  { pattern: /shpua_[a-zA-Z0-9]+/g, replacement: "[REDACTED]" },
+  { pattern: /Bearer\s+[a-zA-Z0-9_-]+/g, replacement: "Bearer [REDACTED]" },
+  { pattern: /access_token[=:]\s*[a-zA-Z0-9_-]+/gi, replacement: "access_token=[REDACTED]" },
+  { pattern: /client_secret[=:]\s*[a-zA-Z0-9_-]+/gi, replacement: "client_secret=[REDACTED]" }
 ];
 function sanitizeLogMessage(message) {
   let result = message;
@@ -313,6 +359,283 @@ async function withRateLimit(operation, context, config = DEFAULT_RATE_LIMIT_CON
 // src/shopify/client.ts
 import "@shopify/shopify-api/adapters/node";
 import { shopifyApi } from "@shopify/shopify-api";
+
+// src/utils/errors.ts
+var sanitizeErrorMessage = sanitizeLogMessage;
+var ToolError = class _ToolError extends Error {
+  /** AI-friendly suggestion for error recovery */
+  suggestion;
+  /**
+   * Create a new ToolError
+   *
+   * @param message - The error message describing what went wrong
+   * @param suggestion - A helpful suggestion for how to resolve the error
+   */
+  constructor(message, suggestion) {
+    super(message);
+    this.name = "ToolError";
+    this.suggestion = suggestion;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _ToolError);
+    }
+  }
+};
+function extractErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  return "Unknown error";
+}
+function createToolError(error, suggestion) {
+  const message = extractErrorMessage(error);
+  const safeMessage = sanitizeErrorMessage(message);
+  const safeSuggestion = sanitizeErrorMessage(suggestion);
+  return {
+    isError: true,
+    content: [
+      {
+        type: "text",
+        text: `Error: ${safeMessage}
+
+Suggestion: ${safeSuggestion}`
+      }
+    ]
+  };
+}
+function safeStringify2(data) {
+  try {
+    const seen = /* @__PURE__ */ new WeakSet();
+    return JSON.stringify(
+      data,
+      (_key, value) => {
+        if (typeof value === "object" && value !== null) {
+          if (seen.has(value)) {
+            return "[Circular]";
+          }
+          seen.add(value);
+        }
+        return value;
+      },
+      2
+    );
+  } catch {
+    return "[Unable to stringify]";
+  }
+}
+function createToolSuccess(data) {
+  const text = safeStringify2(data);
+  return {
+    content: [
+      {
+        type: "text",
+        text
+      }
+    ],
+    structuredContent: data
+  };
+}
+
+// src/shopify/token-manager.ts
+var TokenManager = class _TokenManager {
+  config;
+  cachedToken = null;
+  refreshPromise = null;
+  /**
+   * Refresh buffer: 5 minutes before expiry
+   *
+   * Tokens are refreshed when within this window of expiration
+   * to ensure requests don't fail due to token expiry mid-request.
+   */
+  static REFRESH_BUFFER_MS = 5 * 60 * 1e3;
+  /**
+   * Create a new TokenManager instance
+   *
+   * @param config - Configuration containing store URL and OAuth credentials
+   */
+  constructor(config) {
+    this.config = config;
+    log.debug("TokenManager initialized", { storeUrl: config.storeUrl });
+  }
+  /**
+   * Get a valid access token
+   *
+   * Returns a cached token if valid and not expiring soon.
+   * Automatically fetches a new token if:
+   * - No token is cached
+   * - Cached token is within 5 minutes of expiration
+   *
+   * Concurrent calls are deduplicated - only one OAuth request
+   * is made even if multiple callers request a token simultaneously.
+   *
+   * @returns Promise resolving to a valid access token string
+   * @throws ToolError if token acquisition fails
+   */
+  async getAccessToken() {
+    if (this.refreshPromise) {
+      log.debug("Token refresh in progress, waiting...");
+      return this.refreshPromise;
+    }
+    if (this.cachedToken && !this.needsRefresh()) {
+      log.debug("Using cached token");
+      return this.cachedToken.accessToken;
+    }
+    log.debug("Fetching new OAuth token");
+    this.refreshPromise = this.fetchNewToken().then((token) => {
+      this.cachedToken = token;
+      log.debug("Token cached successfully", {
+        expiresIn: Math.round((token.expiresAt - Date.now()) / 1e3)
+      });
+      return token.accessToken;
+    }).finally(() => {
+      this.refreshPromise = null;
+    });
+    return this.refreshPromise;
+  }
+  /**
+   * Fetch a new token from Shopify OAuth endpoint
+   *
+   * Implements OAuth 2.0 client credentials grant flow:
+   * - POST to /admin/oauth/access_token
+   * - Content-Type: application/x-www-form-urlencoded
+   * - Body: grant_type, client_id, client_secret
+   *
+   * @returns Promise resolving to cached token with expiry
+   * @throws ToolError on OAuth failure (401, 400, network error)
+   * @private
+   */
+  async fetchNewToken() {
+    const tokenEndpoint = this.buildTokenEndpoint();
+    try {
+      const response = await fetch(tokenEndpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        body: new URLSearchParams({
+          grant_type: "client_credentials",
+          client_id: this.config.clientId,
+          client_secret: this.config.clientSecret
+        })
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw this.handleOAuthError(response.status, errorText);
+      }
+      const data = await response.json();
+      if (!data.access_token) {
+        throw new ToolError(
+          "Invalid OAuth response: missing access_token",
+          "This may be a temporary Shopify API issue. Try again in a few minutes."
+        );
+      }
+      const expiresAt = Date.now() + data.expires_in * 1e3;
+      return {
+        accessToken: data.access_token,
+        expiresAt
+      };
+    } catch (error) {
+      if (error instanceof ToolError) {
+        throw error;
+      }
+      const message = error instanceof Error ? error.message : "Unknown error";
+      throw new ToolError(
+        `OAuth token request failed: ${message}`,
+        "Check your network connection and ensure SHOPIFY_CLIENT_ID and SHOPIFY_CLIENT_SECRET are correct."
+      );
+    }
+  }
+  /**
+   * Build the OAuth token endpoint URL
+   *
+   * @returns Full URL to the Shopify OAuth token endpoint
+   * @private
+   */
+  buildTokenEndpoint() {
+    const storeUrl = this.config.storeUrl.includes("://") ? this.config.storeUrl : `https://${this.config.storeUrl}`;
+    const baseUrl = storeUrl.replace(/\/$/, "");
+    return `${baseUrl}/admin/oauth/access_token`;
+  }
+  /**
+   * Check if the cached token needs to be refreshed
+   *
+   * Returns true if:
+   * - No token is cached
+   * - Token expires within REFRESH_BUFFER_MS (5 minutes)
+   *
+   * @returns true if token should be refreshed
+   * @private
+   */
+  needsRefresh() {
+    if (!this.cachedToken) {
+      return true;
+    }
+    const refreshThreshold = Date.now() + _TokenManager.REFRESH_BUFFER_MS;
+    return refreshThreshold >= this.cachedToken.expiresAt;
+  }
+  /**
+   * Handle OAuth error responses
+   *
+   * Creates appropriate ToolError with actionable suggestions
+   * based on HTTP status code.
+   *
+   * @param status - HTTP status code
+   * @param responseText - Error response body
+   * @returns ToolError with appropriate message and suggestion
+   * @private
+   */
+  handleOAuthError(status, responseText) {
+    switch (status) {
+      case 401:
+        return new ToolError(
+          "OAuth authentication failed (HTTP 401)",
+          "Verify that SHOPIFY_CLIENT_ID and SHOPIFY_CLIENT_SECRET are correct. Ensure the app has the required scopes configured in the Dev Dashboard."
+        );
+      case 400:
+        return new ToolError(
+          "OAuth bad request (HTTP 400)",
+          "The OAuth request parameters are invalid. Ensure SHOPIFY_CLIENT_ID and SHOPIFY_CLIENT_SECRET are set correctly and the app is properly configured in the Dev Dashboard."
+        );
+      case 403:
+        return new ToolError(
+          "OAuth forbidden (HTTP 403)",
+          "The app may not have permission to access this store. Ensure the app is installed on the store and has the required access scopes."
+        );
+      case 404:
+        return new ToolError(
+          "OAuth endpoint not found (HTTP 404)",
+          `Verify SHOPIFY_STORE_URL is correct and includes the .myshopify.com domain. Current value appears incorrect. Received: ${responseText.slice(0, 100)}`
+        );
+      case 429:
+        return new ToolError(
+          "OAuth rate limited (HTTP 429)",
+          "Too many token requests. Wait a few minutes before trying again."
+        );
+      default:
+        return new ToolError(
+          `OAuth request failed (HTTP ${status})`,
+          `Unexpected error from Shopify OAuth endpoint. Response: ${responseText.slice(0, 200)}`
+        );
+    }
+  }
+  /**
+   * Clear the cached token
+   *
+   * Use this for:
+   * - Testing: Reset state between tests
+   * - Error recovery: Force new token after auth failures
+   *
+   * The next call to getAccessToken() will fetch a new token.
+   */
+  clearCache() {
+    this.cachedToken = null;
+    log.debug("Token cache cleared");
+  }
+};
+
+// src/shopify/client.ts
 var DEFAULT_API_VERSION = "2025-10";
 var SHOP_QUERY = `
   query {
@@ -322,6 +645,7 @@ var SHOP_QUERY = `
   }
 `;
 var _defaultClient = null;
+var _tokenManager = null;
 async function verifyConnectivity(client) {
   const response = await client.graphql.request(SHOP_QUERY);
   if (response.errors && response.errors.length > 0) {
@@ -377,18 +701,59 @@ async function createShopifyClient(credentials, options = {}) {
   }
   return client;
 }
+async function createClientWithTokenRefresh(credentials, tokenManager) {
+  const baseClient = buildClient(credentials);
+  let currentToken = credentials.accessToken;
+  return {
+    ...baseClient,
+    graphql: {
+      request: async (query, options) => {
+        const token = await tokenManager.getAccessToken();
+        if (token !== currentToken) {
+          log.debug("Token refreshed, updating client credentials");
+          currentToken = token;
+          credentials.accessToken = token;
+          const refreshedClient = buildClient(credentials);
+          return refreshedClient.graphql.request(query, options);
+        }
+        return baseClient.graphql.request(query, options);
+      }
+    }
+  };
+}
 async function getShopifyClient() {
   if (_defaultClient !== null) {
     return _defaultClient;
   }
   const config = getConfig();
-  const credentials = {
-    storeUrl: config.SHOPIFY_STORE_URL,
-    accessToken: config.SHOPIFY_ACCESS_TOKEN,
-    apiVersion: config.SHOPIFY_API_VERSION
-  };
+  const authMode = getAuthMode(config);
+  log.info(`Initializing Shopify client with auth mode: ${authMode}`);
   try {
-    const client = await createShopifyClient(credentials);
+    if (authMode === "token") {
+      const credentials2 = {
+        storeUrl: config.SHOPIFY_STORE_URL,
+        accessToken: config.SHOPIFY_ACCESS_TOKEN,
+        apiVersion: config.SHOPIFY_API_VERSION
+      };
+      const client2 = await createShopifyClient(credentials2);
+      _defaultClient = client2;
+      return _defaultClient;
+    }
+    log.debug("Creating TokenManager for client_credentials auth");
+    _tokenManager = new TokenManager({
+      storeUrl: config.SHOPIFY_STORE_URL,
+      clientId: config.SHOPIFY_CLIENT_ID,
+      clientSecret: config.SHOPIFY_CLIENT_SECRET
+    });
+    const initialToken = await _tokenManager.getAccessToken();
+    log.debug("Initial OAuth token acquired successfully");
+    const credentials = {
+      storeUrl: config.SHOPIFY_STORE_URL,
+      accessToken: initialToken,
+      apiVersion: config.SHOPIFY_API_VERSION
+    };
+    const client = await createClientWithTokenRefresh(credentials, _tokenManager);
+    await verifyConnectivity(client);
     _defaultClient = client;
     return _defaultClient;
   } catch (error) {
@@ -1967,84 +2332,6 @@ function createSingleTenantContext(client, shopDomain) {
   };
 }
 
-// src/utils/errors.ts
-var sanitizeErrorMessage = sanitizeLogMessage;
-var ToolError = class _ToolError extends Error {
-  /** AI-friendly suggestion for error recovery */
-  suggestion;
-  /**
-   * Create a new ToolError
-   *
-   * @param message - The error message describing what went wrong
-   * @param suggestion - A helpful suggestion for how to resolve the error
-   */
-  constructor(message, suggestion) {
-    super(message);
-    this.name = "ToolError";
-    this.suggestion = suggestion;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, _ToolError);
-    }
-  }
-};
-function extractErrorMessage(error) {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  if (typeof error === "string") {
-    return error;
-  }
-  return "Unknown error";
-}
-function createToolError(error, suggestion) {
-  const message = extractErrorMessage(error);
-  const safeMessage = sanitizeErrorMessage(message);
-  const safeSuggestion = sanitizeErrorMessage(suggestion);
-  return {
-    isError: true,
-    content: [
-      {
-        type: "text",
-        text: `Error: ${safeMessage}
-
-Suggestion: ${safeSuggestion}`
-      }
-    ]
-  };
-}
-function safeStringify2(data) {
-  try {
-    const seen = /* @__PURE__ */ new WeakSet();
-    return JSON.stringify(
-      data,
-      (_key, value) => {
-        if (typeof value === "object" && value !== null) {
-          if (seen.has(value)) {
-            return "[Circular]";
-          }
-          seen.add(value);
-        }
-        return value;
-      },
-      2
-    );
-  } catch {
-    return "[Unable to stringify]";
-  }
-}
-function createToolSuccess(data) {
-  const text = safeStringify2(data);
-  return {
-    content: [
-      {
-        type: "text",
-        text
-      }
-    ],
-    structuredContent: data
-  };
-}
-
 // src/tools/registration.ts
 var KEBAB_CASE_REGEX = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
 var registeredTools = /* @__PURE__ */ new Map();

package/package.json

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