@yashwant.dharmdas/elementor-mcp 3.9.0 → 3.11.0

package/dist/index.js

@@ -270,6 +270,89 @@ function createMcpServer(sites) {
             return { content: [{ type: "text", text: `Error setting element link: ${error.response?.data?.message || error.message}` }], isError: true };
         }
     });
+    server.tool("clone-element", "Clone an existing Elementor element (button, heading, container, etc.) with optional setting overrides and insert it at a position. **PERFECT for 'add another button like this one' tasks** — preserves all styling, classes, sizing, and structure from the source widget; you just override the content (text, link, image, etc.). 100 % server-side: no full-page download or upload — uses ~95 % fewer tokens than get-data + update-data. ALWAYS prefer this over add-widget-to-page or update-data when adding similar elements.", {
+        page_id: z.string().describe("WordPress Page ID"),
+        element_id: z.string().describe("Element ID to clone (the source — its styling and structure are copied; new IDs are auto-generated for the clone)"),
+        position: z.enum(["before", "after", "first_child", "last_child"]).optional().describe("Where to place the clone relative to target_id. Default: 'after'"),
+        target_id: z.string().optional().describe("Place clone near this element instead of the source. Default: same as element_id (places clone next to source)"),
+        overrides: z.string().optional().describe("JSON object of settings to override on the clone. Example: '{\"text\":\"Go to Growth99\",\"link\":{\"url\":\"https://growth99.com\",\"is_external\":\"on\"}}'. Top-level keys deep-merge for objects, replace for scalars."),
+        site: siteParam,
+    }, async ({ page_id, element_id, position, target_id, overrides, site }) => {
+        try {
+            let parsedOverrides = {};
+            if (overrides) {
+                try {
+                    parsedOverrides = JSON.parse(overrides);
+                }
+                catch {
+                    return { content: [{ type: "text", text: "Invalid JSON in overrides parameter." }], isError: true };
+                }
+            }
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const body = {};
+            if (position)
+                body.position = position;
+            if (target_id)
+                body.target_id = target_id;
+            if (overrides)
+                body.overrides = parsedOverrides;
+            const r = await axios.post(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/elements/${element_id}/clone`, 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 cloning element: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    server.tool("insert-element", "Insert a brand-new Elementor element (custom JSON) at a specific position. Server-side — never downloads or uploads the full page JSON. Use this when there's no similar element to clone. For 'add another button like this one' use clone-element instead — it preserves styling automatically.", {
+        page_id: z.string().describe("WordPress Page ID"),
+        element: z.string().describe("JSON string of the element to insert. Schema: {elType, widgetType, settings, elements?}. ID auto-generated."),
+        target_id: z.string().optional().describe("Element ID to insert relative to. Omit to insert at page top/bottom."),
+        position: z.string().optional().describe("With target_id: 'before', 'after', 'first_child', 'last_child' (default 'after'). Without target_id: 'top' or 'bottom' (default 'bottom')."),
+        site: siteParam,
+    }, async ({ page_id, element, target_id, position, site }) => {
+        try {
+            let parsedElement;
+            try {
+                parsedElement = JSON.parse(element);
+            }
+            catch {
+                return { content: [{ type: "text", text: "Invalid JSON in element parameter." }], isError: true };
+            }
+            if (!parsedElement || typeof parsedElement !== "object") {
+                return { content: [{ type: "text", text: "element must be a JSON object." }], isError: true };
+            }
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const body = { element: parsedElement };
+            if (target_id)
+                body.target_id = target_id;
+            if (position)
+                body.position = position;
+            const r = await axios.post(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/insert-element`, 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 inserting element: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    server.tool("move-element", "Move an existing Elementor element to a new position in the tree. Server-side — no full-page round-trip.", {
+        page_id: z.string().describe("WordPress Page ID"),
+        element_id: z.string().describe("Element ID to move"),
+        target_id: z.string().describe("Element ID to move next to"),
+        position: z.enum(["before", "after", "first_child", "last_child"]).optional().describe("Position relative to target_id. Default: 'after'"),
+        site: siteParam,
+    }, async ({ page_id, element_id, target_id, position, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            const body = { target_id };
+            if (position)
+                body.position = position;
+            const r = await axios.post(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/elements/${element_id}/move`, 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 moving element: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
     server.tool("merge-element-settings", "Deep-merge settings into a specific Elementor element without replacing the full element. Use for small setting adjustments.", {
         page_id: z.string().describe("WordPress Page ID"),
         element_id: z.string().describe("Elementor Element ID"),
@@ -1008,13 +1091,14 @@ function createMcpServer(sites) {
         }
     });
     // ── Group 8: Page Creation & Publishing ──────────────────────────────────
-    server.tool("create-page", "Create a new WordPress page, optionally publish it immediately, and enable the Elementor editor. Returns the page ID and direct Elementor edit URL.", {
+    server.tool("create-page", "Create a new WordPress page, optionally publish it immediately, and enable the Elementor editor. Returns the page ID and direct Elementor edit URL. Supports any WordPress post type — use post_type='astra-portfolio' for Astra portfolio items, 'post' for blog posts, etc.", {
         title: z.string().describe("Page title"),
         status: z.enum(["draft", "publish", "private", "pending"]).optional().describe("Page status — default: draft"),
         page_template: z.string().optional().describe("WordPress page template filename (e.g. 'elementor_canvas'). Leave blank for default."),
         enable_elementor: z.boolean().optional().describe("Initialize the Elementor editor on this page (default: true)"),
+        post_type: z.string().optional().describe("WordPress post type. Default: 'page'. Use 'astra-portfolio' for Astra portfolio, 'post' for blog posts, or any registered custom post type."),
         site: siteParam,
-    }, async ({ title, status, page_template, enable_elementor, site }) => {
+    }, async ({ title, status, page_template, enable_elementor, post_type, site }) => {
         try {
             const { wpUrl, authHeader } = resolveSite(sites, site);
             const body = {
@@ -1024,6 +1108,8 @@ function createMcpServer(sites) {
             };
             if (page_template)
                 body.page_template = page_template;
+            if (post_type)
+                body.post_type = post_type;
             const r = await axios.post(`${wpUrl}/wp-json/erc/v1/pages`, body, {
                 headers: { Authorization: authHeader, "Content-Type": "application/json" },
             });
@@ -1033,6 +1119,93 @@ function createMcpServer(sites) {
             return { content: [{ type: "text", text: `Error creating page: ${error.response?.data?.message || error.message}` }], isError: true };
         }
     });
+    server.tool("import-template-to-page", "Push a local Elementor JSON file from disk directly to an existing page. The MCP server reads the file and sends it straight to WordPress — the JSON NEVER passes through Claude's context, so there is NO 25K-token limit. Use when you have generated a large Elementor JSON locally and need to push it to an existing page. File path must be accessible on this machine (where the MCP server is running).", {
+        page_id: z.string().describe("WordPress Page ID to write the Elementor data to"),
+        file_path: z.string().describe("Absolute path to the Elementor JSON file on disk (e.g. D:\\Project\\final-service-pages\\botox.json). Must contain a valid Elementor elements array."),
+        site: siteParam,
+    }, async ({ page_id, file_path, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            // Read file from local disk — bypasses Claude context entirely
+            if (!fs.existsSync(file_path)) {
+                return { content: [{ type: "text", text: `Error: File not found at path: ${file_path}` }], isError: true };
+            }
+            const raw = fs.readFileSync(file_path, "utf8");
+            let elementorData;
+            try {
+                elementorData = JSON.parse(raw);
+            }
+            catch {
+                return { content: [{ type: "text", text: `Error: File at ${file_path} is not valid JSON.` }], isError: true };
+            }
+            // Push to WordPress
+            const r = await axios.put(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/data`, elementorData, { headers: { Authorization: authHeader, "Content-Type": "application/json" } });
+            // Clear cache
+            await axios.post(`${wpUrl}/wp-json/erc/v1/site/clear-cache`, {}, { headers: { Authorization: authHeader }, params: { post_id: page_id } }).catch(() => { });
+            return { content: [{ type: "text", text: JSON.stringify({ success: true, page_id, file: file_path, result: r.data }, null, 2) }] };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error importing template: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
+    server.tool("create-page-from-file", "Create a new WordPress page AND populate it with Elementor data from a local JSON file — all in one step. The MCP server reads the file from disk and sends it straight to WordPress. The JSON NEVER passes through Claude's context, so there is NO 25K-token limit. This is the correct tool for the service-pages workflow: write a script that generates Elementor JSONs locally, then call this tool for each file. Supports any post_type (astra-portfolio, page, post, etc.). Steps internally: 1) create page → get ID, 2) push Elementor data from file, 3) clear cache.", {
+        title: z.string().describe("Page title"),
+        file_path: z.string().describe("Absolute path to the Elementor JSON file on disk (e.g. D:\\Project\\final-service-pages\\botox.json)"),
+        post_type: z.string().optional().describe("WordPress post type. Default: 'page'. Use 'astra-portfolio' for Astra portfolio items, 'post' for blog posts, or any registered custom post type."),
+        status: z.enum(["draft", "publish", "private", "pending"]).optional().describe("Page status — default: publish"),
+        page_template: z.string().optional().describe("WordPress page template (e.g. 'elementor_canvas'). Leave blank for default."),
+        site: siteParam,
+    }, async ({ title, file_path, post_type, status, page_template, site }) => {
+        try {
+            const { wpUrl, authHeader } = resolveSite(sites, site);
+            // Step 1: Read the Elementor JSON from disk
+            if (!fs.existsSync(file_path)) {
+                return { content: [{ type: "text", text: `Error: File not found at path: ${file_path}` }], isError: true };
+            }
+            const raw = fs.readFileSync(file_path, "utf8");
+            let elementorData;
+            try {
+                elementorData = JSON.parse(raw);
+            }
+            catch {
+                return { content: [{ type: "text", text: `Error: File at ${file_path} is not valid JSON.` }], isError: true };
+            }
+            // Step 2: Create the page
+            const createBody = {
+                title,
+                status: status ?? "publish",
+                enable_elementor: true,
+            };
+            if (post_type)
+                createBody.post_type = post_type;
+            if (page_template)
+                createBody.page_template = page_template;
+            const createRes = await axios.post(`${wpUrl}/wp-json/erc/v1/pages`, createBody, { headers: { Authorization: authHeader, "Content-Type": "application/json" } });
+            const page_id = createRes.data.id;
+            // Step 3: Push Elementor data from file (never entered Claude context)
+            await axios.put(`${wpUrl}/wp-json/erc/v1/pages/${page_id}/data`, elementorData, { headers: { Authorization: authHeader, "Content-Type": "application/json" } });
+            // Step 4: Clear cache
+            await axios.post(`${wpUrl}/wp-json/erc/v1/site/clear-cache`, {}, { headers: { Authorization: authHeader }, params: { post_id: page_id } }).catch(() => { });
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            success: true,
+                            page_id,
+                            title,
+                            post_type: post_type ?? "page",
+                            status: status ?? "publish",
+                            url: createRes.data.url,
+                            edit_url: createRes.data.elementor_edit_url,
+                            file_used: file_path,
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error creating page from file: ${error.response?.data?.message || error.message}` }], isError: true };
+        }
+    });
     server.tool("publish-page", "Change the publish status of a WordPress page (publish, draft, private, pending, trash).", {
         page_id: z.string().describe("WordPress Page ID"),
         status: z.enum(["publish", "draft", "private", "pending", "trash"]).describe("Target status"),

package/package.json

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