@flusterduck/mcp-server 0.5.2 → 0.5.4

package/dist/chunk-UDB3HZEI.js

@@ -1,733 +0,0 @@
-// src/index.ts
-import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z } from "zod";
-
-// src/api-client.ts
-var MACHINE_KEY_PATTERN = /^fd_(sec|mcp)_[A-Za-z0-9_-]{48}$/;
-var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-function assertMachineKey(value) {
-  const key = value.trim();
-  if (!MACHINE_KEY_PATTERN.test(key)) {
-    throw new Error("Invalid API key format. Expected a high-entropy fd_sec_ or fd_mcp_ key.");
-  }
-  return key;
-}
-function assertUuid(value, name) {
-  if (!UUID_PATTERN.test(value)) throw new Error(`${name} must be a UUID.`);
-  return value;
-}
-function buildQueryUrl(config, route, params = {}) {
-  const base = assertSafeApiBase(config.baseUrl);
-  const url = new URL(route.replace(/^\/+/, ""), base);
-  url.searchParams.set("site_id", assertUuid(config.siteId, "site_id"));
-  for (const [key, value] of Object.entries(params)) {
-    if (value === void 0 || value === null || value === "") continue;
-    url.searchParams.set(key, String(value));
-  }
-  return url;
-}
-function assertSafeApiBase(baseUrl) {
-  const base = new URL(baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`);
-  if (base.protocol !== "https:" && !["localhost", "127.0.0.1", "[::1]"].includes(base.hostname)) {
-    throw new Error("HTTP is only allowed for local Flusterduck API testing.");
-  }
-  return base;
-}
-var FlusterduckAPI = class {
-  config;
-  constructor(config) {
-    this.config = {
-      baseUrl: config.baseUrl,
-      apiKey: assertMachineKey(config.apiKey),
-      siteId: assertUuid(config.siteId, "site_id"),
-      orgId: config.orgId ? assertUuid(config.orgId, "org_id") : void 0
-    };
-  }
-  getContext() {
-    return this.request("query/mcp/context");
-  }
-  getScores() {
-    return this.request("query/scores");
-  }
-  getPageDetail(page) {
-    return this.request("query/page", { page });
-  }
-  getAlerts(status) {
-    return this.request("query/alerts", { status });
-  }
-  getIssues(status) {
-    return this.request("query/issues", { status });
-  }
-  getElements(page) {
-    return this.request("query/elements", { page });
-  }
-  getSessionDetail(sessionId) {
-    return this.request("query/session", { session_id: sessionId });
-  }
-  getFlows(limit) {
-    return this.request("query/flows", { limit });
-  }
-  getTrends(days = 7, page) {
-    const safeDays = Math.max(1, Math.min(Math.trunc(Number(days) || 7), 90));
-    return this.request("query/trends", { days: safeDays, page });
-  }
-  getDeployImpact() {
-    return this.request("query/deploys");
-  }
-  getRecommendations() {
-    return this.request("query/recommendations");
-  }
-  compare(a, b) {
-    return this.request("query/compare", { a, b });
-  }
-  getRevenueImpact() {
-    return this.request("query/revenue");
-  }
-  getHeuristics() {
-    return this.request("query/heuristics");
-  }
-  getJourneyFriction(params = {}) {
-    return this.request("query/journeys/friction", params);
-  }
-  queryRawRows(params) {
-    return this.request("query/raw", params);
-  }
-  downloadEventsCsv(params = {}) {
-    return this.requestText("query/export/events.csv", params, "text/csv");
-  }
-  getAuditLog(limit = 100) {
-    if (!this.config.orgId) throw new Error("orgId is required for audit log queries.");
-    return this.request("query/audit", { org_id: this.config.orgId, limit }, false);
-  }
-  getDegradation() {
-    if (!this.config.orgId) throw new Error("orgId is required for degradation queries.");
-    return this.request("query/degradation", { org_id: this.config.orgId }, false);
-  }
-  getWebhookDeliveries(limit = 100) {
-    if (!this.config.orgId) throw new Error("orgId is required for webhook delivery queries.");
-    return this.request("query/webhook-deliveries", { org_id: this.config.orgId, limit }, false);
-  }
-  getIssueDetail(issueId) {
-    return this.request(`query/issues/${assertUuid(issueId, "issue_id")}`, {});
-  }
-  getAlertRules() {
-    return this.request("manage/alert-rules", {});
-  }
-  updateAlertRule(ruleId, update) {
-    return this.mutate("PATCH", `manage/alert-rules/${assertUuid(ruleId, "rule_id")}`, update);
-  }
-  updateIssue(issueId, update) {
-    return this.mutate("PATCH", `manage/issues/${assertUuid(issueId, "issue_id")}`, update);
-  }
-  updateAlert(alertId, status, resolvedReason) {
-    const body = { status };
-    if (resolvedReason) body.resolved_reason = resolvedReason;
-    return this.mutate("PATCH", `manage/alerts/${assertUuid(alertId, "alert_id")}`, body);
-  }
-  addAnnotation(message) {
-    return this.mutate("POST", "manage/annotations", {
-      site_id: this.config.siteId,
-      message,
-      type: "mcp"
-    });
-  }
-  createAlertRule(rule) {
-    return this.mutate("POST", "manage/alert-rules", {
-      site_id: this.config.siteId,
-      ...rule
-    });
-  }
-  deleteAlertRule(ruleId) {
-    return this.mutate("DELETE", `manage/alert-rules/${assertUuid(ruleId, "rule_id")}`);
-  }
-  async mutate(method, route, body) {
-    const base = assertSafeApiBase(this.config.baseUrl);
-    const url = new URL(route.replace(/^\/+/, ""), base);
-    const response = await fetch(url, {
-      method,
-      headers: {
-        authorization: `Bearer ${this.config.apiKey}`,
-        "content-type": "application/json",
-        accept: "application/json"
-      },
-      body: body !== void 0 ? JSON.stringify(body) : void 0
-    });
-    let envelope;
-    try {
-      envelope = await response.json();
-    } catch {
-      throw new Error(`Flusterduck API returned non-JSON response (${response.status}).`);
-    }
-    if (!response.ok || envelope.error) {
-      const status = envelope.error?.status ?? response.status;
-      const code = envelope.error?.code ?? "unknown";
-      const message = envelope.error?.message ?? "Flusterduck API request failed.";
-      throw new Error(`Flusterduck API error (${status}: ${code}): ${message}`);
-    }
-    return envelope.data;
-  }
-  async request(route, params = {}, includeSiteId = true) {
-    const url = includeSiteId ? buildQueryUrl(this.config, route, params) : buildOrgUrl(this.config, route, params);
-    const response = await fetch(url, {
-      headers: {
-        authorization: `Bearer ${this.config.apiKey}`,
-        accept: "application/json"
-      }
-    });
-    let envelope;
-    try {
-      envelope = await response.json();
-    } catch {
-      throw new Error(`Flusterduck API returned non-JSON response (${response.status}).`);
-    }
-    if (!response.ok || envelope.error) {
-      const status = envelope.error?.status ?? response.status;
-      const code = envelope.error?.code ?? "unknown";
-      throw new Error(`Flusterduck API request failed (${status}: ${code}).`);
-    }
-    return envelope.data;
-  }
-  async requestText(route, params = {}, accept = "text/plain") {
-    const url = buildQueryUrl(this.config, route, params);
-    const response = await fetch(url, {
-      headers: {
-        authorization: `Bearer ${this.config.apiKey}`,
-        accept
-      }
-    });
-    const text = await response.text();
-    if (!response.ok) {
-      throw new Error(`Flusterduck API request failed (${response.status}).`);
-    }
-    return text;
-  }
-};
-function buildOrgUrl(config, route, params) {
-  const base = assertSafeApiBase(config.baseUrl);
-  const url = new URL(route.replace(/^\/+/, ""), base);
-  for (const [key, value] of Object.entries(params)) {
-    if (value === void 0 || value === null || value === "") continue;
-    url.searchParams.set(key, String(value));
-  }
-  return url;
-}
-
-// src/index.ts
-function jsonText(data) {
-  return JSON.stringify(data, null, 2);
-}
-function toolResult(data) {
-  return { content: [{ type: "text", text: jsonText(data) }] };
-}
-function toolError(error) {
-  const message = error instanceof Error ? error.message : "Unknown Flusterduck MCP error.";
-  return { isError: true, content: [{ type: "text", text: message }] };
-}
-function createFlusterduckMCPServer(config) {
-  const api = new FlusterduckAPI(config);
-  const server = new McpServer({ name: "flusterduck-local", version: "0.3.0" });
-  const readOnly = { readOnlyHint: true, destructiveHint: false, openWorldHint: true };
-  const writeHint = { readOnlyHint: false, destructiveHint: false, openWorldHint: true };
-  const mutateHint = { readOnlyHint: false, destructiveHint: true, openWorldHint: true };
-  const deleteHint = { readOnlyHint: false, destructiveHint: true, openWorldHint: true };
-  const rawTable = z.enum(["events", "signals", "sessions", "page_scores", "score_history", "ux_issues", "alerts", "deploys"]);
-  const sortDir = z.enum(["asc", "desc"]).optional();
-  const rawFilters = {
-    page: z.string().min(1).max(500).optional(),
-    since: z.string().datetime().optional(),
-    until: z.string().datetime().optional(),
-    event_type: z.string().min(1).max(80).optional(),
-    signal_type: z.string().min(1).max(80).optional(),
-    status: z.string().min(1).max(80).optional(),
-    session_id: z.string().min(16).max(128).optional()
-  };
-  server.tool("get_site_context", "Get the full Flusterduck MCP snapshot for the configured site: scores, open issues, active alerts, deploys, and recommendations. Start here for any investigation.", {}, readOnly, async () => {
-    try {
-      return toolResult(await api.getContext());
-    } catch (error) {
-      return toolError(error);
-    }
-  });
-  server.tool("get_scores", "Get current confusion scores for every tracked page, sorted by friction intensity.", {}, readOnly, async () => {
-    try {
-      return toolResult(await api.getScores());
-    } catch (error) {
-      return toolError(error);
-    }
-  });
-  server.tool("get_page", "Get the full context for one page: score history, active issues, element friction, deploys, annotations, and confusion budgets.", {
-    page: z.string().min(1).max(500)
-  }, readOnly, async ({ page }) => {
-    try {
-      return toolResult(await api.getPageDetail(page));
-    } catch (error) {
-      return toolError(error);
-    }
-  });
-  server.tool("get_elements", "Get element-level friction summaries: which buttons, forms, and links generate the most behavioral signals.", {
-    page: z.string().min(1).max(500).optional()
-  }, readOnly, async ({ page }) => {
-    try {
-      return toolResult(await api.getElements(page));
-    } catch (error) {
-      return toolError(error);
-    }
-  });
-  server.tool("get_issues", "Get UX issues for the configured site. Filter by status to focus on what needs attention.", {
-    status: z.enum(["open", "triaged", "in_progress", "ignored", "resolved", "regressed"]).optional()
-  }, readOnly, async ({ status }) => {
-    try {
-      return toolResult(await api.getIssues(status));
-    } catch (error) {
-      return toolError(error);
-    }
-  });
-  server.tool("get_issue", "Get a single UX issue with full evidence, session links, verification history, and deploy correlation. Use this after get_issues to drill into a specific issue.", {
-    issue_id: z.string().uuid()
-  }, readOnly, async ({ issue_id }) => {
-    try {
-      return toolResult(await api.getIssueDetail(issue_id));
-    } catch (error) {
-      return toolError(error);
-    }
-  });
-  server.tool("get_alerts", "Get alerts for the configured site. Filter by status to see what is firing vs already resolved.", {
-    status: z.enum(["open", "acknowledged", "resolved"]).optional()
-  }, readOnly, async ({ status }) => {
-    try {
-      return toolResult(await api.getAlerts(status));
-    } catch (error) {
-      return toolError(error);
-    }
-  });
-  server.tool(
-    "list_alert_rules",
-    "List all alert rules configured for the site: trigger types, thresholds, channels, and enabled status. Call this before create_alert_rule or delete_alert_rule to see what already exists. Requires manage:write scope on the API key.",
-    {},
-    readOnly,
-    async () => {
-      try {
-        return toolResult(await api.getAlertRules());
-      } catch (error) {
-        return toolError(error);
-      }
-    }
-  );
-  server.tool("get_session_detail", "Get the full event timeline for a specific session: every signal, click, scroll, and page view in order.", {
-    session_id: z.string().min(16).max(128)
-  }, readOnly, async ({ session_id }) => {
-    try {
-      return toolResult(await api.getSessionDetail(session_id));
-    } catch (error) {
-      return toolError(error);
-    }
-  });
-  server.tool("get_flows", "Get page-to-page flow edges from recent sessions, showing where users come from and where they go.", {
-    limit: z.number().int().min(1).max(5e3).optional()
-  }, readOnly, async ({ limit }) => {
-    try {
-      return toolResult(await api.getFlows(limit));
-    } catch (error) {
-      return toolError(error);
-    }
-  });
-  server.tool("get_trends", "Get confusion score history for the configured site or a specific page. Use to spot regressions after deploys.", {
-    days: z.number().int().min(1).max(90).optional(),
-    page: z.string().min(1).max(500).optional()
-  }, readOnly, async ({ days, page }) => {
-    try {
-      return toolResult(await api.getTrends(days, page));
-    } catch (error) {
-      return toolError(error);
-    }
-  });
-  server.tool("get_deploys", "Get deploys known to Flusterduck for this site, including confusion_before/after scores for each.", {}, readOnly, async () => {
-    try {
-      return toolResult(await api.getDeployImpact());
-    } catch (error) {
-      return toolError(error);
-    }
-  });
-  server.tool("compare_pages", "Compare confusion score records side-by-side for two page paths.", {
-    a: z.string().min(1).max(500),
-    b: z.string().min(1).max(500)
-  }, readOnly, async ({ a, b }) => {
-    try {
-      return toolResult(await api.compare(a, b));
-    } catch (error) {
-      return toolError(error);
-    }
-  });
-  server.tool("get_recommendations", "Get prioritized fix recommendations ranked by estimated confusion reduction.", {}, readOnly, async () => {
-    try {
-      return toolResult(await api.getRecommendations());
-    } catch (error) {
-      return toolError(error);
-    }
-  });
-  server.tool("get_revenue_impact", "Get revenue impact estimates for active friction when conversion data is connected.", {}, readOnly, async () => {
-    try {
-      return toolResult(await api.getRevenueImpact());
-    } catch (error) {
-      return toolError(error);
-    }
-  });
-  server.tool("get_heuristics", "Get the full Flusterduck friction heuristic catalog: all signal types, thresholds, and scoring weights.", {}, readOnly, async () => {
-    try {
-      return toolResult(await api.getHeuristics());
-    } catch (error) {
-      return toolError(error);
-    }
-  });
-  server.tool("diagnose_journey_friction", "Find high-friction journey edges from recent sessions. Filter by signal type or minimum friction weight to focus on the worst paths.", {
-    journey_id: z.string().uuid().optional(),
-    signal_type: z.string().min(1).max(80).optional(),
-    min_friction_weight: z.number().int().min(0).max(1e3).optional(),
-    limit: z.number().int().min(1).max(1e3).optional()
-  }, readOnly, async ({ journey_id, signal_type, min_friction_weight, limit }) => {
-    try {
-      return toolResult(await api.getJourneyFriction({ journey_id, signal_type, min_friction_weight, limit }));
-    } catch (error) {
-      return toolError(error);
-    }
-  });
-  server.tool("query_raw_rows", "Get SQL-style raw rows from an allowlisted Flusterduck table, scoped to the configured site.", {
-    table: rawTable,
-    limit: z.number().int().min(1).max(1e3).optional(),
-    sort_by: z.string().min(1).max(80).optional(),
-    sort_dir: sortDir,
-    ...rawFilters
-  }, readOnly, async ({ table, limit, sort_by, sort_dir, page, since, until, event_type, signal_type, status, session_id }) => {
-    try {
-      return toolResult(await api.queryRawRows({ table, limit, sort_by, sort_dir, page, since, until, event_type, signal_type, status, session_id }));
-    } catch (error) {
-      return toolError(error);
-    }
-  });
-  server.tool("download_events_csv", "Return a CSV export of raw event rows for the configured site. Save the returned text as a .csv file.", {
-    limit: z.number().int().min(1).max(1e4).optional(),
-    sort_by: z.string().min(1).max(80).optional(),
-    sort_dir: sortDir,
-    page: z.string().min(1).max(500).optional(),
-    since: z.string().datetime().optional(),
-    until: z.string().datetime().optional(),
-    event_type: z.string().min(1).max(80).optional(),
-    signal_type: z.string().min(1).max(80).optional(),
-    session_id: z.string().min(16).max(128).optional()
-  }, readOnly, async ({ limit, sort_by, sort_dir, page, since, until, event_type, signal_type, session_id }) => {
-    try {
-      return { content: [{ type: "text", text: await api.downloadEventsCsv({ limit, sort_by, sort_dir, page, since, until, event_type, signal_type, session_id }) }] };
-    } catch (error) {
-      return toolError(error);
-    }
-  });
-  server.tool("get_audit_log", "Get organization audit log rows. Requires orgId in local MCP config.", {
-    limit: z.number().int().min(1).max(500).optional()
-  }, readOnly, async ({ limit }) => {
-    try {
-      return toolResult(await api.getAuditLog(limit));
-    } catch (error) {
-      return toolError(error);
-    }
-  });
-  server.tool("get_degradation", "Get active and recent backend degradation events. Requires orgId in local MCP config.", {}, readOnly, async () => {
-    try {
-      return toolResult(await api.getDegradation());
-    } catch (error) {
-      return toolError(error);
-    }
-  });
-  server.tool("get_webhook_deliveries", "Get outbound webhook delivery attempts and failure details. Requires orgId in local MCP config.", {
-    limit: z.number().int().min(1).max(500).optional()
-  }, readOnly, async ({ limit }) => {
-    try {
-      return toolResult(await api.getWebhookDeliveries(limit));
-    } catch (error) {
-      return toolError(error);
-    }
-  });
-  server.tool(
-    "update_issue",
-    "Update a UX issue: change its status (open/triaged/in_progress/verified/resolved/ignored), add a triage note, or set an assignee. Resolving or ignoring removes the issue from active triage views. Requires manage:write scope on the API key.",
-    {
-      issue_id: z.string().uuid(),
-      status: z.enum(["open", "triaged", "in_progress", "verified", "resolved", "ignored"]).optional(),
-      note: z.string().max(1e3).nullable().optional(),
-      assigned_to: z.string().max(256).nullable().optional()
-    },
-    mutateHint,
-    async ({ issue_id, status, note, assigned_to }) => {
-      try {
-        return toolResult(await api.updateIssue(issue_id, { status, note, assigned_to }));
-      } catch (error) {
-        return toolError(error);
-      }
-    }
-  );
-  server.tool(
-    "update_alert",
-    "Acknowledge, mark as investigating, or resolve an alert. Resolving stops all channel delivery including PagerDuty. Optionally include a resolved_reason when closing. Requires manage:write scope on the API key.",
-    {
-      alert_id: z.string().uuid(),
-      status: z.enum(["acknowledged", "investigating", "resolved"]),
-      resolved_reason: z.string().max(500).optional()
-    },
-    mutateHint,
-    async ({ alert_id, status, resolved_reason }) => {
-      try {
-        return toolResult(await api.updateAlert(alert_id, status, resolved_reason));
-      } catch (error) {
-        return toolError(error);
-      }
-    }
-  );
-  server.tool(
-    "add_annotation",
-    "Add a timeline annotation to the site to mark deploys, investigation findings, resolved incidents, or any notable event for the team. Requires manage:write scope on the API key.",
-    {
-      message: z.string().min(1).max(1e3)
-    },
-    writeHint,
-    async ({ message }) => {
-      try {
-        return toolResult(await api.addAnnotation(message));
-      } catch (error) {
-        return toolError(error);
-      }
-    }
-  );
-  server.tool(
-    "create_alert_rule",
-    "Create a new alert rule. Trigger types: spike, anomaly, new_page, trend, co_occurrence, positive, budget. Channels: email, slack, webhook, mcp, pagerduty. Requires manage:write scope on the API key.",
-    {
-      name: z.string().min(1).max(120),
-      trigger_type: z.enum(["spike", "anomaly", "new_page", "trend", "co_occurrence", "positive", "budget"]),
-      threshold: z.number().min(0).max(1e3).optional(),
-      cooldown_minutes: z.number().int().min(1).max(1440).optional(),
-      channels: z.array(z.enum(["email", "slack", "webhook", "mcp", "pagerduty"])).optional(),
-      page_pattern: z.string().max(2048).nullable().optional(),
-      enabled: z.boolean().optional()
-    },
-    writeHint,
-    async ({ name, trigger_type, threshold, cooldown_minutes, channels, page_pattern, enabled }) => {
-      try {
-        return toolResult(await api.createAlertRule({ name, trigger_type, threshold, cooldown_minutes, channels, page_pattern, enabled }));
-      } catch (error) {
-        return toolError(error);
-      }
-    }
-  );
-  server.tool(
-    "update_alert_rule",
-    "Update an existing alert rule: toggle enabled, change threshold, adjust channels, rename, or update page_pattern. Prefer this over delete_alert_rule when you want to temporarily silence a rule. Requires manage:write scope on the API key.",
-    {
-      rule_id: z.string().uuid(),
-      name: z.string().min(1).max(120).optional(),
-      trigger_type: z.enum(["spike", "anomaly", "new_page", "trend", "co_occurrence", "positive", "budget"]).optional(),
-      threshold: z.number().min(0).max(1e3).optional(),
-      cooldown_minutes: z.number().int().min(1).max(1440).optional(),
-      channels: z.array(z.enum(["email", "slack", "webhook", "mcp", "pagerduty"])).optional(),
-      page_pattern: z.string().max(2048).nullable().optional(),
-      enabled: z.boolean().optional()
-    },
-    writeHint,
-    async ({ rule_id, name, trigger_type, threshold, cooldown_minutes, channels, page_pattern, enabled }) => {
-      try {
-        return toolResult(await api.updateAlertRule(rule_id, { name, trigger_type, threshold, cooldown_minutes, channels, page_pattern, enabled }));
-      } catch (error) {
-        return toolError(error);
-      }
-    }
-  );
-  server.tool(
-    "delete_alert_rule",
-    "Permanently delete an alert rule by ID. This cannot be undone. Requires manage:write scope on the API key.",
-    {
-      rule_id: z.string().uuid()
-    },
-    deleteHint,
-    async ({ rule_id }) => {
-      try {
-        return toolResult(await api.deleteAlertRule(rule_id));
-      } catch (error) {
-        return toolError(error);
-      }
-    }
-  );
-  server.resource("current_site_context", "flusterduck://site/context", { description: "Current Flusterduck site context" }, async (uri) => ({
-    contents: [{ uri: uri.href, mimeType: "application/json", text: jsonText(await api.getContext()) }]
-  }));
-  server.resource("page", new ResourceTemplate("flusterduck://page/{path}", { list: void 0 }), { description: "Detailed page context" }, async (uri, variables) => ({
-    contents: [{ uri: uri.href, mimeType: "application/json", text: jsonText(await api.getPageDetail(String(variables.path))) }]
-  }));
-  server.prompt(
-    "diagnose_page",
-    "Step-by-step diagnosis of UX friction on a specific page: signals, elements, trends, and a concrete fix recommendation.",
-    { page_path: z.string().min(1).max(500) },
-    ({ page_path }) => ({
-      messages: [{
-        role: "user",
-        content: {
-          type: "text",
-          text: `Diagnose the UX friction on "${page_path}" using Flusterduck.
-
-Step 1: Call get_page with page="${page_path}" to get score, trend, active issues, elements, and deploys.
-Step 2: Call get_elements with page="${page_path}" to see which specific elements have the highest friction signal counts.
-Step 3: Call diagnose_journey_friction to find the highest-friction flow edges across the site. Look for edges where the source or destination path matches "${page_path}" to identify where users struggle entering and exiting this page.
-Step 4: Review the score trend. Is this page getting worse, stable, or recovering? How fast?
-Step 5: Check recent deploys. Did confusion spike after a specific release?
-
-Deliver a diagnosis with:
-- The three worst friction sources on this page (signal type + element label + count)
-- Whether the friction is acute (appeared recently) or chronic (long-standing)
-- One specific, actionable fix recommendation with estimated confusion reduction
-- Whether any open issues should be triaged or escalated based on the evidence
-
-Be concrete. Reference actual signal names, element labels, and numbers from the data.`
-        }
-      }]
-    })
-  );
-  server.prompt(
-    "triage_open_issues",
-    "Systematically triage all open UX issues: classify severity, update the highest-confidence ones, and leave an annotation summarizing what was done.",
-    {},
-    () => ({
-      messages: [{
-        role: "user",
-        content: {
-          type: "text",
-          text: `Triage all open UX issues for this site.
-
-Step 1: Call get_issues with status="open" to get the full list.
-Step 2: For the top 5 issues by signal count or confusion weight, call get_issue on each to get full evidence and session context.
-Step 3: For each reviewed issue, assess:
-  - Severity: high (score impact > 15), medium (5-15), low (< 5)
-  - Root cause: which signal type and element dominates
-  - Confidence: do you have enough evidence to act?
-
-Step 4: Use update_issue to transition issues where you're confident:
-  - Noise or edge case with low evidence \u2192 status: "ignored", note: your reasoning
-  - Reproducible with clear root cause \u2192 status: "triaged", note: specific reproduction steps and affected element
-  - Acute regression affecting a critical flow \u2192 status: "in_progress", note: urgency rationale
-
-Step 5: Call add_annotation to record what was done, e.g. "Agent triage: 2 issues moved to triaged, 1 ignored (noise), 2 left open pending more data."
-
-Report: N issues reviewed, X triaged, Y ignored, Z escalated to in_progress, W left open. One sentence per transitioned issue.`
-        }
-      }]
-    })
-  );
-  server.prompt(
-    "post_deploy_check",
-    "Check for UX confusion regression after the most recent deploy. Returns a go/no-go verdict with specific pages and signals affected.",
-    {},
-    () => ({
-      messages: [{
-        role: "user",
-        content: {
-          type: "text",
-          text: `Run a post-deploy UX check for this site.
-
-Step 1: Call get_deploys to find the most recent deploy. Note the commit SHA, deploy time, and confusion_before/confusion_after scores.
-Step 2: Call get_trends with days=3 to see score movement in the 72-hour window around the deploy.
-Step 3: Call get_issues with status="regressed" to find auto-detected regressions.
-Step 4: For any page where confusion_after > confusion_before by more than 10 points, call get_page for the full signal breakdown.
-
-Evaluate:
-- Did overall site confusion increase after this deploy?
-- Which pages regressed, and by how many points?
-- What specific signals are driving the regression (rage clicks, dead clicks, form friction)?
-- Were any new UX issues created since the deploy?
-
-Deliver a deploy health report:
-- Deploy: [SHA/label], deployed at [time]
-- Verdict: PASS / WARN / FAIL
-- Score delta: [before] \u2192 [after] per affected page
-- Root signal: the dominant friction type if WARN/FAIL
-- Recommendation: ship as-is / monitor closely / consider rollback
-
-If FAIL (> 20 point regression on a critical page), call add_annotation with "Post-deploy check FAILED: [one-line summary of what broke and which page]".`
-        }
-      }]
-    })
-  );
-  server.prompt(
-    "investigate_session",
-    "Investigate one session in full: event timeline, dominant signals, matching issues, and whether it represents a recurring pattern.",
-    { session_id: z.string().min(16).max(128) },
-    ({ session_id }) => ({
-      messages: [{
-        role: "user",
-        content: {
-          type: "text",
-          text: `Investigate session "${session_id}" in Flusterduck.
-
-Step 1: Call get_session_detail with session_id="${session_id}" to get the full event timeline.
-Step 2: Identify the dominant friction signals in this session (rage clicks, dead clicks, form abandonment, scroll thrash). Note which elements and pages generated them.
-Step 3: For the page with the most friction signals, call get_page to get its score, open issues, and element breakdown.
-Step 4: Call get_issues with status="open" to find any existing issues whose affected elements or pages match this session.
-
-Deliver:
-- Session narrative: what this user tried to do, where they struggled, and how the session ended (2-3 sentences)
-- Dominant friction: signal type, element label, page path, and count
-- Issue match: does this session match an open issue? If yes, cite it by title. If no match, describe what a new issue would cover.
-- Representativeness: is this session isolated or part of a recurring pattern? Reference the open issue signal count or page score trend to support your answer.
-
-Reference specific element labels, signal names, and counts from the data.`
-        }
-      }]
-    })
-  );
-  server.prompt(
-    "weekly_summary",
-    "Generate the weekly UX friction digest: score trends, active issues, open alerts, and prioritized recommendations. Ready to share with a PM or eng lead.",
-    {},
-    () => ({
-      messages: [{
-        role: "user",
-        content: {
-          type: "text",
-          text: `Generate the weekly UX friction summary for this site.
-
-Step 1: Call get_site_context for the high-level overview.
-Step 2: Call get_trends with days=7 to see this week's score trajectory.
-Step 3: Call get_issues with status="open", then status="regressed" to get the full active problem set.
-Step 4: Call get_alerts with status="open" to find alerts still requiring attention.
-Step 5: Call get_recommendations for prioritized action items ranked by confusion impact.
-Step 6: Call get_revenue_impact to attach dollar estimates if conversion data is connected.
-
-Format as a weekly digest:
-
-## Weekly UX Friction Summary: [site name]
-
-**Executive summary** (2-3 sentences: are things improving or degrading? What's the headline?)
-
-**Score trend this week**
-- Site-wide confusion: [score] ([+/-X] vs last week), improving / stable / degrading
-- Notable pages: [page] +X, [page] -Y
-
-**Active issues** (top 3 by impact)
-1. [Issue title] | [severity] | [page] | open [N] days | [one-line root cause]
-2. ...
-
-**Alerts needing attention** (if any)
-
-**Top 3 recommended fixes**
-1. [Specific fix], estimated [X]-point confusion reduction on [page]
-2. ...
-
-**Revenue at risk**: $[amount] based on [conversion metric] (if available)
-
-Keep it under 300 words. This should be readable in 90 seconds by someone who hasn't looked at Flusterduck all week.`
-        }
-      }]
-    })
-  );
-  return server;
-}
-
-export {
-  FlusterduckAPI,
-  createFlusterduckMCPServer
-};