@browserstack/mcp-server 2.2.1-beta.1 → 2.2.2

package/dist/lib/feedback-hint.d.ts

@@ -0,0 +1,4 @@
+export declare const FEEDBACK_INSTRUCTION = "If a BrowserStack tool cannot do what the user needs, call submitFeedback before giving up or working around it.";
+export declare const FEEDBACK_HINT = "If this blocks the user's task, report it with submitFeedback.";
+export declare const NO_HINT_TOOLS: ReadonlySet<string>;
+export declare function withFeedbackHint<T>(toolName: string, result: T): T;

package/dist/lib/feedback-hint.js

@@ -0,0 +1,30 @@
+export const FEEDBACK_INSTRUCTION = "If a BrowserStack tool cannot do what the user needs, call submitFeedback before giving up or working around it.";
+export const FEEDBACK_HINT = "If this blocks the user's task, report it with submitFeedback.";
+const SELF_FIXABLE = /\b(400|401|403|404|422)\b|unauthori[sz]ed|forbidden|not found|invalid|required|must be|validation/i;
+function textOf(result) {
+    if (!Array.isArray(result.content))
+        return "";
+    return result.content
+        .map((part) => typeof part?.text === "string"
+        ? part.text
+        : "")
+        .join(" ");
+}
+export const NO_HINT_TOOLS = new Set([
+    "submitFeedback",
+    "createAccessibilityAuthConfig",
+    "getAccessibilityAuthConfig",
+]);
+export function withFeedbackHint(toolName, result) {
+    if (NO_HINT_TOOLS.has(toolName))
+        return result;
+    const r = result;
+    if (typeof r !== "object" || r === null || r.isError !== true)
+        return result;
+    if (!Array.isArray(r.content) || SELF_FIXABLE.test(textOf(r)))
+        return result;
+    return {
+        ...r,
+        content: [...r.content, { type: "text", text: FEEDBACK_HINT }],
+    };
+}

package/dist/lib/tool-latency.js

@@ -1,4 +1,5 @@
 import { withToolCall } from "./instrumentation.js";
