@yashwant.dharmdas/elementor-mcp 3.0.0

package/README.md

@@ -0,0 +1,57 @@
+# @yashwant.dharmdas/elementor-mcp
+
+MCP server for controlling Elementor via Claude. Supports multiple WordPress sites.
+
+## Setup
+
+```bash
+npx @yashwant.dharmdas/elementor-mcp setup
+```
+
+Follow the prompts to enter your WordPress URL, username, and Application Password.  
+Create an Application Password at: **WordPress Admin → Users → Your Profile → Application Passwords**
+
+## Claude Desktop Config
+
+After setup, add this to your `claude_desktop_config.json` under `mcpServers`:
+
+```json
+{
+  "elementor": {
+    "command": "npx",
+    "args": ["-y", "@yashwant.dharmdas/elementor-mcp"]
+  }
+}
+```
+
+Config file location:
+- **macOS:** `~/Library/Application Support/Claude/claude_desktop_config.json`
+- **Windows:** `%APPDATA%\Claude\claude_desktop_config.json`
+
+## Multiple Sites
+
+```bash
+# Add more sites anytime — just run setup again with a different name
+npx @yashwant.dharmdas/elementor-mcp setup
+```
+
+Then specify the `site` parameter in Claude:
+> *"List pages on acme-client"*
+> *"Update the homepage on beta-corp"*
+
+## Tools
+
+35 tools across 7 categories:
+
+- **Core:** `list-pages`, `get-data`, `find-elements`, `update-data`, `patch-data`, `merge-element-settings`
+- **Page/Site Config:** `update-page-settings`, `get-theme-context`, `get-kit-settings`, `update-kit-settings`
+- **Site Operations:** `clear-cache`, `replace-urls`, `get-style-guide`
+- **Templates:** `list-templates`, `get-template`, `create-template`, `update-template`, `delete-template`, `duplicate-template`
+- **Design Intelligence:** `evaluate-design`, `suggest-design-fixes`, `get-official-pattern-guidance`
+- **Layout:** `image-widget-to-background-container`, `enforce-boundary-coherence`, `extract-design-tokens`, `apply-text-hierarchy`, `normalize-section-spacing-rhythm`, `normalize-responsive-values`, `sync-component-variant`
+- **Pro Features:** `list-custom-code`, `create-custom-code`, `update-custom-code`, `delete-custom-code`, `list-form-submissions`, `delete-form-submission`
+
+## Requirements
+
+- Node.js ≥ 18
+- WordPress with the [Elementor Remote Control plugin](https://github.com/yashwant-dharmdas/elementor-mcp) installed

package/dist/index.js

@@ -0,0 +1,958 @@
+#!/usr/bin/env node
+import AjvModule from "ajv";
+const Ajv = AjvModule.default || AjvModule;
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import axios from "axios";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import readline from "readline";
+const CONFIG_DIR = path.join(os.homedir(), ".elementor-mcp");
+const CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+function loadConfig() {
+    if (fs.existsSync(CONFIG_PATH)) {
+        try {
+            const raw = fs.readFileSync(CONFIG_PATH, "utf8");
+            const parsed = JSON.parse(raw);
+            return Array.isArray(parsed) ? parsed : [parsed];
+        }
+        catch {
+            console.error(`Failed to parse config at ${CONFIG_PATH}. Run: npx elementor-mcp setup`);
+            process.exit(1);
+        }
+    }
+    // Env var fallback — useful for CI / containerised deployments
+    const { WP_URL, WP_USER, WP_APP_PASSWORD } = process.env;
+    if (WP_URL && WP_USER && WP_APP_PASSWORD) {
+        return [{ name: "default", wpUrl: WP_URL, user: WP_USER, appPassword: WP_APP_PASSWORD }];
+    }
+    return [];
+}
+function saveConfig(sites) {
+    if (!fs.existsSync(CONFIG_DIR))
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(sites, null, 2), { mode: 0o600 });
+}
+function resolveSite(sites, siteName) {
+    if (sites.length === 0) {
+        throw new Error("No sites configured. Run: npx elementor-mcp setup");
+    }
+    let site;
+    if (!siteName) {
+        if (sites.length === 1) {
+            site = sites[0];
+        }
+        else {
+            const names = sites.map(s => s.name).join(", ");
+            throw new Error(`Multiple sites configured — specify the 'site' parameter. Available: ${names}`);
+        }
+    }
+    else {
+        const found = sites.find(s => s.name === siteName);
+        if (!found) {
+            const names = sites.map(s => s.name).join(", ");
+            throw new Error(`Site "${siteName}" not found. Available: ${names}`);
+        }
+        site = found;
+    }
+    return {
+        wpUrl: site.wpUrl.replace(/\/$/, ""),
+        authHeader: `Basic ${Buffer.from(`${site.user}:${site.appPassword}`).toString("base64")}`,
+    };
+}
+// ─── Setup Wizard ─────────────────────────────────────────────────────────────
+async function runSetup() {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise(resolve => rl.question(q, resolve));
+    const existing = loadConfig();
+    const isAdding = existing.length > 0;
+    console.log(isAdding ? "\n─── Add / Update a WordPress Site ───" : "\n─── Elementor MCP Setup ───");
+    console.log("You need a WordPress Application Password.");
+    console.log("Create one at: WordPress Admin → Users → Your Profile → Application Passwords\n");
+    try {
+        const name = (await ask("Site name (e.g. acme-client):                          ")).trim();
+        const wpUrl = (await ask("WordPress URL  (e.g. https://acme.com):                ")).trim();
+        const user = (await ask("WordPress username:                                     ")).trim();
+        const appPassword = (await ask("Application Password (xxxx xxxx xxxx xxxx xxxx xxxx):  ")).trim();
+        if (!name || !wpUrl || !user || !appPassword) {
+            console.error("\nAll fields are required.");
+            process.exit(1);
+        }
+        // Validate credentials against WordPress
+        process.stdout.write("\nValidating credentials...");
+        const authHeader = `Basic ${Buffer.from(`${user}:${appPassword}`).toString("base64")}`;
+        try {
+            await axios.get(`${wpUrl.replace(/\/$/, "")}/wp-json/wp/v2/users/me`, {
+                headers: { Authorization: authHeader },
+            });
+            console.log(" ✓\n");
+        }
+        catch (err) {
+            const msg = err.response?.data?.message || err.message;
+            console.error(`\n\nCredential validation failed: ${msg}`);
+            console.error("Check that the Application Password is correct and the WP REST API is reachable.");
+            process.exit(1);
+        }
+        // Upsert: replace entry with same name, keep others
+        const updated = [...existing.filter(s => s.name !== name), { name, wpUrl: wpUrl.replace(/\/$/, ""), user, appPassword }];
+        saveConfig(updated);
+        console.log(`Site "${name}" saved to ${CONFIG_PATH}\n`);
+        if (updated.length === 1) {
+            // First-time setup: show full Claude Desktop snippet
+            console.log("─── Claude Desktop Config ───────────────────────────────────────────────────");
+            console.log("Add this block to your claude_desktop_config.json under \"mcpServers\":\n");
+            console.log(JSON.stringify({ elementor: { command: "npx", args: ["-y", "elementor-mcp"] } }, null, 2));
+            console.log("\nConfig file locations:");
+            console.log("  macOS:   ~/Library/Application Support/Claude/claude_desktop_config.json");
+            console.log("  Windows: %APPDATA%\\Claude\\claude_desktop_config.json");
+            console.log("─────────────────────────────────────────────────────────────────────────────\n");
+        }
+        else {
+            console.log(`You now have ${updated.length} sites: ${updated.map(s => s.name).join(", ")}`);
+            console.log("Pass the 'site' parameter in tool calls to target a specific site.\n");
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+// ─── Ajv schema validation ────────────────────────────────────────────────────
+const ajv = new Ajv();
+const elementSchema = {
+    type: "object",
+    properties: {
+        id: { type: "string" },
+        elType: { enum: ["container", "widget"] },
+        settings: { type: "object" },
+        elements: { type: "array" },
+    },
+    required: ["id", "elType"],
+};
+ajv.compile(elementSchema); // pre-compile; used by WP plugin validation
+// ─── MCP Server Factory ───────────────────────────────────────────────────────
+function createMcpServer(sites) {
+    const server = new McpServer({
+        name: "elementor-remote-control",
+        version: "3.0.0",
+    });
+    const siteDesc = sites.length > 1
+        ? `Target site name. Available: ${sites.map(s => s.name).join(", ")}`
+        : `Target site (optional — defaults to "${sites[0]?.name ?? "none"}")`;
+    const siteParam = z.string().optional().describe(siteDesc);
+    // ── Shared helpers ────────────────────────────────────────────────────────
+    const flattenElements = (els, out = []) => {
+        for (const el of els) {
+            out.push(el);
+            if (el.elements?.length)
+                flattenElements(el.elements, out);
+        }
+        return out;
+    };
+    const topLevel = (els) => els.filter((e) => e.elType === "container" || e.elType === "section");
+    const traverseAndMutate = (els, mutate) => els.map((el) => {
+        mutate(el);
+        if (el.elements?.length)
+            el.elements = traverseAndMutate(el.elements, mutate);
+        return el;
+    });
+    const getAndSave = async (wpUrl, authHeader, page_id, transform) => {
+        const getRes = await axios.get(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/data`, { headers: { Authorization: authHeader } });
+        const transformed = transform(getRes.data);
+        const putRes = await axios.put(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/data`, transformed, { headers: { Authorization: authHeader, "Content-Type": "application/json" } });
+        return putRes.data;
+    };
+    // ── Meta: list-sites ──────────────────────────────────────────────────────
+    server.tool("list-sites", "List all configured WordPress sites available to this MCP server.", {}, async () => {
+        if (sites.length === 0) {
+            return { content: [{ type: "text", text: "No sites configured. Run: npx elementor-mcp setup" }] };
+        }
+        const list = sites.map(s => ({ name: s.name, wpUrl: s.wpUrl }));
+        return { content: [{ type: "text", text: JSON.stringify(list, null, 2) }] };
+    });
+    // ── Group 1: Core Read / Write ────────────────────────────────────────────
+    server.tool("list-pages", "List all WordPress pages editable with Elementor.", { site: siteParam }, async ({ site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const r = await axios.get(`${wpUrl}/wp-json/erc/v1/pages`, { headers: { Authorization: authHeader } });
+            return { content: [{ type: "text", text: JSON.stringify(r.data, null, 2) }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+        }
+    });
+    server.tool("get-data", "Get the full raw Elementor JSON element tree for a page (all elements with all settings). Use this before find-elements, patch-data, or any bulk transform.", {
+        page_id: z.string().describe("WordPress Page ID"),
+        site: siteParam,
+    }, async ({ page_id, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const r = await axios.get(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/data`, { headers: { Authorization: authHeader } });
+            return { content: [{ type: "text", text: JSON.stringify(r.data, null, 2) }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error fetching page data: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    server.tool("find-elements", "Search the Elementor element tree of a page and return matching elements. Filter by element type, widget type, or text content.", {
+        page_id: z.string().describe("WordPress Page ID"),
+        el_type: z.string().optional().describe("Filter by elType: 'container' or 'widget'"),
+        widget_type: z.string().optional().describe("Filter by widgetType, e.g. 'heading', 'image', 'button'"),
+        contains: z.string().optional().describe("Filter by text content found anywhere in the element's settings"),
+        include_path: z.boolean().optional().describe("Include ancestor IDs in results"),
+        site: siteParam,
+    }, async ({ page_id, el_type, widget_type, contains, include_path, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const r = await axios.get(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/data`, { headers: { Authorization: authHeader } });
+            const results = [];
+            function traverse(els, pathArr) {
+                for (const el of els) {
+                    const currentPath = [...pathArr, el.id];
+                    let match = true;
+                    if (el_type && el.elType !== el_type)
+                        match = false;
+                    if (widget_type && el.widgetType !== widget_type)
+                        match = false;
+                    if (contains && !JSON.stringify(el.settings || {}).includes(contains))
+                        match = false;
+                    if (match)
+                        results.push(include_path ? { ...el, _path: currentPath } : el);
+                    if (el.elements?.length)
+                        traverse(el.elements, currentPath);
+                }
+            }
+            traverse(r.data, []);
+            return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    server.tool("merge-element-settings", "Deep-merge settings into a specific Elementor element without replacing the full element. Use for small setting adjustments.", {
+        page_id: z.string().describe("WordPress Page ID"),
+        element_id: z.string().describe("Elementor Element ID"),
+        settings: z.string().describe("JSON object of settings to merge (stringified)"),
+        site: siteParam,
+    }, async ({ page_id, element_id, settings, site }) => {
+        let parsedSettings;
+        try {
+            parsedSettings = JSON.parse(settings);
+        }
+        catch {
+            return { content: [{ type: "text", text: "Invalid JSON in settings parameter." }], isError: true };
+        }
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const getRes = await axios.get(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/elements/${element_id}`, { headers: { Authorization: authHeader } });
+            const merged = { ...getRes.data, settings: { ...(getRes.data.settings || {}), ...parsedSettings } };
+            const postRes = await axios.post(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/elements/${element_id}`, merged, { headers: { Authorization: authHeader } });
+            return { content: [{ type: "text", text: JSON.stringify(postRes.data, null, 2) }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error merging settings: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    server.tool("update-data", "Replace the entire Elementor element tree for a page. By default refuses if the new data is dramatically smaller than existing. Use force_replace=true to override.", {
+        page_id: z.string().describe("WordPress Page ID"),
+        elements_json: z.string().describe("Full elements array as stringified JSON"),
+        force_replace: z.boolean().optional().describe("Set true to allow replacing with dramatically fewer top-level elements"),
+        site: siteParam,
+    }, async ({ page_id, elements_json, force_replace, site }) => {
+        let parsed;
+        try {
+            parsed = JSON.parse(elements_json);
+        }
+        catch {
+            return { content: [{ type: "text", text: "Invalid JSON in elements_json." }], isError: true };
+        }
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const r = await axios.put(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/data`, parsed, {
+                headers: { Authorization: authHeader, "Content-Type": "application/json" },
+                params: { force_replace: force_replace ? "true" : "false" },
+            });
+            return { content: [{ type: "text", text: JSON.stringify(r.data, null, 2) }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error updating page data: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    server.tool("patch-data", "Find and replace a text string within the Elementor JSON of a page. Useful for bulk URL or text changes on a single page.", {
+        page_id: z.string().describe("WordPress Page ID"),
+        find: z.string().describe("Text to find (exact string match within JSON)"),
+        replace: z.string().describe("Text to replace it with"),
+        site: siteParam,
+    }, async ({ page_id, find, replace, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const getRes = await axios.get(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/data`, { headers: { Authorization: authHeader } });
+            const raw = JSON.stringify(getRes.data);
+            const patched = raw.split(find).join(replace);
+            const putRes = await axios.put(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/data`, JSON.parse(patched), { headers: { Authorization: authHeader, "Content-Type": "application/json" } });
+            const count = raw.split(find).length - 1;
+            return { content: [{ type: "text", text: `Replaced ${count} occurrence(s). ${JSON.stringify(putRes.data)}` }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error patching data: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    // ── Group 2: Page & Site Config ───────────────────────────────────────────
+    server.tool("update-page-settings", "Update Elementor page-level settings (e.g. hide title, custom CSS, page layout). Merges with existing settings.", {
+        page_id: z.string().describe("WordPress Page ID"),
+        settings: z.string().describe("Settings object to merge as stringified JSON"),
+        site: siteParam,
+    }, async ({ page_id, settings, site }) => {
+        let parsed;
+        try {
+            parsed = JSON.parse(settings);
+        }
+        catch {
+            return { content: [{ type: "text", text: "Invalid JSON in settings." }], isError: true };
+        }
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const r = await axios.patch(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/settings`, parsed, { headers: { Authorization: authHeader, "Content-Type": "application/json" } });
+            return { content: [{ type: "text", text: JSON.stringify(r.data, null, 2) }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error updating page settings: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    server.tool("get-theme-context", "Get a summary of the active WordPress theme, Elementor version, active kit ID, Pro status, and viewport breakpoints.", { site: siteParam }, async ({ site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const r = await axios.get(`${wpUrl}/wp-json/erc/v1/site/theme-context`, { headers: { Authorization: authHeader } });
+            const ctx = r.data;
+            const issues = [];
+            if (!ctx.elementor_version)
+                issues.push("Elementor version not detected — plugin may not be active.");
+            if (!ctx.active_kit_id)
+                issues.push("No active Elementor kit — global styles may not be applied.");
+            if (!ctx.elementor_pro)
+                issues.push("Elementor Pro not detected — Pro widgets and Theme Builder unavailable.");
+            if (ctx.theme?.parent)
+                issues.push(`Child theme active (${ctx.theme.name} → ${ctx.theme.parent}).`);
+            return { content: [{ type: "text", text: JSON.stringify({ ...ctx, _issues: issues }, null, 2) }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error fetching theme context: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    server.tool("get-kit-settings", "Get the full settings of the active Elementor kit (global colors, typography, spacing). Use before update-kit-settings.", { site: siteParam }, async ({ site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const r = await axios.get(`${wpUrl}/wp-json/erc/v1/site/kit-settings`, { headers: { Authorization: authHeader } });
+            return { content: [{ type: "text", text: JSON.stringify(r.data, null, 2) }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.response?.data?.message || e.message}` }], isError: true };
+        }
+    });
+    server.tool("update-kit-settings", "Update global colors, typography, or other settings on the active Elementor kit.", {
+        settings: z.string().describe("Settings object to merge as stringified JSON"),
+        site: siteParam,
+    }, async ({ settings, site }) => {
+        let parsed;
+        try {
+            parsed = JSON.parse(settings);
+        }
+        catch {
+            return { content: [{ type: "text", text: "Invalid JSON." }], isError: true };
+        }
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const r = await axios.put(`${wpUrl}/wp-json/erc/v1/site/kit-settings`, parsed, { headers: { Authorization: authHeader } });
+            return { content: [{ type: "text", text: JSON.stringify(r.data, null, 2) }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.response?.data?.message || e.message}` }], isError: true };
+        }
+    });
+    // ── Group 3: Site Operations ──────────────────────────────────────────────
+    server.tool("clear-cache", "Clear the Elementor CSS/file cache. Omit post_id to clear the entire site cache. Always call after programmatic edits.", {
+        post_id: z.string().optional().describe("Specific post ID to clear, or omit to clear all"),
+        site: siteParam,
+    }, async ({ post_id, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const r = await axios.post(`${wpUrl}/wp-json/erc/v1/site/clear-cache`, {}, {
+                headers: { Authorization: authHeader },
+                params: post_id ? { post_id } : {},
+            });
+            return { content: [{ type: "text", text: JSON.stringify(r.data, null, 2) }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.response?.data?.message || e.message}` }], isError: true };
+        }
+    });
+    server.tool("replace-urls", "Find and replace a URL string across ALL Elementor data in the database. Use for domain migrations.", {
+        from: z.string().describe("URL to find"),
+        to: z.string().describe("URL to replace it with"),
+        site: siteParam,
+    }, async ({ from, to, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const r = await axios.post(`${wpUrl}/wp-json/erc/v1/site/replace-urls`, { from, to }, { headers: { Authorization: authHeader } });
+            return { content: [{ type: "text", text: JSON.stringify(r.data, null, 2) }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.response?.data?.message || e.message}` }], isError: true };
+        }
+    });
+    server.tool("get-style-guide", "Build a style-guide summary from the active Elementor kit: global colors, typography, and spacing tokens.", { site: siteParam }, async ({ site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const r = await axios.get(`${wpUrl}/wp-json/erc/v1/site/style-guide`, { headers: { Authorization: authHeader } });
+            return { content: [{ type: "text", text: JSON.stringify(r.data, null, 2) }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error fetching style guide: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    // ── Group 4: Templates ────────────────────────────────────────────────────
+    server.tool("list-templates", "List all saved Elementor templates. Optionally filter by type: page, section, popup, header, footer.", {
+        type: z.string().optional().describe("Filter by template type (page, section, popup, header, footer)"),
+        site: siteParam,
+    }, async ({ type, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const r = await axios.get(`${wpUrl}/wp-json/erc/v1/templates`, {
+                headers: { Authorization: authHeader },
+                params: type ? { type } : {},
+            });
+            return { content: [{ type: "text", text: JSON.stringify(r.data, null, 2) }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error listing templates: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    server.tool("get-template", "Get a single Elementor template with its full element data.", {
+        template_id: z.string().describe("Template ID"),
+        site: siteParam,
+    }, async ({ template_id, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const r = await axios.get(`${wpUrl}/wp-json/erc/v1/templates/${template_id}`, { headers: { Authorization: authHeader } });
+            return { content: [{ type: "text", text: JSON.stringify(r.data, null, 2) }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error fetching template: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    server.tool("create-template", "Create a new Elementor template of any type (page, section, popup, header, footer).", {
+        title: z.string().describe("Template title"),
+        type: z.string().describe("Template type: page, section, popup, header, footer"),
+        status: z.string().optional().describe("Post status: publish (default) or draft"),
+        elements: z.string().optional().describe("Initial elements JSON (stringified array)"),
+        site: siteParam,
+    }, async ({ title, type, status, elements, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const body = { title, type, status: status || "publish" };
+            if (elements) {
+                try {
+                    body.elements = JSON.parse(elements);
+                }
+                catch { }
+            }
+            const r = await axios.post(`${wpUrl}/wp-json/erc/v1/templates`, body, { headers: { Authorization: authHeader } });
+            return { content: [{ type: "text", text: JSON.stringify(r.data, null, 2) }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error creating template: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    server.tool("update-template", "Modify an existing Elementor template's title, status, or element data.", {
+        template_id: z.string().describe("Template ID"),
+        title: z.string().optional().describe("New title"),
+        status: z.string().optional().describe("New post status"),
+        elements: z.string().optional().describe("New elements JSON (stringified array)"),
+        site: siteParam,
+    }, async ({ template_id, title, status, elements, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const body = {};
+            if (title)
+                body.title = title;
+            if (status)
+                body.status = status;
+            if (elements) {
+                try {
+                    body.elements = JSON.parse(elements);
+                }
+                catch { }
+            }
+            const r = await axios.put(`${wpUrl}/wp-json/erc/v1/templates/${template_id}`, body, { headers: { Authorization: authHeader } });
+            return { content: [{ type: "text", text: JSON.stringify(r.data, null, 2) }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error updating template: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    server.tool("delete-template", "Move a template to trash or permanently delete it. Set force=true to permanently delete.", {
+        template_id: z.string().describe("Template ID"),
+        force: z.boolean().optional().describe("Set true to permanently delete instead of trash"),
+        site: siteParam,
+    }, async ({ template_id, force, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const r = await axios.delete(`${wpUrl}/wp-json/erc/v1/templates/${template_id}`, {
+                headers: { Authorization: authHeader },
+                params: { force: force ? "true" : "false" },
+            });
+            return { content: [{ type: "text", text: JSON.stringify(r.data, null, 2) }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error deleting template: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    server.tool("duplicate-template", "Create a copy of an Elementor template as a new draft.", {
+        template_id: z.string().describe("Template ID to duplicate"),
+        site: siteParam,
+    }, async ({ template_id, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const r = await axios.post(`${wpUrl}/wp-json/erc/v1/templates/${template_id}/duplicate`, {}, { headers: { Authorization: authHeader } });
+            return { content: [{ type: "text", text: JSON.stringify(r.data, null, 2) }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error duplicating template: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    // ── Group 5: Design Intelligence ──────────────────────────────────────────
+    server.tool("get-official-pattern-guidance", "Return the official Elementor.com guidance catalog used for widget and layout recommendations.", {}, async () => {
+        const guidance = {
+            source: "Elementor.com official documentation",
+            principles: [
+                "Prefer native Elementor widgets over hand-built container patterns when a native widget covers the use case.",
+                "Use Grid layout for equal symmetric column groups; use Flexbox for asymmetric or content-driven layouts.",
+                "Use Container (Flexbox/Grid) instead of Section/Column for all new layouts — Sections are legacy.",
+                "Global colors and typography should come from the active Kit; avoid inline overrides.",
+                "Use Global Widgets for repeated components that must stay in sync across pages.",
+                "Theme Builder templates (header, footer, single, archive) use display conditions to control scope.",
+                "Popups should use the Popup template type and be triggered via Elementor's popup trigger system.",
+                "Custom CSS should go in Custom Code snippets (Pro) rather than inline element CSS where possible.",
+                "Responsive values should be set per breakpoint; avoid relying on automatic inheritance for spacing.",
+            ],
+            widget_recommendations: {
+                hero: ["Heading widget", "Text Editor widget", "Button widget", "Image widget inside a Container"],
+                navigation: ["Nav Menu widget (Pro)", "Theme Builder Header template"],
+                testimonials: ["Testimonial Carousel widget (Pro)", "Star Rating widget"],
+                pricing: ["Price Table widget (Pro)", "Price List widget (Pro)"],
+                forms: ["Form widget (Pro)", "Login widget (Pro)"],
+                media: ["Image widget", "Video widget", "Image Carousel widget"],
+            },
+        };
+        return { content: [{ type: "text", text: JSON.stringify(guidance, null, 2) }] };
+    });
+    server.tool("evaluate-design", "Aggregate all design audits into one score, issue list, and recommendations. Use this as the main entry point for design evaluation.", {
+        page_id: z.string().describe("WordPress Page ID"),
+        site: siteParam,
+    }, async ({ page_id, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const r = await axios.get(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/data`, { headers: { Authorization: authHeader } });
+            const all = flattenElements(r.data);
+            const top = topLevel(r.data);
+            const allIssues = [];
+            const buttons = all.filter((e) => e.widgetType === "button").length;
+            const headings = all.filter((e) => e.widgetType === "heading").length;
+            const dividers = all.filter((e) => e.widgetType === "divider").length;
+            const icons = all.filter((e) => e.widgetType === "icon-box" || e.widgetType === "icon").length;
+            const types = all.map((e) => e.widgetType).filter(Boolean);
+            const uniqueT = new Set(types).size;
+            if (buttons > 5)
+                allIssues.push(`Button overuse: ${buttons} buttons — reduce to 2–3 primary CTAs.`);
+            if (headings > top.length * 1.5)
+                allIssues.push(`Heading density: ${headings} headings across ${top.length} sections.`);
+            if (dividers > top.length)
+                allIssues.push(`Separator overuse: ${dividers} dividers for ${top.length} sections.`);
+            if (icons > 6)
+                allIssues.push(`Icon repetition: ${icons} icon/icon-box widgets — may feel generic.`);
+            if (top.length > 8)
+                allIssues.push(`Page length: ${top.length} top-level sections — consider merging.`);
+            const bgCounts = {};
+            top.map((e) => e.settings?.background_color || "none")
+                .forEach((b) => { bgCounts[b] = (bgCounts[b] || 0) + 1; });
+            Object.entries(bgCounts).filter(([k, v]) => k !== "none" && v > 2)
+                .forEach(([bg, count]) => allIssues.push(`Surface repeat: "${bg}" used ${count} times.`));
+            const loud = top.filter((e) => {
+                const s = e.settings || {};
+                return s.background_background === "classic" || s.background_background === "gradient" || s.background_overlay_opacity?.size > 0;
+            }).length;
+            if (loud > top.length * 0.6)
+                allIssues.push(`${loud} of ${top.length} sections use strong backgrounds — too many competing for attention.`);
+            const colPatterns = {};
+            all.filter((e) => e.elType === "container" && e.elements?.length >= 2)
+                .forEach((e) => { const k = `${e.elements.length}-col`; colPatterns[k] = (colPatterns[k] || 0) + 1; });
+            Object.entries(colPatterns).filter(([, v]) => v > 3)
+                .forEach(([k, v]) => allIssues.push(`Column pattern: ${k} repeated ${v} times.`));
+            const flex = all.filter((e) => e.settings?.flex_direction && e.elements?.length >= 3 && e.elements.length <= 4);
+            if (flex.length > 0)
+                allIssues.push(`${flex.length} Flexbox container(s) with 3–4 equal children — consider Grid layout.`);
+            const imageHeadingPairs = all.filter((e) => {
+                if (e.elType !== "container")
+                    return false;
+                const childTypes = (e.elements || []).map((c) => c.widgetType);
+                return childTypes.includes("image") && childTypes.includes("heading");
+            });
+            if (imageHeadingPairs.length > 1)
+                allIssues.push(`${imageHeadingPairs.length} hand-built image+heading containers — consider using native Image Box widget.`);
+            const variety = Math.min(100, Math.round((uniqueT / (types.length || 1)) * 200));
+            const penalty = Math.min(50, allIssues.length * 8);
+            const score = Math.max(0, Math.round(variety - penalty));
+            return { content: [{ type: "text", text: JSON.stringify({ page_id, score, total_issues: allIssues.length, issues: allIssues, widget_variety_score: variety, sections: top.length, total_widgets: types.length }, null, 2) }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.response?.data?.message || e.message}` }], isError: true };
+        }
+    });
+    server.tool("suggest-design-fixes", "Turn the aggregated design evaluation into concrete, actionable design-fix suggestions.", {
+        page_id: z.string().describe("WordPress Page ID"),
+        site: siteParam,
+    }, async ({ page_id, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const r = await axios.get(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/data`, { headers: { Authorization: authHeader } });
+            const all = flattenElements(r.data);
+            const top = topLevel(r.data);
+            const fixes = [];
+            const buttons = all.filter((e) => e.widgetType === "button").length;
+            if (buttons > 5)
+                fixes.push(`Reduce from ${buttons} buttons to 2–3 primary CTAs. Keep one hero CTA and one secondary CTA per page.`);
+            const dividers = all.filter((e) => e.widgetType === "divider").length;
+            if (dividers > top.length)
+                fixes.push(`Remove ${dividers - top.length} excess dividers. Use section padding/margin for spacing instead.`);
+            const bgs = {};
+            top.forEach((e) => { const b = e.settings?.background_color || "none"; bgs[b] = (bgs[b] || 0) + 1; });
+            Object.entries(bgs).filter(([k, v]) => k !== "none" && v > 2)
+                .forEach(([, count]) => fixes.push(`Alternate section backgrounds — ${count} consecutive identical surfaces break visual rhythm.`));
+            if (top.length > 8)
+                fixes.push(`Consider merging related sections — ${top.length} sections is long. Target 5–7 for a focused landing page.`);
+            const imageHeading = all.filter((e) => {
+                if (e.elType !== "container")
+                    return false;
+                const kids = (e.elements || []).map((c) => c.widgetType);
+                return kids.includes("image") && kids.includes("heading");
+            }).length;
+            if (imageHeading > 1)
+                fixes.push(`${imageHeading} hand-built image+heading containers — replace with native Image Box widget for better responsiveness.`);
+            const colPatterns = {};
+            all.filter((e) => e.elType === "container" && e.elements?.length >= 2)
+                .forEach((e) => { const k = `${e.elements.length}-col`; colPatterns[k] = (colPatterns[k] || 0) + 1; });
+            Object.entries(colPatterns).filter(([, v]) => v > 3)
+                .forEach(([k, v]) => fixes.push(`${k} column layout used ${v} times — vary widths or column count to break repetition.`));
+            return { content: [{ type: "text", text: JSON.stringify({ page_id, fix_count: fixes.length, fixes }, null, 2) }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.response?.data?.message || e.message}` }], isError: true };
+        }
+    });
+    // ── Group 6: Layout Operations ────────────────────────────────────────────
+    server.tool("image-widget-to-background-container", "Convert an image-widget container into a native background-image container by moving the image src to the container's background settings.", {
+        page_id: z.string(),
+        container_id: z.string(),
+        site: siteParam,
+    }, async ({ page_id, container_id, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const el = await axios.get(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/elements/${container_id}`, { headers: { Authorization: authHeader } });
+            const imageChild = (el.data.elements || []).find((c) => c.widgetType === "image");
+            if (!imageChild)
+                return { content: [{ type: "text", text: "No image widget found as direct child of this container." }], isError: true };
+            const imgUrl = imageChild.settings?.image?.url;
+            if (!imgUrl)
+                return { content: [{ type: "text", text: "Image widget has no URL set." }], isError: true };
+            const updated = {
+                ...el.data,
+                settings: {
+                    ...el.data.settings,
+                    background_background: "classic",
+                    background_image: { url: imgUrl, id: imageChild.settings?.image?.id || "" },
+                    background_size: "cover",
+                    background_position: "center center",
+                    _attributes: { ...(el.data.settings?._attributes || {}), class: ((el.data.settings?._attributes?.class || "") + " e-no-lazyload").trim() },
+                },
+                elements: (el.data.elements || []).filter((c) => c.id !== imageChild.id),
+            };
+            const r = await axios.post(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/elements/${container_id}`, updated, { headers: { Authorization: authHeader } });
+            return { content: [{ type: "text", text: JSON.stringify(r.data, null, 2) }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.response?.data?.message || e.message}` }], isError: true };
+        }
+    });
+    server.tool("enforce-boundary-coherence", "Normalize a subtree to true full-width or coherent boxed left/right boundaries.", {
+        page_id: z.string(),
+        mode: z.enum(["full-width", "boxed"]).describe("Target boundary mode"),
+        root_id: z.string().optional(),
+        site: siteParam,
+    }, async ({ page_id, mode, root_id, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const result = await getAndSave(wpUrl, authHeader, page_id, (els) => traverseAndMutate(els, (el) => {
+                if (root_id && el.id !== root_id && !root_id)
+                    return;
+                if (el.elType === "container") {
+                    el.settings = mode === "full-width"
+                        ? { ...el.settings, content_width: "full", width: { size: 100, unit: "%" } }
+                        : { ...el.settings, content_width: "boxed" };
+                }
+            }));
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.response?.data?.message || e.message}` }], isError: true };
+        }
+    });
+    server.tool("extract-design-tokens", "Extract recurring colors, typography, spacing, and dimensional tokens from a page or subtree.", {
+        page_id: z.string(),
+        site: siteParam,
+    }, async ({ page_id, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const r = await axios.get(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/data`, { headers: { Authorization: authHeader } });
+            const all = flattenElements(r.data);
+            const colors = {};
+            const fonts = {};
+            const pads = {};
+            all.forEach((el) => {
+                const s = el.settings || {};
+                if (s.background_color)
+                    colors[s.background_color] = (colors[s.background_color] || 0) + 1;
+                if (s.color)
+                    colors[s.color] = (colors[s.color] || 0) + 1;
+                if (s.typography_font_family)
+                    fonts[s.typography_font_family] = (fonts[s.typography_font_family] || 0) + 1;
+                if (s.padding?.top) {
+                    const k = s.padding.top + (s.padding.unit || "px");
+                    pads[k] = (pads[k] || 0) + 1;
+                }
+            });
+            return { content: [{ type: "text", text: JSON.stringify({
+                            page_id,
+                            colors: Object.entries(colors).sort(([, a], [, b]) => b - a).slice(0, 10),
+                            fonts: Object.entries(fonts).sort(([, a], [, b]) => b - a).slice(0, 5),
+                            padding_values: Object.entries(pads).sort(([, a], [, b]) => b - a).slice(0, 8),
+                        }, null, 2) }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.response?.data?.message || e.message}` }], isError: true };
+        }
+    });
+    server.tool("apply-text-hierarchy", "Normalize heading/body/button typography in a subtree using kit system typography values.", {
+        page_id: z.string(),
+        heading_size: z.string().optional().describe("e.g. 36px"),
+        body_size: z.string().optional().describe("e.g. 16px"),
+        site: siteParam,
+    }, async ({ page_id, heading_size, body_size, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const result = await getAndSave(wpUrl, authHeader, page_id, (els) => traverseAndMutate(els, (el) => {
+                if (el.widgetType === "heading" && heading_size) {
+                    el.settings = { ...el.settings, typography_font_size: { size: parseInt(heading_size), unit: "px" } };
+                }
+                if ((el.widgetType === "text-editor" || el.widgetType === "text") && body_size) {
+                    el.settings = { ...el.settings, typography_font_size: { size: parseInt(body_size), unit: "px" } };
+                }
+            }));
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.response?.data?.message || e.message}` }], isError: true };
+        }
+    });
+    server.tool("normalize-section-spacing-rhythm", "Snap section padding and row gaps to a consistent rhythm value across the page.", {
+        page_id: z.string(),
+        rhythm: z.string().optional().describe("Spacing unit in px, default 60"),
+        site: siteParam,
+    }, async ({ page_id, rhythm, site }) => {
+        const r = parseInt(rhythm || "60");
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const result = await getAndSave(wpUrl, authHeader, page_id, (els) => traverseAndMutate(els, (el) => {
+                if (el.elType === "container" || el.elType === "section") {
+                    const s = el.settings || {};
+                    const snap = (v) => String(Math.round(v / r) * r || r);
+                    el.settings = { ...s, padding: { ...(s.padding || {}), unit: "px", top: snap(parseFloat(s.padding?.top || "0")), bottom: snap(parseFloat(s.padding?.bottom || "0")) } };
+                }
+            }));
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.response?.data?.message || e.message}` }], isError: true };
+        }
+    });
+    server.tool("normalize-responsive-values", "Fill missing tablet/mobile values from desktop settings with capped inherited side spacing.", {
+        page_id: z.string(),
+        site: siteParam,
+    }, async ({ page_id, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const result = await getAndSave(wpUrl, authHeader, page_id, (els) => traverseAndMutate(els, (el) => {
+                const s = el.settings || {};
+                if (s.padding && !s.padding_tablet) {
+                    el.settings.padding_tablet = { ...s.padding, right: "20", left: "20" };
+                }
+                if (s.padding && !s.padding_mobile) {
+                    el.settings.padding_mobile = {
+                        ...s.padding,
+                        top: String(Math.round(parseFloat(s.padding.top || "0") * 0.6)),
+                        bottom: String(Math.round(parseFloat(s.padding.bottom || "0") * 0.6)),
+                        right: "15",
+                        left: "15",
+                    };
+                }
+            }));
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.response?.data?.message || e.message}` }], isError: true };
+        }
+    });
+    server.tool("sync-component-variant", "Copy design-relevant settings from one component subtree to another (colors, typography, spacing — not content).", {
+        page_id: z.string(),
+        source_id: z.string(),
+        target_id: z.string(),
+        site: siteParam,
+    }, async ({ page_id, source_id, target_id, site }) => {
+        const designKeys = ["background_color", "background_background", "color", "typography_font_family", "typography_font_size", "padding", "margin", "border_radius", "box_shadow", "_css_classes"];
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const src = await axios.get(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/elements/${source_id}`, { headers: { Authorization: authHeader } });
+            const tgt = await axios.get(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/elements/${target_id}`, { headers: { Authorization: authHeader } });
+            const designSettings = Object.fromEntries(designKeys.map(k => [k, src.data.settings?.[k]]).filter(([, v]) => v !== undefined));
+            const merged = { ...tgt.data, settings: { ...tgt.data.settings, ...designSettings } };
+            const r = await axios.post(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/elements/${target_id}`, merged, { headers: { Authorization: authHeader } });
+            return { content: [{ type: "text", text: JSON.stringify({ synced: Object.keys(designSettings), result: r.data }, null, 2) }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.response?.data?.message || e.message}` }], isError: true };
+        }
+    });
+    // ── Group 7: Pro Features ─────────────────────────────────────────────────
+    server.tool("list-custom-code", "List all custom code snippets (requires Elementor Pro). Optionally filter by status.", {
+        status: z.string().optional(),
+        site: siteParam,
+    }, async ({ status, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const r = await axios.get(`${wpUrl}/wp-json/erc/v1/site/custom-code`, {
+                headers: { Authorization: authHeader },
+                params: status ? { status } : {},
+            });
+            return { content: [{ type: "text", text: JSON.stringify(r.data, null, 2) }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.response?.data?.message || e.message}` }], isError: true };
+        }
+    });
+    server.tool("create-custom-code", "Create a new custom code snippet (requires Elementor Pro).", {
+        title: z.string(),
+        code: z.string(),
+        location: z.string().optional().describe("head or body"),
+        status: z.string().optional(),
+        site: siteParam,
+    }, async ({ title, code, location, status, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const r = await axios.post(`${wpUrl}/wp-json/erc/v1/site/custom-code`, { title, code, location: location || "head", status: status || "draft" }, { headers: { Authorization: authHeader } });
+            return { content: [{ type: "text", text: JSON.stringify(r.data, null, 2) }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.response?.data?.message || e.message}` }], isError: true };
+        }
+    });
+    server.tool("update-custom-code", "Update a custom code snippet (requires Elementor Pro).", {
+        snippet_id: z.string(),
+        title: z.string().optional(),
+        code: z.string().optional(),
+        location: z.string().optional(),
+        status: z.string().optional(),
+        site: siteParam,
+    }, async ({ snippet_id, title, code, location, status, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const body = {};
+            if (title)
+                body.title = title;
+            if (code)
+                body.code = code;
+            if (location)
+                body.location = location;
+            if (status)
+                body.status = status;
+            const r = await axios.put(`${wpUrl}/wp-json/erc/v1/site/custom-code/${snippet_id}`, body, { headers: { Authorization: authHeader } });
+            return { content: [{ type: "text", text: JSON.stringify(r.data, null, 2) }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.response?.data?.message || e.message}` }], isError: true };
+        }
+    });
+    server.tool("delete-custom-code", "Delete a custom code snippet (requires Elementor Pro).", {
+        snippet_id: z.string(),
+        site: siteParam,
+    }, async ({ snippet_id, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const r = await axios.delete(`${wpUrl}/wp-json/erc/v1/site/custom-code/${snippet_id}`, { headers: { Authorization: authHeader } });
+            return { content: [{ type: "text", text: JSON.stringify(r.data, null, 2) }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.response?.data?.message || e.message}` }], isError: true };
+        }
+    });
+    server.tool("list-form-submissions", "List Elementor Pro form submissions. Optionally filter by form_id or date range (requires Elementor Pro).", {
+        form_id: z.string().optional().describe("Filter by specific form ID"),
+        date_after: z.string().optional().describe("ISO date string — return submissions after this date"),
+        per_page: z.number().optional().describe("Number of results per page (default 20)"),
+        site: siteParam,
+    }, async ({ form_id, date_after, per_page, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const params = {};
+            if (form_id)
+                params.form_id = form_id;
+            if (date_after)
+                params.date_after = date_after;
+            if (per_page)
+                params.per_page = per_page;
+            const r = await axios.get(`${wpUrl}/wp-json/erc/v1/site/form-submissions`, { headers: { Authorization: authHeader }, params });
+            return { content: [{ type: "text", text: JSON.stringify(r.data, null, 2) }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.response?.data?.message || e.message}` }], isError: true };
+        }
+    });
+    server.tool("delete-form-submission", "Delete a single Elementor Pro form submission.", {
+        submission_id: z.string(),
+        site: siteParam,
+    }, async ({ submission_id, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const r = await axios.delete(`${wpUrl}/wp-json/erc/v1/site/form-submissions/${submission_id}`, { headers: { Authorization: authHeader } });
+            return { content: [{ type: "text", text: JSON.stringify(r.data, null, 2) }] };
+        }
+        catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e.response?.data?.message || e.message}` }], isError: true };
+        }
+    });
+    return server;
+}
+// ─── Entry Point ──────────────────────────────────────────────────────────────
+const command = process.argv[2];
+if (command === "setup") {
+    await runSetup();
+}
+else {
+    const sites = loadConfig();
+    if (sites.length === 0) {
+        console.error("No sites configured. Run first: npx elementor-mcp setup");
+        process.exit(1);
+    }
+    const server = createMcpServer(sites);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@yashwant.dharmdas/elementor-mcp",
+  "version": "3.0.0",
+  "description": "MCP server for controlling Elementor via Claude — supports multiple WordPress sites",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "elementor-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "ajv": "^8.12.0",
+    "axios": "^1.6.0",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.24",
+    "tsx": "^4.21.0",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "mcp",
+    "elementor",
+    "wordpress",
+    "claude",
+    "ai"
+  ],
+  "license": "MIT"
+}