@yashwant.dharmdas/elementor-mcp 3.2.4 → 3.2.6

package/dist/index.js

@@ -1090,28 +1090,56 @@ function createMcpServer(sites) {
                 await page.setViewport({ width: vpWidth, height: vpHeight, deviceScaleFactor: 1 });
                 // Navigate and wait for network to go idle
                 await page.goto(pageUrl, { waitUntil: "networkidle2", timeout: 45_000 });
-                // ── Auto-scroll: trigger lazy-loaded images/content ─────────────
+                // ── 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.
                 if (auto_scroll !== false) {
                     await page.evaluate(async () => {
-                        await new Promise((resolve) => {
-                            let totalHeight = 0;
-                            const distance = 200;
+                        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 timer = setInterval(() => {
-                                const scrollHeight = document.body.scrollHeight;
-                                window.scrollBy(0, distance);
-                                totalHeight += distance;
-                                if (totalHeight >= scrollHeight) {
+                                const h = getHeight();
+                                window.scrollBy(0, step);
+                                y += step;
+                                if (y >= h) {
                                     clearInterval(timer);
                                     resolve();
                                 }
-                            }, 80);
+                            }, 60);
                         });
+                        // 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 scrollOnce();
+                            // Wait at the bottom for lazy content to trigger
+                            await new Promise(r => setTimeout(r, 800));
+                            const h = getHeight();
+                            if (h === lastHeight)
+                                break;
+                            lastHeight = h;
+                        }
+                        // Back to top for the capture
+                        window.scrollTo(0, 0);
                     });
-                    // Scroll back to top for the capture
-                    await page.evaluate(() => window.scrollTo(0, 0));
                 }
-                // ── Wait for all <img> tags to finish loading ──────────────────
+                // ── Force-load all <img> tags (including data-src / loading=lazy) ─
                 await page.evaluate(async () => {
+                    // Strip loading="lazy" so the browser loads everything eagerly
+                    document.querySelectorAll('img[loading="lazy"]').forEach((img) => {
+                        img.setAttribute("loading", "eager");
+                    });
+                    // Resolve data-src → src for libraries that defer loading
+                    document.querySelectorAll("img[data-src]").forEach((img) => {
+                        const ds = img.getAttribute("data-src");
+                        if (ds && !img.getAttribute("src"))
+                            img.setAttribute("src", ds);
+                    });
                     const images = Array.from(document.querySelectorAll("img"));
                     await Promise.all(images.map((img) => {
                         if (img.complete && img.naturalWidth > 0)
@@ -1119,39 +1147,65 @@ function createMcpServer(sites) {
                         return new Promise((resolve) => {
                             img.addEventListener("load", () => resolve(), { once: true });
                             img.addEventListener("error", () => resolve(), { once: true });
-                            // Safety timeout per image
                             setTimeout(() => resolve(), 5000);
                         });
                     }));
                 });
-                // Extra settle time for fonts, animations, videos
-                await new Promise(resolve => setTimeout(resolve, wait ?? 2000));
+                // Extra settle time for fonts, CSS animations, video posters
+                await new Promise(resolve => setTimeout(resolve, wait ?? 2500));
                 const fmt = format ?? "jpeg";
                 const baseOptions = { type: fmt, fullPage: !max_height && (full_page ?? true) };
                 if (max_height)
                     baseOptions.clip = { x: 0, y: 0, width: vpWidth, height: vpHeight };
-                // ── Adaptive quality: always fit under the MCP 1MB tool-result limit ──
+                // ── Adaptive capture: always fit under the MCP 1MB tool-result limit ──
                 // (base64 overhead ~33%, so raw buffer must be ≤ ~780KB)
                 const PREVIEW_LIMIT = 750 * 1024;
-                let buf;
+                let buf = Buffer.alloc(0);
                 let usedQuality = undefined;
+                let usedScale = 1;
+                const takeOne = async (q, scale) => {
+                    if (scale !== 1) {
+                        // Re-apply viewport with scale factor to shrink pixel dimensions
+                        await page.setViewport({ width: Math.round(vpWidth * scale), height: Math.round(vpHeight * scale), deviceScaleFactor: 1 });
+                        // Allow layout to reflow
+                        await new Promise(r => setTimeout(r, 500));
+                    }
+                    const opts = { ...baseOptions };
+                    if (q !== undefined)
+                        opts.quality = q;
+                    const raw = await page.screenshot(opts);
+                    return Buffer.isBuffer(raw) ? raw : Buffer.from(raw);
+                };
                 if (fmt === "jpeg") {
-                    // Try user-requested quality first; fall back progressively lower until it fits.
+                    // Stage 1: try full resolution, progressive quality
                     const q0 = quality ?? 82;
                     const qualitySteps = Array.from(new Set([q0, 70, 55, 40, 25, 15])).filter(q => q <= q0);
                     for (const q of qualitySteps) {
-                        const raw = await page.screenshot({ ...baseOptions, quality: q });
-                        buf = Buffer.isBuffer(raw) ? raw : Buffer.from(raw);
+                        buf = await takeOne(q, 1);
                         usedQuality = q;
                         if (buf.length <= PREVIEW_LIMIT)
                             break;
                     }
+                    // Stage 2: if still too big, shrink viewport width progressively
+                    const scaleSteps = [0.7, 0.5, 0.35, 0.25];
+                    for (const s of scaleSteps) {
+                        if (buf.length <= PREVIEW_LIMIT)
+                            break;
+                        buf = await takeOne(40, s);
+                        usedQuality = 40;
+                        usedScale = s;
+                        if (buf.length <= PREVIEW_LIMIT)
+                            break;
+                        // Inner quality drop at this scale
+                        buf = await takeOne(20, s);
+                        usedQuality = 20;
+                        if (buf.length <= PREVIEW_LIMIT)
+                            break;
+                    }
                 }
                 else {
-                    const raw = await page.screenshot(baseOptions);
-                    buf = Buffer.isBuffer(raw) ? raw : Buffer.from(raw);
+                    buf = await takeOne(undefined, 1);
                 }
-                buf = buf;
                 // ── 5. Save to disk ─────────────────────────────────────────────
                 const ext = fmt === "jpeg" ? "jpg" : "png";
                 const idPart = page_id ?? (pageUrl.replace(/https?:\/\//, "").replace(/[^a-z0-9]/gi, "_").slice(0, 40));
@@ -1161,7 +1215,7 @@ function createMcpServer(sites) {
                 const sizeKB = Math.round(buf.length / 1024);
                 const mimeType = `image/${fmt}`;
                 const qualityNote = usedQuality !== undefined && usedQuality !== (quality ?? 82)
-                    ? `  |  Auto-downscaled to quality ${usedQuality} to fit MCP limit`
+                    ? `  |  Auto-downscaled to quality ${usedQuality}${usedScale !== 1 ? ` @ ${Math.round(usedScale * 100)}% width` : ""} to fit MCP limit`
                     : "";
                 // ── 6. Always return the image so Claude can analyse it ──────
                 const content = [];

package/package.json

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