@yashwant.dharmdas/elementor-mcp 3.2.8 → 3.4.0

package/dist/index.js

@@ -1370,6 +1370,574 @@ function createMcpServer(sites) {
             };
         }
     });
+    // ── Group 10: Breakpoints ────────────────────────────────────────────────────
+    server.tool("set-header-breakpoint", "Set the exact pixel width at which the desktop nav collapses into a hamburger menu globally across the site. Writes to Elementor's global breakpoints in the active kit.", {
+        breakpoint_px: z.number().describe("Pixel width at which mobile hamburger menu activates (e.g. 1300)"),
+        site: siteParam,
+    }, async ({ breakpoint_px, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const r = await axios.post(`${wpUrl}/wp-json/erc/v1/site/header-breakpoint`, { breakpoint_px }, { 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 setting header breakpoint: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    server.tool("set-responsive-breakpoints", "Add or update custom global breakpoints in Elementor Pro's responsive settings. Lets you target non-standard viewport widths (e.g. 1280–1366px laptop range) natively without CSS workarounds.", {
+        breakpoints: z.string().describe('JSON array of breakpoint objects. Each object: { "name": string, "min_width": number, "max_width": number }. Example: [{"name":"laptop","min_width":1280,"max_width":1366}]'),
+        site: siteParam,
+    }, async ({ breakpoints, site }) => {
+        let parsed;
+        try {
+            parsed = JSON.parse(breakpoints);
+        }
+        catch {
+            return { content: [{ type: "text", text: "Invalid JSON in breakpoints parameter." }], isError: true };
+        }
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const r = await axios.post(`${wpUrl}/wp-json/erc/v1/site/responsive-breakpoints`, { breakpoints: 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 setting responsive breakpoints: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    // ── Group 11: Form Settings ───────────────────────────────────────────────────
+    server.tool("update-form-settings", "Update 'Actions After Submit' settings on a specific Elementor Pro form widget — redirect URL, success message, email recipient, and email subject. No WP admin access needed.", {
+        page_id: z.string().describe("WordPress Page ID containing the form"),
+        form_widget_id: z.string().describe("Elementor element ID of the form widget"),
+        redirect_url: z.string().optional().describe("URL to redirect to after successful submission"),
+        success_message: z.string().optional().describe("Text message shown on successful submission"),
+        email_to: z.string().optional().describe("Email address for form notification emails"),
+        email_subject: z.string().optional().describe("Subject line for notification emails"),
+        site: siteParam,
+    }, async ({ page_id, form_widget_id, redirect_url, success_message, email_to, email_subject, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            // Fetch the current element
+            const getRes = await axios.get(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/elements/${form_widget_id}`, { headers: { Authorization: authHeader } });
+            const el = getRes.data;
+            const settings = el.settings || {};
+            // Merge form action settings
+            const emailSettings = settings.email || {};
+            const redirectSettings = settings.redirect || {};
+            if (email_to)
+                emailSettings.to = email_to;
+            if (email_subject)
+                emailSettings.subject = email_subject;
+            if (redirect_url)
+                redirectSettings.url = redirect_url;
+            const updatedSettings = { ...settings };
+            if (email_to || email_subject)
+                updatedSettings.email = emailSettings;
+            if (redirect_url)
+                updatedSettings.redirect = redirectSettings;
+            if (success_message !== undefined)
+                updatedSettings.success_message = success_message;
+            const merged = { ...el, settings: updatedSettings };
+            const postRes = await axios.post(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/elements/${form_widget_id}`, merged, { headers: { Authorization: authHeader, "Content-Type": "application/json" } });
+            return { content: [{ type: "text", text: JSON.stringify(postRes.data, null, 2) }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error updating form settings: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    // ── Group 12: SEO Meta ────────────────────────────────────────────────────────
+    server.tool("update-seo-meta", "Set SEO meta title, meta description, OG title, OG description, and OG image for a page. Works with Yoast SEO and RankMath without needing WP admin access.", {
+        page_id: z.string().describe("WordPress Page ID"),
+        meta_title: z.string().optional().describe("SEO meta title (shown in browser tab and search results)"),
+        meta_description: z.string().optional().describe("SEO meta description (max 160 characters recommended)"),
+        og_title: z.string().optional().describe("Open Graph title for social sharing"),
+        og_description: z.string().optional().describe("Open Graph description for social sharing"),
+        og_image_url: z.string().optional().describe("Full URL of the Open Graph share image"),
+        site: siteParam,
+    }, async ({ page_id, meta_title, meta_description, og_title, og_description, og_image_url, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const body = {};
+            if (meta_title)
+                body.meta_title = meta_title;
+            if (meta_description)
+                body.meta_description = meta_description;
+            if (og_title)
+                body.og_title = og_title;
+            if (og_description)
+                body.og_description = og_description;
+            if (og_image_url)
+                body.og_image_url = og_image_url;
+            const r = await axios.post(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/seo-meta`, body, { 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 SEO meta: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    // ── Group 13: Page Slug ───────────────────────────────────────────────────────
+    server.tool("update-page-slug", "Update a WordPress page's slug/permalink and optionally create a 301 redirect from the old URL to the new one — both in a single operation.", {
+        page_id: z.string().describe("WordPress Page ID"),
+        new_slug: z.string().describe("New URL slug (e.g. 'services/cryotherapy-in-verona-nj'). Do not include leading/trailing slashes."),
+        create_redirect: z.boolean().optional().describe("Automatically create a 301 redirect from the old URL to the new one (default: true)"),
+        site: siteParam,
+    }, async ({ page_id, new_slug, create_redirect, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const r = await axios.post(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/slug`, { new_slug, create_redirect: create_redirect ?? true }, { 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 slug: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    // ── Group 14: Find & Replace Across Pages ────────────────────────────────────
+    server.tool("find-and-replace-across-pages", "Search all Elementor page data site-wide for a text string and replace it everywhere it appears — in one operation. Can target all pages or a specific list of page IDs. Use for bulk fixes: phone numbers, addresses, hours, placeholder text.", {
+        find: z.string().describe("Exact text string to find"),
+        replace: z.string().describe("Text to replace it with (use empty string to remove)"),
+        scope: z.enum(["all_pages", "page_ids"]).describe("'all_pages' to scan every page, or 'page_ids' to target specific pages"),
+        page_ids: z.array(z.number()).optional().describe("Required when scope is 'page_ids'. Array of WordPress page IDs to target."),
+        site: siteParam,
+    }, async ({ find, replace, scope, page_ids, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const body = { find, replace, scope };
+            if (scope === "page_ids") {
+                if (!page_ids || page_ids.length === 0) {
+                    return { content: [{ type: "text", text: "page_ids is required when scope is 'page_ids'." }], isError: true };
+                }
+                body.page_ids = page_ids;
+            }
+            const r = await axios.post(`${wpUrl}/wp-json/erc/v1/site/find-replace`, body, { 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 running find-and-replace: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    // ── Group 15: Element Visibility ─────────────────────────────────────────────
+    server.tool("set-element-visibility-per-device", "Show or hide a specific Elementor element on desktop, tablet, and/or mobile — without needing to know the widget-type-specific internal setting key.", {
+        page_id: z.string().describe("WordPress Page ID"),
+        element_id: z.string().describe("Elementor element ID"),
+        show_on: z.array(z.enum(["desktop", "tablet", "mobile"])).describe("Devices on which this element should be VISIBLE. Devices not listed will have the element hidden."),
+        site: siteParam,
+    }, async ({ page_id, element_id, show_on, site }) => {
+        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 el = getRes.data;
+            const visibilitySettings = {
+                hide_desktop: show_on.includes("desktop") ? "" : "hidden",
+                hide_tablet: show_on.includes("tablet") ? "" : "hidden",
+                hide_mobile: show_on.includes("mobile") ? "" : "hidden",
+            };
+            const merged = { ...el, settings: { ...(el.settings || {}), ...visibilitySettings } };
+            const postRes = await axios.post(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/elements/${element_id}`, merged, { headers: { Authorization: authHeader, "Content-Type": "application/json" } });
+            return { content: [{ type: "text", text: JSON.stringify({ visibility: visibilitySettings, result: postRes.data }, null, 2) }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error setting element visibility: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    // ── Group 16: Sync Spacing Across Pages ──────────────────────────────────────
+    server.tool("sync-spacing-across-pages", "Copy spacing settings (padding, margin, gap) from a reference element on one page and apply the same values to matching elements across multiple target pages — all in one operation.", {
+        source_page_id: z.string().describe("Page ID to copy spacing FROM"),
+        source_element_id: z.string().describe("Element ID on the source page to copy spacing FROM"),
+        target_page_ids: z.array(z.number()).describe("Array of page IDs to apply spacing TO"),
+        target_element_selector: z.string().describe("Widget type or CSS class to match on target pages (e.g. 'section', 'heading', or a CSS class name)"),
+        settings_to_sync: z.array(z.string()).optional().describe("Specific spacing keys to copy. Defaults to: padding, padding_tablet, padding_mobile, margin, margin_tablet, margin_mobile, gap"),
+        site: siteParam,
+    }, async ({ source_page_id, source_element_id, target_page_ids, target_element_selector, settings_to_sync, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const keysToSync = settings_to_sync ?? ["padding", "padding_tablet", "padding_mobile", "margin", "margin_tablet", "margin_mobile", "gap"];
+            // 1. Fetch source element settings
+            const srcRes = await axios.get(`${wpUrl}/wp-json/erc/v1/pages/${source_page_id}/elements/${source_element_id}`, { headers: { Authorization: authHeader } });
+            const srcSettings = srcRes.data.settings || {};
+            const spacingToCopy = Object.fromEntries(keysToSync.map(k => [k, srcSettings[k]]).filter(([, v]) => v !== undefined));
+            if (Object.keys(spacingToCopy).length === 0) {
+                return { content: [{ type: "text", text: `No matching spacing keys found on source element. Checked: ${keysToSync.join(", ")}` }], isError: true };
+            }
+            // 2. Apply to each target page
+            const results = [];
+            for (const targetPageId of target_page_ids) {
+                try {
+                    const pageRes = await axios.get(`${wpUrl}/wp-json/erc/v1/pages/${targetPageId}/data`, { headers: { Authorization: authHeader } });
+                    const allEls = flattenElements(pageRes.data);
+                    const targets = allEls.filter((el) => el.widgetType === target_element_selector ||
+                        el.elType === target_element_selector ||
+                        (el.settings?._css_classes || "").includes(target_element_selector));
+                    let updated = 0;
+                    for (const tgt of targets) {
+                        const merged = { ...tgt, settings: { ...(tgt.settings || {}), ...spacingToCopy } };
+                        await axios.post(`${wpUrl}/wp-json/erc/v1/pages/${targetPageId}/elements/${tgt.id}`, merged, { headers: { Authorization: authHeader, "Content-Type": "application/json" } });
+                        updated++;
+                    }
+                    results.push({ page_id: targetPageId, elements_updated: updated });
+                }
+                catch (err) {
+                    results.push({ page_id: targetPageId, error: err.response?.data?.message || err.message });
+                }
+            }
+            return { content: [{ type: "text", text: JSON.stringify({ spacing_copied: spacingToCopy, pages: results }, null, 2) }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error syncing spacing: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    // ── Group 17: Popup Settings ──────────────────────────────────────────────────
+    server.tool("update-popup-settings", "Update popup-level settings on an Elementor Pro popup template — dimensions, screen position, entrance animation, overlay toggle, and close button delay. Does not modify popup content elements.", {
+        popup_id: z.string().describe("Elementor popup template ID"),
+        width: z.string().optional().describe('Width as JSON: {"unit":"px","size":400} or {"unit":"%","size":80}'),
+        height: z.string().optional().describe('Height as JSON: {"unit":"vh","size":100} or {"unit":"px","size":600}'),
+        position: z.string().optional().describe("Screen position: top-left, top-center, top-right, center-left, center-center, center-right, bottom-left, bottom-center, bottom-right"),
+        entrance_animation: z.string().optional().describe("CSS animation name: fadeIn, slideInRight, slideInLeft, slideInUp, slideInDown, zoomIn, bounceIn, etc."),
+        show_overlay: z.boolean().optional().describe("Show background overlay behind the popup"),
+        close_button_delay: z.number().optional().describe("Seconds before the close (×) button appears (0 = immediately)"),
+        site: siteParam,
+    }, async ({ popup_id, width, height, position, entrance_animation, show_overlay, close_button_delay, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const settings = {};
+            if (width !== undefined) {
+                try {
+                    settings.width = JSON.parse(width);
+                }
+                catch {
+                    settings.width = width;
+                }
+            }
+            if (height !== undefined) {
+                try {
+                    settings.height = JSON.parse(height);
+                }
+                catch {
+                    settings.height = height;
+                }
+            }
+            if (position !== undefined)
+                settings.position = position;
+            if (entrance_animation !== undefined)
+                settings.entrance_animation = entrance_animation;
+            if (show_overlay !== undefined)
+                settings.overlay_prevent_close = !show_overlay;
+            if (close_button_delay !== undefined)
+                settings.close_button_delay = close_button_delay;
+            const r = await axios.patch(`${wpUrl}/wp-json/erc/v1/templates/${popup_id}/popup-settings`, settings, { 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 popup settings: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    // ── Group 18: Add Widget To Page ─────────────────────────────────────────────
+    server.tool("add-widget-to-page", "Copy a specific widget from a source page or template and insert it into a target page at a defined position. Handles JSON extraction and insertion automatically.", {
+        source_page_id: z.string().describe("Page or template ID to copy the widget FROM"),
+        source_element_id: z.string().describe("Element ID of the widget to copy"),
+        target_page_id: z.string().describe("Page ID to insert the widget INTO"),
+        position: z.enum(["top", "bottom"]).optional().describe("Where to insert: 'top' = before the first section, 'bottom' = after the last section (default: bottom)"),
+        after_element_id: z.string().optional().describe("Insert after this specific element ID on the target page (overrides position if provided)"),
+        site: siteParam,
+    }, async ({ source_page_id, source_element_id, target_page_id, position, after_element_id, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            // 1. Fetch the source widget
+            const srcRes = await axios.get(`${wpUrl}/wp-json/erc/v1/pages/${source_page_id}/elements/${source_element_id}`, { headers: { Authorization: authHeader } });
+            const widgetToCopy = srcRes.data;
+            // Give the copy a new unique ID suffix so it doesn't clash
+            const newId = `${source_element_id}_copy_${Date.now().toString(36)}`;
+            const widgetCopy = { ...widgetToCopy, id: newId };
+            // 2. Fetch target page data
+            const tgtRes = await axios.get(`${wpUrl}/wp-json/erc/v1/pages/${target_page_id}/data`, { headers: { Authorization: authHeader } });
+            let elements = tgtRes.data;
+            // 3. Insert at the correct position
+            if (after_element_id) {
+                // Find the element and insert after it in the top-level array
+                const idx = elements.findIndex((el) => el.id === after_element_id);
+                if (idx === -1) {
+                    return { content: [{ type: "text", text: `Element with id "${after_element_id}" not found at top level of target page.` }], isError: true };
+                }
+                elements = [...elements.slice(0, idx + 1), widgetCopy, ...elements.slice(idx + 1)];
+            }
+            else if (position === "top") {
+                elements = [widgetCopy, ...elements];
+            }
+            else {
+                // bottom (default)
+                elements = [...elements, widgetCopy];
+            }
+            // 4. Save updated target page
+            const putRes = await axios.put(`${wpUrl}/wp-json/erc/v1/pages/${target_page_id}/data`, elements, { headers: { Authorization: authHeader, "Content-Type": "application/json" } });
+            return { content: [{ type: "text", text: JSON.stringify({ new_element_id: newId, result: putRes.data }, null, 2) }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error adding widget to page: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    // ── Group 19: Disable Read More Sitewide ─────────────────────────────────────
+    server.tool("disable-read-more-sitewide", "Find all Elementor Posts widgets across the site (or specific pages) and disable the Read More button using the native Elementor Posts widget setting — not CSS. Standard SEO practice applied in one operation.", {
+        scope: z.enum(["all_pages", "page_ids"]).describe("'all_pages' to process every page, or 'page_ids' to target specific pages"),
+        page_ids: z.array(z.number()).optional().describe("Required when scope is 'page_ids'. Array of WordPress page IDs."),
+        site: siteParam,
+    }, async ({ scope, page_ids, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            // 1. Build list of pages to process
+            let pageList = [];
+            if (scope === "all_pages") {
+                const listRes = await axios.get(`${wpUrl}/wp-json/erc/v1/pages`, { headers: { Authorization: authHeader } });
+                pageList = listRes.data.map((p) => Number(p.id || p.ID));
+            }
+            else {
+                if (!page_ids || page_ids.length === 0) {
+                    return { content: [{ type: "text", text: "page_ids is required when scope is 'page_ids'." }], isError: true };
+                }
+                pageList = page_ids;
+            }
+            const results = [];
+            for (const pid of pageList) {
+                try {
+                    const dataRes = await axios.get(`${wpUrl}/wp-json/erc/v1/pages/${pid}/data`, { headers: { Authorization: authHeader } });
+                    const allEls = flattenElements(dataRes.data);
+                    const postWidgets = allEls.filter((el) => el.widgetType === "posts" || el.widgetType === "archive-posts");
+                    if (postWidgets.length === 0) {
+                        results.push({ page_id: pid, widgets_updated: 0 });
+                        continue;
+                    }
+                    for (const widget of postWidgets) {
+                        const merged = {
+                            ...widget,
+                            settings: { ...(widget.settings || {}), show_read_more: "no" },
+                        };
+                        await axios.post(`${wpUrl}/wp-json/erc/v1/pages/${pid}/elements/${widget.id}`, merged, { headers: { Authorization: authHeader, "Content-Type": "application/json" } });
+                    }
+                    results.push({ page_id: pid, widgets_updated: postWidgets.length });
+                }
+                catch (err) {
+                    results.push({ page_id: pid, error: err.response?.data?.message || err.message });
+                }
+            }
+            const total = results.reduce((acc, r) => acc + (r.widgets_updated || 0), 0);
+            return { content: [{ type: "text", text: JSON.stringify({ total_widgets_updated: total, pages: results }, null, 2) }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error disabling Read More: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    // ── Group 20: Update Video URL ────────────────────────────────────────────────
+    server.tool("update-video-url", "Update the video source URL on a specific Elementor video widget. Validates the URL format, updates the widget setting, and clears Elementor cache so the new video loads immediately.", {
+        page_id: z.string().describe("WordPress Page ID containing the video widget"),
+        widget_id: z.string().describe("Elementor element ID of the video widget"),
+        video_url: z.string().describe("New video URL (e.g. Bunny CDN embed URL, YouTube, Vimeo, or direct MP4 URL)"),
+        video_type: z.enum(["youtube", "vimeo", "hosted", "bunny_cdn"]).optional().describe("Video source type. Use 'hosted' for direct MP4 or 'bunny_cdn' for Bunny CDN embed (default: auto-detect from URL)"),
+        site: siteParam,
+    }, async ({ page_id, widget_id, video_url, video_type, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            // Auto-detect type if not provided
+            let resolvedType = video_type;
+            if (!resolvedType) {
+                if (video_url.includes("youtube.com") || video_url.includes("youtu.be")) {
+                    resolvedType = "youtube";
+                }
+                else if (video_url.includes("vimeo.com")) {
+                    resolvedType = "vimeo";
+                }
+                else if (video_url.includes("mediadelivery.net") || video_url.includes("bunnycdn") || video_url.includes("iframe.mediadelivery")) {
+                    resolvedType = "bunny_cdn";
+                }
+                else {
+                    resolvedType = "hosted";
+                }
+            }
+            // Fetch current element
+            const getRes = await axios.get(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/elements/${widget_id}`, { headers: { Authorization: authHeader } });
+            const el = getRes.data;
+            // Build updated settings based on video type
+            const videoSettings = {
+                video_type: resolvedType === "bunny_cdn" ? "hosted" : resolvedType,
+            };
+            if (resolvedType === "youtube") {
+                videoSettings.youtube_url = video_url;
+            }
+            else if (resolvedType === "vimeo") {
+                videoSettings.vimeo_url = video_url;
+            }
+            else {
+                // hosted / bunny_cdn — use external_url for Bunny CDN iframes, hosted_url for direct MP4
+                if (resolvedType === "bunny_cdn") {
+                    videoSettings.video_type = "hosted";
+                    videoSettings.hosted_url = { url: video_url };
+                }
+                else {
+                    videoSettings.hosted_url = { url: video_url };
+                }
+            }
+            const merged = { ...el, settings: { ...(el.settings || {}), ...videoSettings } };
+            const postRes = await axios.post(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/elements/${widget_id}`, merged, { headers: { Authorization: authHeader, "Content-Type": "application/json" } });
+            // Clear cache so new video is served immediately
+            await axios.post(`${wpUrl}/wp-json/erc/v1/site/clear-cache`, {}, { headers: { Authorization: authHeader }, params: { post_id: page_id } });
+            return { content: [{ type: "text", text: JSON.stringify({ video_type: resolvedType, video_url, result: postRes.data }, null, 2) }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error updating video URL: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    // ── Group 21: WordPress Menu ─────────────────────────────────────────────────
+    server.tool("update-wordpress-menu", "Read and update a WordPress navigation menu — reorder items, add items, remove items, or disable links. The Elementor Nav Menu widget order is controlled here, not in Elementor.", {
+        menu_name: z.string().describe("WordPress menu name (e.g. 'Primary Menu', 'Footer Menu') or numeric menu ID"),
+        action: z.enum(["get", "reorder", "disable_link", "enable_link", "remove_item", "add_item"]).describe("Action to perform: 'get' = read current menu, 'reorder' = set item order, 'disable_link' = make item non-clickable (#), 'enable_link' = restore item URL, 'remove_item' = delete a menu item, 'add_item' = append a new item"),
+        item_order: z.array(z.string()).optional().describe("Required for 'reorder'. Array of item titles in desired display order."),
+        item_title: z.string().optional().describe("Required for disable_link / enable_link / remove_item. The menu item title to target."),
+        item_url: z.string().optional().describe("Required for add_item. The URL of the new menu item."),
+        item_parent: z.string().optional().describe("For add_item — title of the parent item (for dropdown sub-items). Omit for top-level."),
+        site: siteParam,
+    }, async ({ menu_name, action, item_order, item_title, item_url, item_parent, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const body = { menu_name, action };
+            if (item_order)
+                body.item_order = item_order;
+            if (item_title)
+                body.item_title = item_title;
+            if (item_url)
+                body.item_url = item_url;
+            if (item_parent)
+                body.item_parent = item_parent;
+            const r = await axios.post(`${wpUrl}/wp-json/erc/v1/site/menu`, body, { 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 WordPress menu: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    // ── Group 22: Rank Math SEO ───────────────────────────────────────────────────
+    server.tool("update-rank-math-seo", "Update Rank Math SEO settings for a page — meta title, meta description, OG title, OG description, and social share image. Writes directly to Rank Math post meta. Use the hero section image as the og_image_url as per standard procedure.", {
+        page_id: z.string().describe("WordPress Page ID"),
+        meta_title: z.string().optional().describe("SEO meta title shown in search results and browser tab"),
+        meta_description: z.string().optional().describe("SEO meta description (max 160 characters recommended)"),
+        og_title: z.string().optional().describe("Open Graph / social share title"),
+        og_description: z.string().optional().describe("Open Graph / social share description"),
+        og_image_url: z.string().optional().describe("Full URL of the social share image (use hero section image as standard)"),
+        og_image_id: z.number().optional().describe("WordPress media attachment ID of the OG image (preferred over URL if available)"),
+        site: siteParam,
+    }, async ({ page_id, meta_title, meta_description, og_title, og_description, og_image_url, og_image_id, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            // Rank Math stores its data in specific post meta keys:
+            // rank_math_title, rank_math_description, rank_math_og_title,
+            // rank_math_og_description, rank_math_facebook_image,
+            // rank_math_facebook_image_id
+            const meta = {};
+            if (meta_title)
+                meta.rank_math_title = meta_title;
+            if (meta_description)
+                meta.rank_math_description = meta_description;
+            if (og_title)
+                meta.rank_math_og_title = og_title;
+            if (og_description)
+                meta.rank_math_og_description = og_description;
+            if (og_image_url)
+                meta.rank_math_facebook_image = og_image_url;
+            if (og_image_id)
+                meta.rank_math_facebook_image_id = og_image_id;
+            const r = await axios.post(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/post-meta`, { meta }, { 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 Rank Math SEO: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    // ── Group 23: Element Order Per Device ───────────────────────────────────────
+    server.tool("set-element-order-per-device", "Set the CSS display order of an Elementor element per breakpoint — desktop, tablet, and/or mobile. Changes visual stacking order without altering the DOM. Use to move images above text on mobile (order 1) while keeping them below on desktop (order 2).", {
+        page_id: z.string().describe("WordPress Page ID"),
+        element_id: z.string().describe("Elementor element ID"),
+        order_desktop: z.number().optional().describe("CSS order value for desktop (e.g. 1 = first, 2 = second)"),
+        order_tablet: z.number().optional().describe("CSS order value for tablet"),
+        order_mobile: z.number().optional().describe("CSS order value for mobile"),
+        site: siteParam,
+    }, async ({ page_id, element_id, order_desktop, order_tablet, order_mobile, site }) => {
+        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 el = getRes.data;
+            const orderSettings = {};
+            if (order_desktop !== undefined)
+                orderSettings._element_order = order_desktop;
+            if (order_tablet !== undefined)
+                orderSettings._element_order_tablet = order_tablet;
+            if (order_mobile !== undefined)
+                orderSettings._element_order_mobile = order_mobile;
+            const merged = { ...el, settings: { ...(el.settings || {}), ...orderSettings } };
+            const postRes = await axios.post(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/elements/${element_id}`, merged, { headers: { Authorization: authHeader, "Content-Type": "application/json" } });
+            return { content: [{ type: "text", text: JSON.stringify({ order_applied: orderSettings, result: postRes.data }, null, 2) }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error setting element order: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    // ── Group 24: Element Z-Index ─────────────────────────────────────────────────
+    server.tool("set-element-z-index", "Set the Z-index value for a specific Elementor element. Use to fix images showing over the header, overlapping sections, or elements bleeding through other elements. Can set an absolute value or relative to another element (above/below).", {
+        page_id: z.string().describe("WordPress Page ID"),
+        element_id: z.string().describe("Elementor element ID to update"),
+        z_index: z.number().optional().describe("Absolute Z-index value (e.g. 1, 10, 100). Use this OR reference_element_id — not both."),
+        reference_element_id: z.string().optional().describe("Element ID to compare against. Use with 'position' to set z-index relative to another element."),
+        position: z.enum(["above", "below"]).optional().describe("'above' = z-index of reference + 1, 'below' = z-index of reference - 1"),
+        site: siteParam,
+    }, async ({ page_id, element_id, z_index, reference_element_id, position, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            let finalZIndex = z_index;
+            // If relative mode: fetch reference element's current z-index
+            if (reference_element_id && position) {
+                const refRes = await axios.get(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/elements/${reference_element_id}`, { headers: { Authorization: authHeader } });
+                const refZ = parseInt(refRes.data.settings?._z_index || "0", 10);
+                finalZIndex = position === "above" ? refZ + 1 : Math.max(0, refZ - 1);
+            }
+            if (finalZIndex === undefined) {
+                return { content: [{ type: "text", text: "Provide either z_index or reference_element_id + position." }], isError: true };
+            }
+            const getRes = await axios.get(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/elements/${element_id}`, { headers: { Authorization: authHeader } });
+            const el = getRes.data;
+            const merged = { ...el, settings: { ...(el.settings || {}), _z_index: finalZIndex } };
+            const postRes = await axios.post(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/elements/${element_id}`, merged, { headers: { Authorization: authHeader, "Content-Type": "application/json" } });
+            return { content: [{ type: "text", text: JSON.stringify({ z_index_set: finalZIndex, result: postRes.data }, null, 2) }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error setting Z-index: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    // ── Group 25: Video Overlay ───────────────────────────────────────────────────
+    server.tool("update-video-overlay", "Set the image overlay on an Elementor video widget so the video appears to load immediately on page load. The overlay image (typically the video thumbnail or hero image) is shown until the user clicks play. This is the correct fix for 'video not loading immediately' QA issues — not changing the video URL.", {
+        page_id: z.string().describe("WordPress Page ID containing the video widget"),
+        widget_id: z.string().describe("Elementor element ID of the video widget"),
+        overlay_image_url: z.string().describe("Full URL of the overlay/thumbnail image (use the video thumbnail or hero section image)"),
+        overlay_image_id: z.number().optional().describe("WordPress media attachment ID of the overlay image (preferred over URL if available)"),
+        show_play_icon: z.boolean().optional().describe("Show a play button icon over the overlay image (default: true)"),
+        site: siteParam,
+    }, async ({ page_id, widget_id, overlay_image_url, overlay_image_id, show_play_icon, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const getRes = await axios.get(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/elements/${widget_id}`, { headers: { Authorization: authHeader } });
+            const el = getRes.data;
+            const overlaySettings = {
+                show_image_overlay: "yes",
+                image_overlay: {
+                    url: overlay_image_url,
+                    id: overlay_image_id ?? 0,
+                },
+                show_play_icon: (show_play_icon ?? true) ? "yes" : "no",
+                lightbox: "no", // Ensure video plays inline, not in a lightbox
+            };
+            const merged = { ...el, settings: { ...(el.settings || {}), ...overlaySettings } };
+            const postRes = await axios.post(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/elements/${widget_id}`, merged, { headers: { Authorization: authHeader, "Content-Type": "application/json" } });
+            // Clear page cache so the updated overlay loads immediately
+            await axios.post(`${wpUrl}/wp-json/erc/v1/site/clear-cache`, {}, { headers: { Authorization: authHeader }, params: { post_id: page_id } });
+            return { content: [{ type: "text", text: JSON.stringify({ overlay_image_url, result: postRes.data }, null, 2) }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error updating video overlay: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
     return server;
 }
 // ─── Entry Point ──────────────────────────────────────────────────────────────

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yashwant.dharmdas/elementor-mcp",
-  "version": "3.2.8",
+  "version": "3.4.0",
   "description": "MCP server for controlling Elementor via Claude — supports multiple WordPress sites",
   "main": "dist/index.js",
   "type": "module",