woo-mcp-server 1.0.0

package/dist/server.cjs

@@ -0,0 +1,3061 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/server.ts
+var server_exports = {};
+__export(server_exports, {
+  SERVER_NAME: () => SERVER_NAME,
+  SERVER_VERSION: () => SERVER_VERSION,
+  connectStdio: () => connectStdio,
+  createServer: () => createServer,
+  createWooClient: () => createWooClient,
+  loadConfig: () => loadConfig,
+  registerAll: () => registerAll,
+  startServer: () => startServer
+});
+module.exports = __toCommonJS(server_exports);
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+
+// src/config.ts
+var import_zod = require("zod");
+var ConfigSchema = import_zod.z.object({
+  WC_URL: import_zod.z.string({ required_error: "WC_URL is required" }).url("WC_URL must be a valid URL (e.g. https://mystore.com)").describe("Base URL of the WooCommerce store"),
+  WC_KEY: import_zod.z.string({ required_error: "WC_KEY is required" }).min(1, "WC_KEY cannot be empty").describe("WooCommerce REST API consumer key (ck_...)"),
+  WC_SECRET: import_zod.z.string({ required_error: "WC_SECRET is required" }).min(1, "WC_SECRET cannot be empty").describe("WooCommerce REST API consumer secret (cs_...)"),
+  WC_VERSION: import_zod.z.string().default("wc/v3").describe("WooCommerce REST API version prefix"),
+  WC_RATE_LIMIT_PER_SECOND: import_zod.z.coerce.number().int().positive().default(5).describe("Max outgoing WC API requests per second (default 5)"),
+  WC_QUERY_STRING_AUTH: import_zod.z.enum(["true", "false", "1", "0", ""]).optional().transform((v) => v === "true" || v === "1").describe("Use query-string auth instead of Basic Auth over HTTPS")
+});
+var MISSING_ENV_HELP = `
+WooCommerce MCP Server configuration error.
+
+Required environment variables:
+  WC_URL     \u2014 Store base URL, e.g. https://mystore.com
+  WC_KEY     \u2014 REST API consumer key (WooCommerce \u2192 Settings \u2192 Advanced \u2192 REST API)
+  WC_SECRET  \u2014 REST API consumer secret
+
+Optional:
+  WC_VERSION                 \u2014 API version (default: wc/v3)
+  WC_RATE_LIMIT_PER_SECOND   \u2014 Max requests/sec (default: 5)
+  WC_QUERY_STRING_AUTH       \u2014 "true" to pass credentials as query params
+
+Example (Claude Desktop config):
+  {
+    "mcpServers": {
+      "woocommerce": {
+        "command": "npx",
+        "args": ["woo-mcp-server"],
+        "env": {
+          "WC_URL": "https://mystore.com",
+          "WC_KEY": "ck_xxxxxxxx",
+          "WC_SECRET": "cs_xxxxxxxx"
+        }
+      }
+    }
+  }
+`.trim();
+function loadConfig(env = process.env) {
+  const result = ConfigSchema.safeParse({
+    WC_URL: env.WC_URL,
+    WC_KEY: env.WC_KEY,
+    WC_SECRET: env.WC_SECRET,
+    WC_VERSION: env.WC_VERSION,
+    WC_RATE_LIMIT_PER_SECOND: env.WC_RATE_LIMIT_PER_SECOND ?? "5",
+    WC_QUERY_STRING_AUTH: env.WC_QUERY_STRING_AUTH ?? ""
+  });
+  if (!result.success) {
+    const details = result.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new Error(`${MISSING_ENV_HELP}
+
+Validation issues:
+${details}`);
+  }
+  return result.data;
+}
+
+// src/client.ts
+var import_woocommerce_rest_ts_api = __toESM(require("woocommerce-rest-ts-api"), 1);
+var WooCommerceRestApi = import_woocommerce_rest_ts_api.default.default ?? import_woocommerce_rest_ts_api.default;
+var ConcurrencyThrottler = class {
+  current = 0;
+  queue = [];
+  maxConcurrent;
+  constructor(maxConcurrent) {
+    this.maxConcurrent = maxConcurrent;
+  }
+  async acquire() {
+    if (this.maxConcurrent <= 0) return;
+    if (this.current < this.maxConcurrent) {
+      this.current++;
+      return;
+    }
+    return new Promise((resolve) => {
+      this.queue.push(() => {
+        this.current++;
+        resolve();
+      });
+    });
+  }
+  release() {
+    if (this.maxConcurrent <= 0) return;
+    this.current = Math.max(0, this.current - 1);
+    const next = this.queue.shift();
+    if (next) next();
+  }
+};
+var RateLimiter = class {
+  intervalMs;
+  throttler;
+  lastRequestAt = 0;
+  chain = Promise.resolve();
+  constructor(requestsPerSecond, maxConcurrent) {
+    this.intervalMs = Math.ceil(1e3 / Math.max(1, requestsPerSecond));
+    this.throttler = new ConcurrencyThrottler(
+      maxConcurrent ?? Math.max(1, requestsPerSecond)
+    );
+  }
+  /**
+   * Schedule `fn` to run respecting both rate and concurrency limits.
+   */
+  async schedule(fn) {
+    const run = this.chain.then(async () => {
+      const now = Date.now();
+      const wait = Math.max(0, this.lastRequestAt + this.intervalMs - now);
+      if (wait > 0) {
+        await new Promise((r) => setTimeout(r, wait));
+      }
+      this.lastRequestAt = Date.now();
+    });
+    this.chain = run.catch(() => void 0);
+    await run;
+    await this.throttler.acquire();
+    try {
+      return await fn();
+    } finally {
+      this.throttler.release();
+    }
+  }
+};
+function createWooClient(config) {
+  const rateLimiter = new RateLimiter(config.WC_RATE_LIMIT_PER_SECOND);
+  const ApiCtor = WooCommerceRestApi;
+  const apiInstance = new ApiCtor({
+    url: config.WC_URL,
+    consumerKey: config.WC_KEY,
+    consumerSecret: config.WC_SECRET,
+    version: config.WC_VERSION,
+    queryStringAuth: config.WC_QUERY_STRING_AUTH,
+    maxConcurrentRequests: config.WC_RATE_LIMIT_PER_SECOND
+  });
+  const cleanParams = (params) => {
+    if (!params) return void 0;
+    const out = {};
+    for (const [k, v] of Object.entries(params)) {
+      if (v === void 0 || v === null || v === "") continue;
+      out[k] = v;
+    }
+    return Object.keys(out).length ? out : void 0;
+  };
+  const client = {
+    api: apiInstance,
+    rateLimiter,
+    config,
+    get: (endpoint, params) => rateLimiter.schedule(() => apiInstance.get(endpoint, cleanParams(params))),
+    post: (endpoint, data, params) => rateLimiter.schedule(
+      () => apiInstance.post(endpoint, data, cleanParams(params))
+    ),
+    put: (endpoint, data, params) => rateLimiter.schedule(
+      () => apiInstance.put(endpoint, data, cleanParams(params))
+    ),
+    delete: (endpoint, data, params) => rateLimiter.schedule(
+      () => apiInstance.delete(
+        endpoint,
+        data ?? { force: true },
+        cleanParams(params)
+      )
+    ),
+    pagination(response, page, perPage) {
+      const info = (0, import_woocommerce_rest_ts_api.parsePaginationHeaders)(response);
+      return {
+        total: info.total,
+        totalPages: info.totalPages,
+        currentPage: page,
+        perPage
+      };
+    }
+  };
+  return client;
+}
+
+// src/tools/products.ts
+var import_zod3 = require("zod");
+
+// src/errors.ts
+var import_woocommerce_rest_ts_api2 = require("woocommerce-rest-ts-api");
+function messageOf(err, fallback) {
+  if (err instanceof Error && err.message) return err.message;
+  if (typeof err === "string" && err) return err;
+  return fallback;
+}
+function normalizeError(err) {
+  if (err instanceof import_woocommerce_rest_ts_api2.AuthenticationError) {
+    return {
+      code: "authentication_error",
+      message: messageOf(
+        err,
+        "WooCommerce authentication failed. Check WC_KEY and WC_SECRET."
+      ),
+      status: 401
+    };
+  }
+  if (err instanceof import_woocommerce_rest_ts_api2.WooCommerceApiError) {
+    const anyErr = err;
+    const maybeStatus = err.status;
+    const status = anyErr.statusCode ?? anyErr.response?.status ?? (typeof maybeStatus === "number" ? maybeStatus : void 0);
+    return {
+      code: anyErr.code || "woocommerce_api_error",
+      message: messageOf(err, "WooCommerce API request failed"),
+      status,
+      details: anyErr.response?.data
+    };
+  }
+  if (err instanceof import_woocommerce_rest_ts_api2.OptionsException) {
+    return {
+      code: "options_error",
+      message: messageOf(err, "Invalid WooCommerce client options")
+    };
+  }
+  if (err instanceof Error) {
+    const axiosLike = err;
+    if (axiosLike.response) {
+      const data = axiosLike.response.data;
+      return {
+        code: data?.code || axiosLike.code || "http_error",
+        message: data?.message || messageOf(err, `HTTP ${axiosLike.response.status} error from WooCommerce`),
+        status: axiosLike.response.status,
+        details: data
+      };
+    }
+    return {
+      code: axiosLike.code || "internal_error",
+      message: messageOf(err, "Internal error"),
+      status: axiosLike.status
+    };
+  }
+  return {
+    code: "unknown_error",
+    message: typeof err === "string" ? err : "An unknown error occurred"
+  };
+}
+function toMcpToolError(err) {
+  const normalized = normalizeError(err);
+  const parts = [
+    `Error [${normalized.code}]${normalized.status ? ` (HTTP ${normalized.status})` : ""}: ${normalized.message}`
+  ];
+  if (normalized.details !== void 0) {
+    try {
+      parts.push(`Details: ${JSON.stringify(normalized.details)}`);
+    } catch {
+    }
+  }
+  return {
+    isError: true,
+    content: [{ type: "text", text: parts.join("\n") }]
+  };
+}
+
+// src/types.ts
+var import_zod2 = require("zod");
+var PaginationInputSchema = import_zod2.z.object({
+  page: import_zod2.z.number().int().min(1).default(1).describe("Page number to retrieve (1-based). Example: 1").optional(),
+  per_page: import_zod2.z.number().int().min(1).max(100).default(10).describe("Number of items per page (1\u2013100). Example: 20").optional()
+});
+var PaginationMetaSchema = import_zod2.z.object({
+  total: import_zod2.z.number().describe("Total number of matching items across all pages"),
+  totalPages: import_zod2.z.number().describe("Total number of pages available"),
+  currentPage: import_zod2.z.number().describe("The page that was returned"),
+  perPage: import_zod2.z.number().describe("Items requested per page")
+});
+var WcEntitySchema = import_zod2.z.object({
+  id: import_zod2.z.union([import_zod2.z.number(), import_zod2.z.string()]).optional()
+}).passthrough();
+var ProductSchema = import_zod2.z.object({
+  id: import_zod2.z.number().optional(),
+  name: import_zod2.z.string().optional(),
+  slug: import_zod2.z.string().optional(),
+  permalink: import_zod2.z.string().optional(),
+  type: import_zod2.z.string().optional(),
+  status: import_zod2.z.string().optional(),
+  description: import_zod2.z.string().optional(),
+  short_description: import_zod2.z.string().optional(),
+  sku: import_zod2.z.string().optional(),
+  price: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.number()]).optional(),
+  regular_price: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.number()]).optional(),
+  sale_price: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.number()]).optional(),
+  stock_quantity: import_zod2.z.number().nullable().optional(),
+  stock_status: import_zod2.z.string().optional(),
+  manage_stock: import_zod2.z.boolean().optional(),
+  categories: import_zod2.z.array(import_zod2.z.unknown()).optional(),
+  tags: import_zod2.z.array(import_zod2.z.unknown()).optional(),
+  images: import_zod2.z.array(import_zod2.z.unknown()).optional()
+}).passthrough();
+var OrderSchema = import_zod2.z.object({
+  id: import_zod2.z.number().optional(),
+  status: import_zod2.z.string().optional(),
+  currency: import_zod2.z.string().optional(),
+  total: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.number()]).optional(),
+  customer_id: import_zod2.z.number().optional(),
+  billing: import_zod2.z.record(import_zod2.z.unknown()).optional(),
+  shipping: import_zod2.z.record(import_zod2.z.unknown()).optional(),
+  line_items: import_zod2.z.array(import_zod2.z.unknown()).optional(),
+  date_created: import_zod2.z.string().optional()
+}).passthrough();
+var CustomerSchema = import_zod2.z.object({
+  id: import_zod2.z.number().optional(),
+  email: import_zod2.z.string().optional(),
+  first_name: import_zod2.z.string().optional(),
+  last_name: import_zod2.z.string().optional(),
+  username: import_zod2.z.string().optional(),
+  role: import_zod2.z.string().optional(),
+  billing: import_zod2.z.record(import_zod2.z.unknown()).optional(),
+  shipping: import_zod2.z.record(import_zod2.z.unknown()).optional()
+}).passthrough();
+var CouponSchema = import_zod2.z.object({
+  id: import_zod2.z.number().optional(),
+  code: import_zod2.z.string().optional(),
+  amount: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.number()]).optional(),
+  discount_type: import_zod2.z.string().optional(),
+  description: import_zod2.z.string().optional()
+}).passthrough();
+var CategorySchema = import_zod2.z.object({
+  id: import_zod2.z.number().optional(),
+  name: import_zod2.z.string().optional(),
+  slug: import_zod2.z.string().optional(),
+  parent: import_zod2.z.number().optional(),
+  description: import_zod2.z.string().optional(),
+  count: import_zod2.z.number().optional()
+}).passthrough();
+var TagSchema = import_zod2.z.object({
+  id: import_zod2.z.number().optional(),
+  name: import_zod2.z.string().optional(),
+  slug: import_zod2.z.string().optional(),
+  description: import_zod2.z.string().optional(),
+  count: import_zod2.z.number().optional()
+}).passthrough();
+var VariationSchema = import_zod2.z.object({
+  id: import_zod2.z.number().optional(),
+  sku: import_zod2.z.string().optional(),
+  price: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.number()]).optional(),
+  regular_price: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.number()]).optional(),
+  stock_quantity: import_zod2.z.number().nullable().optional(),
+  stock_status: import_zod2.z.string().optional(),
+  attributes: import_zod2.z.array(import_zod2.z.unknown()).optional()
+}).passthrough();
+var WebhookSchema = import_zod2.z.object({
+  id: import_zod2.z.number().optional(),
+  name: import_zod2.z.string().optional(),
+  status: import_zod2.z.string().optional(),
+  topic: import_zod2.z.string().optional(),
+  delivery_url: import_zod2.z.string().optional()
+}).passthrough();
+var TaxRateSchema = import_zod2.z.object({
+  id: import_zod2.z.number().optional(),
+  country: import_zod2.z.string().optional(),
+  state: import_zod2.z.string().optional(),
+  rate: import_zod2.z.string().optional(),
+  name: import_zod2.z.string().optional(),
+  class: import_zod2.z.string().optional()
+}).passthrough();
+var OrderNoteSchema = import_zod2.z.object({
+  id: import_zod2.z.number().optional(),
+  author: import_zod2.z.string().optional(),
+  date_created: import_zod2.z.string().optional(),
+  note: import_zod2.z.string().optional(),
+  customer_note: import_zod2.z.boolean().optional()
+}).passthrough();
+function listResponseSchema(itemSchema) {
+  return import_zod2.z.object({
+    items: import_zod2.z.array(itemSchema),
+    pagination: PaginationMetaSchema
+  });
+}
+function singleResponseSchema(itemSchema) {
+  return import_zod2.z.object({
+    item: itemSchema
+  });
+}
+var DeleteResponseSchema = import_zod2.z.object({
+  deleted: import_zod2.z.boolean(),
+  previous: import_zod2.z.unknown().optional(),
+  id: import_zod2.z.number().optional()
+});
+var BatchResponseSchema = import_zod2.z.object({
+  create: import_zod2.z.array(import_zod2.z.unknown()).optional(),
+  update: import_zod2.z.array(import_zod2.z.unknown()).optional(),
+  delete: import_zod2.z.array(import_zod2.z.unknown()).optional()
+});
+var BatchOperationSchema = import_zod2.z.object({
+  create: import_zod2.z.array(import_zod2.z.record(import_zod2.z.unknown())).optional().describe("Array of objects to create"),
+  update: import_zod2.z.array(
+    import_zod2.z.object({ id: import_zod2.z.number().describe("ID of the resource to update") }).passthrough()
+  ).optional().describe("Array of objects to update (each must include id)"),
+  delete: import_zod2.z.array(import_zod2.z.number()).optional().describe("Array of resource IDs to delete")
+});
+function parseListOutput(items, page, perPage, total, totalPages, itemSchema) {
+  const schema = listResponseSchema(itemSchema);
+  return schema.parse({
+    items: Array.isArray(items) ? items : [],
+    pagination: {
+      total,
+      totalPages,
+      currentPage: page,
+      perPage
+    }
+  });
+}
+function parseSingleOutput(item, itemSchema) {
+  return singleResponseSchema(itemSchema).parse({ item });
+}
+function textContent(data) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: typeof data === "string" ? data : JSON.stringify(data, null, 2)
+      }
+    ]
+  };
+}
+
+// src/tools/products.ts
+var ProductCreateSchema = import_zod3.z.object({
+  name: import_zod3.z.string().describe('Product name. Example: "Blue T-Shirt"'),
+  type: import_zod3.z.enum(["simple", "grouped", "external", "variable"]).optional().describe("Product type. Default simple."),
+  regular_price: import_zod3.z.string().optional().describe('Regular price as string. Example: "29.99"'),
+  description: import_zod3.z.string().optional().describe("Full HTML description"),
+  short_description: import_zod3.z.string().optional().describe("Short description / excerpt"),
+  sku: import_zod3.z.string().optional().describe("Stock keeping unit"),
+  manage_stock: import_zod3.z.boolean().optional().describe("Whether to manage stock"),
+  stock_quantity: import_zod3.z.number().optional().describe("Stock quantity when manage_stock is true"),
+  categories: import_zod3.z.array(import_zod3.z.object({ id: import_zod3.z.number() })).optional().describe("Category IDs to assign"),
+  images: import_zod3.z.array(import_zod3.z.object({ src: import_zod3.z.string().url() })).optional().describe("Product images by source URL"),
+  status: import_zod3.z.enum(["draft", "pending", "private", "publish"]).optional().describe("Publish status")
+}).passthrough();
+function registerProductTools(server, client) {
+  server.registerTool(
+    "woo_products_list",
+    {
+      title: "List products",
+      description: "Lists products from the WooCommerce catalog with pagination. Use this when you need to browse the catalog, build an inventory overview, or feed product data into a report. Returns product objects plus pagination metadata (total, totalPages, currentPage).",
+      inputSchema: {
+        ...PaginationInputSchema.shape,
+        status: import_zod3.z.enum(["any", "draft", "pending", "private", "publish"]).optional().describe("Filter by publish status. Example: publish"),
+        category: import_zod3.z.string().optional().describe('Filter by category ID. Example: "15"'),
+        tag: import_zod3.z.string().optional().describe("Filter by tag ID"),
+        stock_status: import_zod3.z.enum(["instock", "outofstock", "onbackorder"]).optional().describe("Filter by stock status"),
+        orderby: import_zod3.z.enum(["date", "id", "title", "slug", "price", "popularity", "rating"]).optional().describe("Sort field"),
+        order: import_zod3.z.enum(["asc", "desc"]).optional().describe("Sort direction")
+      }
+    },
+    async (args) => {
+      try {
+        const page = args.page ?? 1;
+        const per_page = args.per_page ?? 10;
+        const res = await client.get("products", {
+          page,
+          per_page,
+          status: args.status,
+          category: args.category,
+          tag: args.tag,
+          stock_status: args.stock_status,
+          orderby: args.orderby,
+          order: args.order
+        });
+        const meta = client.pagination(res, page, per_page);
+        const out = parseListOutput(
+          res.data,
+          meta.currentPage,
+          meta.perPage,
+          meta.total,
+          meta.totalPages,
+          ProductSchema
+        );
+        return textContent(out);
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_products_get",
+    {
+      title: "Get product",
+      description: "Retrieves a single product by its numeric ID, including prices, stock, images, categories, and attributes. Use this when you already know the product ID and need full details for editing, display, or diagnostics.",
+      inputSchema: {
+        id: import_zod3.z.number().int().positive().describe("Product ID. Example: 42")
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.get("products", { id: args.id });
+        return textContent(parseSingleOutput(res.data, ProductSchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_products_create",
+    {
+      title: "Create product",
+      description: "Creates a new product in the WooCommerce catalog. Use this to add simple or variable products with pricing, descriptions, categories, and images. Returns the created product object including the new ID.",
+      inputSchema: ProductCreateSchema.shape
+    },
+    async (args) => {
+      try {
+        const res = await client.post("products", args);
+        return textContent(parseSingleOutput(res.data, ProductSchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_products_update",
+    {
+      title: "Update product",
+      description: "Updates an existing product by ID. Only fields you provide are changed (partial update). Use this for price changes, stock adjustments, description edits, or status transitions without re-sending the full product.",
+      inputSchema: {
+        id: import_zod3.z.number().int().positive().describe("Product ID to update"),
+        data: ProductCreateSchema.partial().passthrough().describe("Fields to update on the product")
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.put(
+          "products",
+          args.data,
+          { id: args.id }
+        );
+        return textContent(parseSingleOutput(res.data, ProductSchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_products_delete",
+    {
+      title: "Delete product",
+      description: "Deletes a product by ID. By default force=true permanently deletes; set force=false to move to trash when supported. Use this for catalog cleanup or removing test products.",
+      inputSchema: {
+        id: import_zod3.z.number().int().positive().describe("Product ID to delete"),
+        force: import_zod3.z.boolean().default(true).optional().describe("Permanently delete when true (default true)")
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.delete(
+          "products",
+          { force: args.force ?? true },
+          { id: args.id }
+        );
+        const out = DeleteResponseSchema.parse({
+          deleted: true,
+          previous: res.data,
+          id: args.id
+        });
+        return textContent(out);
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_products_search",
+    {
+      title: "Search products",
+      description: "Searches products by a free-text query matching name, SKU, and description fields. Use this when the user asks to find products by keyword rather than by ID or filters. Returns paginated matching products.",
+      inputSchema: {
+        query: import_zod3.z.string().min(1).describe('Search query string. Example: "blue shirt"'),
+        ...PaginationInputSchema.shape
+      }
+    },
+    async (args) => {
+      try {
+        const page = args.page ?? 1;
+        const per_page = args.per_page ?? 10;
+        const res = await client.get("products", {
+          search: args.query,
+          page,
+          per_page
+        });
+        const meta = client.pagination(res, page, per_page);
+        const out = parseListOutput(
+          res.data,
+          meta.currentPage,
+          meta.perPage,
+          meta.total,
+          meta.totalPages,
+          ProductSchema
+        );
+        return textContent(out);
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_products_batch",
+    {
+      title: "Batch products",
+      description: "Performs multiple product create, update, and/or delete operations in a single API call. Use this for bulk catalog imports, mass price updates, or multi-item cleanup to reduce round-trips and respect rate limits.",
+      inputSchema: BatchOperationSchema.shape
+    },
+    async (args) => {
+      try {
+        const res = await client.post("products/batch", args);
+        const out = BatchResponseSchema.parse(res.data ?? {});
+        return textContent(out);
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+}
+
+// src/tools/orders.ts
+var import_zod4 = require("zod");
+var LineItemInput = import_zod4.z.object({
+  product_id: import_zod4.z.number().describe("Product ID to order"),
+  quantity: import_zod4.z.number().int().positive().describe("Quantity. Example: 2"),
+  variation_id: import_zod4.z.number().optional().describe("Variation ID for variable products")
+});
+var OrderCreateSchema = import_zod4.z.object({
+  status: import_zod4.z.enum([
+    "pending",
+    "processing",
+    "on-hold",
+    "completed",
+    "cancelled",
+    "refunded",
+    "failed"
+  ]).optional().describe("Order status"),
+  customer_id: import_zod4.z.number().optional().describe("Existing customer ID (0 for guest)"),
+  payment_method: import_zod4.z.string().optional().describe("Payment method ID, e.g. bacs"),
+  payment_method_title: import_zod4.z.string().optional().describe("Payment method title"),
+  set_paid: import_zod4.z.boolean().optional().describe("Mark order as paid on create"),
+  billing: import_zod4.z.record(import_zod4.z.unknown()).optional().describe("Billing address object"),
+  shipping: import_zod4.z.record(import_zod4.z.unknown()).optional().describe("Shipping address object"),
+  line_items: import_zod4.z.array(LineItemInput).optional().describe("Products to include"),
+  shipping_lines: import_zod4.z.array(import_zod4.z.record(import_zod4.z.unknown())).optional(),
+  coupon_lines: import_zod4.z.array(import_zod4.z.object({ code: import_zod4.z.string() })).optional(),
+  customer_note: import_zod4.z.string().optional().describe("Note visible to customer")
+}).passthrough();
+function registerOrderTools(server, client) {
+  server.registerTool(
+    "woo_orders_list",
+    {
+      title: "List orders",
+      description: "Lists store orders with pagination and optional filters for status, date range, and customer. Use this to build order queues, support lookups, or feed sales analysis. Returns order objects plus pagination metadata.",
+      inputSchema: {
+        ...PaginationInputSchema.shape,
+        status: import_zod4.z.string().optional().describe(
+          "Order status or comma-separated list. Example: processing,completed"
+        ),
+        customer: import_zod4.z.number().optional().describe("Filter by customer ID. Example: 12"),
+        after: import_zod4.z.string().optional().describe("ISO8601 date \u2014 only orders after this. Example: 2024-01-01T00:00:00"),
+        before: import_zod4.z.string().optional().describe("ISO8601 date \u2014 only orders before this"),
+        product: import_zod4.z.number().optional().describe("Filter orders containing product ID"),
+        orderby: import_zod4.z.enum(["date", "id", "include", "title", "slug"]).optional().describe("Sort field"),
+        order: import_zod4.z.enum(["asc", "desc"]).optional().describe("Sort direction")
+      }
+    },
+    async (args) => {
+      try {
+        const page = args.page ?? 1;
+        const per_page = args.per_page ?? 10;
+        const res = await client.get("orders", {
+          page,
+          per_page,
+          status: args.status,
+          customer: args.customer,
+          after: args.after,
+          before: args.before,
+          product: args.product,
+          orderby: args.orderby,
+          order: args.order
+        });
+        const meta = client.pagination(res, page, per_page);
+        const out = parseListOutput(
+          res.data,
+          meta.currentPage,
+          meta.perPage,
+          meta.total,
+          meta.totalPages,
+          OrderSchema
+        );
+        return textContent(out);
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_orders_get",
+    {
+      title: "Get order",
+      description: "Retrieves a single order by ID including line items, billing/shipping, totals, and status history fields. Use this for support tickets, fulfillment, or when an order number is already known.",
+      inputSchema: {
+        id: import_zod4.z.number().int().positive().describe("Order ID. Example: 101")
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.get("orders", { id: args.id });
+        return textContent(parseSingleOutput(res.data, OrderSchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_orders_create",
+    {
+      title: "Create order",
+      description: "Creates a new order with optional customer, line items, addresses, and payment fields. Use this to place orders on behalf of customers, seed test data, or automate checkout-like flows from an agent.",
+      inputSchema: OrderCreateSchema.shape
+    },
+    async (args) => {
+      try {
+        const res = await client.post("orders", args);
+        return textContent(parseSingleOutput(res.data, OrderSchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_orders_update",
+    {
+      title: "Update order",
+      description: "Updates an existing order by ID (status changes, notes, addresses, line items). Use this for fulfillment transitions (e.g. processing \u2192 completed), address corrections, or partial refunds workflows that only need field updates.",
+      inputSchema: {
+        id: import_zod4.z.number().int().positive().describe("Order ID to update"),
+        data: OrderCreateSchema.partial().passthrough().describe("Fields to update on the order")
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.put(
+          "orders",
+          args.data,
+          { id: args.id }
+        );
+        return textContent(parseSingleOutput(res.data, OrderSchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_orders_delete",
+    {
+      title: "Delete order",
+      description: "Deletes an order by ID. force=true permanently deletes; force=false moves to trash. Use carefully for test cleanup or GDPR-style removal when appropriate policies allow.",
+      inputSchema: {
+        id: import_zod4.z.number().int().positive().describe("Order ID to delete"),
+        force: import_zod4.z.boolean().default(true).optional().describe("Permanent delete (default true)")
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.delete(
+          "orders",
+          { force: args.force ?? true },
+          { id: args.id }
+        );
+        return textContent(
+          DeleteResponseSchema.parse({
+            deleted: true,
+            previous: res.data,
+            id: args.id
+          })
+        );
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_orders_notes_list",
+    {
+      title: "List order notes",
+      description: "Lists notes attached to a specific order (customer-visible and private staff notes). Use this when reviewing order history, support context, or audit trails for a single order.",
+      inputSchema: {
+        order_id: import_zod4.z.number().int().positive().describe("Order ID whose notes to list"),
+        ...PaginationInputSchema.shape
+      }
+    },
+    async (args) => {
+      try {
+        const page = args.page ?? 1;
+        const per_page = args.per_page ?? 10;
+        const res = await client.get(`orders/${args.order_id}/notes`, {
+          page,
+          per_page
+        });
+        const meta = client.pagination(res, page, per_page);
+        const out = parseListOutput(
+          res.data,
+          meta.currentPage,
+          meta.perPage,
+          meta.total,
+          meta.totalPages,
+          OrderNoteSchema
+        );
+        return textContent(out);
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_orders_notes_create",
+    {
+      title: "Create order note",
+      description: "Adds a note to an order. Set customer_note=true to show it to the customer (email may be triggered by WC). Use this to document support actions or notify customers of fulfillment updates.",
+      inputSchema: {
+        order_id: import_zod4.z.number().int().positive().describe("Order ID to attach the note to"),
+        note: import_zod4.z.string().min(1).describe("Note text content"),
+        customer_note: import_zod4.z.boolean().optional().describe("If true, note is customer-facing")
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.post(`orders/${args.order_id}/notes`, {
+          note: args.note,
+          customer_note: args.customer_note ?? false
+        });
+        return textContent(parseSingleOutput(res.data, OrderNoteSchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_orders_batch",
+    {
+      title: "Batch orders",
+      description: "Runs multiple order create/update/delete operations in one batch request. Use this for bulk status updates (e.g. mark many orders completed) or mass test-data management while minimizing API calls.",
+      inputSchema: BatchOperationSchema.shape
+    },
+    async (args) => {
+      try {
+        const res = await client.post("orders/batch", args);
+        return textContent(BatchResponseSchema.parse(res.data ?? {}));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+}
+
+// src/tools/customers.ts
+var import_zod5 = require("zod");
+var CustomerCreateSchema = import_zod5.z.object({
+  email: import_zod5.z.string().email().describe("Customer email. Example: jane@example.com"),
+  first_name: import_zod5.z.string().optional().describe("First name"),
+  last_name: import_zod5.z.string().optional().describe("Last name"),
+  username: import_zod5.z.string().optional().describe("Login username"),
+  password: import_zod5.z.string().optional().describe("Account password (create only)"),
+  billing: import_zod5.z.record(import_zod5.z.unknown()).optional().describe("Billing address"),
+  shipping: import_zod5.z.record(import_zod5.z.unknown()).optional().describe("Shipping address")
+}).passthrough();
+function registerCustomerTools(server, client) {
+  server.registerTool(
+    "woo_customers_list",
+    {
+      title: "List customers",
+      description: "Lists WooCommerce customers with pagination. Use this for CRM-style overviews, segmenting audiences, or finding accounts before creating orders. Returns customer objects and pagination metadata.",
+      inputSchema: {
+        ...PaginationInputSchema.shape,
+        role: import_zod5.z.string().optional().describe("Filter by role, e.g. customer"),
+        email: import_zod5.z.string().optional().describe("Filter by exact email"),
+        orderby: import_zod5.z.enum(["id", "include", "name", "registered_date"]).optional().describe("Sort field"),
+        order: import_zod5.z.enum(["asc", "desc"]).optional().describe("Sort direction")
+      }
+    },
+    async (args) => {
+      try {
+        const page = args.page ?? 1;
+        const per_page = args.per_page ?? 10;
+        const res = await client.get("customers", {
+          page,
+          per_page,
+          role: args.role,
+          email: args.email,
+          orderby: args.orderby,
+          order: args.order
+        });
+        const meta = client.pagination(res, page, per_page);
+        return textContent(
+          parseListOutput(
+            res.data,
+            meta.currentPage,
+            meta.perPage,
+            meta.total,
+            meta.totalPages,
+            CustomerSchema
+          )
+        );
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_customers_get",
+    {
+      title: "Get customer",
+      description: "Retrieves a single customer by ID including billing/shipping and meta. Use this when you have a customer ID from an order or search and need full account details.",
+      inputSchema: {
+        id: import_zod5.z.number().int().positive().describe("Customer ID")
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.get("customers", { id: args.id });
+        return textContent(parseSingleOutput(res.data, CustomerSchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_customers_create",
+    {
+      title: "Create customer",
+      description: "Creates a new customer account with email and optional name, addresses, and password. Use this to onboard users from an agent workflow or seed demo accounts.",
+      inputSchema: CustomerCreateSchema.shape
+    },
+    async (args) => {
+      try {
+        const res = await client.post("customers", args);
+        return textContent(parseSingleOutput(res.data, CustomerSchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_customers_update",
+    {
+      title: "Update customer",
+      description: "Updates an existing customer by ID. Use this to fix addresses, names, or billing details without recreating the account.",
+      inputSchema: {
+        id: import_zod5.z.number().int().positive().describe("Customer ID"),
+        data: CustomerCreateSchema.partial().passthrough().describe("Fields to update")
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.put(
+          "customers",
+          args.data,
+          { id: args.id }
+        );
+        return textContent(parseSingleOutput(res.data, CustomerSchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_customers_delete",
+    {
+      title: "Delete customer",
+      description: "Deletes a customer by ID. force=true is required by WooCommerce for permanent deletion. Use for GDPR erasure or test cleanup only when authorized.",
+      inputSchema: {
+        id: import_zod5.z.number().int().positive().describe("Customer ID"),
+        force: import_zod5.z.boolean().default(true).optional().describe("Must be true to delete"),
+        reassign: import_zod5.z.number().optional().describe("User ID to reassign posts to (optional)")
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.delete(
+          "customers",
+          { force: args.force ?? true },
+          { id: args.id }
+        );
+        return textContent(
+          DeleteResponseSchema.parse({
+            deleted: true,
+            previous: res.data,
+            id: args.id
+          })
+        );
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_customers_search",
+    {
+      title: "Search customers",
+      description: "Searches customers by free-text query (name, email, username). Use this when the user provides a partial name or email and you need matching accounts before acting on orders.",
+      inputSchema: {
+        query: import_zod5.z.string().min(1).describe('Search query. Example: "jane@"'),
+        ...PaginationInputSchema.shape
+      }
+    },
+    async (args) => {
+      try {
+        const page = args.page ?? 1;
+        const per_page = args.per_page ?? 10;
+        const res = await client.get("customers", {
+          search: args.query,
+          page,
+          per_page
+        });
+        const meta = client.pagination(res, page, per_page);
+        return textContent(
+          parseListOutput(
+            res.data,
+            meta.currentPage,
+            meta.perPage,
+            meta.total,
+            meta.totalPages,
+            CustomerSchema
+          )
+        );
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+}
+
+// src/tools/coupons.ts
+var import_zod6 = require("zod");
+var CouponCreateSchema = import_zod6.z.object({
+  code: import_zod6.z.string().describe("Coupon code. Example: SUMMER20"),
+  discount_type: import_zod6.z.enum(["percent", "fixed_cart", "fixed_product"]).optional().describe("How the discount is calculated"),
+  amount: import_zod6.z.string().optional().describe('Discount amount as string. Example: "20"'),
+  description: import_zod6.z.string().optional().describe("Internal description"),
+  individual_use: import_zod6.z.boolean().optional(),
+  exclude_sale_items: import_zod6.z.boolean().optional(),
+  minimum_amount: import_zod6.z.string().optional(),
+  maximum_amount: import_zod6.z.string().optional(),
+  usage_limit: import_zod6.z.number().optional(),
+  usage_limit_per_user: import_zod6.z.number().optional(),
+  free_shipping: import_zod6.z.boolean().optional(),
+  date_expires: import_zod6.z.string().nullable().optional().describe("ISO date when coupon expires")
+}).passthrough();
+function registerCouponTools(server, client) {
+  server.registerTool(
+    "woo_coupons_list",
+    {
+      title: "List coupons",
+      description: "Lists discount coupons with pagination. Use this to audit active promotions, find a code by browsing, or report on campaign inventory.",
+      inputSchema: {
+        ...PaginationInputSchema.shape,
+        code: import_zod6.z.string().optional().describe("Filter by exact coupon code")
+      }
+    },
+    async (args) => {
+      try {
+        const page = args.page ?? 1;
+        const per_page = args.per_page ?? 10;
+        const res = await client.get("coupons", {
+          page,
+          per_page,
+          code: args.code
+        });
+        const meta = client.pagination(res, page, per_page);
+        return textContent(
+          parseListOutput(
+            res.data,
+            meta.currentPage,
+            meta.perPage,
+            meta.total,
+            meta.totalPages,
+            CouponSchema
+          )
+        );
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_coupons_get",
+    {
+      title: "Get coupon",
+      description: "Retrieves a single coupon by ID including amount, limits, and expiry. Use this when you already have the coupon ID from a list or order coupon_lines.",
+      inputSchema: {
+        id: import_zod6.z.number().int().positive().describe("Coupon ID")
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.get("coupons", { id: args.id });
+        return textContent(parseSingleOutput(res.data, CouponSchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_coupons_create",
+    {
+      title: "Create coupon",
+      description: "Creates a new coupon code with discount type, amount, and optional limits. Use this to launch promotions or generate one-off support discounts.",
+      inputSchema: CouponCreateSchema.shape
+    },
+    async (args) => {
+      try {
+        const res = await client.post("coupons", args);
+        return textContent(parseSingleOutput(res.data, CouponSchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_coupons_update",
+    {
+      title: "Update coupon",
+      description: "Updates an existing coupon by ID (amount, expiry, usage limits, etc.). Use this to extend campaigns or disable a code without deleting history.",
+      inputSchema: {
+        id: import_zod6.z.number().int().positive().describe("Coupon ID"),
+        data: CouponCreateSchema.partial().passthrough().describe("Fields to update")
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.put(
+          "coupons",
+          args.data,
+          { id: args.id }
+        );
+        return textContent(parseSingleOutput(res.data, CouponSchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_coupons_delete",
+    {
+      title: "Delete coupon",
+      description: "Deletes a coupon by ID. Use this to retire obsolete or leaked promo codes. force=true permanently removes the coupon.",
+      inputSchema: {
+        id: import_zod6.z.number().int().positive().describe("Coupon ID"),
+        force: import_zod6.z.boolean().default(true).optional()
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.delete(
+          "coupons",
+          { force: args.force ?? true },
+          { id: args.id }
+        );
+        return textContent(
+          DeleteResponseSchema.parse({
+            deleted: true,
+            previous: res.data,
+            id: args.id
+          })
+        );
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+}
+
+// src/tools/categories.ts
+var import_zod7 = require("zod");
+var CategoryCreateSchema = import_zod7.z.object({
+  name: import_zod7.z.string().describe("Category name. Example: Apparel"),
+  slug: import_zod7.z.string().optional().describe("URL slug"),
+  parent: import_zod7.z.number().optional().describe("Parent category ID for hierarchy"),
+  description: import_zod7.z.string().optional().describe("Category description HTML"),
+  display: import_zod7.z.enum(["default", "products", "subcategories", "both"]).optional().describe("Catalog display type"),
+  image: import_zod7.z.object({ src: import_zod7.z.string().url() }).optional().describe("Category image"),
+  menu_order: import_zod7.z.number().optional()
+}).passthrough();
+function registerCategoryTools(server, client) {
+  server.registerTool(
+    "woo_categories_list",
+    {
+      title: "List product categories",
+      description: "Lists product categories with pagination and optional parent filter. Use this to understand catalog taxonomy, build navigation, or assign products to the correct category IDs.",
+      inputSchema: {
+        ...PaginationInputSchema.shape,
+        parent: import_zod7.z.number().optional().describe("Only children of this category ID"),
+        hide_empty: import_zod7.z.boolean().optional().describe("Hide categories with no products"),
+        search: import_zod7.z.string().optional().describe("Search category names")
+      }
+    },
+    async (args) => {
+      try {
+        const page = args.page ?? 1;
+        const per_page = args.per_page ?? 10;
+        const res = await client.get("products/categories", {
+          page,
+          per_page,
+          parent: args.parent,
+          hide_empty: args.hide_empty,
+          search: args.search
+        });
+        const meta = client.pagination(res, page, per_page);
+        return textContent(
+          parseListOutput(
+            res.data,
+            meta.currentPage,
+            meta.perPage,
+            meta.total,
+            meta.totalPages,
+            CategorySchema
+          )
+        );
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_categories_get",
+    {
+      title: "Get product category",
+      description: "Retrieves a single product category by ID. Use this when you need the full category record including description, image, and product count.",
+      inputSchema: {
+        id: import_zod7.z.number().int().positive().describe("Category ID")
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.get("products/categories", { id: args.id });
+        return textContent(parseSingleOutput(res.data, CategorySchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_categories_create",
+    {
+      title: "Create product category",
+      description: "Creates a new product category, optionally nested under a parent. Use this when structuring or expanding the store catalog taxonomy.",
+      inputSchema: CategoryCreateSchema.shape
+    },
+    async (args) => {
+      try {
+        const res = await client.post(
+          "products/categories",
+          args
+        );
+        return textContent(parseSingleOutput(res.data, CategorySchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_categories_update",
+    {
+      title: "Update product category",
+      description: "Updates an existing product category by ID. Use this to rename categories, fix slugs, re-parent nodes, or update descriptions for SEO.",
+      inputSchema: {
+        id: import_zod7.z.number().int().positive().describe("Category ID"),
+        data: CategoryCreateSchema.partial().passthrough().describe("Fields to update")
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.put(
+          "products/categories",
+          args.data,
+          { id: args.id }
+        );
+        return textContent(parseSingleOutput(res.data, CategorySchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_categories_delete",
+    {
+      title: "Delete product category",
+      description: "Deletes a product category by ID. Products are not deleted; they simply lose this category assignment. force=true permanently deletes.",
+      inputSchema: {
+        id: import_zod7.z.number().int().positive().describe("Category ID"),
+        force: import_zod7.z.boolean().default(true).optional()
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.delete(
+          "products/categories",
+          { force: args.force ?? true },
+          { id: args.id }
+        );
+        return textContent(
+          DeleteResponseSchema.parse({
+            deleted: true,
+            previous: res.data,
+            id: args.id
+          })
+        );
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+}
+
+// src/tools/tags.ts
+var import_zod8 = require("zod");
+var TagCreateSchema = import_zod8.z.object({
+  name: import_zod8.z.string().describe("Tag name. Example: organic"),
+  slug: import_zod8.z.string().optional().describe("URL slug"),
+  description: import_zod8.z.string().optional().describe("Tag description")
+}).passthrough();
+function registerTagTools(server, client) {
+  server.registerTool(
+    "woo_tags_list",
+    {
+      title: "List product tags",
+      description: "Lists product tags with pagination. Use this to discover available tags for filtering, merchandising, or assigning to products during catalog work.",
+      inputSchema: {
+        ...PaginationInputSchema.shape,
+        search: import_zod8.z.string().optional().describe("Search tag names"),
+        hide_empty: import_zod8.z.boolean().optional()
+      }
+    },
+    async (args) => {
+      try {
+        const page = args.page ?? 1;
+        const per_page = args.per_page ?? 10;
+        const res = await client.get("products/tags", {
+          page,
+          per_page,
+          search: args.search,
+          hide_empty: args.hide_empty
+        });
+        const meta = client.pagination(res, page, per_page);
+        return textContent(
+          parseListOutput(
+            res.data,
+            meta.currentPage,
+            meta.perPage,
+            meta.total,
+            meta.totalPages,
+            TagSchema
+          )
+        );
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_tags_get",
+    {
+      title: "Get product tag",
+      description: "Retrieves a single product tag by ID. Use this when you need the full tag record including slug and product count.",
+      inputSchema: {
+        id: import_zod8.z.number().int().positive().describe("Tag ID")
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.get("products/tags", { id: args.id });
+        return textContent(parseSingleOutput(res.data, TagSchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_tags_create",
+    {
+      title: "Create product tag",
+      description: "Creates a new product tag. Use this when introducing a new merchandising or SEO label that products can share.",
+      inputSchema: TagCreateSchema.shape
+    },
+    async (args) => {
+      try {
+        const res = await client.post("products/tags", args);
+        return textContent(parseSingleOutput(res.data, TagSchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_tags_update",
+    {
+      title: "Update product tag",
+      description: "Updates an existing product tag by ID. Use this to rename tags or improve descriptions for storefront filters and SEO.",
+      inputSchema: {
+        id: import_zod8.z.number().int().positive().describe("Tag ID"),
+        data: TagCreateSchema.partial().passthrough().describe("Fields to update")
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.put(
+          "products/tags",
+          args.data,
+          { id: args.id }
+        );
+        return textContent(parseSingleOutput(res.data, TagSchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_tags_delete",
+    {
+      title: "Delete product tag",
+      description: "Deletes a product tag by ID. Products keep their other tags; only this association is removed. force=true permanently deletes.",
+      inputSchema: {
+        id: import_zod8.z.number().int().positive().describe("Tag ID"),
+        force: import_zod8.z.boolean().default(true).optional()
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.delete(
+          "products/tags",
+          { force: args.force ?? true },
+          { id: args.id }
+        );
+        return textContent(
+          DeleteResponseSchema.parse({
+            deleted: true,
+            previous: res.data,
+            id: args.id
+          })
+        );
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+}
+
+// src/tools/variations.ts
+var import_zod9 = require("zod");
+var VariationCreateSchema = import_zod9.z.object({
+  regular_price: import_zod9.z.string().optional().describe('Regular price. Example: "19.99"'),
+  sale_price: import_zod9.z.string().optional().describe("Sale price"),
+  sku: import_zod9.z.string().optional().describe("Variation SKU"),
+  manage_stock: import_zod9.z.boolean().optional(),
+  stock_quantity: import_zod9.z.number().optional(),
+  stock_status: import_zod9.z.enum(["instock", "outofstock", "onbackorder"]).optional(),
+  attributes: import_zod9.z.array(
+    import_zod9.z.object({
+      id: import_zod9.z.number().optional(),
+      name: import_zod9.z.string(),
+      option: import_zod9.z.string()
+    })
+  ).optional().describe("Attribute options that define this variation"),
+  image: import_zod9.z.object({ src: import_zod9.z.string().url() }).optional(),
+  status: import_zod9.z.enum(["publish", "private", "draft"]).optional()
+}).passthrough();
+function registerVariationTools(server, client) {
+  server.registerTool(
+    "woo_variations_list",
+    {
+      title: "List product variations",
+      description: "Lists variations for a parent variable product with pagination. Use this when managing size/color SKUs, checking per-variant stock, or syncing variant pricing.",
+      inputSchema: {
+        product_id: import_zod9.z.number().int().positive().describe("Parent variable product ID"),
+        ...PaginationInputSchema.shape
+      }
+    },
+    async (args) => {
+      try {
+        const page = args.page ?? 1;
+        const per_page = args.per_page ?? 10;
+        const res = await client.get(
+          `products/${args.product_id}/variations`,
+          { page, per_page }
+        );
+        const meta = client.pagination(res, page, per_page);
+        return textContent(
+          parseListOutput(
+            res.data,
+            meta.currentPage,
+            meta.perPage,
+            meta.total,
+            meta.totalPages,
+            VariationSchema
+          )
+        );
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_variations_get",
+    {
+      title: "Get product variation",
+      description: "Retrieves a single product variation by parent product ID and variation ID. Use this for detailed variant pricing, stock, or attribute inspection.",
+      inputSchema: {
+        product_id: import_zod9.z.number().int().positive().describe("Parent product ID"),
+        id: import_zod9.z.number().int().positive().describe("Variation ID")
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.get(
+          `products/${args.product_id}/variations/${args.id}`
+        );
+        return textContent(parseSingleOutput(res.data, VariationSchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_variations_create",
+    {
+      title: "Create product variation",
+      description: "Creates a new variation under a variable product. Use this when adding a new size/color combination with its own price and stock.",
+      inputSchema: {
+        product_id: import_zod9.z.number().int().positive().describe("Parent product ID"),
+        data: VariationCreateSchema.describe("Variation fields")
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.post(
+          `products/${args.product_id}/variations`,
+          args.data
+        );
+        return textContent(parseSingleOutput(res.data, VariationSchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_variations_update",
+    {
+      title: "Update product variation",
+      description: "Updates an existing product variation. Use this for variant price changes, stock adjustments, or attribute corrections.",
+      inputSchema: {
+        product_id: import_zod9.z.number().int().positive().describe("Parent product ID"),
+        id: import_zod9.z.number().int().positive().describe("Variation ID"),
+        data: VariationCreateSchema.partial().passthrough().describe("Fields to update")
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.put(
+          `products/${args.product_id}/variations/${args.id}`,
+          args.data
+        );
+        return textContent(parseSingleOutput(res.data, VariationSchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_variations_delete",
+    {
+      title: "Delete product variation",
+      description: "Deletes a product variation by ID. Use this to remove obsolete size/color SKUs from a variable product. force=true permanently deletes.",
+      inputSchema: {
+        product_id: import_zod9.z.number().int().positive().describe("Parent product ID"),
+        id: import_zod9.z.number().int().positive().describe("Variation ID"),
+        force: import_zod9.z.boolean().default(true).optional()
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.delete(
+          `products/${args.product_id}/variations/${args.id}`,
+          { force: args.force ?? true }
+        );
+        return textContent(
+          DeleteResponseSchema.parse({
+            deleted: true,
+            previous: res.data,
+            id: args.id
+          })
+        );
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+}
+
+// src/tools/shipping.ts
+var import_zod10 = require("zod");
+function registerShippingTools(server, client) {
+  server.registerTool(
+    "woo_shipping_zones_list",
+    {
+      title: "List shipping zones",
+      description: "Lists all shipping zones configured in the store. Use this to understand regional shipping setup before inspecting methods or diagnosing delivery options.",
+      inputSchema: {
+        ...PaginationInputSchema.shape
+      }
+    },
+    async (args) => {
+      try {
+        const page = args.page ?? 1;
+        const per_page = args.per_page ?? 10;
+        const res = await client.get("shipping/zones", { page, per_page });
+        const meta = client.pagination(res, page, per_page);
+        return textContent(
+          parseListOutput(
+            res.data,
+            meta.currentPage,
+            meta.perPage,
+            meta.total || (Array.isArray(res.data) ? res.data.length : 0),
+            meta.totalPages,
+            WcEntitySchema
+          )
+        );
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_shipping_zones_get",
+    {
+      title: "Get shipping zone",
+      description: "Retrieves a single shipping zone by ID including name and order. Use this when drilling into a specific zone from the list.",
+      inputSchema: {
+        id: import_zod10.z.number().int().nonnegative().describe("Shipping zone ID (0 = Locations not covered)")
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.get(`shipping/zones/${args.id}`);
+        return textContent(parseSingleOutput(res.data, WcEntitySchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_shipping_zone_methods_list",
+    {
+      title: "List shipping zone methods",
+      description: "Lists shipping methods enabled for a given zone (flat rate, free shipping, local pickup, etc.). Use this to audit delivery options available to customers in that region.",
+      inputSchema: {
+        zone_id: import_zod10.z.number().int().nonnegative().describe("Shipping zone ID"),
+        ...PaginationInputSchema.shape
+      }
+    },
+    async (args) => {
+      try {
+        const page = args.page ?? 1;
+        const per_page = args.per_page ?? 10;
+        const res = await client.get(
+          `shipping/zones/${args.zone_id}/methods`,
+          { page, per_page }
+        );
+        const meta = client.pagination(res, page, per_page);
+        return textContent(
+          parseListOutput(
+            res.data,
+            meta.currentPage,
+            meta.perPage,
+            meta.total || (Array.isArray(res.data) ? res.data.length : 0),
+            meta.totalPages,
+            WcEntitySchema
+          )
+        );
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_shipping_methods_list",
+    {
+      title: "List shipping methods",
+      description: "Lists all registered shipping method types available in WooCommerce (not zone assignments). Use this to see which method plugins/classes the store supports.",
+      inputSchema: {
+        ...PaginationInputSchema.shape
+      }
+    },
+    async (args) => {
+      try {
+        const page = args.page ?? 1;
+        const per_page = args.per_page ?? 10;
+        const res = await client.get("shipping_methods", { page, per_page });
+        const meta = client.pagination(res, page, per_page);
+        return textContent(
+          parseListOutput(
+            res.data,
+            meta.currentPage,
+            meta.perPage,
+            meta.total || (Array.isArray(res.data) ? res.data.length : 0),
+            meta.totalPages,
+            WcEntitySchema
+          )
+        );
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_shipping_classes_list",
+    {
+      title: "List shipping classes",
+      description: "Lists product shipping classes used to group products for rate calculation. Use this when assigning classes to products or configuring class-based flat rates.",
+      inputSchema: {
+        ...PaginationInputSchema.shape
+      }
+    },
+    async (args) => {
+      try {
+        const page = args.page ?? 1;
+        const per_page = args.per_page ?? 10;
+        const res = await client.get("products/shipping_classes", {
+          page,
+          per_page
+        });
+        const meta = client.pagination(res, page, per_page);
+        return textContent(
+          parseListOutput(
+            res.data,
+            meta.currentPage,
+            meta.perPage,
+            meta.total,
+            meta.totalPages,
+            WcEntitySchema
+          )
+        );
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_shipping_classes_get",
+    {
+      title: "Get shipping class",
+      description: "Retrieves a single product shipping class by ID. Use this to inspect slug, description, and count for a specific class.",
+      inputSchema: {
+        id: import_zod10.z.number().int().positive().describe("Shipping class ID")
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.get("products/shipping_classes", { id: args.id });
+        return textContent(parseSingleOutput(res.data, WcEntitySchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+}
+
+// src/tools/payments.ts
+var import_zod11 = require("zod");
+function registerPaymentTools(server, client) {
+  server.registerTool(
+    "woo_payments_list",
+    {
+      title: "List payment gateways",
+      description: "Lists all payment gateways registered in the store (enabled and disabled). Use this to audit checkout payment options or find gateway IDs before updating settings.",
+      inputSchema: {
+        ...PaginationInputSchema.shape
+      }
+    },
+    async (args) => {
+      try {
+        const page = args.page ?? 1;
+        const per_page = args.per_page ?? 10;
+        const res = await client.get("payment_gateways", {
+          page,
+          per_page
+        });
+        const meta = client.pagination(res, page, per_page);
+        const items = Array.isArray(res.data) ? res.data : [];
+        return textContent(
+          parseListOutput(
+            items,
+            meta.currentPage,
+            meta.perPage,
+            meta.total || items.length,
+            meta.totalPages,
+            WcEntitySchema
+          )
+        );
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_payments_get",
+    {
+      title: "Get payment gateway",
+      description: "Retrieves a single payment gateway by its ID string (e.g. bacs, cod, stripe). Use this to inspect title, enabled flag, and settings fields for a specific method.",
+      inputSchema: {
+        id: import_zod11.z.string().min(1).describe('Gateway ID. Example: "bacs" or "cod"')
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.get(`payment_gateways/${args.id}`);
+        return textContent(parseSingleOutput(res.data, WcEntitySchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_payments_update",
+    {
+      title: "Update payment gateway",
+      description: "Updates payment gateway settings such as enabled state, title, or method-specific options. Use this carefully when enabling/disabling checkout methods or fixing gateway configuration from an agent workflow.",
+      inputSchema: {
+        id: import_zod11.z.string().min(1).describe("Gateway ID to update"),
+        data: import_zod11.z.object({
+          enabled: import_zod11.z.boolean().optional().describe("Whether gateway is enabled"),
+          title: import_zod11.z.string().optional().describe("Checkout title"),
+          description: import_zod11.z.string().optional().describe("Checkout description"),
+          order: import_zod11.z.number().optional().describe("Display order"),
+          settings: import_zod11.z.record(import_zod11.z.unknown()).optional().describe("Gateway-specific settings map")
+        }).passthrough().describe("Fields to update on the gateway")
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.put(
+          `payment_gateways/${args.id}`,
+          args.data
+        );
+        return textContent(parseSingleOutput(res.data, WcEntitySchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+}
+
+// src/tools/reports.ts
+var import_zod12 = require("zod");
+var DateRangeSchema = {
+  date_min: import_zod12.z.string().optional().describe("Start date YYYY-MM-DD. Example: 2024-01-01"),
+  date_max: import_zod12.z.string().optional().describe("End date YYYY-MM-DD. Example: 2024-01-31"),
+  period: import_zod12.z.enum(["week", "month", "last_month", "year"]).optional().describe("Preset period alternative to date_min/date_max")
+};
+function registerReportTools(server, client) {
+  server.registerTool(
+    "woo_reports_sales",
+    {
+      title: "Sales report",
+      description: "Fetches the WooCommerce sales report for a period or custom date range, including totals, averages, and order counts. Use this for revenue dashboards, period comparisons, or answering \u201Chow much did we sell last month?\u201D.",
+      inputSchema: DateRangeSchema
+    },
+    async (args) => {
+      try {
+        const res = await client.get("reports/sales", {
+          date_min: args.date_min,
+          date_max: args.date_max,
+          period: args.period
+        });
+        const data = Array.isArray(res.data) ? res.data : [res.data];
+        return textContent({ report: data });
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_reports_top_sellers",
+    {
+      title: "Top sellers report",
+      description: "Returns the top-selling products for a period with quantities sold. Use this to identify bestsellers, plan restocks, or build merchandising recommendations.",
+      inputSchema: DateRangeSchema
+    },
+    async (args) => {
+      try {
+        const res = await client.get("reports/top_sellers", {
+          date_min: args.date_min,
+          date_max: args.date_max,
+          period: args.period
+        });
+        return textContent({
+          items: Array.isArray(res.data) ? res.data : []
+        });
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_reports_orders_totals",
+    {
+      title: "Orders totals report",
+      description: "Returns order counts grouped by status (pending, processing, completed, etc.). Use this for operational dashboards and backlog visibility without listing every order.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const res = await client.get("reports/orders/totals");
+        return textContent({
+          items: Array.isArray(res.data) ? res.data : []
+        });
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_reports_customers_totals",
+    {
+      title: "Customers totals report",
+      description: "Returns customer counts by role or segment totals exposed by WooCommerce. Use this for a quick snapshot of the customer base size without paging through all customer records.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const res = await client.get("reports/customers/totals");
+        return textContent({
+          items: Array.isArray(res.data) ? res.data : []
+        });
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_reports_products_totals",
+    {
+      title: "Products totals report",
+      description: "Returns product counts by type (simple, variable, etc.). Use this for catalog composition analysis and inventory planning at a high level.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const res = await client.get("reports/products/totals");
+        WcEntitySchema.array().or(import_zod12.z.array(import_zod12.z.unknown())).parse(
+          Array.isArray(res.data) ? res.data : []
+        );
+        return textContent({
+          items: Array.isArray(res.data) ? res.data : []
+        });
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_reports_coupons_totals",
+    {
+      title: "Coupons totals report",
+      description: "Returns coupon usage/count totals from the reports API. Use this to measure promotion adoption without listing every coupon record.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const res = await client.get("reports/coupons/totals");
+        return textContent({
+          items: Array.isArray(res.data) ? res.data : []
+        });
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_reports_reviews_totals",
+    {
+      title: "Reviews totals report",
+      description: "Returns product review counts by status (approved, hold, spam, etc.). Use this to monitor moderation backlog and review health.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const res = await client.get("reports/reviews/totals");
+        return textContent({
+          items: Array.isArray(res.data) ? res.data : []
+        });
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+}
+
+// src/tools/settings.ts
+var import_zod13 = require("zod");
+function registerSettingsTools(server, client) {
+  server.registerTool(
+    "woo_settings_groups_list",
+    {
+      title: "List settings groups",
+      description: "Lists WooCommerce settings groups (general, products, tax, shipping, checkout, account, email, advanced, etc.). Use this to discover which setting groups exist before reading or updating options.",
+      inputSchema: {
+        ...PaginationInputSchema.shape
+      }
+    },
+    async (args) => {
+      try {
+        const page = args.page ?? 1;
+        const per_page = args.per_page ?? 100;
+        const res = await client.get("settings", { page, per_page });
+        const meta = client.pagination(res, page, per_page);
+        const items = Array.isArray(res.data) ? res.data : [];
+        return textContent(
+          parseListOutput(
+            items,
+            meta.currentPage,
+            meta.perPage,
+            meta.total || items.length,
+            meta.totalPages,
+            WcEntitySchema
+          )
+        );
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_settings_list",
+    {
+      title: "List settings in a group",
+      description: "Lists all setting options within a settings group (e.g. general, products). Use this to inspect current store configuration values such as currency, country, or tax display.",
+      inputSchema: {
+        group: import_zod13.z.string().min(1).describe("Settings group ID. Example: general, products, tax"),
+        ...PaginationInputSchema.shape
+      }
+    },
+    async (args) => {
+      try {
+        const page = args.page ?? 1;
+        const per_page = args.per_page ?? 100;
+        const res = await client.get(`settings/${args.group}`, {
+          page,
+          per_page
+        });
+        const meta = client.pagination(res, page, per_page);
+        const items = Array.isArray(res.data) ? res.data : [];
+        return textContent(
+          parseListOutput(
+            items,
+            meta.currentPage,
+            meta.perPage,
+            meta.total || items.length,
+            meta.totalPages,
+            WcEntitySchema
+          )
+        );
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_settings_get",
+    {
+      title: "Get setting option",
+      description: "Retrieves a single setting option by group and option ID. Use this when you need the current value and metadata (type, default, options) for one configuration key.",
+      inputSchema: {
+        group: import_zod13.z.string().min(1).describe("Settings group ID. Example: general"),
+        id: import_zod13.z.string().min(1).describe("Setting option ID. Example: woocommerce_currency")
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.get(`settings/${args.group}/${args.id}`);
+        return textContent(parseSingleOutput(res.data, WcEntitySchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_settings_update",
+    {
+      title: "Update setting option",
+      description: "Updates a single setting option value. Use this carefully for configuration changes such as currency, store address, or tax display \u2014 always confirm intent with the user for production stores.",
+      inputSchema: {
+        group: import_zod13.z.string().min(1).describe("Settings group ID"),
+        id: import_zod13.z.string().min(1).describe("Setting option ID"),
+        value: import_zod13.z.union([import_zod13.z.string(), import_zod13.z.number(), import_zod13.z.boolean(), import_zod13.z.array(import_zod13.z.string())]).describe("New value for the setting")
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.put(`settings/${args.group}/${args.id}`, {
+          value: args.value
+        });
+        return textContent(parseSingleOutput(res.data, WcEntitySchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+}
+
+// src/tools/system-status.ts
+var import_zod14 = require("zod");
+var SystemStatusSchema = import_zod14.z.object({
+  environment: import_zod14.z.record(import_zod14.z.unknown()).optional(),
+  database: import_zod14.z.record(import_zod14.z.unknown()).optional(),
+  active_plugins: import_zod14.z.array(import_zod14.z.unknown()).optional(),
+  theme: import_zod14.z.record(import_zod14.z.unknown()).optional(),
+  settings: import_zod14.z.record(import_zod14.z.unknown()).optional(),
+  security: import_zod14.z.record(import_zod14.z.unknown()).optional(),
+  pages: import_zod14.z.array(import_zod14.z.unknown()).optional()
+}).passthrough();
+function registerSystemStatusTools(server, client) {
+  server.registerTool(
+    "woo_system_status_get",
+    {
+      title: "Get system status",
+      description: "Fetches the full WooCommerce system status report including environment (PHP, WordPress, WC version), database, active plugins, theme, and security flags. Use this for store health checks, debugging plugin conflicts, or verifying the runtime before bulk operations.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const res = await client.get("system_status");
+        const parsed = SystemStatusSchema.parse(res.data ?? {});
+        return textContent({ item: parsed });
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_system_status_tools_list",
+    {
+      title: "List system status tools",
+      description: "Lists available WooCommerce system tools (clear transients, recount terms, regenerate thumbnails, etc.). Use this to discover maintenance actions before running one.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const res = await client.get("system_status/tools");
+        const items = Array.isArray(res.data) ? res.data : [];
+        WcEntitySchema.array().parse(items.length ? items : [{ id: 0 }]);
+        return textContent({ items });
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_system_status_tools_run",
+    {
+      title: "Run system status tool",
+      description: "Runs a WooCommerce system maintenance tool by ID (e.g. clear_transients). Use this only when the user explicitly requests a maintenance action \u2014 these can be destructive or slow on large stores.",
+      inputSchema: {
+        id: import_zod14.z.string().min(1).describe("Tool ID. Example: clear_transients")
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.put(`system_status/tools/${args.id}`, {
+          confirm: true
+        });
+        return textContent({ item: res.data });
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+}
+
+// src/tools/webhooks.ts
+var import_zod15 = require("zod");
+var WebhookCreateSchema = import_zod15.z.object({
+  name: import_zod15.z.string().optional().describe("Friendly webhook name"),
+  status: import_zod15.z.enum(["active", "paused", "disabled"]).optional().describe("Webhook status"),
+  topic: import_zod15.z.string().describe(
+    "Event topic. Example: order.created, product.updated, customer.deleted"
+  ),
+  delivery_url: import_zod15.z.string().url().describe("HTTPS URL that receives the webhook payload"),
+  secret: import_zod15.z.string().optional().describe("Optional signing secret")
+}).passthrough();
+function registerWebhookTools(server, client) {
+  server.registerTool(
+    "woo_webhooks_list",
+    {
+      title: "List webhooks",
+      description: "Lists configured WooCommerce webhooks with pagination. Use this to audit integrations, find broken delivery URLs, or inventory event subscriptions.",
+      inputSchema: {
+        ...PaginationInputSchema.shape,
+        status: import_zod15.z.enum(["all", "active", "paused", "disabled"]).optional().describe("Filter by webhook status"),
+        search: import_zod15.z.string().optional().describe("Search webhook names")
+      }
+    },
+    async (args) => {
+      try {
+        const page = args.page ?? 1;
+        const per_page = args.per_page ?? 10;
+        const res = await client.get("webhooks", {
+          page,
+          per_page,
+          status: args.status,
+          search: args.search
+        });
+        const meta = client.pagination(res, page, per_page);
+        return textContent(
+          parseListOutput(
+            res.data,
+            meta.currentPage,
+            meta.perPage,
+            meta.total,
+            meta.totalPages,
+            WebhookSchema
+          )
+        );
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_webhooks_get",
+    {
+      title: "Get webhook",
+      description: "Retrieves a single webhook by ID including topic, delivery URL, and status. Use this when diagnosing a specific integration endpoint.",
+      inputSchema: {
+        id: import_zod15.z.number().int().positive().describe("Webhook ID")
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.get("webhooks", { id: args.id });
+        return textContent(parseSingleOutput(res.data, WebhookSchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_webhooks_create",
+    {
+      title: "Create webhook",
+      description: "Creates a new webhook subscription for a topic and delivery URL. Use this to connect the store to external systems (ERP, Slack, custom services) on order/product/customer events.",
+      inputSchema: WebhookCreateSchema.shape
+    },
+    async (args) => {
+      try {
+        const res = await client.post("webhooks", args);
+        return textContent(parseSingleOutput(res.data, WebhookSchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_webhooks_update",
+    {
+      title: "Update webhook",
+      description: "Updates an existing webhook by ID (status, URL, topic, name). Use this to pause/resume integrations or rotate delivery endpoints.",
+      inputSchema: {
+        id: import_zod15.z.number().int().positive().describe("Webhook ID"),
+        data: WebhookCreateSchema.partial().passthrough().describe("Fields to update")
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.put(
+          "webhooks",
+          args.data,
+          { id: args.id }
+        );
+        return textContent(parseSingleOutput(res.data, WebhookSchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_webhooks_delete",
+    {
+      title: "Delete webhook",
+      description: "Deletes a webhook by ID. Use this to remove obsolete integrations or stop noisy event delivery. force=true permanently deletes.",
+      inputSchema: {
+        id: import_zod15.z.number().int().positive().describe("Webhook ID"),
+        force: import_zod15.z.boolean().default(true).optional()
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.delete(
+          "webhooks",
+          { force: args.force ?? true },
+          { id: args.id }
+        );
+        return textContent(
+          DeleteResponseSchema.parse({
+            deleted: true,
+            previous: res.data,
+            id: args.id
+          })
+        );
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+}
+
+// src/tools/tax.ts
+var import_zod16 = require("zod");
+var TaxRateCreateSchema = import_zod16.z.object({
+  country: import_zod16.z.string().optional().describe("ISO country code. Example: US"),
+  state: import_zod16.z.string().optional().describe("State code. Example: CA"),
+  postcode: import_zod16.z.string().optional().describe("Postcode / ZIP"),
+  city: import_zod16.z.string().optional().describe("City name"),
+  rate: import_zod16.z.string().describe('Tax rate percentage as string. Example: "8.5000"'),
+  name: import_zod16.z.string().optional().describe("Tax name. Example: VAT"),
+  priority: import_zod16.z.number().optional(),
+  compound: import_zod16.z.boolean().optional(),
+  shipping: import_zod16.z.boolean().optional().describe("Whether rate applies to shipping"),
+  class: import_zod16.z.string().optional().describe("Tax class slug. Example: standard")
+}).passthrough();
+function registerTaxTools(server, client) {
+  server.registerTool(
+    "woo_tax_rates_list",
+    {
+      title: "List tax rates",
+      description: "Lists configured tax rates with pagination and optional filters. Use this to audit regional tax setup or find rate IDs before updates.",
+      inputSchema: {
+        ...PaginationInputSchema.shape,
+        class: import_zod16.z.string().optional().describe("Filter by tax class slug"),
+        country: import_zod16.z.string().optional().describe("Filter by country code")
+      }
+    },
+    async (args) => {
+      try {
+        const page = args.page ?? 1;
+        const per_page = args.per_page ?? 10;
+        const res = await client.get("taxes", {
+          page,
+          per_page,
+          class: args.class,
+          country: args.country
+        });
+        const meta = client.pagination(res, page, per_page);
+        return textContent(
+          parseListOutput(
+            res.data,
+            meta.currentPage,
+            meta.perPage,
+            meta.total,
+            meta.totalPages,
+            TaxRateSchema
+          )
+        );
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_tax_rates_get",
+    {
+      title: "Get tax rate",
+      description: "Retrieves a single tax rate by ID. Use this when you need the full rate record including location and class details.",
+      inputSchema: {
+        id: import_zod16.z.number().int().positive().describe("Tax rate ID")
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.get("taxes", { id: args.id });
+        return textContent(parseSingleOutput(res.data, TaxRateSchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_tax_rates_create",
+    {
+      title: "Create tax rate",
+      description: "Creates a new tax rate for a location and optional tax class. Use this when expanding into new regions or adding reduced/zero rates.",
+      inputSchema: TaxRateCreateSchema.shape
+    },
+    async (args) => {
+      try {
+        const res = await client.post("taxes", args);
+        return textContent(parseSingleOutput(res.data, TaxRateSchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_tax_rates_update",
+    {
+      title: "Update tax rate",
+      description: "Updates an existing tax rate by ID. Use this when tax legislation changes or location matching needs correction.",
+      inputSchema: {
+        id: import_zod16.z.number().int().positive().describe("Tax rate ID"),
+        data: TaxRateCreateSchema.partial().passthrough().describe("Fields to update")
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.put(
+          "taxes",
+          args.data,
+          { id: args.id }
+        );
+        return textContent(parseSingleOutput(res.data, TaxRateSchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_tax_rates_delete",
+    {
+      title: "Delete tax rate",
+      description: "Deletes a tax rate by ID. Use this to remove obsolete regional rates. force=true permanently deletes.",
+      inputSchema: {
+        id: import_zod16.z.number().int().positive().describe("Tax rate ID"),
+        force: import_zod16.z.boolean().default(true).optional()
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.delete(
+          "taxes",
+          { force: args.force ?? true },
+          { id: args.id }
+        );
+        return textContent(
+          DeleteResponseSchema.parse({
+            deleted: true,
+            previous: res.data,
+            id: args.id
+          })
+        );
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_tax_classes_list",
+    {
+      title: "List tax classes",
+      description: "Lists tax classes (standard, reduced-rate, zero-rate, and custom). Use this when assigning tax classes to products or configuring class-specific rates.",
+      inputSchema: {
+        ...PaginationInputSchema.shape
+      }
+    },
+    async (args) => {
+      try {
+        const page = args.page ?? 1;
+        const per_page = args.per_page ?? 10;
+        const res = await client.get("taxes/classes", {
+          page,
+          per_page
+        });
+        const meta = client.pagination(res, page, per_page);
+        const items = Array.isArray(res.data) ? res.data : [];
+        return textContent(
+          parseListOutput(
+            items,
+            meta.currentPage,
+            meta.perPage,
+            meta.total || items.length,
+            meta.totalPages,
+            WcEntitySchema
+          )
+        );
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+  server.registerTool(
+    "woo_tax_classes_get",
+    {
+      title: "Get tax class",
+      description: "Retrieves a tax class by slug. Use this to confirm a class exists before assigning it to products or rates.",
+      inputSchema: {
+        slug: import_zod16.z.string().min(1).describe("Tax class slug. Example: reduced-rate")
+      }
+    },
+    async (args) => {
+      try {
+        const res = await client.get(`taxes/classes/${args.slug}`);
+        const data = Array.isArray(res.data) ? res.data[0] : res.data;
+        return textContent(parseSingleOutput(data, WcEntitySchema));
+      } catch (err) {
+        return toMcpToolError(err);
+      }
+    }
+  );
+}
+
+// src/resources/store-info.ts
+var STORE_INFO_URI = "woo://store/info";
+function registerStoreInfoResource(server, client) {
+  server.registerResource(
+    "store-info",
+    STORE_INFO_URI,
+    {
+      title: "WooCommerce store info",
+      description: "Read-only snapshot of the connected store: name, URL, currency, timezone, weight/dimension units, and WooCommerce version from system status / settings. Use this as grounding context before making catalog or order changes.",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      try {
+        const [statusRes, generalRes] = await Promise.all([
+          client.get("system_status"),
+          client.get("settings/general")
+        ]);
+        const env = statusRes.data?.environment ?? {};
+        const settings = statusRes.data?.settings ?? {};
+        const general = Array.isArray(
+          generalRes.data
+        ) ? generalRes.data : [];
+        const findSetting = (id) => general.find((s) => s.id === id)?.value;
+        const info = {
+          url: client.config.WC_URL,
+          name: findSetting("woocommerce_store_address") || settings.store_id || "WooCommerce Store",
+          currency: findSetting("woocommerce_currency") || settings.currency || null,
+          currency_symbol: settings.currency_symbol ?? null,
+          timezone: env.default_timezone || findSetting("woocommerce_default_customer_address") || null,
+          weight_unit: settings.weight_unit ?? findSetting("woocommerce_weight_unit") ?? null,
+          dimension_unit: settings.dimension_unit ?? findSetting("woocommerce_dimension_unit") ?? null,
+          woocommerce_version: env.version ?? null,
+          wordpress_version: env.wp_version ?? null,
+          php_version: env.php_version ?? null,
+          api_version: client.config.WC_VERSION
+        };
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: JSON.stringify(info, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        const n = normalizeError(err);
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: JSON.stringify({ error: n }, null, 2)
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+
+// src/resources/api-schema.ts
+var API_SCHEMA_URI = "woo://api/schema";
+var WC_API_SCHEMA = {
+  version: "wc/v3",
+  description: "WooCommerce REST API surface wrapped by woo-mcp-server tools. Prefer purpose-built tools over inventing raw paths.",
+  endpoints: [
+    {
+      resource: "products",
+      path: "/products",
+      methods: ["GET", "POST", "PUT", "DELETE"],
+      batch: "/products/batch",
+      search_param: "search",
+      tools: [
+        "woo_products_list",
+        "woo_products_get",
+        "woo_products_create",
+        "woo_products_update",
+        "woo_products_delete",
+        "woo_products_search",
+        "woo_products_batch"
+      ]
+    },
+    {
+      resource: "orders",
+      path: "/orders",
+      methods: ["GET", "POST", "PUT", "DELETE"],
+      batch: "/orders/batch",
+      notes: "/orders/{id}/notes",
+      filters: ["status", "customer", "after", "before", "product"],
+      tools: [
+        "woo_orders_list",
+        "woo_orders_get",
+        "woo_orders_create",
+        "woo_orders_update",
+        "woo_orders_delete",
+        "woo_orders_notes_list",
+        "woo_orders_notes_create",
+        "woo_orders_batch"
+      ]
+    },
+    {
+      resource: "customers",
+      path: "/customers",
+      methods: ["GET", "POST", "PUT", "DELETE"],
+      search_param: "search",
+      tools: [
+        "woo_customers_list",
+        "woo_customers_get",
+        "woo_customers_create",
+        "woo_customers_update",
+        "woo_customers_delete",
+        "woo_customers_search"
+      ]
+    },
+    {
+      resource: "coupons",
+      path: "/coupons",
+      methods: ["GET", "POST", "PUT", "DELETE"],
+      tools: [
+        "woo_coupons_list",
+        "woo_coupons_get",
+        "woo_coupons_create",
+        "woo_coupons_update",
+        "woo_coupons_delete"
+      ]
+    },
+    {
+      resource: "categories",
+      path: "/products/categories",
+      methods: ["GET", "POST", "PUT", "DELETE"],
+      tools: [
+        "woo_categories_list",
+        "woo_categories_get",
+        "woo_categories_create",
+        "woo_categories_update",
+        "woo_categories_delete"
+      ]
+    },
+    {
+      resource: "tags",
+      path: "/products/tags",
+      methods: ["GET", "POST", "PUT", "DELETE"],
+      tools: [
+        "woo_tags_list",
+        "woo_tags_get",
+        "woo_tags_create",
+        "woo_tags_update",
+        "woo_tags_delete"
+      ]
+    },
+    {
+      resource: "variations",
+      path: "/products/{product_id}/variations",
+      methods: ["GET", "POST", "PUT", "DELETE"],
+      tools: [
+        "woo_variations_list",
+        "woo_variations_get",
+        "woo_variations_create",
+        "woo_variations_update",
+        "woo_variations_delete"
+      ]
+    },
+    {
+      resource: "shipping",
+      paths: [
+        "/shipping/zones",
+        "/shipping/zones/{id}/methods",
+        "/shipping_methods",
+        "/products/shipping_classes"
+      ],
+      tools: [
+        "woo_shipping_zones_list",
+        "woo_shipping_zones_get",
+        "woo_shipping_zone_methods_list",
+        "woo_shipping_methods_list",
+        "woo_shipping_classes_list",
+        "woo_shipping_classes_get"
+      ]
+    },
+    {
+      resource: "payments",
+      path: "/payment_gateways",
+      methods: ["GET", "PUT"],
+      tools: ["woo_payments_list", "woo_payments_get", "woo_payments_update"]
+    },
+    {
+      resource: "reports",
+      paths: [
+        "/reports/sales",
+        "/reports/top_sellers",
+        "/reports/orders/totals",
+        "/reports/customers/totals",
+        "/reports/products/totals",
+        "/reports/coupons/totals",
+        "/reports/reviews/totals"
+      ],
+      tools: [
+        "woo_reports_sales",
+        "woo_reports_top_sellers",
+        "woo_reports_orders_totals",
+        "woo_reports_customers_totals",
+        "woo_reports_products_totals",
+        "woo_reports_coupons_totals",
+        "woo_reports_reviews_totals"
+      ]
+    },
+    {
+      resource: "settings",
+      path: "/settings",
+      methods: ["GET", "PUT"],
+      tools: [
+        "woo_settings_groups_list",
+        "woo_settings_list",
+        "woo_settings_get",
+        "woo_settings_update"
+      ]
+    },
+    {
+      resource: "system_status",
+      path: "/system_status",
+      tools: [
+        "woo_system_status_get",
+        "woo_system_status_tools_list",
+        "woo_system_status_tools_run"
+      ]
+    },
+    {
+      resource: "webhooks",
+      path: "/webhooks",
+      methods: ["GET", "POST", "PUT", "DELETE"],
+      tools: [
+        "woo_webhooks_list",
+        "woo_webhooks_get",
+        "woo_webhooks_create",
+        "woo_webhooks_update",
+        "woo_webhooks_delete"
+      ]
+    },
+    {
+      resource: "tax",
+      paths: ["/taxes", "/taxes/classes"],
+      methods: ["GET", "POST", "PUT", "DELETE"],
+      tools: [
+        "woo_tax_rates_list",
+        "woo_tax_rates_get",
+        "woo_tax_rates_create",
+        "woo_tax_rates_update",
+        "woo_tax_rates_delete",
+        "woo_tax_classes_list",
+        "woo_tax_classes_get"
+      ]
+    }
+  ],
+  pagination: {
+    params: ["page", "per_page"],
+    headers: ["x-wp-total", "x-wp-totalpages"]
+  },
+  authentication: "OAuth 1.0a (HTTP) or Basic Auth over HTTPS with consumer key/secret"
+};
+function registerApiSchemaResource(server, client) {
+  server.registerResource(
+    "api-schema",
+    API_SCHEMA_URI,
+    {
+      title: "WooCommerce REST API schema",
+      description: "Documents the WooCommerce REST endpoints and corresponding MCP tools available in this server. Helps the model choose the correct tool instead of inventing raw API paths.",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      try {
+        let live = null;
+        try {
+          const opt = await client.api.options("products");
+          live = opt.data;
+        } catch {
+        }
+        const payload = {
+          ...WC_API_SCHEMA,
+          store_url: client.config.WC_URL,
+          live_products_options: live
+        };
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: JSON.stringify(payload, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        const n = normalizeError(err);
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: JSON.stringify({ error: n, static: WC_API_SCHEMA }, null, 2)
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+
+// src/prompts/store-audit.ts
+var import_zod17 = require("zod");
+function registerStoreAuditPrompt(server) {
+  server.registerPrompt(
+    "store-audit",
+    {
+      title: "Store product SEO & quality audit",
+      description: "Guides an audit of catalog products for missing images, empty short descriptions, uncategorized items, zero stock, and basic SEO issues. Use when the user asks to review catalog quality or SEO readiness.",
+      argsSchema: {
+        sample_size: import_zod17.z.string().optional().describe('How many products to sample (default 50). Example: "50"'),
+        focus: import_zod17.z.string().optional().describe(
+          "Optional focus area: seo, inventory, images, categories, or all"
+        )
+      }
+    },
+    ({ sample_size, focus }) => {
+      const size = sample_size || "50";
+      const area = focus || "all";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `You are auditing a WooCommerce store catalog for quality and SEO issues.
+
+Focus area: ${area}
+Sample size: up to ${size} products
+
+Steps:
+1. Read the woo://store/info resource for store context (currency, WC version).
+2. Use woo_products_list with per_page appropriate for the sample (paginate if needed).
+3. For each product, flag issues:
+   - Missing or empty images array
+   - Empty or very short short_description (< 20 chars)
+   - No categories assigned
+   - stock_quantity is 0 or stock_status is outofstock while status is publish
+   - Missing or generic name / slug issues (slug equals "product" or empty)
+   - description longer than 0 but missing title-like H1 keywords (basic SEO note)
+4. Group findings by severity (critical / warning / info).
+5. Produce a prioritized action list with product IDs and suggested fixes.
+6. Do not modify products unless the user explicitly asks you to apply fixes.
+
+Return a structured markdown report with counts and a table of affected product IDs.`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/prompts/order-report.ts
+var import_zod18 = require("zod");
+function registerOrderReportPrompt(server) {
+  server.registerPrompt(
+    "order-report",
+    {
+      title: "Sales / order report",
+      description: "Generates a sales report for a given date range: orders by status, revenue totals, and top products. Defaults to the last 30 days when dates are omitted.",
+      argsSchema: {
+        date_min: import_zod18.z.string().optional().describe("Start date YYYY-MM-DD (default: 30 days ago)"),
+        date_max: import_zod18.z.string().optional().describe("End date YYYY-MM-DD (default: today)"),
+        status: import_zod18.z.string().optional().describe("Optional order status filter, e.g. completed,processing")
+      }
+    },
+    ({ date_min, date_max, status }) => {
+      const min = date_min || "(30 days ago \u2014 compute ISO date)";
+      const max = date_max || "(today \u2014 compute ISO date)";
+      const statusFilter = status || "any relevant statuses";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Generate a WooCommerce sales report for the date range ${min} to ${max}.
+
+Status filter: ${statusFilter}
+
+Steps:
+1. Read woo://store/info for currency and store name.
+2. Call woo_reports_sales with date_min/date_max (or period if appropriate).
+3. Call woo_reports_top_sellers for the same range.
+4. Call woo_reports_orders_totals for status distribution.
+5. Optionally list recent orders with woo_orders_list (after/before filters, status) for qualitative notes.
+6. Summarize:
+   - Total revenue and order count
+   - Average order value
+   - Breakdown by order status
+   - Top 5 products by quantity sold
+   - Notable anomalies (refunds, failed spikes)
+
+Present results as executive-friendly markdown with bullet KPIs and a short narrative. Do not invent numbers \u2014 only use tool results.`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/prompts/inventory-check.ts
+var import_zod19 = require("zod");
+function registerInventoryCheckPrompt(server) {
+  server.registerPrompt(
+    "inventory-check",
+    {
+      title: "Low-stock inventory check",
+      description: "Finds products with stock below a threshold, groups them by category, and suggests reorder quantities. Use for replenishment planning and stock-out prevention.",
+      argsSchema: {
+        threshold: import_zod19.z.string().optional().describe('Stock quantity threshold (default 5). Example: "5"'),
+        include_outofstock: import_zod19.z.string().optional().describe("Whether to include outofstock items: true|false (default true)")
+      }
+    },
+    ({ threshold, include_outofstock }) => {
+      const thr = threshold || "5";
+      const includeOoS = include_outofstock ?? "true";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Perform a low-stock inventory check for this WooCommerce store.
+
+Threshold: stock_quantity < ${thr} (or null with manage_stock)
+Include out-of-stock products: ${includeOoS}
+
+Steps:
+1. Use woo_products_list with stock_status filters and paginate through results (per_page=50).
+2. Also fetch categories with woo_categories_list for grouping labels.
+3. Filter products where manage_stock is true and stock_quantity is below ${thr}, plus outofstock if requested.
+4. For variable products, use woo_variations_list when parent stock is not authoritative.
+5. Group low-stock items by primary category name.
+6. Suggest a reorder quantity per SKU: max(${thr} * 2 - current_stock, ${thr}) unless historical sales data is available from woo_reports_top_sellers to refine.
+7. Produce a markdown table: SKU | Name | Category | Stock | Suggested reorder | Product ID.
+
+Do not change stock levels unless the user explicitly asks to update products.`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/registry.ts
+function registerAll(server, client) {
+  registerProductTools(server, client);
+  registerOrderTools(server, client);
+  registerCustomerTools(server, client);
+  registerCouponTools(server, client);
+  registerCategoryTools(server, client);
+  registerTagTools(server, client);
+  registerVariationTools(server, client);
+  registerShippingTools(server, client);
+  registerPaymentTools(server, client);
+  registerReportTools(server, client);
+  registerSettingsTools(server, client);
+  registerSystemStatusTools(server, client);
+  registerWebhookTools(server, client);
+  registerTaxTools(server, client);
+  registerStoreInfoResource(server, client);
+  registerApiSchemaResource(server, client);
+  registerStoreAuditPrompt(server);
+  registerOrderReportPrompt(server);
+  registerInventoryCheckPrompt(server);
+}
+
+// src/server.ts
+var SERVER_NAME = "woo-mcp-server";
+var SERVER_VERSION = "1.0.0";
+function createServer(options = {}) {
+  const config = options.config ?? loadConfig();
+  const client = options.client ?? createWooClient(config);
+  const server = new import_mcp.McpServer({
+    name: SERVER_NAME,
+    version: SERVER_VERSION
+  });
+  registerAll(server, client);
+  return { server, client, config };
+}
+async function connectStdio(server) {
+  const transport = new import_stdio.StdioServerTransport();
+  await server.connect(transport);
+}
+async function startServer() {
+  let created;
+  try {
+    created = createServer();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(message);
+    process.exit(1);
+  }
+  await connectStdio(created.server);
+  return created;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SERVER_NAME,
+  SERVER_VERSION,
+  connectStdio,
+  createServer,
+  createWooClient,
+  loadConfig,
+  registerAll,
+  startServer
+});
+//# sourceMappingURL=server.cjs.map