claude-plugin-wordpress-manager 1.7.2 → 1.8.0

package/servers/wp-rest-bridge/build/tools/wc-orders.js

@@ -0,0 +1,128 @@
+import { makeWooCommerceRequest } from '../wordpress.js';
+import { z } from 'zod';
+const wcListOrdersSchema = z.object({
+    per_page: z.number().optional().default(10).describe("Results per page (1-100)"),
+    page: z.number().optional().default(1).describe("Page number"),
+    status: z.enum(['pending', 'processing', 'on-hold', 'completed', 'cancelled', 'refunded', 'failed', 'trash', 'any']).optional().describe("Order status filter"),
+    customer: z.number().optional().describe("Filter by customer ID"),
+    after: z.string().optional().describe("Orders after date (ISO 8601)"),
+    before: z.string().optional().describe("Orders before date (ISO 8601)"),
+    orderby: z.enum(['date', 'id', 'title', 'slug']).optional().describe("Sort by field"),
+    order: z.enum(['asc', 'desc']).optional().default('desc').describe("Sort order"),
+}).strict();
+const wcGetOrderSchema = z.object({
+    id: z.number().describe("Order ID"),
+}).strict();
+const wcUpdateOrderStatusSchema = z.object({
+    id: z.number().describe("Order ID"),
+    status: z.enum(['pending', 'processing', 'on-hold', 'completed', 'cancelled', 'refunded', 'failed']).describe("New order status"),
+}).strict();
+const wcListOrderNotesSchema = z.object({
+    order_id: z.number().describe("Order ID"),
+}).strict();
+const wcCreateOrderNoteSchema = z.object({
+    order_id: z.number().describe("Order ID"),
+    note: z.string().describe("Note content"),
+    customer_note: z.boolean().optional().default(false).describe("If true, note is visible to customer"),
+}).strict();
+const wcCreateRefundSchema = z.object({
+    order_id: z.number().describe("Order ID"),
+    amount: z.string().describe("Refund amount (e.g. '9.99')"),
+    reason: z.string().optional().describe("Reason for refund"),
+}).strict();
+export const wcOrderTools = [
+    {
+        name: "wc_list_orders",
+        description: "Lists WooCommerce orders with filtering by status, customer, and date range",
+        inputSchema: { type: "object", properties: wcListOrdersSchema.shape },
+    },
+    {
+        name: "wc_get_order",
+        description: "Retrieves a single WooCommerce order with full details including line items",
+        inputSchema: { type: "object", properties: wcGetOrderSchema.shape },
+    },
+    {
+        name: "wc_update_order_status",
+        description: "Updates the status of a WooCommerce order (e.g. processing to completed)",
+        inputSchema: { type: "object", properties: wcUpdateOrderStatusSchema.shape },
+    },
+    {
+        name: "wc_list_order_notes",
+        description: "Lists all notes for a WooCommerce order",
+        inputSchema: { type: "object", properties: wcListOrderNotesSchema.shape },
+    },
+    {
+        name: "wc_create_order_note",
+        description: "Adds a note to a WooCommerce order (internal or customer-visible)",
+        inputSchema: { type: "object", properties: wcCreateOrderNoteSchema.shape },
+    },
+    {
+        name: "wc_create_refund",
+        description: "Creates a refund for a WooCommerce order",
+        inputSchema: { type: "object", properties: wcCreateRefundSchema.shape },
+    },
+];
+export const wcOrderHandlers = {
+    wc_list_orders: async (params) => {
+        try {
+            const response = await makeWooCommerceRequest("GET", "orders", params);
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error listing orders: ${errorMessage}` }] } };
+        }
+    },
+    wc_get_order: async (params) => {
+        try {
+            const response = await makeWooCommerceRequest("GET", `orders/${params.id}`);
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error retrieving order: ${errorMessage}` }] } };
+        }
+    },
+    wc_update_order_status: async (params) => {
+        try {
+            const response = await makeWooCommerceRequest("PUT", `orders/${params.id}`, { status: params.status });
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error updating order status: ${errorMessage}` }] } };
+        }
+    },
+    wc_list_order_notes: async (params) => {
+        try {
+            const response = await makeWooCommerceRequest("GET", `orders/${params.order_id}/notes`);
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error listing order notes: ${errorMessage}` }] } };
+        }
+    },
+    wc_create_order_note: async (params) => {
+        try {
+            const { order_id, ...data } = params;
+            const response = await makeWooCommerceRequest("POST", `orders/${order_id}/notes`, data);
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error creating order note: ${errorMessage}` }] } };
+        }
+    },
+    wc_create_refund: async (params) => {
+        try {
+            const { order_id, ...data } = params;
+            const response = await makeWooCommerceRequest("POST", `orders/${order_id}/refunds`, data);
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error creating refund: ${errorMessage}` }] } };
+        }
+    },
+};

