claude-plugin-wordpress-manager 2.1.0 → 2.2.0

package/docs/plans/2026-02-28-wcop-strategic-assessment.md

@@ -0,0 +1,220 @@
+# WordPress Manager — Assessment Strategico WCOP
+
+> **WordPress Content Orchestration Platform (WCOP)**
+> Valutazione del plugin v2.1.1 come piattaforma di orchestrazione per content management distribuito a supporto di strategie SEO, engagement e social amplification.
+
+**Data:** 2026-02-28
+**Versione plugin:** 2.1.1
+**Scope:** Alto livello strategico — nessuna implementazione
+
+---
+
+## 1. Modello di Riferimento: WCOP a 5 Layer
+
+Il plugin v2.1.1 va valutato non come "gestore di siti WordPress" ma come **piattaforma di orchestrazione contenuti** strutturata su 5 livelli:
+
+```
+Layer 5 ─ Automation     CI/CD pipeline, webhook, trigger
+Layer 4 ─ Observability  Monitoring, baseline, alerting
+Layer 3 ─ Distribution   Headless, syndication, social, email
+Layer 2 ─ Quality Assur. Testing, security, accessibility, PHPStan
+Layer 1 ─ Content Factory Multisite, WooCommerce, REST API, block dev
+```
+
+### Punteggi per Layer
+
+| Layer | Copertura | Score | Note |
+|-------|-----------|-------|------|
+| 1 — Content Factory | Eccellente | **9/10** | 81 tool MCP, 28 skill, multisite, WooCommerce, headless skill |
+| 2 — Quality Assurance | Forte | **8/10** | E2E + PHPStan + security audit + a11y + hardening |
+| 3 — Distribution | **Debole** | **4/10** | Solo headless skill teorico, nessun connettore outbound reale |
+| 4 — Observability | Parziale | **5/10** | Monitoring single-site, manca fleet monitoring cross-site |
+| 5 — Automation | Parziale | **4/10** | CI/CD per codice, non per contenuto; manca webhook propagation |
+
+**Score complessivo: 6/10** — Il plugin e forte **centripetalmente** (portare contenuto DENTRO WordPress) ma debole **centrifugalmente** (distribuire contenuto FUORI DA WordPress).
+
+---
+
+## 2. Hub Content Architecture
+
+Il plugin ha la base per un modello **Hub-and-Spoke**:
+
+- **Hub**: WordPress Multisite (10 tool MCP) come sorgente canonica
+- **Spoke**: Frontend headless via `wp-headless` skill (REST/WPGraphQL -> Next.js/Nuxt/Astro)
+- **Commerce layer**: WooCommerce (30 tool MCP) come transazione integrata
+
+**Punto di forza**: L'orchestrazione `wp-site-manager` -> delegazione a 10 agent specializzati e un pattern raro nel panorama plugin CLI. La catena audit->hardening (`wp-security-auditor` -> `wp-security-hardener`) e la delegazione monitor->specialist (`wp-monitoring-agent` -> performance/security agent) sono differenzianti.
+
+**Gap**: L'hub e forte nella creazione ma non nella propagazione. Il contenuto nasce in WordPress e li resta.
+
+---
+
+## 3. SEO Topology
+
+| Strategia SEO | Supporto | Dettaglio |
+|---------------|----------|-----------|
+| Pillar-Cluster | ✅ Forte | Content strategist + REST API categories/tags + headless rendering |
+| E-Commerce SEO | ✅ Forte | WooCommerce products + structured data via headless |
+| Programmatic SEO | ⚠️ Parziale | Headless skill copre il pattern, ma manca generazione template scalabile |
+| Local SEO (multi-location) | ⚠️ Parziale | Multisite permette siti per location, manca schema LocalBusiness |
+| Cross-Domain SEO | ❌ Assente | Nessun tool per canonical cross-domain, hreflang fleet, o link graph |
+
+**Opportunita chiave**: Programmatic SEO tramite headless + Multisite e a portata di mano. Un sito multisite dove ogni sub-site genera pagine programmatiche (es. "/prodotto/citta/variante") con Next.js ISR sarebbe potente.
+
+---
+
+## 4. Content Syndication
+
+| Livello | Descrizione | Supporto |
+|---------|-------------|----------|
+| L1 — Canonical Source | WordPress come sorgente unica di verita | ✅ Eccellente (REST API, WPGraphQL) |
+| L2 — Format Adaptation | Trasformare contenuto per canali diversi | ⚠️ Solo manuale (content strategist) |
+| L3 — Channel Distribution | Pubblicare su social, email, ads, partner | ❌ Assente |
+
+Il plugin produce contenuto strutturato di alta qualita (L1) ma non ha pipeline per riformattarlo (L2) ne distribuirlo (L3). Il contenuto "muore" dentro WordPress.
+
+---
+
+## 5. Commerce-Content Integration
+
+WooCommerce e ben integrato (30 tool) ma come layer **transazionale**, non come layer **content-driven**:
+
+- **Content -> Commerce** ⚠️: Si possono creare prodotti e gestire ordini, ma manca il funnel content->conversion tracking
+- **Commerce -> Content** ⚠️: I dati vendita (report WC) esistono ma non alimentano automaticamente la strategia contenuti
+- **Headless Commerce** ⚠️: `wp-headless` skill copre la teoria ma non c'e un workflow "WooCommerce headless" dedicato
+
+---
+
+## 6. Social Amplification
+
+**Posizione corretta del plugin**: Non deve diventare un social media manager (esistono tool dedicati). Deve essere il **miglior fornitore di contenuto strutturato** per tool di distribuzione esterni.
+
+Cio significa: API-first content packaging. WordPress produce JSON strutturato (titolo, excerpt, immagini ottimizzate, categorie, schema markup) che un tool esterno (Buffer, Hootsuite, Zapier) può consumare.
+
+**Gap**: Manca un layer di "content packaging for distribution" — endpoint REST dedicati che formattino il contenuto per i vari canali.
+
+---
+
+## 7. Monitoring come Quality Gate + CI/CD come Content Pipeline
+
+### Monitoring (Differenziante)
+
+Il monitoring v2.1.0 e un **differenziante unico**: nessun altro plugin CLI offre monitoring integrato con delegazione a agent specializzati. La catena:
+
+```
+wp-monitoring-agent (detect anomaly)
+  -> wp-performance-optimizer (if performance issue)
+  -> wp-security-auditor (if security issue)
+  -> wp-site-manager (if infrastructure issue)
+```
+
+Questo pattern va **esteso a fleet level**: monitorare N siti simultaneamente, aggregare metriche, identificare pattern cross-site.
+
+### CI/CD come Content Pipeline (Innovativo)
+
+L'insight piu interessante: CI/CD non dovrebbe essere solo per codice ma anche per **contenuto**:
+
+- Quality gate su contenuti (SEO score minimo, a11y check, reading level)
+- Preview environment per contenuto (staging -> produzione)
+- Rollback contenuto (versioning via REST API revisions)
+
+Il plugin ha gia `wp-cicd-engineer` per codice. Estenderlo a "content pipeline" sarebbe innovativo.
+
+---
+
+## 8. Gap Analysis — Roadmap Strategica
+
+### Tier 1 — Alto Impatto, Alta Fattibilita
+
+| Gap | Descrizione | Effort | Impatto |
+|-----|-------------|--------|---------|
+| **Fleet Monitoring** | Estendere monitoring a N siti (loop su sites.json) | Medio | Trasforma il plugin da single-site a network operator |
+| **Content Repurposing Skill** | Skill che guida la trasformazione contenuto->formati (social post, email, snippet) | Basso | Sblocca L2 syndication |
+| **Webhook Propagation** | Skill/tool per configurare webhook WordPress -> servizi esterni | Basso | Primo mattone per distribuzione automatica |
+
+### Tier 2 — Alto Impatto, Media Fattibilita
+
+| Gap | Descrizione | Effort | Impatto |
+|-----|-------------|--------|---------|
+| **Programmatic SEO Skill** | Generazione template pagine scalabili (headless + multisite) | Medio | SEO topology massiva |
+| **Content-Commerce Attribution** | Collegare metriche WooCommerce a contenuti che generano conversioni | Medio | ROI content misurabile |
+| **Multi-Language Network** | Orchestrazione multisite multilingua (hreflang, i18n + multisite) | Alto | Sblocca mercati internazionali |
+
+### Tier 3 — Alto Impatto, Richiede Ecosistema
+
+| Gap | Descrizione | Effort | Impatto |
+|-----|-------------|--------|---------|
+| **Social/Email Connectors** | MCP tool per Mailchimp, Buffer, etc. (o Zapier bridge) | Alto | L3 distribution completa |
+| **Google Search Console Integration** | MCP tool per GSC API (keyword tracking, indexing) | Medio | SEO feedback loop |
+| **AI Content Optimization** | Skill per ottimizzazione contenuto con AI (headline testing, readability) | Medio | Content quality automatica |
+
+---
+
+## 9. Modello d'Impiego Massimizzato
+
+### Scenario: "Content Hub Distribuito per Brand D2C"
+
+Esempio concreto di impiego simultaneo massimale del plugin:
+
+```
+                    ┌─────────────────────┐
+                    │  WORDPRESS MULTISITE │
+                    │    (Hub Centrale)    │
+                    │   wp-site-manager    │
+                    └──────────┬──────────┘
+           ┌───────────────────┼───────────────────┐
+           │                   │                   │
+    ┌──────▼──────┐    ┌──────▼──────┐    ┌──────▼──────┐
+    │  Sub-site 1 │    │  Sub-site 2 │    │  Sub-site 3 │
+    │  Blog/SEO   │    │ WooCommerce │    │   Landing   │
+    │  (content)  │    │   (shop)    │    │  (campaign) │
+    └──────┬──────┘    └──────┬──────┘    └──────┬──────┘
+           │                   │                   │
+    ┌──────▼──────┐    ┌──────▼──────┐    ┌──────▼──────┐
+    │  Next.js    │    │  Nuxt.js    │    │  Astro      │
+    │  (headless) │    │  (headless) │    │  (static)   │
+    └─────────────┘    └─────────────┘    └─────────────┘
+```
+
+**Agent attivi simultaneamente:**
+
+1. `wp-content-strategist` — crea contenuto pillar nel sub-site blog
+2. `wp-ecommerce-manager` — gestisce catalogo e promozioni nel sub-site shop
+3. `wp-cicd-engineer` — mantiene pipeline deploy per i 3 frontend headless
+4. `wp-monitoring-agent` — sorveglia uptime e performance di tutti i sub-siti
+5. `wp-security-auditor` + `wp-security-hardener` — ciclo audit/hardening periodico
+6. `wp-test-engineer` — E2E testing sui frontend headless
+7. `wp-accessibility-auditor` — compliance WCAG sui frontend pubblici
+
+**Skill attive:**
+
+- `wp-multisite` per gestione rete
+- `wp-headless` per configurazione API layer
+- `wp-woocommerce` per store operations
+- `wp-cicd` per pipeline automation
+- `wp-monitoring` per observability
+- `wordpress-router` per orchestrazione decisionale
+
+> Questo scenario usa **7 degli 11 agent** e **6 delle 28 skill** simultaneamente.
+
+---
+
+## 10. Conclusione Strategica
+
+Il plugin WordPress Manager v2.1.1 e una **piattaforma di orchestrazione contenuti matura al 60%**:
+
+- **Eccellente** come Content Factory (Layer 1) e Quality Assurance (Layer 2)
+- **Differenziante** nel pattern monitoring->delegazione e nella copertura agent (11 specializzati)
+- **Carente** nella distribuzione outbound (Layer 3) e nell'automazione contenuto (Layer 5)
+
+### La trasformazione da "gestore WordPress" a "Content Orchestration Platform" richiede 3 mosse strategiche:
+
+1. **Fleet-first**: Ogni tool e agent deve pensare "N siti", non "1 sito"
+2. **Content-out**: Aggiungere il layer di distribuzione (content packaging -> webhook -> canali)
+3. **Content pipeline**: Estendere CI/CD dal codice al contenuto (quality gates, staging, rollback)
+
+Con queste 3 evoluzioni, il plugin passerebbe da **6/10 a 8-9/10** come piattaforma WCOP, posizionandosi come l'unico strumento CLI che copre l'intero ciclo di vita del contenuto WordPress: **creazione -> qualita -> distribuzione -> osservabilita -> automazione**.
+
+---
+
+*Assessment WCOP v1.0 — wordpress-manager v2.1.1 — 2026-02-28*

