@browserstack/mcp-server 1.2.14 → 1.2.15-beta.2

package/dist/tools/percy-mcp/v2/manage-insights-email.js

@@ -0,0 +1,49 @@
+import { percyGet, percyPost, percyPatch, } from "../../../lib/percy-api/percy-auth.js";
+export async function percyManageInsightsEmail(args, config) {
+    const action = args.action || "get";
+    if (action === "get") {
+        const response = await percyGet(`/organizations/${args.org_id}/insights-email-settings`, config);
+        const data = response?.data?.attributes || {};
+        let output = `## Insights Email Settings\n\n`;
+        output += `**Enabled:** ${data["is-enabled"] ?? data.isEnabled ?? "unknown"}\n`;
+        output += `**Recipients:** ${(data.emails || []).join(", ") || "none"}\n`;
+        return { content: [{ type: "text", text: output }] };
+    }
+    if (action === "create" || action === "update") {
+        const emailList = args.emails
+            ? args.emails.split(",").map((e) => e.trim())
+            : [];
+        const body = {
+            data: {
+                type: "insights-email-settings",
+                attributes: {
+                    emails: emailList,
+                    "is-enabled": args.enabled !== false,
+                },
+            },
+        };
+        if (action === "create") {
+            await percyPost(`/organizations/${args.org_id}/insights-email-settings`, config, body);
+        }
+        else {
+            await percyPatch(`/insights-email-settings/${args.org_id}`, config, body);
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Insights email ${action}d. Recipients: ${emailList.join(", ")}`,
+                },
+            ],
+        };
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Unknown action: ${action}. Use get, create, or update.`,
+            },
+        ],
+        isError: true,
+    };
+}

package/dist/tools/percy-mcp/v2/manage-usage-alerts.d.ts

@@ -0,0 +1,10 @@
+import { BrowserStackConfig } from "../../../lib/types.js";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+export declare function percyManageUsageAlerts(args: {
+    org_id: string;
+    action?: string;
+    threshold?: number;
+    emails?: string;
+    enabled?: boolean;
+    product?: string;
+}, config: BrowserStackConfig): Promise<CallToolResult>;

package/dist/tools/percy-mcp/v2/manage-usage-alerts.js

@@ -0,0 +1,43 @@
+import { percyGet, percyPost, percyPatch, } from "../../../lib/percy-api/percy-auth.js";
+export async function percyManageUsageAlerts(args, config) {
+    const action = args.action || "get";
+    if (action === "get") {
+        const response = await percyGet(`/organizations/${args.org_id}/usage_notification_settings`, config, {
+            "data[attributes][type]": args.product || "web",
+        });
+        const data = response?.data?.attributes || {};
+        let output = `## Usage Alert Settings\n\n`;
+        output += `**Enabled:** ${data["is-enabled"] ?? "unknown"}\n`;
+        output += `**Thresholds:** ${JSON.stringify(data.thresholds || {})}\n`;
+        output += `**Emails:** ${(data.emails || []).join(", ") || "none"}\n`;
+        return { content: [{ type: "text", text: output }] };
+    }
+    const emailList = args.emails
+        ? args.emails.split(",").map((e) => e.trim())
+        : [];
+    const body = {
+        data: {
+            type: "usage-notification-settings",
+            attributes: {
+                type: args.product || "web",
+                "is-enabled": args.enabled !== false,
+                thresholds: args.threshold ? { "snapshot-count": args.threshold } : {},
+                emails: emailList,
+            },
+        },
+    };
+    if (action === "create") {
+        await percyPost(`/organization/${args.org_id}/usage-notification-settings`, config, body);
+    }
+    else {
+        await percyPatch(`/usage-notification-settings/${args.org_id}`, config, body);
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Usage alerts ${action}d. Threshold: ${args.threshold || "default"}`,
+            },
+        ],
+    };
+}

package/dist/tools/percy-mcp/v2/migrate-integrations.d.ts

@@ -0,0 +1,6 @@
+import { BrowserStackConfig } from "../../../lib/types.js";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+export declare function percyMigrateIntegrations(args: {
+    source_org_id: string;
+    target_org_id: string;
+}, config: BrowserStackConfig): Promise<CallToolResult>;

package/dist/tools/percy-mcp/v2/migrate-integrations.js

@@ -0,0 +1,20 @@
+import { percyPost } from "../../../lib/percy-api/percy-auth.js";
+export async function percyMigrateIntegrations(args, config) {
+    await percyPost("/integration-migrations/migrate", config, {
+        data: {
+            type: "integration-migrations",
+            attributes: {
+                "source-organization-id": args.source_org_id,
+                "target-organization-id": args.target_org_id,
+            },
+        },
+    });
+    return {
+        content: [
+            {
+                type: "text",
+                text: `## Integration Migration\n\nIntegrations migrated from org ${args.source_org_id} to ${args.target_org_id}.`,
+            },
+        ],
+    };
+}

