@yashwant.dharmdas/elementor-mcp 3.2.7 → 3.3.0

package/dist/index.js

@@ -1092,15 +1092,16 @@ function createMcpServer(sites) {
                 await page.goto(pageUrl, { waitUntil: "networkidle2", timeout: 45_000 });
                 // ── Auto-scroll with multi-pass stabilization ────────────────────
                 // Many Elementor pages lazy-load content on scroll (images, Swiper
-                // carousels, reveal animations). A single scroll pass is not enough —
-                // the page can grow as content loads. We keep scrolling until the
-                // total page height stops increasing between passes.
+                // carousels, reveal animations). We scroll slowly so IntersectionObservers
+                // have time to fire, then wait at the bottom for content to settle, and
+                // repeat passes until the total page height stops increasing.
                 if (auto_scroll !== false) {
                     await page.evaluate(async () => {
                         const getHeight = () => Math.max(document.body.scrollHeight, document.documentElement.scrollHeight, document.body.offsetHeight, document.documentElement.offsetHeight);
                         const scrollOnce = () => new Promise((resolve) => {
                             let y = 0;
-                            const step = 300;
+                            const step = 180; // smaller step
+                            const delay = 110; // slower interval — gives observers time to fire
                             const timer = setInterval(() => {
                                 const h = getHeight();
                                 window.scrollBy(0, step);
@@ -1109,89 +1110,166 @@ function createMcpServer(sites) {
                                     clearInterval(timer);
                                     resolve();
                                 }
-                            }, 60);
+                            }, delay);
                         });
                         // Repeat until height stabilizes (max 4 passes)
                         let lastHeight = 0;
                         for (let i = 0; i < 4; i++) {
                             window.scrollTo(0, 0);
-                            await new Promise(r => setTimeout(r, 150));
+                            await new Promise(r => setTimeout(r, 200));
                             await scrollOnce();
-                            // Wait at the bottom for lazy content to trigger
-                            await new Promise(r => setTimeout(r, 800));
+                            // Long wait at the bottom — bg images / Swipers need time
+                            await new Promise(r => setTimeout(r, 1500));
                             const h = getHeight();
-                            if (h === lastHeight)
+                            if (h === lastHeight && i > 0)
                                 break;
                             lastHeight = h;
                         }
+                        // One more slow scroll pass at half speed to nail any stragglers
+                        await new Promise((resolve) => {
+                            window.scrollTo(0, 0);
+                            let y = 0;
+                            const step = 120;
+                            const timer = setInterval(() => {
+                                const h = getHeight();
+                                window.scrollBy(0, step);
+                                y += step;
+                                if (y >= h) {
+                                    clearInterval(timer);
+                                    resolve();
+                                }
+                            }, 130);
+                        });
+                        await new Promise(r => setTimeout(r, 1000));
                         // Back to top for the capture
                         window.scrollTo(0, 0);
                     });
                 }