package/servers/wp-rest-bridge/build/tools/wc-products.d.ts

@@ -0,0 +1,324 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+declare const wcListProductsSchema: z.ZodObject<{
+    per_page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    search: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<["draft", "pending", "private", "publish", "any"]>>;
+    category: z.ZodOptional<z.ZodNumber>;
+    tag: z.ZodOptional<z.ZodNumber>;
+    sku: z.ZodOptional<z.ZodString>;
+    stock_status: z.ZodOptional<z.ZodEnum<["instock", "outofstock", "onbackorder"]>>;
+    orderby: z.ZodOptional<z.ZodEnum<["date", "id", "title", "slug", "price", "popularity", "rating"]>>;
+    order: z.ZodDefault<z.ZodOptional<z.ZodEnum<["asc", "desc"]>>>;
+}, "strict", z.ZodTypeAny, {
+    page: number;
+    per_page: number;
+    order: "asc" | "desc";
+    search?: string | undefined;
+    status?: "draft" | "pending" | "private" | "publish" | "any" | undefined;
+    orderby?: "slug" | "date" | "id" | "title" | "price" | "popularity" | "rating" | undefined;
+    category?: number | undefined;
+    tag?: number | undefined;
+    sku?: string | undefined;
+    stock_status?: "instock" | "outofstock" | "onbackorder" | undefined;
+}, {
+    page?: number | undefined;
+    per_page?: number | undefined;
+    search?: string | undefined;
+    status?: "draft" | "pending" | "private" | "publish" | "any" | undefined;
+    orderby?: "slug" | "date" | "id" | "title" | "price" | "popularity" | "rating" | undefined;
+    order?: "asc" | "desc" | undefined;
+    category?: number | undefined;
+    tag?: number | undefined;
+    sku?: string | undefined;
+    stock_status?: "instock" | "outofstock" | "onbackorder" | undefined;
+}>;
+declare const wcGetProductSchema: z.ZodObject<{
+    id: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    id: number;
+}, {
+    id: number;
+}>;
+declare const wcCreateProductSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodDefault<z.ZodOptional<z.ZodEnum<["simple", "grouped", "external", "variable"]>>>;
+    status: z.ZodDefault<z.ZodOptional<z.ZodEnum<["draft", "pending", "private", "publish"]>>>;
+    regular_price: z.ZodOptional<z.ZodString>;
+    sale_price: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    short_description: z.ZodOptional<z.ZodString>;
+    sku: z.ZodOptional<z.ZodString>;
+    manage_stock: z.ZodOptional<z.ZodBoolean>;
+    stock_quantity: z.ZodOptional<z.ZodNumber>;
+    categories: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        id: number;
+    }, {
+        id: number;
+    }>, "many">>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        id: number;
+    }, {
+        id: number;
+    }>, "many">>;
+    images: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        src: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        src: string;
+    }, {
+        src: string;
+    }>, "many">>;
+}, "strict", z.ZodTypeAny, {
+    status: "draft" | "pending" | "private" | "publish";
+    type: "simple" | "grouped" | "external" | "variable";
+    name: string;
+    categories?: {
+        id: number;
+    }[] | undefined;
+    tags?: {
+        id: number;
+    }[] | undefined;
+    description?: string | undefined;
+    sku?: string | undefined;
+    regular_price?: string | undefined;
+    sale_price?: string | undefined;
+    short_description?: string | undefined;
+    manage_stock?: boolean | undefined;
+    stock_quantity?: number | undefined;
+    images?: {
+        src: string;
+    }[] | undefined;
+}, {
+    name: string;
+    status?: "draft" | "pending" | "private" | "publish" | undefined;
+    type?: "simple" | "grouped" | "external" | "variable" | undefined;
+    categories?: {
+        id: number;
+    }[] | undefined;
+    tags?: {
+        id: number;
+    }[] | undefined;
+    description?: string | undefined;
+    sku?: string | undefined;
+    regular_price?: string | undefined;
+    sale_price?: string | undefined;
+    short_description?: string | undefined;
+    manage_stock?: boolean | undefined;
+    stock_quantity?: number | undefined;
+    images?: {
+        src: string;
+    }[] | undefined;
+}>;
+declare const wcUpdateProductSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<["draft", "pending", "private", "publish"]>>;
+    regular_price: z.ZodOptional<z.ZodString>;
+    sale_price: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    short_description: z.ZodOptional<z.ZodString>;
+    sku: z.ZodOptional<z.ZodString>;
+    manage_stock: z.ZodOptional<z.ZodBoolean>;
+    stock_quantity: z.ZodOptional<z.ZodNumber>;
+    stock_status: z.ZodOptional<z.ZodEnum<["instock", "outofstock", "onbackorder"]>>;
+}, "strict", z.ZodTypeAny, {
+    id: number;
+    status?: "draft" | "pending" | "private" | "publish" | undefined;
+    description?: string | undefined;
+    name?: string | undefined;
+    sku?: string | undefined;
+    stock_status?: "instock" | "outofstock" | "onbackorder" | undefined;
+    regular_price?: string | undefined;
+    sale_price?: string | undefined;
+    short_description?: string | undefined;
+    manage_stock?: boolean | undefined;
+    stock_quantity?: number | undefined;
+}, {
+    id: number;
+    status?: "draft" | "pending" | "private" | "publish" | undefined;
+    description?: string | undefined;
+    name?: string | undefined;
+    sku?: string | undefined;
+    stock_status?: "instock" | "outofstock" | "onbackorder" | undefined;
+    regular_price?: string | undefined;
+    sale_price?: string | undefined;
+    short_description?: string | undefined;
+    manage_stock?: boolean | undefined;
+    stock_quantity?: number | undefined;
+}>;
+declare const wcDeleteProductSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    force: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strict", z.ZodTypeAny, {
+    id: number;
+    force: boolean;
+}, {
+    id: number;
+    force?: boolean | undefined;
+}>;
+declare const wcListProductCategoriesSchema: z.ZodObject<{
+    per_page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    search: z.ZodOptional<z.ZodString>;
+    parent: z.ZodOptional<z.ZodNumber>;
+    orderby: z.ZodOptional<z.ZodEnum<["id", "name", "slug", "count"]>>;
+    order: z.ZodDefault<z.ZodOptional<z.ZodEnum<["asc", "desc"]>>>;
+}, "strict", z.ZodTypeAny, {
+    page: number;
+    per_page: number;
+    order: "asc" | "desc";
+    search?: string | undefined;
+    parent?: number | undefined;
+    orderby?: "slug" | "id" | "name" | "count" | undefined;
+}, {
+    page?: number | undefined;
+    per_page?: number | undefined;
+    search?: string | undefined;
+    parent?: number | undefined;
+    orderby?: "slug" | "id" | "name" | "count" | undefined;
+    order?: "asc" | "desc" | undefined;
+}>;
+declare const wcListProductVariationsSchema: z.ZodObject<{
+    product_id: z.ZodNumber;
+    per_page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    status: z.ZodOptional<z.ZodEnum<["draft", "pending", "private", "publish", "any"]>>;
+}, "strict", z.ZodTypeAny, {
+    page: number;
+    per_page: number;
+    product_id: number;
+    status?: "draft" | "pending" | "private" | "publish" | "any" | undefined;
+}, {
+    product_id: number;
+    page?: number | undefined;
+    per_page?: number | undefined;
+    status?: "draft" | "pending" | "private" | "publish" | "any" | undefined;
+}>;
+export declare const wcProductTools: Tool[];
+export declare const wcProductHandlers: {
+    wc_list_products: (params: z.infer<typeof wcListProductsSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    wc_get_product: (params: z.infer<typeof wcGetProductSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    wc_create_product: (params: z.infer<typeof wcCreateProductSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    wc_update_product: (params: z.infer<typeof wcUpdateProductSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    wc_delete_product: (params: z.infer<typeof wcDeleteProductSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    wc_list_product_categories: (params: z.infer<typeof wcListProductCategoriesSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    wc_list_product_variations: (params: z.infer<typeof wcListProductVariationsSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+};
+export {};

package/servers/wp-rest-bridge/build/tools/wc-products.js

@@ -0,0 +1,177 @@
+import { makeWooCommerceRequest } from '../wordpress.js';
+import { z } from 'zod';
+// ── Schemas ──────────────────────────────────────────────────────────
+const wcListProductsSchema = z.object({
+    per_page: z.number().optional().default(10).describe("Results per page (1-100)"),
+    page: z.number().optional().default(1).describe("Page number"),
+    search: z.string().optional().describe("Search products by keyword"),
+    status: z.enum(['draft', 'pending', 'private', 'publish', 'any']).optional().describe("Product status filter"),
+    category: z.number().optional().describe("Filter by category ID"),
+    tag: z.number().optional().describe("Filter by tag ID"),
+    sku: z.string().optional().describe("Filter by exact SKU"),
+    stock_status: z.enum(['instock', 'outofstock', 'onbackorder']).optional().describe("Filter by stock status"),
+    orderby: z.enum(['date', 'id', 'title', 'slug', 'price', 'popularity', 'rating']).optional().describe("Sort by field"),
+    order: z.enum(['asc', 'desc']).optional().default('desc').describe("Sort order"),
+}).strict();
+const wcGetProductSchema = z.object({
+    id: z.number().describe("Product ID"),
+}).strict();
+const wcCreateProductSchema = z.object({
+    name: z.string().describe("Product name"),
+    type: z.enum(['simple', 'grouped', 'external', 'variable']).optional().default('simple').describe("Product type"),
+    status: z.enum(['draft', 'pending', 'private', 'publish']).optional().default('publish').describe("Product status"),
+    regular_price: z.string().optional().describe("Regular price (e.g. '19.99')"),
+    sale_price: z.string().optional().describe("Sale price"),
+    description: z.string().optional().describe("Full product description (HTML)"),
+    short_description: z.string().optional().describe("Short product description (HTML)"),
+    sku: z.string().optional().describe("Stock Keeping Unit"),
+    manage_stock: z.boolean().optional().describe("Enable stock management"),
+    stock_quantity: z.number().optional().describe("Stock quantity (requires manage_stock: true)"),
+    categories: z.array(z.object({ id: z.number() })).optional().describe("Category IDs, e.g. [{id: 15}]"),
+    tags: z.array(z.object({ id: z.number() })).optional().describe("Tag IDs, e.g. [{id: 3}]"),
+    images: z.array(z.object({ src: z.string() })).optional().describe("Image URLs, e.g. [{src: 'https://...'}]"),
+}).strict();
+const wcUpdateProductSchema = z.object({
+    id: z.number().describe("Product ID to update"),
+    name: z.string().optional().describe("Product name"),
+    status: z.enum(['draft', 'pending', 'private', 'publish']).optional().describe("Product status"),
+    regular_price: z.string().optional().describe("Regular price"),
+    sale_price: z.string().optional().describe("Sale price"),
+    description: z.string().optional().describe("Full description"),
+    short_description: z.string().optional().describe("Short description"),
+    sku: z.string().optional().describe("SKU"),
+    manage_stock: z.boolean().optional().describe("Enable stock management"),
+    stock_quantity: z.number().optional().describe("Stock quantity"),
+    stock_status: z.enum(['instock', 'outofstock', 'onbackorder']).optional().describe("Stock status"),
+}).strict();
+const wcDeleteProductSchema = z.object({
+    id: z.number().describe("Product ID to delete"),
+    force: z.boolean().optional().default(false).describe("True to permanently delete, false to move to trash"),
+}).strict();
+const wcListProductCategoriesSchema = z.object({
+    per_page: z.number().optional().default(10).describe("Results per page (1-100)"),
+    page: z.number().optional().default(1).describe("Page number"),
+    search: z.string().optional().describe("Search categories by keyword"),
+    parent: z.number().optional().describe("Filter by parent category ID"),
+    orderby: z.enum(['id', 'name', 'slug', 'count']).optional().describe("Sort by field"),
+    order: z.enum(['asc', 'desc']).optional().default('asc').describe("Sort order"),
+}).strict();
+const wcListProductVariationsSchema = z.object({
+    product_id: z.number().describe("Parent product ID"),
+    per_page: z.number().optional().default(10).describe("Results per page (1-100)"),
+    page: z.number().optional().default(1).describe("Page number"),
+    status: z.enum(['draft', 'pending', 'private', 'publish', 'any']).optional().describe("Variation status"),
+}).strict();
+// ── Tool Definitions ─────────────────────────────────────────────────
+export const wcProductTools = [
+    {
+        name: "wc_list_products",
+        description: "Lists WooCommerce products with filtering, sorting, and pagination",
+        inputSchema: { type: "object", properties: wcListProductsSchema.shape },
+    },
+    {
+        name: "wc_get_product",
+        description: "Retrieves a single WooCommerce product by ID with full details",
+        inputSchema: { type: "object", properties: wcGetProductSchema.shape },
+    },
+    {
+        name: "wc_create_product",
+        description: "Creates a new WooCommerce product (simple, grouped, external, or variable)",
+        inputSchema: { type: "object", properties: wcCreateProductSchema.shape },
+    },
+    {
+        name: "wc_update_product",
+        description: "Updates an existing WooCommerce product's fields",
+        inputSchema: { type: "object", properties: wcUpdateProductSchema.shape },
+    },
+    {
+        name: "wc_delete_product",
+        description: "Deletes a WooCommerce product (trash or permanent)",
+        inputSchema: { type: "object", properties: wcDeleteProductSchema.shape },
+    },
+    {
+        name: "wc_list_product_categories",
+        description: "Lists WooCommerce product categories with hierarchy support",
+        inputSchema: { type: "object", properties: wcListProductCategoriesSchema.shape },
+    },
+    {
+        name: "wc_list_product_variations",
+        description: "Lists variations of a variable WooCommerce product",
+        inputSchema: { type: "object", properties: wcListProductVariationsSchema.shape },
+    },
+];
+// ── Handlers ─────────────────────────────────────────────────────────
+export const wcProductHandlers = {
+    wc_list_products: async (params) => {
+        try {
+            const response = await makeWooCommerceRequest("GET", "products", params);
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error listing products: ${errorMessage}` }] } };
+        }
+    },
+    wc_get_product: async (params) => {
+        try {
+            const response = await makeWooCommerceRequest("GET", `products/${params.id}`);
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error retrieving product: ${errorMessage}` }] } };
+        }
+    },
+    wc_create_product: async (params) => {
+        try {
+            const response = await makeWooCommerceRequest("POST", "products", params);
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error creating product: ${errorMessage}` }] } };
+        }
+    },
+    wc_update_product: async (params) => {
+        try {
+            const { id, ...data } = params;
+            const response = await makeWooCommerceRequest("PUT", `products/${id}`, data);
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error updating product: ${errorMessage}` }] } };
+        }
+    },
+    wc_delete_product: async (params) => {
+        try {
+            const response = await makeWooCommerceRequest("DELETE", `products/${params.id}`, { force: params.force });
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error deleting product: ${errorMessage}` }] } };
+        }
+    },
+    wc_list_product_categories: async (params) => {
+        try {
+            const response = await makeWooCommerceRequest("GET", "products/categories", params);
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error listing product categories: ${errorMessage}` }] } };
+        }
+    },
+    wc_list_product_variations: async (params) => {
+        try {
+            const { product_id, ...queryParams } = params;
+            const response = await makeWooCommerceRequest("GET", `products/${product_id}/variations`, queryParams);
+            return { toolResult: { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return { toolResult: { isError: true, content: [{ type: "text", text: `Error listing product variations: ${errorMessage}` }] } };
+        }
+    },
+};