@shoppexio/mcp-commerce-server 0.4.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shoppexio/mcp-commerce-server",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Shoppex MCP server for commerce operations over the Dev API",
   "type": "module",
   "repository": {

package/src/server.mjs

@@ -12,6 +12,9 @@ function resolveBaseUrl(explicitValue) {
 }
 
 function jsonContent(value) {
+  const structured = Array.isArray(value) || value === null || typeof value !== 'object'
+    ? { result: value }
+    : value;
   return {
     content: [
       {
@@ -19,7 +22,7 @@ function jsonContent(value) {
         text: JSON.stringify(value, null, 2),
       },
     ],
-    structuredContent: value,
+    structuredContent: structured,
   };
 }
 
@@ -254,6 +257,84 @@ export class ShoppexCommerceDevApiClient {
       body: input,
     });
   }
+
+  productsDelete(productId) {
+    return this.request('DELETE', `/dev/v1/products/${encodeURIComponent(productId)}`);
+  }
+
+  productsDuplicate(productId) {
+    return this.request('POST', `/dev/v1/products/${encodeURIComponent(productId)}/duplicate`);
+  }
+
+  productsUploadSerials(productId, input) {
+    return this.request('POST', `/dev/v1/products/${encodeURIComponent(productId)}/serials`, {
+      body: input,
+    });
+  }
+
+  customersList(input = {}) {
+    return this.request('GET', '/dev/v1/customers', {
+      query: { limit: input.limit, filters: input.filters },
+    });
+  }
+
+  categoriesList() {
+    return this.request('GET', '/dev/v1/categories');
+  }
+
+  categoriesCreate(input) {
+    return this.request('POST', '/dev/v1/categories', { body: input });
+  }
+
+  categoriesUpdate(categoryId, input) {
+    return this.request('PATCH', `/dev/v1/categories/${encodeURIComponent(categoryId)}`, { body: input });
+  }
+
+  webhooksList() {
+    return this.request('GET', '/dev/v1/webhooks');
+  }
+
+  webhooksCreate(input) {
+    return this.request('POST', '/dev/v1/webhooks', { body: input });
+  }
+
+  invoicesList(input = {}) {
+    return this.request('GET', '/dev/v1/invoices', {
+      query: { limit: input.limit, status: input.status, customer_email: input.customer_email },
+    });
+  }
+
+  invoicesGet(uniqid) {
+    return this.request('GET', `/dev/v1/invoices/${encodeURIComponent(uniqid)}`);
+  }
+
+  disputesList(input = {}) {
+    return this.request('GET', '/dev/v1/disputes', {
+      query: { limit: input.limit, status: input.status },
+    });
+  }
+
+  licensesList() {
+    return this.request('GET', '/dev/v1/licenses');
+  }
+
+  affiliatesList(input = {}) {
+    return this.request('GET', '/dev/v1/affiliates', {
+      query: { limit: input.limit },
+    });
+  }
+
+  subscriptionsList(input = {}) {
+    return this.request('GET', '/dev/v1/subscriptions', {
+      query: { limit: input.limit, status: input.status },
+    });
+  }
+
+  subscriptionsCancel(subscriptionId, input = {}) {
+    return this.request('POST', `/dev/v1/subscriptions/${encodeURIComponent(subscriptionId)}/cancel`, {
+      body: input,
+    });
+  }
 }
 
 const BaseToolSchema = {
@@ -535,6 +616,190 @@ export function createCommerceToolCatalog() {
         return createClient(args).productsUpdate(args.product_id, body);
       },
     },