-                // ── Force-load all <img> tags + Elementor lazy backgrounds ────────
+                // ── Force-load all images, Elementor backgrounds, and reveal sections ─
                 await page.evaluate(async () => {
-                    // 1. Strip loading="lazy" so the browser loads everything eagerly
+                    // 1. Inject CSS that disables animations AND forces opacity:1
+                    //    on Elementor's hidden reveal states. This MUST be first so
+                    //    subsequent layout / render passes don't re-hide content.
+                    const style = document.createElement("style");
+                    style.id = "__mcp_screenshot_overrides__";
+                    style.textContent = `
+							*, *::before, *::after {
+								animation-duration: 0s !important;
+								animation-delay: 0s !important;
+								transition-duration: 0s !important;
+								transition-delay: 0s !important;
+							}
+							.elementor-invisible,
+							.elementor-element[data-settings*="animation"] {
+								opacity: 1 !important;
+								visibility: visible !important;
+								transform: none !important;
+							}
+							/* Defeat any lazy-load opacity tricks */
+							.elementor-element { opacity: 1 !important; }
+						`;
+                    document.head.appendChild(style);
+                    // 2. Strip loading="lazy" on images
                     document.querySelectorAll('img[loading="lazy"]').forEach((img) => {
                         img.setAttribute("loading", "eager");
                     });
-                    // 2. Resolve data-src → src for libraries that defer image loading
+                    // 3. Resolve data-src → src for any deferred-load libraries
                     document.querySelectorAll("img[data-src]").forEach((img) => {
                         const ds = img.getAttribute("data-src");
                         if (ds && !img.getAttribute("src"))
                             img.setAttribute("src", ds);
                     });
-                    // 3. Force-load Elementor's lazy background images
-                    //    Elementor uses class .elementor-element-bg-lazyload + sets a
-                    //    CSS variable --e-bg-lazyload, OR data-bg / data-background-image
-                    const bgEls = document.querySelectorAll(".elementor-element-bg-lazyload, [data-bg], [data-background-image]");
-                    bgEls.forEach((el) => {
-                        const url = el.getAttribute("data-bg") ||
-                            el.getAttribute("data-background-image") ||
-                            getComputedStyle(el).getPropertyValue("--e-bg-lazyload").trim().replace(/^url\(["']?|["']?\)$/g, "");
-                        if (url && url !== "none" && !el.style.backgroundImage) {
-                            el.style.backgroundImage = `url("${url}")`;
+                    // 4. Resolve <source srcset> inside <picture> (just in case)
+                    document.querySelectorAll("source[data-srcset]").forEach((src) => {
+                        const ds = src.getAttribute("data-srcset");
+                        if (ds && !src.getAttribute("srcset"))
+                            src.setAttribute("srcset", ds);
+                    });
+                    // 5. Force-load Elementor's lazy background images.
+                    //    Elementor uses MULTIPLE patterns over the years:
+                    //      - class .elementor-element-bg-lazyload + CSS var --e-bg-lazyload
+                    //      - data-bg / data-background-image
+                    //      - data-settings JSON containing background_image
+                    //    We try all of them.
+                    document.querySelectorAll(".elementor-element-bg-lazyload, [data-bg], [data-background-image], [data-settings]").forEach((el) => {
+                        let url = el.getAttribute("data-bg") ||
+                            el.getAttribute("data-background-image");
+                        // Try the CSS variable
+                        if (!url) {
+                            const v = getComputedStyle(el).getPropertyValue("--e-bg-lazyload").trim();
+                            if (v && v !== "none") {
+                                url = v.replace(/^url\(["']?|["']?\)$/g, "");
+                            }
+                        }
+                        // Try parsing data-settings JSON
+                        if (!url) {
+                            try {
+                                const ds = el.getAttribute("data-settings");
+                                if (ds) {
+                                    const obj = JSON.parse(ds);
+                                    url = obj?.background_image?.url
+                                        || obj?._background_image?.url
+                                        || obj?.background_overlay_image?.url
+                                        || null;
+                                }
+                            }
+                            catch { /* ignore */ }
+                        }
+                        if (url && url !== "none") {
+                            // Set inline so it overrides any external lazy CSS
+                            el.style.setProperty("background-image", `url("${url}")`, "important");
+                            el.style.setProperty("--e-bg-lazyload", "none");
                         }
                         el.classList.remove("elementor-element-bg-lazyload");
                     });
-                    // 4. Force-show Elementor reveal-animation elements that are still
-                    //    hidden (opacity:0 / .elementor-invisible) waiting for scroll trigger
+                    // 6. Force-show Elementor reveal-animation elements
                     document.querySelectorAll(".elementor-invisible").forEach((el) => {
                         el.classList.remove("elementor-invisible");
                         el.style.opacity = "1";
                         el.style.visibility = "visible";
                         el.style.transform = "none";
                     });
-                    // 5. Disable CSS animations / transitions during capture so nothing
-                    //    is mid-flight when the screenshot fires
-                    const style = document.createElement("style");
-                    style.id = "__mcp_screenshot_overrides__";
-                    style.textContent = `
-							*, *::before, *::after {
-								animation-duration: 0s !important;
-								animation-delay: 0s !important;
-								transition-duration: 0s !important;
-								transition-delay: 0s !important;
-							}
-							.elementor-invisible { opacity: 1 !important; visibility: visible !important; }
-						`;
-                    document.head.appendChild(style);
-                    // 6. Wake up any IntersectionObserver-based loaders one more time
+                    // 7. Re-trigger Elementor frontend lazy-load if available.
+                    //    Elementor exposes the global `elementorFrontend`; calling its
+                    //    elementsHandler reinitialises lazy modules.
+                    try {
+                        const ef = window.elementorFrontend;
+                        if (ef?.elementsHandler?.runReadyTrigger) {
+                            document.querySelectorAll(".elementor-element").forEach((el) => {
+                                try {
+                                    ef.elementsHandler.runReadyTrigger(el);
+                                }
+                                catch { /* ignore */ }
+                            });
+                        }
+                    }
+                    catch { /* ignore */ }
+                    // 8. Dispatch scroll/resize to wake any remaining IntersectionObservers
                     window.dispatchEvent(new Event("scroll"));
                     window.dispatchEvent(new Event("resize"));
-                    // 7. Wait for ALL <img> tags (now eager) to finish loading
+                    document.dispatchEvent(new Event("DOMContentLoaded"));
+                    // 9. Wait for ALL <img> tags (now eager) to finish loading + decode
                     const images = Array.from(document.querySelectorAll("img"));
                     await Promise.all(images.map((img) => {
-                        if (img.complete && img.naturalWidth > 0)
-                            return Promise.resolve();
+                        if (img.complete && img.naturalWidth > 0) {
+                            return img.decode?.().catch(() => { }) ?? Promise.resolve();
+                        }
                         return new Promise((resolve) => {
                             img.addEventListener("load", () => resolve(), { once: true });
                             img.addEventListener("error", () => resolve(), { once: true });
                             setTimeout(() => resolve(), 5000);
                         });
                     }));
+                    // 10. Wait for fonts to be fully ready (avoids FOUT in screenshot)
+                    if (document.fonts?.ready) {
+                        try {
+                            await document.fonts.ready;
+                        }
+                        catch { /* ignore */ }
+                    }
                 });
-                // Extra settle time for fonts, video posters, and bg image decoding
-                await new Promise(resolve => setTimeout(resolve, wait ?? 2500));
+                // Extra settle time — bumped to 3500ms default to handle slow CDNs / videos
+                await new Promise(resolve => setTimeout(resolve, wait ?? 3500));
                 const fmt = format ?? "jpeg";
                 const baseOptions = { type: fmt, fullPage: !max_height && (full_page ?? true) };
                 if (max_height)
@@ -1292,6 +1370,418 @@ 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 };
+        }
+    });
     return server;
 }
 // ─── Entry Point ──────────────────────────────────────────────────────────────

package/package.json

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