package/dist/tools/percy-mcp/v2/preview-comparison.d.ts

@@ -0,0 +1,5 @@
+import { BrowserStackConfig } from "../../../lib/types.js";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+export declare function percyPreviewComparison(args: {
+    comparison_id: string;
+}, config: BrowserStackConfig): Promise<CallToolResult>;

package/dist/tools/percy-mcp/v2/preview-comparison.js

@@ -0,0 +1,17 @@
+import { percyPost } from "../../../lib/percy-api/percy-auth.js";
+export async function percyPreviewComparison(args, config) {
+    await percyPost("/comparison-previews", config, {
+        data: {
+            type: "comparison-previews",
+            attributes: { "comparison-id": args.comparison_id },
+        },
+    });
+    return {
+        content: [
+            {
+                type: "text",
+                text: `## Comparison Preview\n\nRecomputation triggered for comparison ${args.comparison_id}.\nThe diff will be re-processed with current AI and region settings.\nRefresh the build in Percy to see updated results.`,
+            },
+        ],
+    };
+}

package/dist/tools/percy-mcp/v2/search-build-items.d.ts

@@ -0,0 +1,12 @@
+import { BrowserStackConfig } from "../../../lib/types.js";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+export declare function percySearchBuildItems(args: {
+    build_id: string;
+    category?: string;
+    browser_ids?: string;
+    widths?: string;
+    os?: string;
+    device_name?: string;
+    sort_by?: string;
+    limit?: number;
+}, config: BrowserStackConfig): Promise<CallToolResult>;

package/dist/tools/percy-mcp/v2/search-build-items.js

@@ -0,0 +1,45 @@
+import { percyGet } from "../../../lib/percy-api/percy-auth.js";
+export async function percySearchBuildItems(args, config) {
+    const params = { "filter[build-id]": args.build_id };
+    if (args.category)
+        params["filter[category]"] = args.category;
+    if (args.sort_by)
+        params["filter[sort_by]"] = args.sort_by;
+    if (args.limit)
+        params["page[limit]"] = String(args.limit);
+    // Array filters
+    if (args.browser_ids)
+        args.browser_ids.split(",").forEach((id) => {
+            params[`filter[browser_ids][]`] = id.trim();
+        });
+    if (args.widths)
+        args.widths.split(",").forEach((w) => {
+            params[`filter[widths][]`] = w.trim();
+        });
+    if (args.os)
+        params["filter[os]"] = args.os;
+    if (args.device_name)
+        params["filter[device_name]"] = args.device_name;
+    const response = await percyGet("/build-items", config, params);
+    const items = response?.data || [];
+    if (!items.length) {
+        return {
+            content: [
+                { type: "text", text: "No items match the specified filters." },
+            ],
+        };
+    }
+    let output = `## Build Items (${items.length})\n\n`;
+    output += `| # | Name | Diff | Review | Items |\n|---|---|---|---|---|\n`;
+    items.forEach((item, i) => {
+        const attrs = item.attributes || item;
+        const name = attrs.coverSnapshotName || attrs["cover-snapshot-name"] || "?";
+        const diff = attrs.maxDiffRatio != null
+            ? `${(attrs.maxDiffRatio * 100).toFixed(1)}%`
+            : "—";
+        const review = attrs.reviewState || attrs["review-state"] || "?";
+        const count = attrs.itemCount || attrs["item-count"] || 1;
+        output += `| ${i + 1} | ${name} | ${diff} | ${review} | ${count} |\n`;
+    });
+    return { content: [{ type: "text", text: output }] };
+}

package/dist/tools/percy-mcp/workflows/auto-triage.d.ts

@@ -0,0 +1,7 @@
+import { BrowserStackConfig } from "../../../lib/types.js";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+export declare function percyAutoTriage(args: {
+    build_id: string;
+    noise_threshold?: number;
+    review_threshold?: number;
+}, config: BrowserStackConfig): Promise<CallToolResult>;

package/dist/tools/percy-mcp/workflows/auto-triage.js

