@screenshotscout/mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Oleksii Velykyi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,194 @@
+# Screenshot Scout MCP Server
+
+Use [Screenshot Scout](https://screenshotscout.com/) from an MCP client to capture
+HTTP or HTTPS webpages as images or PDFs.
+
+This server exposes one tool, `capture_screenshot`. It supports full-page and
+element captures, device and viewport controls, location selection, page
+interaction and blocking options, image sizing and quality, PDF layout, caching,
+temporary result URLs and eligible MCP image content.
+
+## What you need
+
+- A [Screenshot Scout account](https://screenshotscout.com/auth/signup) and an
+  access key from the [API keys page](https://screenshotscout.com/app/api-keys).
+- Node.js 22 or newer for npm/stdio installation. Claude Desktop's MCPB runtime
+  is bundled by Claude.
+- The optional secret key only when your selected API key requires signed
+  Screenshot Scout requests.
+
+Every capture uses your Screenshot Scout account and is subject to its plan,
+quota, and rate limits.
+
+## Local stdio with npm
+
+Start with this local stdio configuration:
+
+```json
+{
+  "mcpServers": {
+    "screenshotscout": {
+      "command": "npx",
+      "args": ["-y", "@screenshotscout/mcp"],
+      "env": {
+        "SCREENSHOTSCOUT_ACCESS_KEY": "YOUR_ACCESS_KEY"
+      }
+    }
+  }
+}
+```
+
+If the access key requires request signing, add the secret locally:
+
+```json
+"SCREENSHOTSCOUT_SECRET_KEY": "YOUR_SECRET_KEY"
+```
+
+Keep personal configuration files out of source control. Credentials are process
+environment values, not tool arguments. See
+[client-specific copy-paste configurations](examples/README.md) for Claude
+Desktop, Claude Code, Cursor, VS Code/GitHub Copilot, Devin, and Cline.
+
+### Run from a source checkout
+
+```sh
+npm ci
+npm run build
+```
+
+Point the client at the absolute path to `dist/stdio.js` with `node`, and provide
+the same environment variables shown above.
+
+## Claude Desktop MCPB
+
+To install the Claude Desktop extension:
+
+1. Download `screenshotscout-mcp-<version>.mcpb` from that version's GitHub
+   release.
+2. In Claude Desktop, open **Settings → Extensions → Advanced settings** and
+   choose **Install Extension…**.
+3. Select the downloaded file.
+4. Enter the required access key. Enter the secret key only for an API key that
+   requires signed requests.
+
+Claude Desktop treats both fields as sensitive settings. The `v0.1.0` MCPB
+supports Windows.
+
+## Hosted Streamable HTTP
+
+The hosted API-key endpoint is live at:
+
+```text
+https://mcp.screenshotscout.com/mcp/api-key
+```
+
+It is intended only for clients that can attach a static HTTP header:
+
+```text
+Authorization: Bearer YOUR_ACCESS_KEY
+```
+
+The endpoint accepts an access key only. Never send a Screenshot Scout secret
+key to it, and never put either key in the URL or a tool argument. Clients that
+cannot attach a static Bearer header cannot use this endpoint.
+
+API keys that require request signatures must instead use local stdio or MCPB,
+or use a dedicated unsigned access key for the hosted endpoint.
+
+## Tool: `capture_screenshot`
+
+`capture_screenshot` sends one capture request for the supplied URL and options.
+The target webpage is external, and its returned content must be treated as
+untrusted.
+
+### Inputs
+
+Only `url` is required. Captures use a 1280×720 viewport by default. When no
+format is specified, the tool returns JPEG at quality 60. `resultMode` defaults
+to `"auto"`.
+
+| Group                 | Inputs                                                                                                                                                                                       |
+| --------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Target and output     | `url`; `format` (`png`, `jpg`, `jpeg`, `webp`, `gif`, `tiff`, `pdf`); `resultMode` (`auto`, `url_only`)                                                                                      |
+| Location and viewport | `country` (two-letter country code), `device`, `deviceViewportWidth`, `deviceViewportHeight`, `colorScheme` (`auto`, `dark`, `light`), `fullPage`                                            |
+| Page preparation      | `blockCookieBanners`, `blockAds`, `blockChatWidgets`, `selector`, `hideSelectors`, `clickSelectors`                                                                                          |
+| Timing                | `waitUntil` (`load`, `domcontentloaded`, `networkidle0`, `networkidle2`), `delay` (0–30 seconds), `navigationTimeout` (5–90 seconds), `timeout` (1–240 seconds)                              |
+| Cache                 | `cache`, `cacheTtl` (14,400–2,592,000 seconds)                                                                                                                                               |
+| Output resizing       | `imageWidth`, `imageHeight` (1–8,192; available for images and PDFs)                                                                                                                         |
+| Image only            | `imageQuality` (0–100, JPEG/WebP only)                                                                                                                                                       |
+| PDF only              | `pdfPaperFormat` (`letter`, `legal`, `tabloid`, `a4`, `a3`, `content`), `pdfLandscape`, `pdfPrintBackground`, `pdfMargin`, per-side margin fields, `pdfScale` (greater than 0 and at most 3) |
+
+When both output dimensions are provided, their product cannot exceed 64,000,000
+pixels. PDF margins accept non-negative values in `px`, `in`, `mm`, or `cm`.
+`imageQuality` requires JPEG or WebP output, and PDF-only options require
+`format: "pdf"`.
+
+### Results
+
+- PNG, JPEG, WebP, and GIF may be included as MCP image content when
+  `resultMode` is `auto`, the MIME type is eligible, dimensions are known and at
+  most 8,000 pixels per side, raw data is at most 5 MiB, and the complete
+  serialized result fits the current 128,000-byte server limit.
+- A capture that is not eligible to embed remains successful and returns its
+  temporary URL plus an actionable omission reason.
+- TIFF is URL-only.
+- PDF bytes are never embedded. A PDF result includes safe text and structured
+  metadata, plus a resource link when Screenshot Scout provides a result URL.
+- `resultMode: "url_only"` omits image bytes for every format.
+
+MCP clients control whether returned image content or resource links are
+displayed or made available to a model.
+
+Structured metadata can include `screenshotUrl`, `screenshotUrlExpiresAt`,
+`cacheStatus`, `format`, `mimeType`, `imageWidth`, `imageHeight`,
+`inlineImageIncluded`, and `inlineImageOmissionReason`.
+
+Treat result URLs as sensitive, temporary links and respect their reported
+expiry.
+
+## Example prompts
+
+- “Capture `https://example.com` as a full-page PNG in dark mode. Return only a
+  URL.”
+- “Take a 1280×720 JPEG screenshot of `https://example.com/pricing`, block cookie
+  banners and ads, and use quality 80.”
+- “Create an A4 PDF of `https://example.com/report` with backgrounds enabled and
+  10 mm margins.”
+
+## Privacy and security
+
+The server sends the target URL and selected capture options to Screenshot Scout,
+which loads the target website. Review the
+[Screenshot Scout privacy policy](https://screenshotscout.com/privacy-policy)
+before capturing private or regulated material.
+
+- Do not capture pages you are not authorized to access.
+- Do not paste credentials into prompts, tool inputs, URLs, issue reports, or
+  logs.
+- Keep local access and secret keys in client-managed secret storage or private
+  environment configuration.
+- The local stdio server adds no telemetry. Application logging for the hosted
+  service is limited to request method, response status, duration, and sanitized
+  unexpected errors. It is designed not to include credentials, target URLs,
+  screenshot URLs, request or response content, or image bytes.
+- Review each target and capture request before allowing tool use. The tool is
+  open-world, consumes quota, and interacts with an external website.
+- Report vulnerabilities privately as described in [SECURITY.md](SECURITY.md).
+
+## Development
+
+```sh
+npm ci
+npm run format:check
+npm run lint
+npm run typecheck
+npm test
+npm run metadata:check
+npm run registry:validate
+npm run mcpb:validate
+npm run mcpb:pack
+```
+
+## License
+
+[MIT](LICENSE) © Oleksii Velykyi

package/SECURITY.md

@@ -0,0 +1,21 @@
+# Security Policy
+
+## Supported versions
+
+| Version | Supported |
+| ------- | --------- |
+| 0.1.x   | Yes       |
+
+## Reporting a vulnerability
+
+Email suspected vulnerabilities privately to
+[support@screenshotscout.com](mailto:support@screenshotscout.com). Do not open a
+public issue for an undisclosed vulnerability.
+
+Never include live Screenshot Scout access keys, secret keys, authorization
+headers, signatures, screenshot URLs, captured content, or other customer data
+in a report. Revoke any credential that may have been exposed and use clearly
+marked synthetic values in reproduction steps.
+
+Include the affected version or commit, the observed impact, and minimal
+reproduction details that do not contain secrets.

package/dist/core/capture-input.d.ts

@@ -0,0 +1,85 @@
+import { type BinaryCaptureOptions } from "@screenshotscout/sdk";
+import { z } from "zod";
+export declare const CAPTURE_FORMATS: readonly ["png", "jpg", "jpeg", "webp", "gif", "tiff", "pdf"];
+export declare const IMAGE_CAPTURE_FORMATS: readonly ["png", "jpg", "jpeg", "webp", "gif", "tiff"];
+export declare const CAPTURE_RESULT_MODES: readonly ["auto", "url_only"];
+/**
+ * The complete curated MCP input surface. Credentials and SDK-owned
+ * `responseType` controls are deliberately absent.
+ */
+export declare const captureScreenshotInputSchema: z.ZodObject<{
+    url: z.ZodString;
+    format: z.ZodDefault<z.ZodEnum<{
+        png: "png";
+        jpg: "jpg";
+        jpeg: "jpeg";
+        webp: "webp";
+        gif: "gif";
+        tiff: "tiff";
+        pdf: "pdf";
+    }>>;
+    country: z.ZodOptional<z.ZodString>;
+    device: z.ZodOptional<z.ZodString>;
+    deviceViewportWidth: z.ZodOptional<z.ZodNumber>;
+    deviceViewportHeight: z.ZodOptional<z.ZodNumber>;
+    colorScheme: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        dark: "dark";
+        light: "light";
+    }>>;
+    fullPage: z.ZodOptional<z.ZodBoolean>;
+    blockCookieBanners: z.ZodOptional<z.ZodBoolean>;
+    blockAds: z.ZodOptional<z.ZodBoolean>;
+    blockChatWidgets: z.ZodOptional<z.ZodBoolean>;
+    selector: z.ZodOptional<z.ZodString>;
+    hideSelectors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    clickSelectors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    waitUntil: z.ZodOptional<z.ZodEnum<{
+        load: "load";
+        domcontentloaded: "domcontentloaded";
+        networkidle0: "networkidle0";
+        networkidle2: "networkidle2";
+    }>>;
+    delay: z.ZodOptional<z.ZodNumber>;
+    navigationTimeout: z.ZodOptional<z.ZodNumber>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    cache: z.ZodOptional<z.ZodBoolean>;
+    cacheTtl: z.ZodOptional<z.ZodNumber>;
+    resultMode: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        url_only: "url_only";
+    }>>;
+    imageWidth: z.ZodOptional<z.ZodNumber>;
+    imageHeight: z.ZodOptional<z.ZodNumber>;
+    imageQuality: z.ZodOptional<z.ZodNumber>;
+    pdfPaperFormat: z.ZodOptional<z.ZodEnum<{
+        letter: "letter";
+        legal: "legal";
+        tabloid: "tabloid";
+        a4: "a4";
+        a3: "a3";
+        content: "content";
+    }>>;
+    pdfLandscape: z.ZodOptional<z.ZodBoolean>;
+    pdfPrintBackground: z.ZodOptional<z.ZodBoolean>;
+    pdfMargin: z.ZodOptional<z.ZodString>;
+    pdfMarginTop: z.ZodOptional<z.ZodString>;
+    pdfMarginRight: z.ZodOptional<z.ZodString>;
+    pdfMarginBottom: z.ZodOptional<z.ZodString>;
+    pdfMarginLeft: z.ZodOptional<z.ZodString>;
+    pdfScale: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type CaptureScreenshotInput = z.infer<typeof captureScreenshotInputSchema>;
+export type CaptureResultMode = CaptureScreenshotInput["resultMode"];
+export type MappedCaptureRequest = {
+    readonly targetUrl: string;
+    readonly resultMode: CaptureResultMode;
+    readonly captureOptions: Readonly<BinaryCaptureOptions>;
+};
+export declare function parseCaptureScreenshotInput(input: unknown): CaptureScreenshotInput;
+/**
+ * Applies MCP-owned image defaults, then maps the curated fields to the
+ * identically named SDK fields. The SDK remains solely responsible for request
+ * serialization.
+ */
+export declare function mapCaptureInputToSdk(input: CaptureScreenshotInput): MappedCaptureRequest;

package/dist/core/capture-input.js

@@ -0,0 +1,332 @@
+import { CaptureResponseType, } from "@screenshotscout/sdk";
+import { z } from "zod";
+export const CAPTURE_FORMATS = [
+    "png",
+    "jpg",
+    "jpeg",
+    "webp",
+    "gif",
+    "tiff",
+    "pdf",
+];
+export const IMAGE_CAPTURE_FORMATS = [
+    "png",
+    "jpg",
+    "jpeg",
+    "webp",
+    "gif",
+    "tiff",
+];
+export const CAPTURE_RESULT_MODES = ["auto", "url_only"];
+const DEFAULT_VIEWPORT_WIDTH = 1_280;
+const DEFAULT_VIEWPORT_HEIGHT = 720;
+const DEFAULT_JPEG_QUALITY = 60;
+const lossyImageFormatSet = new Set(["jpg", "jpeg", "webp"]);
+const pdfFieldNames = [
+    "pdfPaperFormat",
+    "pdfLandscape",
+    "pdfPrintBackground",
+    "pdfMargin",
+    "pdfMarginTop",
+    "pdfMarginRight",
+    "pdfMarginBottom",
+    "pdfMarginLeft",
+    "pdfScale",
+];
+const nonBlankStringSchema = z
+    .string()
+    .refine((value) => value.trim().length > 0, "Must not be blank.");
+const selectorListSchema = z
+    .array(nonBlankStringSchema)
+    .min(1, "Provide at least one non-blank selector.");
+const cssLengthSchema = z
+    .string()
+    .trim()
+    .regex(/^(?:[0-9]+(?:\.[0-9]+)?)(?:\s*(?:px|in|mm|cm))?$/i, "Must be a non-negative CSS length in px, in, mm, or cm.");
+const targetUrlSchema = z
+    .string()
+    .trim()
+    .min(1)
+    .max(8_192)
+    .refine((value) => {
+    try {
+        const parsed = new URL(value);
+        return ((parsed.protocol === "http:" || parsed.protocol === "https:") &&
+            parsed.hostname.length > 0);
+    }
+    catch {
+        return false;
+    }
+}, "Must be a valid HTTP or HTTPS URL.");
+/**
+ * The complete curated MCP input surface. Credentials and SDK-owned
+ * `responseType` controls are deliberately absent.
+ */
+export const captureScreenshotInputSchema = z
+    .object({
+    url: targetUrlSchema.describe("HTTP or HTTPS page URL to capture."),
+    format: z
+        .enum(CAPTURE_FORMATS)
+        .default("jpeg")
+        .describe("Output image or document format. Defaults to JPEG."),
+    country: z
+        .string()
+        .trim()
+        .regex(/^[A-Za-z]{2}$/, "Use a two-letter ISO 3166-1 country code.")
+        .optional()
+        .describe("Two-letter country code for the capture location."),
+    device: nonBlankStringSchema
+        .optional()
+        .describe("Screenshot Scout device preset name."),
+    deviceViewportWidth: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe("Viewport width override in CSS pixels. Captures use a 1280×720 viewport when no device or viewport dimension is supplied."),
+    deviceViewportHeight: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe("Viewport height override in CSS pixels. Captures use a 1280×720 viewport when no device or viewport dimension is supplied."),
+    colorScheme: z
+        .enum(["auto", "dark", "light"])
+        .optional()
+        .describe("Preferred page color scheme."),
+    fullPage: z
+        .boolean()
+        .optional()
+        .describe("Capture the full scrollable page when true."),
+    blockCookieBanners: z
+        .boolean()
+        .optional()
+        .describe("Attempt to block common cookie banners."),
+    blockAds: z
+        .boolean()
+        .optional()
+        .describe("Attempt to block advertisements."),
+    blockChatWidgets: z
+        .boolean()
+        .optional()
+        .describe("Attempt to block common chat widgets."),
+    selector: nonBlankStringSchema
+        .optional()
+        .describe("CSS selector for an element-only capture."),
+    hideSelectors: selectorListSchema
+        .optional()
+        .describe("CSS selectors for elements to hide before capture."),
+    clickSelectors: selectorListSchema
+        .optional()
+        .describe("CSS selectors for elements to click before capture."),
+    waitUntil: z
+        .enum(["load", "domcontentloaded", "networkidle0", "networkidle2"])
+        .optional()
+        .describe("Page lifecycle event to await before capture."),
+    delay: z
+        .number()
+        .int()
+        .min(0)
+        .max(30)
+        .optional()
+        .describe("Additional delay before capture, in seconds."),
+    navigationTimeout: z
+        .number()
+        .int()
+        .min(5)
+        .max(90)
+        .optional()
+        .describe("Page navigation timeout, in seconds."),
+    timeout: z
+        .number()
+        .int()
+        .min(1)
+        .max(240)
+        .optional()
+        .describe("Overall capture timeout, in seconds."),
+    cache: z
+        .boolean()
+        .optional()
+        .describe("Allow Screenshot Scout result caching."),
+    cacheTtl: z
+        .number()
+        .int()
+        .min(14_400)
+        .max(2_592_000)
+        .optional()
+        .describe("Cache lifetime in seconds."),
+    resultMode: z
+        .enum(CAPTURE_RESULT_MODES)
+        .default("auto")
+        .describe("Use auto for eligible inline images or url_only to omit inline bytes."),
+    imageWidth: z
+        .number()
+        .int()
+        .min(1)
+        .max(8_192)
+        .optional()
+        .describe("Resize the captured content to this width in pixels before creating the image or PDF."),
+    imageHeight: z
+        .number()
+        .int()
+        .min(1)
+        .max(8_192)
+        .optional()
+        .describe("Resize the captured content to this height in pixels before creating the image or PDF."),
+    imageQuality: z
+        .number()
+        .int()
+        .min(0)
+        .max(100)
+        .optional()
+        .describe("JPEG or WebP output quality from 0 to 100. JPEG uses quality 60 when omitted."),
+    pdfPaperFormat: z
+        .enum(["letter", "legal", "tabloid", "a4", "a3", "content"])
+        .optional()
+        .describe("PDF paper size; requires format pdf."),
+    pdfLandscape: z
+        .boolean()
+        .optional()
+        .describe("Use landscape PDF orientation."),
+    pdfPrintBackground: z
+        .boolean()
+        .optional()
+        .describe("Include CSS backgrounds in PDF output."),
+    pdfMargin: cssLengthSchema
+        .optional()
+        .describe("PDF margin applied to all sides."),
+    pdfMarginTop: cssLengthSchema.optional().describe("PDF top margin."),
+    pdfMarginRight: cssLengthSchema.optional().describe("PDF right margin."),
+    pdfMarginBottom: cssLengthSchema.optional().describe("PDF bottom margin."),
+    pdfMarginLeft: cssLengthSchema.optional().describe("PDF left margin."),
+    pdfScale: z
+        .number()
+        .positive()
+        .max(3)
+        .optional()
+        .describe("PDF rendering scale greater than 0 and at most 3."),
+})
+    .strict()
+    .superRefine((input, context) => {
+    if (input.format !== "pdf") {
+        for (const field of pdfFieldNames) {
+            if (input[field] !== undefined) {
+                context.addIssue({
+                    code: "custom",
+                    path: [field],
+                    message: `${field} requires format "pdf".`,
+                });
+            }
+        }
+    }
+    if (input.imageQuality !== undefined &&
+        !lossyImageFormatSet.has(input.format)) {
+        context.addIssue({
+            code: "custom",
+            path: ["imageQuality"],
+            message: 'imageQuality requires format "jpg", "jpeg", or "webp".',
+        });
+    }
+    if (input.imageWidth !== undefined &&
+        input.imageHeight !== undefined &&
+        input.imageWidth * input.imageHeight > 64_000_000) {
+        context.addIssue({
+            code: "custom",
+            path: ["imageHeight"],
+            message: "imageWidth multiplied by imageHeight must not exceed 64,000,000 pixels.",
+        });
+    }
+});
+export function parseCaptureScreenshotInput(input) {
+    return captureScreenshotInputSchema.parse(input);
+}
+/**
+ * Applies MCP-owned image defaults, then maps the curated fields to the
+ * identically named SDK fields. The SDK remains solely responsible for request
+ * serialization.
+ */
+export function mapCaptureInputToSdk(input) {
+    const hideSelectors = input.hideSelectors === undefined
+        ? undefined
+        : Object.freeze([...input.hideSelectors]);
+    const clickSelectors = input.clickSelectors === undefined
+        ? undefined
+        : Object.freeze([...input.clickSelectors]);
+    const useDefaultViewport = input.device === undefined &&
+        input.deviceViewportWidth === undefined &&
+        input.deviceViewportHeight === undefined;
+    const useDefaultJpegQuality = (input.format === "jpg" || input.format === "jpeg") &&
+        input.imageQuality === undefined;
+    const deviceViewportWidth = useDefaultViewport
+        ? DEFAULT_VIEWPORT_WIDTH
+        : input.deviceViewportWidth;
+    const deviceViewportHeight = useDefaultViewport
+        ? DEFAULT_VIEWPORT_HEIGHT
+        : input.deviceViewportHeight;
+    const imageQuality = useDefaultJpegQuality
+        ? DEFAULT_JPEG_QUALITY
+        : input.imageQuality;
+    const captureOptions = {
+        format: input.format,
+        responseType: CaptureResponseType.BINARY,
+        ...(input.country === undefined ? {} : { country: input.country }),
+        ...(input.device === undefined ? {} : { device: input.device }),
+        ...(deviceViewportWidth === undefined ? {} : { deviceViewportWidth }),
+        ...(deviceViewportHeight === undefined ? {} : { deviceViewportHeight }),
+        ...(input.colorScheme === undefined
+            ? {}
+            : { colorScheme: input.colorScheme }),
+        ...(input.fullPage === undefined ? {} : { fullPage: input.fullPage }),
+        ...(input.blockCookieBanners === undefined
+            ? {}
+            : { blockCookieBanners: input.blockCookieBanners }),
+        ...(input.blockAds === undefined ? {} : { blockAds: input.blockAds }),
+        ...(input.blockChatWidgets === undefined
+            ? {}
+            : { blockChatWidgets: input.blockChatWidgets }),
+        ...(input.selector === undefined ? {} : { selector: input.selector }),
+        ...(hideSelectors === undefined ? {} : { hideSelectors }),
+        ...(clickSelectors === undefined ? {} : { clickSelectors }),
+        ...(input.waitUntil === undefined ? {} : { waitUntil: input.waitUntil }),
+        ...(input.delay === undefined ? {} : { delay: input.delay }),
+        ...(input.navigationTimeout === undefined
+            ? {}
+            : { navigationTimeout: input.navigationTimeout }),
+        ...(input.timeout === undefined ? {} : { timeout: input.timeout }),
+        ...(input.cache === undefined ? {} : { cache: input.cache }),
+        ...(input.cacheTtl === undefined ? {} : { cacheTtl: input.cacheTtl }),
+        ...(input.imageWidth === undefined ? {} : { imageWidth: input.imageWidth }),
+        ...(input.imageHeight === undefined
+            ? {}
+            : { imageHeight: input.imageHeight }),
+        ...(imageQuality === undefined ? {} : { imageQuality }),
+        ...(input.pdfPaperFormat === undefined
+            ? {}
+            : { pdfPaperFormat: input.pdfPaperFormat }),
+        ...(input.pdfLandscape === undefined
+            ? {}
+            : { pdfLandscape: input.pdfLandscape }),
+        ...(input.pdfPrintBackground === undefined
+            ? {}
+            : { pdfPrintBackground: input.pdfPrintBackground }),
+        ...(input.pdfMargin === undefined ? {} : { pdfMargin: input.pdfMargin }),
+        ...(input.pdfMarginTop === undefined
+            ? {}
+            : { pdfMarginTop: input.pdfMarginTop }),
+        ...(input.pdfMarginRight === undefined
+            ? {}
+            : { pdfMarginRight: input.pdfMarginRight }),
+        ...(input.pdfMarginBottom === undefined
+            ? {}
+            : { pdfMarginBottom: input.pdfMarginBottom }),
+        ...(input.pdfMarginLeft === undefined
+            ? {}
+            : { pdfMarginLeft: input.pdfMarginLeft }),
+        ...(input.pdfScale === undefined ? {} : { pdfScale: input.pdfScale }),
+    };
+    return Object.freeze({
+        targetUrl: input.url,
+        resultMode: input.resultMode,
+        captureOptions: Object.freeze(captureOptions),
+    });
+}

package/dist/core/capture-tool.d.ts

@@ -0,0 +1,25 @@
+import type { McpServer, RegisteredTool } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { type CaptureScreenshotInput } from "./capture-input.js";
+import type { ScreenshotScoutCaptureClient } from "./client.js";
+import { type InlineImageMimeType } from "./image.js";
+import type { RedactedDiagnostic } from "./redaction.js";
+export type CaptureScreenshotToolDependencies = {
+    readonly client: ScreenshotScoutCaptureClient;
+    readonly clientSupportsInlineImage?: (mimeType: InlineImageMimeType) => boolean;
+    readonly maxSerializedResultBytes?: number;
+    readonly sensitiveValues?: readonly (string | null | undefined)[];
+    readonly onUnexpectedError?: (diagnostic: RedactedDiagnostic) => void;
+};
+export type CaptureScreenshotInvocationContext = {
+    readonly signal?: AbortSignal;
+};
+/**
+ * Invokes the official Screenshot Scout SDK after MCP schema validation.
+ * Result-content branching remains in the shared result layer.
+ */
+export declare function invokeCaptureScreenshot(input: CaptureScreenshotInput, dependencies: CaptureScreenshotToolDependencies, context?: CaptureScreenshotInvocationContext): Promise<CallToolResult>;
+/**
+ * Registers the one approved tool on a transport-neutral MCP server.
+ */
+export declare function registerCaptureScreenshotTool(server: McpServer, dependencies: CaptureScreenshotToolDependencies): RegisteredTool;