@shoppexio/mcp-commerce-server 0.2.0

package/README.md

@@ -0,0 +1,103 @@
+# @shoppexio/mcp-commerce-server
+
+Model Context Protocol server for Shoppex commerce operations.
+
+Connect Claude Desktop, Claude Code, Cursor, Windsurf, or Codex to your Shoppex store. Read products, orders, customers, and analytics, create payment links, manage coupons, and create or update products — directly from chat.
+
+## Install
+
+```bash
+npm install -g @shoppexio/mcp-commerce-server
+```
+
+Or run without installing:
+
+```bash
+npx -y @shoppexio/mcp-commerce-server
+```
+
+## Claude Desktop
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows):
+
+```json
+{
+  "mcpServers": {
+    "shoppex-commerce": {
+      "command": "npx",
+      "args": ["-y", "@shoppexio/mcp-commerce-server"],
+      "env": {
+        "SHOPPEX_SHOP_API_KEY": "shx_your_dev_api_key"
+      }
+    }
+  }
+}
+```
+
+Restart Claude Desktop. Tools accept a `shop_api_key` argument on each call; the env var is available for clients that forward env to tool arguments.
+
+## Cursor / Windsurf / Other
+
+Any MCP client with stdio transport works. Set the same env var and point to `shoppex-mcp-commerce-server` as the command.
+
+## Tools (12)
+
+### Read
+
+| Tool | Purpose |
+|------|---------|
+| `products.list` | Search or list products |
+| `products.get` | Fetch one product by id or uniqid |
+| `orders.list` | List recent orders, optionally filtered |
+| `orders.get` | Fetch one order with line items |
+| `customers.get` | Fetch a customer by id or email |
+| `coupons.list` | List active coupons |
+| `analytics.revenue` | Revenue totals for a date range |
+
+### Write
+
+| Tool | Purpose |
+|------|---------|
+| `products.create` | Create a product (service, serials, dynamic, file) |
+| `products.update` | Update a product's price, title, gateways, stock, visibility |
+| `coupons.create` | Create a coupon (percentage or fixed discount) |
+| `coupons.update` | Update an existing coupon |
+| `payment_links.create` | Create a payment link |
+
+## Required Scopes
+
+Your Shoppex Dev API key needs the scopes matching the tools you use (e.g. `products.read`, `products.write`, `orders.read`, `coupons.write`, `analytics.read`, `payment_links.write`).
+
+Create one at [dashboard.shoppex.io/developer/api](https://dashboard.shoppex.io/developer/api).
+
+## Environment Variables
+
+| Variable | Required | Default |
+|----------|----------|---------|
+| `SHOPPEX_SHOP_API_KEY` | passed per call, or set here | — |
+| `SHOPPEX_API_BASE_URL` | no | `https://api.shoppex.io` |
+| `SHOPPEX_DEV_API_TIMEOUT_MS` | no | `10000` |
+
+## Example Prompts
+
+Once connected in Claude Desktop:
+
+- "Create a Discord Nitro 3-month product for $14.99 paid in crypto."
+- "Show me this month's top 10 customers by revenue."
+- "Generate a 20% off coupon for my Discord members, valid until end of month."
+- "Update the price of product `prd_abc123` to $12.99."
+- "Make a payment link for a $50 USDT one-time purchase."
+
+## Companion
+
+Pair with [`@shoppexio/mcp-theme-server`](https://www.npmjs.com/package/@shoppexio/mcp-theme-server) for storefront theme operations.
+
+## Docs
+
+- [Developer API Reference](https://docs.shoppex.io/api-reference/introduction)
+- [Quickstart](https://docs.shoppex.io/api-reference/quickstart)
+- [Authentication](https://docs.shoppex.io/api-reference/authentication)
+
+## License
+
+Proprietary. © Shoppex.

package/bin/shoppex-mcp-commerce-server.mjs

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+import { startCommerceMcpServer } from '../src/server.mjs';
+
+await startCommerceMcpServer().catch((error) => {
+  console.error(error instanceof Error ? error.message : 'Failed to start Shoppex commerce MCP server.');
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@shoppexio/mcp-commerce-server",
+  "version": "0.2.0",
+  "description": "Shoppex MCP server for commerce operations over the Dev API",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ShoppexIO/shoppex.git",
+    "directory": "packages/mcp-commerce-server"
+  },
+  "homepage": "https://docs.shoppex.io/developer-api",
+  "bugs": {
+    "url": "https://github.com/ShoppexIO/shoppex/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "import": "./src/server.mjs",
+      "types": "./src/index.d.ts"
+    }
+  },
+  "keywords": [
+    "shoppex",
+    "mcp",
+    "commerce",
+    "server",
+    "telegram"
+  ],
+  "bin": {
+    "shoppex-mcp-commerce-server": "./bin/shoppex-mcp-commerce-server.mjs"
+  },
+  "files": [
+    "bin",
+    "src/server.mjs",
+    "src/index.d.ts",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "bun test"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.28.0",
+    "zod": "^4.1.12"
+  }
+}

package/src/index.d.ts

@@ -0,0 +1,20 @@
+export type CommerceToolDefinition = {
+  name: string;
+  description: string;
+  inputSchema: unknown;
+  execute: (args: Record<string, unknown>) => Promise<unknown>;
+};
+
+export function createCommerceToolCatalog(): CommerceToolDefinition[];
+export function executeCommerceTool(toolName: string, args: Record<string, unknown>): Promise<unknown>;
+export function createCommerceMcpServer(): unknown;
+export function startCommerceMcpServer(): Promise<void>;
+export class ShoppexCommerceDevApiClient {
+  constructor(input: { shopApiKey: string; apiBaseUrl?: string; fetchImpl?: typeof fetch });
+  request(method: string, path: string, options?: { query?: Record<string, unknown>; body?: unknown }): Promise<unknown>;
+}
+export class ShoppexCommerceDevApiError extends Error {
+  status: number | null;
+  code: string;
+  retryable: boolean;
+}

package/src/server.mjs

@@ -0,0 +1,557 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import * as z from 'zod/v4';
+
+const DEV_API_TIMEOUT_MS = Number.parseInt(process.env.SHOPPEX_DEV_API_TIMEOUT_MS ?? '10000', 10);
+
+function resolveBaseUrl(explicitValue) {
+  const rawValue = typeof explicitValue === 'string' && explicitValue.trim()
+    ? explicitValue.trim()
+    : (process.env.SHOPPEX_API_BASE_URL?.trim() || process.env.API_URL?.trim() || 'https://api.shoppex.io');
+  return rawValue.replace(/\/+$/, '');
+}
+
+function jsonContent(value) {
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify(value, null, 2),
+      },
+    ],
+    structuredContent: value,
+  };
+}
+
+export class ShoppexCommerceDevApiError extends Error {
+  constructor(
+    message,
+    {
+      status = null,
+      code = 'unknown_error',
+      retryable = false,
+      cause = undefined,
+    } = {},
+  ) {
+    super(message, cause ? { cause } : undefined);
+    this.name = 'ShoppexCommerceDevApiError';
+    this.status = status;
+    this.code = code;
+    this.retryable = retryable;
+  }
+}
+
+function classifyHttpError(status) {
+  if (status === 401 || status === 403) {
+    return { code: 'auth_error', retryable: false };
+  }
+
+  if (status === 404) {
+    return { code: 'not_found', retryable: false };
+  }
+
+  if (status === 408 || status === 429) {
+    return { code: 'rate_limited', retryable: true };
+  }
+
+  if (status >= 500) {
+    return { code: 'upstream_error', retryable: true };
+  }
+
+  return { code: 'bad_request', retryable: false };
+}
+
+export class ShoppexCommerceDevApiClient {
+  constructor({ shopApiKey, apiBaseUrl, fetchImpl = fetch }) {
+    this.shopApiKey = shopApiKey.trim();
+    this.apiBaseUrl = resolveBaseUrl(apiBaseUrl);
+    this.fetchImpl = fetchImpl;
+  }
+
+  async request(method, path, { query, body } = {}) {
+    const url = new URL(`${this.apiBaseUrl}${path}`);
+    if (query && typeof query === 'object') {
+      for (const [key, value] of Object.entries(query)) {
+        if (value === null || value === undefined || value === '') {
+          continue;
+        }
+        url.searchParams.set(key, String(value));
+      }
+    }
+
+    const controller = new AbortController();
+    const timeout = setTimeout(() => {
+      controller.abort(new Error(`Shoppex Dev API request timed out after ${DEV_API_TIMEOUT_MS}ms.`));
+    }, DEV_API_TIMEOUT_MS);
+
+    try {
+      const response = await this.fetchImpl(url, {
+        method,
+        headers: {
+          Authorization: `Bearer ${this.shopApiKey}`,
+          'Content-Type': 'application/json',
+        },
+        body: body === undefined ? undefined : JSON.stringify(body),
+        signal: controller.signal,
+      });
+
+      const rawPayload = await response.text();
+      const payload = rawPayload.length > 0
+        ? JSON.parse(rawPayload)
+        : null;
+
+      if (!response.ok) {
+        const classification = classifyHttpError(response.status);
+        const message = payload?.error?.message ?? payload?.message ?? `Shoppex Dev API request failed (${response.status}).`;
+        throw new ShoppexCommerceDevApiError(message, {
+          status: response.status,
+          code: classification.code,
+          retryable: classification.retryable,
+        });
+      }
+
+      if (rawPayload.length > 0 && payload === null) {
+        throw new ShoppexCommerceDevApiError('Shoppex Dev API returned an empty payload.', {
+          status: response.status,
+          code: 'invalid_response',
+          retryable: true,
+        });
+      }
+
+      return payload?.data ?? payload ?? null;
+    } catch (error) {
+      if (error instanceof ShoppexCommerceDevApiError) {
+        throw error;
+      }
+
+      if (error instanceof SyntaxError) {
+        throw new ShoppexCommerceDevApiError('Shoppex Dev API returned invalid JSON.', {
+          code: 'invalid_response',
+          retryable: true,
+          cause: error,
+        });
+      }
+
+      const message = error instanceof Error ? error.message : 'Shoppex Dev API request failed.';
+      const isTimeout = message.toLowerCase().includes('timed out') || message.toLowerCase().includes('aborted');
+      throw new ShoppexCommerceDevApiError(message, {
+        code: isTimeout ? 'timeout' : 'network_error',
+        retryable: true,
+        cause: error instanceof Error ? error : undefined,
+      });
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+
+  productsList(input = {}) {
+    const search = typeof input.search === 'string' ? input.search.trim() : '';
+    if (search) {
+      return this.request('GET', '/dev/v1/products/search', {
+        query: {
+          q: search,
+          limit: input.limit,
+          include_variants: true,
+        },
+      });
+    }
+
+    return this.request('GET', '/dev/v1/products', {
+      query: {
+        limit: input.limit,
+        status: input.status,
+        include_variants: true,
+      },
+    });
+  }
+
+  productsGet(productId) {
+    return this.request('GET', `/dev/v1/products/${encodeURIComponent(productId)}`, {
+      query: {
+        include_variants: true,
+      },
+    });
+  }
+
+  ordersList(input = {}) {
+    return this.request('GET', '/dev/v1/orders', {
+      query: {
+        limit: input.limit,
+        status: input.status,
+        customerEmail: input.customerEmail,
+      },
+    });
+  }
+
+  ordersGet(orderId) {
+    return this.request('GET', `/dev/v1/orders/${encodeURIComponent(orderId)}`);
+  }
+
+  customersGet(input) {
+    if (input.customerId) {
+      return this.request('GET', `/dev/v1/customers/${encodeURIComponent(input.customerId)}`);
+    }
+
+    if (!input.email) {
+      throw new ShoppexCommerceDevApiError('customers.get requires customer_id or email.', {
+        code: 'bad_request',
+        retryable: false,
+      });
+    }
+
+    return this.request('GET', '/dev/v1/customers', {
+      query: {
+        limit: 1,
+        filters: `email:${input.email}`,
+      },
+    }).then((data) => Array.isArray(data) ? (data[0] ?? null) : data);
+  }
+
+  paymentLinksCreate(input) {
+    return this.request('POST', '/dev/v1/payment-links', {
+      body: input,
+    });
+  }
+
+  analyticsRevenue(input = {}) {
+    return this.request('GET', '/dev/v1/analytics/revenue', {
+      query: {
+        from: input.from,
+        to: input.to,
+        currency: input.currency,
+      },
+    });
+  }
+
+  couponsList(input = {}) {
+    return this.request('GET', '/dev/v1/coupons', {
+      query: {
+        limit: input.limit,
+      },
+    });
+  }
+
+  couponsCreate(input) {
+    return this.request('POST', '/dev/v1/coupons', {
+      body: input,
+    });
+  }
+
+  couponsUpdate(couponId, input) {
+    return this.request('PATCH', `/dev/v1/coupons/${encodeURIComponent(couponId)}`, {
+      body: input,
+    });
+  }
+
+  productsCreate(input) {
+    return this.request('POST', '/dev/v1/products', {
+      body: input,
+    });
+  }
+
+  productsUpdate(productId, input) {
+    return this.request('PATCH', `/dev/v1/products/${encodeURIComponent(productId)}`, {
+      body: input,
+    });
+  }
+}
+
+const BaseToolSchema = {
+  shop_api_key: z.string().trim().min(1),
+  api_base_url: z.string().trim().url().optional(),
+};
+
+function createClient(args) {
+  return new ShoppexCommerceDevApiClient({
+    shopApiKey: args.shop_api_key,
+    apiBaseUrl: args.api_base_url,
+  });
+}
+
+export function createCommerceToolCatalog() {
+  return [
+    {
+      name: 'products.list',
+      description: 'Search or list products for one Shoppex shop.',
+      inputSchema: {
+        ...BaseToolSchema,
+        search: z.string().trim().min(1).optional(),
+        limit: z.number().int().min(1).max(50).optional(),
+        status: z.enum(['active', 'private', 'unlisted', 'all']).optional(),
+      },
+      execute: async (args) => createClient(args).productsList({
+        search: args.search,
+        limit: args.limit,
+        status: args.status,
+      }),
+    },
+    {
+      name: 'products.get',
+      description: 'Fetch one product by Shoppex product id or uniqid.',
+      inputSchema: {
+        ...BaseToolSchema,
+        product_id: z.string().trim().min(1),
+      },
+      execute: async (args) => createClient(args).productsGet(args.product_id),
+    },
+    {
+      name: 'orders.list',
+      description: 'List recent orders. Optionally filter by status or customer email.',
+      inputSchema: {
+        ...BaseToolSchema,
+        limit: z.number().int().min(1).max(50).optional(),
+        status: z.string().trim().min(1).optional(),
+        customer_email: z.string().trim().email().optional(),
+      },
+      execute: async (args) => createClient(args).ordersList({
+        limit: args.limit,
+        status: args.status,
+        customerEmail: args.customer_email,
+      }),
+    },
+    {
+      name: 'orders.get',
+      description: 'Fetch one order with line items by id or uniqid.',
+      inputSchema: {
+        ...BaseToolSchema,
+        order_id: z.string().trim().min(1),
+      },
+      execute: async (args) => createClient(args).ordersGet(args.order_id),
+    },
+    {
+      name: 'customers.get',
+      description: 'Fetch one customer by Shoppex customer id or email.',
+      inputSchema: {
+        ...BaseToolSchema,
+        customer_id: z.string().trim().min(1).optional(),
+        email: z.string().trim().email().optional(),
+      },
+      execute: async (args) => createClient(args).customersGet({
+        customerId: args.customer_id,
+        email: args.email,
+      }),
+    },
+    {
+      name: 'payment_links.create',
+      description: 'Create a Shoppex payment link.',
+      inputSchema: {
+        ...BaseToolSchema,
+        name: z.string().trim().min(1).max(255),
+        type: z.enum(['PRODUCT', 'SUBSCRIPTION', 'SUBSCRIPTION_V2', 'LICENSE', 'PAY_WHAT_YOU_WANT', 'FIXED_PRICE']),
+        description: z.string().max(255).optional().nullable(),
+        active: z.boolean().default(true),
+        price: z.number().positive(),
+        currency: z.string().trim().min(3).max(8).default('USD'),
+        gateways: z.array(z.string().trim().min(1)).min(1),
+        product_ids: z.array(z.string().trim().min(1)).optional(),
+        cta: z.enum(['PAY', 'BOOK', 'DONATE', 'SUBSCRIBE']).default('PAY'),
+        allow_discount_code: z.boolean().default(false),
+        require_customer_address: z.boolean().default(false),
+        require_customer_phone: z.boolean().default(false),
+        show_confirmation_page: z.boolean().default(true),
+        return_url: z.string().trim().url().optional().nullable(),
+      },
+      execute: async (args) => createClient(args).paymentLinksCreate({
+        name: args.name,
+        type: args.type,
+        description: args.description ?? null,
+        status: args.active,
+        price: args.price,
+        currency: args.currency,
+        gateways: args.gateways.join(','),
+        products_ids: (args.product_ids ?? []).join(','),
+        discount_code_allowed: args.allow_discount_code,
+        customer_address_required: args.require_customer_address,
+        customer_phone_required: args.require_customer_phone,
+        cta: args.cta,
+        show_confirmation_page: args.show_confirmation_page,
+        return_url: args.return_url ?? null,
+      }),
+    },
+    {
+      name: 'analytics.revenue',
+      description: 'Fetch revenue totals for a date range.',
+      inputSchema: {
+        ...BaseToolSchema,
+        from: z.string().trim().min(1).optional(),
+        to: z.string().trim().min(1).optional(),
+        currency: z.string().trim().min(3).max(8).default('USD'),
+      },
+      execute: async (args) => createClient(args).analyticsRevenue({
+        from: args.from,
+        to: args.to,
+        currency: args.currency,
+      }),
+    },
+    {
+      name: 'coupons.list',
+      description: 'List active coupons for a shop.',
+      inputSchema: {
+        ...BaseToolSchema,
+        limit: z.number().int().min(1).max(50).optional(),
+      },
+      execute: async (args) => createClient(args).couponsList({
+        limit: args.limit,
+      }),
+    },
+    {
+      name: 'coupons.create',
+      description: 'Create a coupon in Shoppex.',
+      inputSchema: {
+        ...BaseToolSchema,
+        code: z.string().trim().min(1).max(64),
+        discount_value: z.number().positive(),
+        discount_type: z.enum(['PERCENTAGE', 'FIXED']).default('PERCENTAGE'),
+        max_uses: z.number().int().positive().optional().nullable(),
+        product_ids: z.array(z.string().trim().min(1)).optional(),
+        min_order_amount: z.number().nonnegative().optional().nullable(),
+        max_discount: z.number().nonnegative().optional().nullable(),
+        valid_from: z.string().trim().optional().nullable(),
+        valid_until: z.string().trim().optional().nullable(),
+      },
+      execute: async (args) => createClient(args).couponsCreate({
+        code: args.code,
+        discount_value: args.discount_value,
+        discount_type: args.discount_type,
+        max_uses: args.max_uses ?? null,
+        products_bound: args.product_ids ?? [],
+        min_order_amount: args.min_order_amount ?? null,
+        max_discount: args.max_discount ?? null,
+        valid_from: args.valid_from ?? null,
+        valid_until: args.valid_until ?? null,
+      }),
+    },
+    {
+      name: 'coupons.update',
+      description: 'Update an existing coupon by uniqid. Only provided fields are changed.',
+      inputSchema: {
+        ...BaseToolSchema,
+        coupon_id: z.string().trim().min(1),
+        code: z.string().trim().min(1).max(64).optional(),
+        discount_value: z.number().positive().optional(),
+        discount_type: z.enum(['PERCENTAGE', 'FIXED']).optional(),
+        max_uses: z.number().int().positive().optional().nullable(),
+        min_order_amount: z.number().nonnegative().optional().nullable(),
+        max_discount: z.number().nonnegative().optional().nullable(),
+        valid_from: z.string().trim().optional().nullable(),
+        valid_until: z.string().trim().optional().nullable(),
+      },
+      execute: async (args) => {
+        const body = {};
+        if (args.code !== undefined) body.code = args.code;
+        if (args.discount_value !== undefined) body.discount_value = args.discount_value;
+        if (args.discount_type !== undefined) body.discount_type = args.discount_type;
+        if (args.max_uses !== undefined) body.max_uses = args.max_uses;
+        if (args.min_order_amount !== undefined) body.min_order_amount = args.min_order_amount;
+        if (args.max_discount !== undefined) body.max_discount = args.max_discount;
+        if (args.valid_from !== undefined) body.valid_from = args.valid_from;
+        if (args.valid_until !== undefined) body.valid_until = args.valid_until;
+        return createClient(args).couponsUpdate(args.coupon_id, body);
+      },
+    },
+    {
+      name: 'products.create',
+      description: 'Create a product. Defaults to a simple digital/service product. For key-based products pass type="SERIALS" and provide the serials array.',
+      inputSchema: {
+        ...BaseToolSchema,
+        title: z.string().trim().min(1).max(128),
+        price: z.number().min(0),
+        description: z.string().optional(),
+        currency: z.string().trim().min(3).max(8).optional(),
+        type: z.enum(['SERVICE', 'SERIALS', 'DYNAMIC', 'FILE']).default('SERVICE'),
+        gateways: z.array(z.string().trim().min(1)).optional(),
+        serials: z.array(z.string().trim().min(1)).optional(),
+        service_text: z.string().optional(),
+        delivery_text: z.string().optional(),
+        stock: z.number().int().min(-1).optional(),
+        category_id: z.string().trim().min(1).optional().nullable(),
+        unlisted: z.boolean().optional(),
+        private: z.boolean().optional(),
+      },
+      execute: async (args) => {
+        const body = {
+          title: args.title,
+          price: args.price,
+          type: args.type,
+        };
+        if (args.description !== undefined) body.description = args.description;
+        if (args.currency !== undefined) body.currency = args.currency;
+        if (args.gateways !== undefined) body.gateways = args.gateways;
+        if (args.serials !== undefined) body.serials = args.serials;
+        if (args.service_text !== undefined) body.service_text = args.service_text;
+        if (args.delivery_text !== undefined) body.delivery_text = args.delivery_text;
+        if (args.stock !== undefined) body.stock = args.stock;
+        if (args.category_id !== undefined) body.category_id = args.category_id;
+        if (args.unlisted !== undefined) body.unlisted = args.unlisted;
+        if (args.private !== undefined) body.private = args.private;
+        return createClient(args).productsCreate(body);
+      },
+    },
+    {
+      name: 'products.update',
+      description: 'Update an existing product by uniqid. Only provided fields are changed.',
+      inputSchema: {
+        ...BaseToolSchema,
+        product_id: z.string().trim().min(1),
+        title: z.string().trim().min(1).max(128).optional(),
+        price: z.number().min(0).optional(),
+        description: z.string().optional(),
+        currency: z.string().trim().min(3).max(8).optional(),
+        gateways: z.array(z.string().trim().min(1)).optional(),
+        stock: z.number().int().min(-1).optional(),
+        unlisted: z.boolean().optional(),
+        private: z.boolean().optional(),
+        on_hold: z.boolean().optional(),
+        category_id: z.string().trim().min(1).optional().nullable(),
+      },
+      execute: async (args) => {
+        const body = {};
+        if (args.title !== undefined) body.title = args.title;
+        if (args.price !== undefined) body.price = args.price;
+        if (args.description !== undefined) body.description = args.description;
+        if (args.currency !== undefined) body.currency = args.currency;
+        if (args.gateways !== undefined) body.gateways = args.gateways;
+        if (args.stock !== undefined) body.stock = args.stock;
+        if (args.unlisted !== undefined) body.unlisted = args.unlisted;
+        if (args.private !== undefined) body.private = args.private;
+        if (args.on_hold !== undefined) body.on_hold = args.on_hold;
+        if (args.category_id !== undefined) body.category_id = args.category_id;
+        return createClient(args).productsUpdate(args.product_id, body);
+      },
+    },
+  ];
+}
+
+export async function executeCommerceTool(toolName, args) {
+  const tool = createCommerceToolCatalog().find((entry) => entry.name === toolName);
+  if (!tool) {
+    throw new Error(`Unknown tool: ${toolName}`);
+  }
+
+  return tool.execute(args);
+}
+
+export function createCommerceMcpServer() {
+  const server = new McpServer({
+    name: 'shoppex-commerce',
+    version: '0.1.0',
+  });
+
+  for (const tool of createCommerceToolCatalog()) {
+    server.registerTool(tool.name, {
+      description: tool.description,
+      inputSchema: tool.inputSchema,
+    }, async (args) => {
+      const result = await tool.execute(args);
+      return jsonContent(result);
+    });
+  }
+
+  return server;
+}
+
+export async function startCommerceMcpServer() {
+  const server = createCommerceMcpServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}