package/hooks/hooks.json

@@ -51,6 +51,15 @@
             "timeout": 15
           }
         ]
+      },
+      {
+        "matcher": "mcp__wp-rest-bridge__wc_delete_webhook",
+        "hooks": [
+          {
+            "type": "prompt",
+            "prompt": "The agent is about to DELETE a WooCommerce webhook. This will stop notifications to the configured delivery URL. Verify the user explicitly requested this deletion and understands that external integrations depending on this webhook will stop receiving events."
+          }
+        ]
       }
     ]
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-plugin-wordpress-manager",
-  "version": "2.1.0",
-  "description": "Unified WordPress management and development plugin for Claude Code. Orchestrates Hostinger MCP, WP REST API bridge (81 tools incl. 30 WooCommerce + 10 Multisite), and WordPress.com MCP with 28 skills, 11 agents, and security hooks. v2.1.0 adds site monitoring: uptime checks, performance baseline, security scanning, content integrity, alerting strategies, and reporting templates.",
+  "version": "2.2.0",
+  "description": "Unified WordPress management and development plugin for Claude Code. Orchestrates Hostinger MCP, WP REST API bridge (85 tools incl. 30 WooCommerce + 10 Multisite + 4 Webhooks), and WordPress.com MCP with 30 skills, 11 agents, and security hooks. v2.2.0 adds fleet monitoring, content repurposing skill, and webhook propagation (WooCommerce webhook MCP tools + mu-plugin patterns).",
   "author": {
     "name": "vinmor",
     "email": "morreale.v@gmail.com"
@@ -33,7 +33,10 @@
     "gitlab-ci",
     "monitoring",
     "uptime",
-    "health-check"
+    "health-check",
+    "webhook",
+    "content-repurposing",
+    "fleet-monitoring"
   ],
   "repository": {
     "type": "git",

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

@@ -1,6 +1,125 @@
 import { Tool } from '@modelcontextprotocol/sdk/types.js';
 export declare const allTools: Tool[];
 export declare const toolHandlers: {
+    wc_list_webhooks: (params: import("zod").TypeOf<import("zod").ZodObject<{
+        status: import("zod").ZodOptional<import("zod").ZodEnum<["active", "paused", "disabled"]>>;
+    }, "strict", import("zod").ZodTypeAny, {
+        status?: "active" | "paused" | "disabled" | undefined;
+    }, {
+        status?: "active" | "paused" | "disabled" | undefined;
+    }>>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    wc_create_webhook: (params: import("zod").TypeOf<import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        topic: import("zod").ZodString;
+        delivery_url: import("zod").ZodString;
+        secret: import("zod").ZodOptional<import("zod").ZodString>;
+        status: import("zod").ZodOptional<import("zod").ZodEnum<["active", "paused", "disabled"]>>;
+    }, "strict", import("zod").ZodTypeAny, {
+        name: string;
+        topic: string;
+        delivery_url: string;
+        status?: "active" | "paused" | "disabled" | undefined;
+        secret?: string | undefined;
+    }, {
+        name: string;
+        topic: string;
+        delivery_url: string;
+        status?: "active" | "paused" | "disabled" | undefined;
+        secret?: string | undefined;
+    }>>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    wc_update_webhook: (params: import("zod").TypeOf<import("zod").ZodObject<{
+        id: import("zod").ZodNumber;
+        name: import("zod").ZodOptional<import("zod").ZodString>;
+        topic: import("zod").ZodOptional<import("zod").ZodString>;
+        delivery_url: import("zod").ZodOptional<import("zod").ZodString>;
+        secret: import("zod").ZodOptional<import("zod").ZodString>;
+        status: import("zod").ZodOptional<import("zod").ZodEnum<["active", "paused", "disabled"]>>;
+    }, "strict", import("zod").ZodTypeAny, {
+        id: number;
+        status?: "active" | "paused" | "disabled" | undefined;
+        name?: string | undefined;
+        topic?: string | undefined;
+        delivery_url?: string | undefined;
+        secret?: string | undefined;
+    }, {
+        id: number;
+        status?: "active" | "paused" | "disabled" | undefined;
+        name?: string | undefined;
+        topic?: string | undefined;
+        delivery_url?: string | undefined;
+        secret?: string | undefined;
+    }>>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    wc_delete_webhook: (params: import("zod").TypeOf<import("zod").ZodObject<{
+        id: import("zod").ZodNumber;
+    }, "strict", import("zod").ZodTypeAny, {
+        id: number;
+    }, {
+        id: number;
+    }>>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
     ms_list_network_plugins: (params: import("zod").TypeOf<import("zod").ZodObject<{
         site_id: import("zod").ZodOptional<import("zod").ZodString>;
     }, "strict", import("zod").ZodTypeAny, {

package/servers/wp-rest-bridge/build/tools/index.js

@@ -14,6 +14,7 @@ import { wcReportTools, wcReportHandlers } from './wc-reports.js';
 import { wcSettingTools, wcSettingHandlers } from './wc-settings.js';
 import { multisiteSiteTools, multisiteSiteHandlers } from './multisite-sites.js';
 import { multisiteNetworkTools, multisiteNetworkHandlers } from './multisite-network.js';
+import { wcWebhookTools, wcWebhookHandlers } from './wc-webhooks.js';
 // Combine all tools
 export const allTools = [
     ...unifiedContentTools, // 8 tools
@@ -32,6 +33,7 @@ export const allTools = [
     ...wcSettingTools, // 4 tools
     ...multisiteSiteTools, // 5 tools
     ...multisiteNetworkTools, // 5 tools
+    ...wcWebhookTools, // 4 tools
 ];
 // Combine all handlers
 export const toolHandlers = {
@@ -51,4 +53,5 @@ export const toolHandlers = {
     ...wcSettingHandlers,
     ...multisiteSiteHandlers,
     ...multisiteNetworkHandlers,
+    ...wcWebhookHandlers,
 };

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

@@ -0,0 +1,129 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+declare const wcListWebhooksSchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodEnum<["active", "paused", "disabled"]>>;
+}, "strict", z.ZodTypeAny, {
+    status?: "active" | "paused" | "disabled" | undefined;
+}, {
+    status?: "active" | "paused" | "disabled" | undefined;
+}>;
+declare const wcCreateWebhookSchema: z.ZodObject<{
+    name: z.ZodString;
+    topic: z.ZodString;
+    delivery_url: z.ZodString;
+    secret: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<["active", "paused", "disabled"]>>;
+}, "strict", z.ZodTypeAny, {
+    name: string;
+    topic: string;
+    delivery_url: string;
+    status?: "active" | "paused" | "disabled" | undefined;
+    secret?: string | undefined;
+}, {
+    name: string;
+    topic: string;
+    delivery_url: string;
+    status?: "active" | "paused" | "disabled" | undefined;
+    secret?: string | undefined;
+}>;
+declare const wcUpdateWebhookSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodOptional<z.ZodString>;
+    topic: z.ZodOptional<z.ZodString>;
+    delivery_url: z.ZodOptional<z.ZodString>;
+    secret: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<["active", "paused", "disabled"]>>;
+}, "strict", z.ZodTypeAny, {
+    id: number;
+    status?: "active" | "paused" | "disabled" | undefined;
+    name?: string | undefined;
+    topic?: string | undefined;
+    delivery_url?: string | undefined;
+    secret?: string | undefined;
+}, {
+    id: number;
+    status?: "active" | "paused" | "disabled" | undefined;
+    name?: string | undefined;
+    topic?: string | undefined;
+    delivery_url?: string | undefined;
+    secret?: string | undefined;
+}>;
+declare const wcDeleteWebhookSchema: z.ZodObject<{
+    id: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    id: number;
+}, {
+    id: number;
+}>;
+export declare const wcWebhookTools: Tool[];
+export declare const wcWebhookHandlers: {
+    wc_list_webhooks: (params: z.infer<typeof wcListWebhooksSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    wc_create_webhook: (params: z.infer<typeof wcCreateWebhookSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    wc_update_webhook: (params: z.infer<typeof wcUpdateWebhookSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    wc_delete_webhook: (params: z.infer<typeof wcDeleteWebhookSchema>) => 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-webhooks.js

@@ -0,0 +1,142 @@
+import { makeWooCommerceRequest } from '../wordpress.js';
+import { z } from 'zod';
+const wcListWebhooksSchema = z.object({
+    status: z.enum(['active', 'paused', 'disabled']).optional()
+        .describe('Filter webhooks by status'),
+}).strict();
+const wcCreateWebhookSchema = z.object({
+    name: z.string().describe('Webhook name (for identification)'),
+    topic: z.string().describe('Event topic, e.g. "order.created", "product.updated"'),
+    delivery_url: z.string().describe('URL to receive the webhook payload'),
+    secret: z.string().optional().describe('Secret for HMAC-SHA256 signature verification'),
+    status: z.enum(['active', 'paused', 'disabled']).optional()
+        .describe('Webhook status (default: active)'),
+}).strict();
+const wcUpdateWebhookSchema = z.object({
+    id: z.number().describe('Webhook ID to update'),
+    name: z.string().optional().describe('Updated webhook name'),
+    topic: z.string().optional().describe('Updated event topic'),
+    delivery_url: z.string().optional().describe('Updated delivery URL'),
+    secret: z.string().optional().describe('Updated secret'),
+    status: z.enum(['active', 'paused', 'disabled']).optional()
+        .describe('Updated webhook status'),
+}).strict();
+const wcDeleteWebhookSchema = z.object({
+    id: z.number().describe('Webhook ID to delete'),
+}).strict();
+export const wcWebhookTools = [
+    {
+        name: "wc_list_webhooks",
+        description: "Lists all WooCommerce webhooks with their status, topic, and delivery URL",
+        inputSchema: {
+            type: "object",
+            properties: {
+                status: {
+                    type: "string",
+                    enum: ["active", "paused", "disabled"],
+                    description: "Filter webhooks by status",
+                },
+            },
+        },
+    },
+    {
+        name: "wc_create_webhook",
+        description: "Creates a new WooCommerce webhook for event notifications (e.g. order.created, product.updated)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Webhook name (for identification)" },
+                topic: { type: "string", description: "Event topic, e.g. 'order.created', 'product.updated'" },
+                delivery_url: { type: "string", description: "URL to receive the webhook payload" },
+                secret: { type: "string", description: "Secret for HMAC-SHA256 signature verification" },
+                status: {
+                    type: "string",
+                    enum: ["active", "paused", "disabled"],
+                    description: "Webhook status (default: active)",
+                },
+            },
+            required: ["name", "topic", "delivery_url"],
+        },
+    },
+    {
+        name: "wc_update_webhook",
+        description: "Updates an existing WooCommerce webhook (status, delivery URL, topic, etc.)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "number", description: "Webhook ID to update" },
+                name: { type: "string", description: "Updated webhook name" },
+                topic: { type: "string", description: "Updated event topic" },
+                delivery_url: { type: "string", description: "Updated delivery URL" },
+                secret: { type: "string", description: "Updated secret" },
+                status: {
+                    type: "string",
+                    enum: ["active", "paused", "disabled"],
+                    description: "Updated webhook status",
+                },
+            },
+            required: ["id"],
+        },
+    },
+    {
+        name: "wc_delete_webhook",
+        description: "Deletes a WooCommerce webhook (stops notifications to the delivery URL)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "number", description: "Webhook ID to delete" },
+            },
+            required: ["id"],
+        },
+    },
+];
+export const wcWebhookHandlers = {
+    wc_list_webhooks: async (params) => {
+        try {
+            const query = params.status ? `?status=${params.status}` : '';
+            const response = await makeWooCommerceRequest("GET", `webhooks${query}`);
+            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 webhooks: ${errorMessage}` }] } };
+        }
+    },
+    wc_create_webhook: async (params) => {
+        try {
+            const { name, topic, delivery_url, secret, status } = params;
+            const body = { name, topic, delivery_url };
+            if (secret)
+                body.secret = secret;
+            if (status)
+                body.status = status;
+            const response = await makeWooCommerceRequest("POST", "webhooks", body);
+            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 webhook: ${errorMessage}` }] } };
+        }
+    },
+    wc_update_webhook: async (params) => {
+        try {
+            const { id, ...updates } = params;
+            const response = await makeWooCommerceRequest("PUT", `webhooks/${id}`, updates);
+            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 webhook: ${errorMessage}` }] } };
+        }
+    },
+    wc_delete_webhook: async (params) => {
+        try {
+            const response = await makeWooCommerceRequest("DELETE", `webhooks/${params.id}?force=true`);
+            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 webhook: ${errorMessage}` }] } };
+        }
+    },
+};