+import { withFeedbackHint } from "./feedback-hint.js";
 const WRAPPED = Symbol.for("browserstack.mcp.latencyWrapped");
 /** Wraps every function handler in `withToolCall`. Idempotent; skips task-style handlers. */
 export function instrumentToolLatency(tools, getClientInfo, config) {
@@ -8,7 +9,7 @@ export function instrumentToolLatency(tools, getClientInfo, config) {
             continue;
         if (inner[WRAPPED])
             continue;
-        const wrapped = (...args) => withToolCall(name, getClientInfo, config, () => inner(...args));
+        const wrapped = (...args) => withToolCall(name, getClientInfo, config, () => inner(...args)).then((result) => withFeedbackHint(name, result));
         wrapped[WRAPPED] = true;
         // Direct assignment: tool.update() would also fire tools/list_changed.
         tool.handler = wrapped;

package/dist/server-factory.js

@@ -20,6 +20,8 @@ import addAskBrowserStackAITool from "./tools/ask-browserstack/register.js";
 import addCapabilityRegistryTools from "./tools/capability-registry/register.js";
 import { instrumentToolLatency } from "./lib/tool-latency.js";
 import { nodeUpgradeNotice } from "./lib/node-version-notice.js";
+import { FEEDBACK_INSTRUCTION } from "./lib/feedback-hint.js";
+import addFeedbackTools from "./tools/feedback.js";
 /**
  * Wrapper class for BrowserStack MCP Server
  * Stores a map of registered tools by name
@@ -34,7 +36,11 @@ export class BrowserStackMcpServer {
         this.server = new McpServer({
             name: "BrowserStack MCP Server",
             version: packageJson.version,
-        }, { instructions: nodeUpgradeNotice() || undefined });
+        }, {
+            instructions: [nodeUpgradeNotice(), FEEDBACK_INSTRUCTION]
+                .filter(Boolean)
+                .join("\n"),
+        });
         setupOnInitialized(this.server, this.config);
         this.registerTools();
     }
@@ -63,6 +69,7 @@ export class BrowserStackMcpServer {
             // nothing (and logs why) when the artifact is absent, so a packaging problem cannot
             // take the other products' tools down with it.
             addCapabilityRegistryTools,
+            addFeedbackTools,
         ];
         toolAdders.forEach((adder) => {
             // Each adder now returns a Record<string, Tool>

package/dist/tools/capability-registry/redact.d.ts

@@ -24,11 +24,13 @@
  */
 export declare const MAX_LENGTH = 512;
 /**
- * Returns the text with shape-identifiable PII replaced, capped at `MAX_LENGTH`.
+ * Returns the text with shape-identifiable PII replaced, capped at `maxLength`.
  *
  * FAILS CLOSED: any throw returns undefined, so the caller records no field rather than
  * the raw value. Non-string and empty input yields undefined for the same reason.
  */
-export declare function redact(text: unknown): string | undefined;
+export declare function redact(text: unknown, maxLength?: number): string | undefined;
 /** The rule names, for documenting what is covered. */
 export declare const REDACTED_TYPES: string[];
+export declare const FEEDBACK_REDACTED_TYPES: string[];
+export declare function redactFeedback(text: unknown, maxLength?: number): string | undefined;

package/dist/tools/capability-registry/redact.js

@@ -72,17 +72,17 @@ const RULES = [
  */
 export const MAX_LENGTH = 512;
 /**
- * Returns the text with shape-identifiable PII replaced, capped at `MAX_LENGTH`.
+ * Returns the text with shape-identifiable PII replaced, capped at `maxLength`.
  *
  * FAILS CLOSED: any throw returns undefined, so the caller records no field rather than
  * the raw value. Non-string and empty input yields undefined for the same reason.
  */
-export function redact(text) {
+export function redact(text, maxLength = MAX_LENGTH) {
     try {
         if (typeof text !== "string")
             return undefined;
         // Slice before the rules run; a multi-KB digit run makes them backtrack.
-        const SCAN_LIMIT = MAX_LENGTH * 8;
+        const SCAN_LIMIT = maxLength * 8;
         let out = text.slice(0, SCAN_LIMIT).replace(/\s+/g, " ").trim();
         if (!out)
             return undefined;
@@ -90,7 +90,7 @@ export function redact(text) {
             out = out.replace(rule.pattern, rule.replacement);
         // Truncate AFTER redacting, so a value that would have been replaced cannot be split
         // across the boundary and leave its first half in the clear.
-        return out.length > MAX_LENGTH ? `${out.slice(0, MAX_LENGTH)}…` : out;
+        return out.length > maxLength ? `${out.slice(0, maxLength)}…` : out;
     }
     catch {
         return undefined;
@@ -98,3 +98,44 @@ export function redact(text) {
 }
 /** The rule names, for documenting what is covered. */
 export const REDACTED_TYPES = RULES.map((r) => r.name);
+const BARE_SECRET_LABEL = /^(password|passwd|pwd|passphrase|bearer)$/i;
+const FEEDBACK_RULES = [
+    {
+        name: "labelled_secret",
+        pattern: /\b(password|passwd|pwd|passphrase|bearer|secret|token|api[_-]?key|access[_-]?key|client[_-]?secret|auth[_-]?token|session[_-]?id)(\s*[:=]\s*|\s+)("[^"]*"|'[^']*'|\S+)/gi,
+        replacement: (match, label, sep, value) => {
+            const explicit = /[:=]/.test(sep);
+            const bare = BARE_SECRET_LABEL.test(label) && /[\d!@#$%^&*_+~]/.test(value);
+            return explicit || bare ? `${label}${sep}[secret]` : match;
+        },
+    },
+    {
+        name: "card",
+        pattern: /\b\d(?:[ -]?\d){12,18}\b/g,
+        replacement: "[card]",
+    },
+    {
+        name: "otp",
+        pattern: /\b(otp|pin|passcode|(?<!(?:status|error|exit|response|http)\s)code)(\s*[:=]?\s*)\d{4,8}\b/gi,
+        replacement: "$1$2[code]",
+    },
+    {
+        name: "url_query",
+        pattern: /\b(https?:\/\/[^\s?#]+)[?#]\S*/gi,
+        replacement: "$1?[query]",
+    },
+];
+export const FEEDBACK_REDACTED_TYPES = FEEDBACK_RULES.map((r) => r.name);
+export function redactFeedback(text, maxLength = MAX_LENGTH) {
+    try {
+        if (typeof text !== "string")
+            return undefined;
+        let out = text.slice(0, maxLength * 8);
+        for (const rule of FEEDBACK_RULES)
+            out = out.replace(rule.pattern, rule.replacement);
+        return redact(out, maxLength);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/tools/feedback.d.ts

@@ -0,0 +1,18 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { BrowserStackConfig } from "../lib/types.js";
+export declare const FEEDBACK_TOOL = "submitFeedback";
+export declare const FEEDBACK_LIMITS: {
+    readonly message: 2000;
+    readonly intent: 300;
+    readonly toolName: 100;
+};
+export declare const FEEDBACK_CATEGORIES: readonly ["missing_capability", "tool_error", "unclear_response", "positive", "other"];
+export declare const FEEDBACK_ACK = "Recorded. No need to mention this report; continue with the user's task.";
+export declare function submitFeedback(args: {
+    message: string;
+    category: (typeof FEEDBACK_CATEGORIES)[number];
+    toolName?: string;
+    intent?: string;
+}, server: McpServer, config: BrowserStackConfig): CallToolResult;
+export default function addFeedbackTools(server: McpServer, config: BrowserStackConfig): Record<string, any>;

package/dist/tools/feedback.js

@@ -0,0 +1,61 @@
+import { z } from "zod";
+import { trackMCP } from "../lib/instrumentation.js";
+import { redactFeedback } from "./capability-registry/redact.js";
+export const FEEDBACK_TOOL = "submitFeedback";
+export const FEEDBACK_LIMITS = {
+    message: 2000,
+    intent: 300,
+    toolName: 100,
+};
+export const FEEDBACK_CATEGORIES = [
+    "missing_capability",
+    "tool_error",
+    "unclear_response",
+    "positive",
+    "other",
+];
+export const FEEDBACK_ACK = "Recorded. No need to mention this report; continue with the user's task.";
+export function submitFeedback(args, server, config) {
+    trackMCP(FEEDBACK_TOOL, server.server.getClientVersion(), undefined, config, {
+        feedback_category: args.category,
+        feedback_message: redactFeedback(args.message, FEEDBACK_LIMITS.message),
+        feedback_tool: redactFeedback(args.toolName, FEEDBACK_LIMITS.toolName),
+        feedback_intent: redactFeedback(args.intent, FEEDBACK_LIMITS.intent),
+    });
+    return { content: [{ type: "text", text: FEEDBACK_ACK }] };
+}
+export default function addFeedbackTools(server, config) {
+    const tools = {};
+    tools.submitFeedback = server.tool(FEEDBACK_TOOL, "Report a blocker, tool error, missing capability, or user feedback to BrowserStack. Never include PII or credentials.", {
+        message: z
+            .string()
+            .min(10)
+            .max(FEEDBACK_LIMITS.message)
+            .describe("What you tried, what happened, what you expected"),
+        category: z.enum(FEEDBACK_CATEGORIES).describe("Kind of report"),
+        toolName: z
+            .string()
+            .max(FEEDBACK_LIMITS.toolName)
+            .optional()
+            .describe("Tool the report is about, if any"),
+        intent: z
+            .string()
+            .max(FEEDBACK_LIMITS.intent)
+            .optional()
+            .describe("What the user was trying to achieve"),
+    }, async (args) => {
+        try {
+            return submitFeedback(args, server, config);
+        }
+        catch (error) {
+            trackMCP(FEEDBACK_TOOL, server.server.getClientVersion(), error, config);
+            return {
+                content: [
+                    { type: "text", text: `Failed to submit feedback: ${error}` },
+                ],
+                isError: true,
+            };
+        }
+    });
+    return tools;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@browserstack/mcp-server",
-  "version": "2.2.1-beta.1",
+  "version": "2.2.2",
   "description": "BrowserStack's Official MCP Server",
   "mcpName": "io.github.browserstack/mcp-server",
   "main": "dist/index.js",