* Added scrollable container detection (findMainScrollableContainer) for dashboard layouts, and simplified the API by removing iframeUid parameter—iframes are now auto-detected when uid + fullPage are used together.

* Adding test coverage for scrollable containers, local iframes (auto-detection), and cross-origin iframe fallback behavior.

Author: absarasw

src/tools/screenshot.ts

@@ -438,13 +438,7 @@ export const screenshot = defineTool({
       .boolean()
       .optional()
       .describe(
-        'If set to true takes a screenshot of the full page instead of the currently visible viewport. Incompatible with uid unless iframeUid is also provided.',
-      ),
-    iframeUid: zod
-      .string()
-      .optional()
-      .describe(
-        'The uid of an iframe element. When used with fullPage=true, captures the full scrollable content of the iframe by temporarily expanding it.',
+        'If set to true takes a screenshot of the full page instead of the currently visible viewport. When used with uid pointing to an iframe element, captures the full scrollable content of the iframe.',
       ),
     filePath: zod
       .string()
@@ -454,38 +448,36 @@ export const screenshot = defineTool({
       ),
   },
   handler: async (request, response, context) => {
-    const {uid, fullPage, iframeUid} = request.params;
-
-    // Validate parameter combinations
-    if (uid && fullPage && !iframeUid) {
-      throw new Error('Providing both "uid" and "fullPage" is not allowed.');
-    }
-    if (uid && iframeUid) {
-      throw new Error('Providing both "uid" and "iframeUid" is not allowed.');
-    }
-    if (iframeUid && !fullPage) {
-      throw new Error(
-        'iframeUid requires fullPage=true to capture the full iframe content.',
-      );
-    }
+    const {uid, fullPage} = request.params;
 
     const format = request.params.format;
     const quality = format === 'png' ? undefined : request.params.quality;
 
     let screenshot: Uint8Array;
     let responseMessage: string;
 
-    if (iframeUid && fullPage) {
-      // Full-page screenshot of iframe content (explicit iframe specified)
-      const iframeHandle = await context.getElementByUid(iframeUid);
+    if (uid && fullPage) {
+      // Check if uid points to an iframe element
+      const handle = await context.getElementByUid(uid);
       try {
-        screenshot = await takeIframeFullPageScreenshot(iframeHandle, {
-          type: format,
-          quality,
-        });
-        responseMessage = `Took a full-page screenshot of iframe with uid "${iframeUid}".`;
+        const isIframe = await handle.evaluate(
+          el => el.tagName.toLowerCase() === 'iframe',
+        );
+
+        if (isIframe) {
+          // Full-page screenshot of iframe content
+          screenshot = await takeIframeFullPageScreenshot(handle, {
+            type: format,
+            quality,
+          });
+          responseMessage = `Took a full-page screenshot of iframe with uid "${uid}".`;
+        } else {
+          throw new Error(
+            'Providing both "uid" and "fullPage" is only allowed when uid points to an iframe element.',
+          );
+        }
       } finally {
-        void iframeHandle.dispose();
+        void handle.dispose();
       }
     } else if (uid) {
       // Screenshot of a specific element

tests/snapshot.ts

@@ -18,4 +18,46 @@ export const screenshots: Record<string, ScreenshotData> = {
   button: {
     html: '<button>I am button click me</button>',
   },
+  scrollableContainer: {
+    html: `
+      <style>
+        body { margin: 0; height: 100vh; display: flex; flex-direction: column; }
+        .header { height: 60px; background: #333; color: white; flex-shrink: 0; }
+        .content { flex: 1; overflow: auto; }
+        .inner { height: 2000px; background: linear-gradient(to bottom, #f0f0f0, #333); }
+      </style>
+      <div class="header">Fixed Header</div>
+      <div class="content" id="scrollable-content">
+        <div class="inner">
+          <p>Top of scrollable content</p>
+          <p style="position: absolute; top: 1900px;">Bottom of scrollable content</p>
+        </div>
+      </div>
+    `,
+  },
+  localIframe: {
+    html: `
+      <style>
+        body { margin: 0; }
+        iframe { width: 100%; height: 400px; border: none; }
+      </style>
+      <iframe id="local-iframe" srcdoc="
+        <style>body { margin: 0; }</style>
+        <div style='height: 1500px; background: linear-gradient(to bottom, #e0e0ff, #3030ff);'>
+          <p>Top of iframe content</p>
+          <p style='position: absolute; top: 1400px;'>Bottom of iframe content</p>
+        </div>
+      "></iframe>
+    `,
+  },
+  crossOriginIframe: {
+    html: `
+      <style>
+        body { margin: 0; }
+        iframe { width: 100%; height: 400px; border: 1px solid #ccc; }
+      </style>
+      <div>Page with cross-origin iframe</div>
+      <iframe id="cross-origin-iframe" src="https://example.com"></iframe>
+    `,
+  },
 };

tests/tools/screenshot.test.ts

@@ -260,5 +260,141 @@ describe('screenshot', () => {
         );
       });
     });
+
+    describe('scrollable container', () => {
+      it('detects and captures full content of scrollable container', async () => {
+        await withMcpContext(async (response, context) => {
+          const fixture = screenshots.scrollableContainer;
+          const page = context.getSelectedPage();
+          await page.setContent(fixture.html);
+
+          await screenshot.handler(
+            {params: {format: 'png', fullPage: true}},
+            response,
+            context,
+          );
+
+          assert.equal(response.images.length, 1);
+          assert.equal(response.images[0].mimeType, 'image/png');
+          assert.equal(
+            response.responseLines.at(0),
+            'Took a full-page screenshot of the main scrollable container.',
+          );
+        });
+      });
+    });
+
+    describe('local iframe', () => {
+      it('auto-detects iframe from uid with fullPage', async () => {
+        await withMcpContext(async (response, context) => {
+          const fixture = screenshots.localIframe;
+          const page = context.getSelectedPage();
+          await page.setContent(fixture.html);
+
+          // Wait for iframe to load
+          await page.waitForSelector('iframe');
+          await new Promise(resolve => setTimeout(resolve, 100));
+
+          await context.createTextSnapshot();
+          // Get the iframe uid from the snapshot
+          const iframeUid = await page.evaluate(() => {
+            const iframe = document.querySelector('iframe');
+            return iframe?.getAttribute('data-elements-snapshot-uid') || '1_1';
+          });
+
+          await screenshot.handler(
+            {
+              params: {
+                format: 'png',
+                fullPage: true,
+                uid: iframeUid,
+              },
+            },
+            response,
+            context,
+          );
+
+          assert.equal(response.images.length, 1);
+          assert.equal(response.images[0].mimeType, 'image/png');
+          assert.ok(
+            response.responseLines.at(0)?.includes('full-page screenshot of iframe'),
+          );
+        });
+      });
+
+      it('captures full iframe content when auto-detected', async () => {
+        await withMcpContext(async (response, context) => {
+          const fixture = screenshots.localIframe;
+          const page = context.getSelectedPage();
+          await page.setContent(fixture.html);
+
+          // Wait for iframe to load
+          await page.waitForSelector('iframe');
+          await new Promise(resolve => setTimeout(resolve, 100));
+
+          await screenshot.handler(
+            {params: {format: 'png', fullPage: true}},
+            response,
+            context,
+          );
+
+          assert.equal(response.images.length, 1);
+          assert.equal(response.images[0].mimeType, 'image/png');
+          assert.equal(
+            response.responseLines.at(0),
+            'Took a full-page screenshot of the main content iframe.',
+          );
+        });
+      });
+
+      it('rejects uid + fullPage for non-iframe elements', async () => {
+        await withMcpContext(async (response, context) => {
+          const fixture = screenshots.button;
+          const page = context.getSelectedPage();
+          await page.setContent(fixture.html);
+          await context.createTextSnapshot();
+
+          await assert.rejects(
+            screenshot.handler(
+              {
+                params: {
+                  format: 'png',
+                  fullPage: true,
+                  uid: '1_1', // Points to button, not iframe
+                },
+              },
+              response,
+              context,
+            ),
+            /only allowed when uid points to an iframe element/,
+          );
+        });
+      });
+    });
+
+    describe('cross-origin iframe', () => {
+      it('falls back to regular screenshot when iframe is not accessible', async () => {
+        await withMcpContext(async (response, context) => {
+          const fixture = screenshots.crossOriginIframe;
+          const page = context.getSelectedPage();
+          await page.setContent(fixture.html);
+
+          // Cross-origin iframes cannot be accessed, so fullPage should fall back
+          await screenshot.handler(
+            {params: {format: 'png', fullPage: true}},
+            response,
+            context,
+          );
+
+          assert.equal(response.images.length, 1);
+          assert.equal(response.images[0].mimeType, 'image/png');
+          // Should fall back to regular full page screenshot
+          assert.equal(
+            response.responseLines.at(0),
+            'Took a screenshot of the full current page.',
+          );
+        });
+      });
+    });
   });
 });