@yashwant.dharmdas/elementor-mcp 3.2.8 → 3.3.0

package/dist/index.js

@@ -1370,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.8",
+  "version": "3.3.0",
   "description": "MCP server for controlling Elementor via Claude — supports multiple WordPress sites",
   "main": "dist/index.js",
   "type": "module",