+    {
+      name: 'products_delete',
+      description: 'Soft-delete a product by uniqid. The product is hidden from the storefront but kept for historical orders.',
+      inputSchema: { ...BaseToolSchema, product_id: z.string().trim().min(1) },
+      execute: async (args) => createClient(args).productsDelete(args.product_id),
+    },
+    {
+      name: 'products_duplicate',
+      description: 'Duplicate a product by uniqid. Returns the newly created product.',
+      inputSchema: { ...BaseToolSchema, product_id: z.string().trim().min(1) },
+      execute: async (args) => createClient(args).productsDuplicate(args.product_id),
+    },
+    {
+      name: 'products_upload_serials',
+      description: 'Upload additional serial keys (license keys) to a product whose type is SERIALS. Useful for restocking digital key-based products.',
+      inputSchema: {
+        ...BaseToolSchema,
+        product_id: z.string().trim().min(1),
+        serials: z.array(z.string().trim().min(1)).min(1),
+        remove_duplicates: z.boolean().optional(),
+      },
+      execute: async (args) => createClient(args).productsUploadSerials(args.product_id, {
+        serials: args.serials,
+        serials_remove_duplicates: args.remove_duplicates ?? false,
+      }),
+    },
+    {
+      name: 'customers_list',
+      description: 'List customers for the authenticated shop. Supports Shoppex-style filter expressions (e.g. "email:john@example.com").',
+      inputSchema: {
+        ...BaseToolSchema,
+        limit: z.number().int().min(1).max(50).optional(),
+        filters: z.string().trim().min(1).optional(),
+      },
+      execute: async (args) => createClient(args).customersList({
+        limit: args.limit,
+        filters: args.filters,
+      }),
+    },
+    {
+      name: 'categories_list',
+      description: 'List product categories for the authenticated shop.',
+      inputSchema: { ...BaseToolSchema },
+      execute: async (args) => createClient(args).categoriesList(),
+    },
+    {
+      name: 'categories_create',
+      description: 'Create a product category.',
+      inputSchema: {
+        ...BaseToolSchema,
+        name: z.string().trim().min(1).max(128),
+        description: z.string().optional(),
+        parent_id: z.string().trim().min(1).optional().nullable(),
+        image_id: z.string().trim().min(1).optional().nullable(),
+      },
+      execute: async (args) => {
+        const body = { name: args.name };
+        if (args.description !== undefined) body.description = args.description;
+        if (args.parent_id !== undefined) body.parent_id = args.parent_id;
+        if (args.image_id !== undefined) body.image_id = args.image_id;
+        return createClient(args).categoriesCreate(body);
+      },
+    },
+    {
+      name: 'categories_update',
+      description: 'Update a category by id. Only provided fields change.',
+      inputSchema: {
+        ...BaseToolSchema,
+        category_id: z.string().trim().min(1),
+        name: z.string().trim().min(1).max(128).optional(),
+        description: z.string().optional(),
+        parent_id: z.string().trim().min(1).optional().nullable(),
+        image_id: z.string().trim().min(1).optional().nullable(),
+      },
+      execute: async (args) => {
+        const body = {};
+        if (args.name !== undefined) body.name = args.name;
+        if (args.description !== undefined) body.description = args.description;
+        if (args.parent_id !== undefined) body.parent_id = args.parent_id;
+        if (args.image_id !== undefined) body.image_id = args.image_id;
+        return createClient(args).categoriesUpdate(args.category_id, body);
+      },
+    },
+    {
+      name: 'webhooks_list',
+      description: 'List webhook subscriptions registered for the authenticated shop.',
+      inputSchema: { ...BaseToolSchema },
+      execute: async (args) => createClient(args).webhooksList(),
+    },
+    {
+      name: 'webhooks_create',
+      description: 'Register a webhook subscription for shop events. Returns the webhook with its signing secret.',
+      inputSchema: {
+        ...BaseToolSchema,
+        url: z.string().trim().url(),
+        events: z.array(z.string().trim().min(1)).min(1),
+        description: z.string().max(255).optional(),
+      },
+      execute: async (args) => {
+        const body = { url: args.url, events: args.events };
+        if (args.description !== undefined) body.description = args.description;
+        return createClient(args).webhooksCreate(body);
+      },
+    },
+    {
+      name: 'invoices_list',
+      description: 'List invoices. Can filter by status (pending, paid, cancelled, refunded) and 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).invoicesList({
+        limit: args.limit,
+        status: args.status,
+        customer_email: args.customer_email,
+      }),
+    },
+    {
+      name: 'invoices_get',
+      description: 'Fetch one invoice with line items, payment, and customer by uniqid.',
+      inputSchema: { ...BaseToolSchema, invoice_id: z.string().trim().min(1) },
+      execute: async (args) => createClient(args).invoicesGet(args.invoice_id),
+    },
+    {
+      name: 'disputes_list',
+      description: 'List chargeback disputes. Filter by status (open, won, lost, warning).',
+      inputSchema: {
+        ...BaseToolSchema,
+        limit: z.number().int().min(1).max(50).optional(),
+        status: z.string().trim().min(1).optional(),
+      },
+      execute: async (args) => createClient(args).disputesList({
+        limit: args.limit,
+        status: args.status,
+      }),
+    },
+    {
+      name: 'licenses_list',
+      description: 'List software licenses issued by the shop. Useful for validating or revoking customer license keys.',
+      inputSchema: { ...BaseToolSchema },
+      execute: async (args) => createClient(args).licensesList(),
+    },
+    {
+      name: 'affiliates_list',
+      description: 'List affiliates (customers with active affiliate links) for the authenticated shop.',
+      inputSchema: {
+        ...BaseToolSchema,
+        limit: z.number().int().min(1).max(50).optional(),
+      },
+      execute: async (args) => createClient(args).affiliatesList({
+        limit: args.limit,
+      }),
+    },
+    {
+      name: 'subscriptions_list',
+      description: 'List recurring subscriptions. Filter by status (active, past_due, cancelled, paused, trialing).',
+      inputSchema: {
+        ...BaseToolSchema,
+        limit: z.number().int().min(1).max(50).optional(),
+        status: z.string().trim().min(1).optional(),
+      },
+      execute: async (args) => createClient(args).subscriptionsList({
+        limit: args.limit,
+        status: args.status,
+      }),
+    },
+    {
+      name: 'subscriptions_cancel',
+      description: 'Cancel a subscription by id. Optionally cancel immediately or at end of current period.',
+      inputSchema: {
+        ...BaseToolSchema,
+        subscription_id: z.string().trim().min(1),
+        cancel_at_period_end: z.boolean().optional(),
+        reason: z.string().max(255).optional(),
+      },
+      execute: async (args) => {
+        const body = {};
+        if (args.cancel_at_period_end !== undefined) body.cancel_at_period_end = args.cancel_at_period_end;
+        if (args.reason !== undefined) body.reason = args.reason;
+        return createClient(args).subscriptionsCancel(args.subscription_id, body);
+      },
+    },
   ];
 }