@@ -0,0 +1,82 @@
+import { PercyClient } from "../../../lib/percy-api/client.js";
+export async function percyAutoTriage(args, config) {
+    const client = new PercyClient(config);
+    const noiseThreshold = args.noise_threshold ?? 0.005; // 0.5%
+    const reviewThreshold = args.review_threshold ?? 0.15; // 15%
+    // Get all changed build items (limit to 90 = 3 pages max)
+    const items = await client.get("/build-items", {
+        "filter[build-id]": args.build_id,
+        "filter[category]": "changed",
+        "page[limit]": "30",
+    });
+    const itemList = Array.isArray(items) ? items : [];
+    const critical = [];
+    const reviewRequired = [];
+    const autoApprovable = [];
+    const noise = [];
+    for (const item of itemList) {
+        const name = item.name || item.snapshotName || "Unknown";
+        const diffRatio = item.diffRatio ?? item.maxDiffRatio ?? 0;
+        const potentialBugs = item.totalPotentialBugs || 0;
+        const aiIgnored = item.aiDiffRatio !== undefined && item.aiDiffRatio === 0 && diffRatio > 0;
+        const entry = { name, diffRatio, potentialBugs };
+        if (potentialBugs > 0) {
+            critical.push(entry);
+        }
+        else if (aiIgnored) {
+            autoApprovable.push({ ...entry, reason: "AI-filtered (IntelliIgnore)" });
+        }
+        else if (diffRatio > reviewThreshold) {
+            reviewRequired.push(entry);
+        }
+        else if (diffRatio <= noiseThreshold) {
+            noise.push(entry);
+        }
+        else {
+            autoApprovable.push({ ...entry, reason: "Low diff ratio" });
+        }
+    }
+    let output = `## Auto-Triage — Build #${args.build_id}\n\n`;
+    output += `**Total changed:** ${itemList.length} | `;
+    output += `Critical: ${critical.length} | Review: ${reviewRequired.length} | `;
+    output += `Auto-approvable: ${autoApprovable.length} | Noise: ${noise.length}\n\n`;
+    if (critical.length > 0) {
+        output += `### CRITICAL — Potential Bugs (${critical.length})\n`;
+        critical.forEach((e, i) => {
+            output += `${i + 1}. **${e.name}** — ${(e.diffRatio * 100).toFixed(1)}% diff, ${e.potentialBugs} bug(s)\n`;
+        });
+        output += "\n";
+    }
+    if (reviewRequired.length > 0) {
+        output += `### REVIEW REQUIRED (${reviewRequired.length})\n`;
+        reviewRequired.forEach((e, i) => {
+            output += `${i + 1}. **${e.name}** — ${(e.diffRatio * 100).toFixed(1)}% diff\n`;
+        });
+        output += "\n";
+    }
+    if (autoApprovable.length > 0) {
+        output += `### AUTO-APPROVABLE (${autoApprovable.length})\n`;
+        autoApprovable.forEach((e, i) => {
+            output += `${i + 1}. ${e.name} — ${e.reason}\n`;
+        });
+        output += "\n";
+    }
+    if (noise.length > 0) {
+        output += `### NOISE (${noise.length})\n`;
+        output += noise.map((e) => e.name).join(", ") + "\n\n";
+    }
+    output += `### Recommended Action\n\n`;
+    if (critical.length > 0) {
+        output += `Investigate ${critical.length} critical item(s) before approving.\n`;
+    }
+    else if (reviewRequired.length > 0) {
+        output += `Review ${reviewRequired.length} item(s) manually. ${autoApprovable.length + noise.length} can be auto-approved.\n`;
+    }
+    else {
+        output += `All changes are auto-approvable or noise. Safe to approve.\n`;
+    }
+    if (itemList.length >= 30) {
+        output += `\n> Note: Results limited to first 30 changed snapshots. Build may have more.\n`;
+    }
+    return { content: [{ type: "text", text: output }] };
+}

package/dist/tools/percy-mcp/workflows/clone-build.d.ts

@@ -0,0 +1,22 @@
+/**
+ * percy_clone_build — Clone snapshots from a source build to a new build,
+ * even across different projects.
+ *
+ * Flow:
+ * 1. Read build-items to get snapshot IDs
+ * 2. For each snapshot: fetch raw JSON:API with includes to get image URLs
+ * 3. Create target build + snapshots + comparisons with downloaded screenshots
+ * 4. Finalize
+ */
+import { BrowserStackConfig } from "../../../lib/types.js";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+interface CloneBuildArgs {
+    source_build_id: string;
+    source_token?: string;
+    target_project_name: string;
+    target_token?: string;
+    branch?: string;
+    commit_sha?: string;
+}
+export declare function percyCloneBuild(args: CloneBuildArgs, config: BrowserStackConfig): Promise<CallToolResult>;
+export {};