@rui.branco/sentry-mcp 1.0.4 → 1.0.6

package/README.md

@@ -20,6 +20,7 @@ When debugging production errors, context switching between Sentry and your code
 | Breadcrumbs | Last N events leading up to the error |
 | HTTP Request | Method, URL, headers from the request that triggered the error |
 | Tags & Contexts | Device, browser, OS, user info, and custom tags |
+| Attachments | List and download event attachments (minidumps, screenshots, logs) to disk |
 | Search | Full Sentry search syntax support |
 | Multi-Instance | Support for multiple Sentry organizations/instances |
 
@@ -202,6 +203,8 @@ Use the `instance` parameter on any tool to target a specific instance, or omit
 | `sentry_ignore_issue` | Ignore/snooze an issue | `issueId` (required), `instance` |
 | `sentry_search_issues` | Search with custom Sentry query | `query` (required), `instance` |
 | `sentry_assign_issue` | Assign an issue to a user or team | `issueId` (required), `assignee` (required), `instance` |
+| `sentry_list_event_attachments` | List attachments (minidumps, screenshots, logs) stored on an event | `eventId` or `issueId`, `instance` |
+| `sentry_download_event_attachment` | Download an event attachment to disk and return the saved path | `attachmentId` (required), `eventId` or `issueId`, `outputPath`, `instance` |
 | `sentry_list_instances` | List all configured instances | none |
 | `sentry_add_instance` | Add or update an instance at runtime | `name`, `token`, `baseUrl`, `orgSlug` (all required), `projectSlug`, `projects`, `setDefault` |
 | `sentry_remove_instance` | Remove an instance | `name` (required) |

package/index.js

@@ -15,6 +15,7 @@ const {
   ListToolsRequestSchema,
 } = require("@modelcontextprotocol/sdk/types.js");
 const fs = require("fs");
+const os = require("os");
 const path = require("path");
 const fetch = require("node-fetch");
 const { spawn, execSync } = require("child_process");
@@ -154,6 +155,43 @@ async function fetchSentry(apiPath, instance, options = {}) {
   return text ? JSON.parse(text) : {};
 }
 
+// Same as fetchSentry but returns the raw response body as a Buffer (for
+// binary downloads like event attachments). Keeps fetchSentry's JSON contract intact.
+async function fetchSentryRaw(apiPath, instance, options = {}) {
+  const inst = instance || defaultInstance;
+  if (!inst) {
+    throw new Error("No Sentry instance configured. Run: sentry-mcp setup");
+  }
+  if (!inst.token) {
+    throw new Error(`Sentry API token not configured for instance "${inst.name}".`);
+  }
+
+  const base = (inst.baseUrl || "https://sentry.io").replace(/\/+$/, "");
+  const url = `${base}${apiPath}`;
+  const { method = "GET" } = options;
+
+  const response = await fetch(url, {
+    method,
+    headers: {
+      Authorization: `Bearer ${inst.token}`,
+      Accept: "*/*",
+    },
+  });
+
+  if (!response.ok) {
+    const errorBody = await response.text().catch(() => "");
+    let errorMsg = `Sentry API error: ${response.status} ${response.statusText}`;
+    try {
+      const parsed = JSON.parse(errorBody);
+      if (parsed.detail) errorMsg = parsed.detail;
+      else if (parsed.message) errorMsg = parsed.message;
+    } catch {}
+    throw new Error(errorMsg);
+  }
+
+  return response.buffer();
+}
+
 // ── Helpers ─────────────────────────────────────────────────────────────────
 
 // Strip noisy/internal fields that waste context but keep everything useful
@@ -167,7 +205,7 @@ function cleanIssueData(issue) {
 }
 
 function cleanEventData(event) {
-  const skip = new Set(["_meta", "groupID", "eventID", "sdk", "dist", "fingerprints"]);
+  const skip = new Set(["_meta", "groupID", "dist", "fingerprints"]);
   const cleaned = {};
   for (const [k, v] of Object.entries(event)) {
     if (!skip.has(k) && v != null && v !== "") cleaned[k] = v;
@@ -175,6 +213,44 @@ function cleanEventData(event) {
   return cleaned;
 }
 
+// Attachments are event-scoped. Accept a raw eventId (preferred) or resolve
+// the issue's latest event when only an issueId is given.
+async function resolveEventId(args, inst) {
+  if (args.eventId) return args.eventId;
+  if (args.issueId) {
+    const latest = await fetchSentry(
+      `/api/0/organizations/${encodeURIComponent(inst.orgSlug)}/issues/${encodeURIComponent(args.issueId)}/events/latest/`,
+      inst,
+    );
+    const id = latest.eventID || latest.id;
+    if (!id) throw new Error(`Could not resolve an event for issue ${args.issueId}.`);
+    return id;
+  }
+  throw new Error("Provide either eventId or issueId.");
+}
+
+// Sanitize a server-provided attachment filename so it can never escape the
+// target directory (path traversal) or introduce awkward characters.
+function safeAttachmentName(name, fallback) {
+  const cleaned = path
+    .basename(String(name || fallback))
+    .replace(/[^a-zA-Z0-9._ -]/g, "_")
+    .replace(/^\.+/, "_")
+    .slice(0, 180);
+  return cleaned || fallback;
+}
+
+// Reduce an id (eventId / attachmentId) to a single safe path segment so it
+// cannot introduce separators or "../" traversal when building the default path.
+function safePathSegment(value, fallback) {
+  const cleaned = path
+    .basename(String(value == null ? "" : value))
+    .replace(/[^a-zA-Z0-9._-]/g, "_")
+    .replace(/^\.+/, "_")
+    .slice(0, 120);
+  return cleaned || fallback;
+}
+
 function formatIssueSummary(issue) {
   const meta = issue.metadata || {};
   const lines = [];
@@ -609,6 +685,83 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
           required: ["version"],
         },
       },
+      {
+        name: "sentry_list_events",
+        description:
+          "List events for a Sentry issue. Returns event IDs, timestamps, user info, and message/title for each occurrence.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            issueId: {
+              type: "string",
+              description: "Sentry issue ID (numeric).",
+            },
+            instance: {
+              type: "string",
+              description:
+                "Instance name (for multi-instance setups). Uses default instance if omitted.",
+            },
+          },
+          required: ["issueId"],
+        },
+      },
+      {
+        name: "sentry_list_event_attachments",
+        description:
+          "List attachments (minidumps, screenshots, logs, view hierarchies, etc.) stored on a Sentry event. Provide either an eventId (32-char hex) or an issueId (resolves to the issue's latest event). Uses the instance's configured projectSlug.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            eventId: {
+              type: "string",
+              description: "Sentry event ID (32-char hex). Takes precedence over issueId.",
+            },
+            issueId: {
+              type: "string",
+              description: "Sentry issue ID (numeric). If eventId is omitted, the issue's latest event is used.",
+            },
+            instance: {
+              type: "string",
+              description:
+                "Instance name (for multi-instance setups). Uses default instance if omitted.",
+            },
+          },
+          required: [],
+        },
+      },
+      {
+        name: "sentry_download_event_attachment",
+        description:
+          "Download a Sentry event attachment to a file on disk and return the saved path. Provide the attachmentId (from sentry_list_event_attachments) plus either an eventId or issueId. By default saves into a temp directory; pass outputPath to choose a file or destination directory.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            attachmentId: {
+              type: "string",
+              description: "Attachment ID to download (from sentry_list_event_attachments).",
+            },
+            eventId: {
+              type: "string",
+              description: "Sentry event ID (32-char hex). Takes precedence over issueId.",
+            },
+            issueId: {
+              type: "string",
+              description: "Sentry issue ID (numeric). If eventId is omitted, the issue's latest event is used.",
+            },
+            outputPath: {
+              type: "string",
+              description:
+                "Optional destination. If it is an existing directory (or ends with a slash), the file is saved inside it using the attachment's name; otherwise it is treated as the full file path. Relative paths resolve from the current working directory. Defaults to a temp directory.",
+            },
+            instance: {
+              type: "string",
+              description:
+                "Instance name (for multi-instance setups). Uses default instance if omitted.",
+            },
+          },
+          required: ["attachmentId"],
+        },
+      },
       {
         name: "sentry_list_instances",
         description:
@@ -1013,6 +1166,119 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         content: [{ type: "text", text: lines.join("\n") }],
       };
 
+    } else if (name === "sentry_list_events") {
+      const inst = getInstanceByName(args.instance);
+      if (!inst) throw new Error("No Sentry instance configured. Run: sentry-mcp setup");
+      const data = await fetchSentry(
+        `/api/0/organizations/${encodeURIComponent(inst.orgSlug)}/issues/${encodeURIComponent(args.issueId)}/events/`,
+        inst,
+      );
+      if (!data || !data.length) {
+        return {
+          content: [{ type: "text", text: `No events found for issue ${args.issueId}.` }],
+        };
+      }
+      const lines = data.map((e) => {
+        const user = e.user ? `${e.user.username || e.user.email || e.user.id || "unknown"}` : "N/A";
+        const title = e.title || e.message || "";
+        return `- **${e.eventID || e.id}** | ${e.dateCreated || "N/A"} | User: ${user} | ${title}`;
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Found ${data.length} event(s) for issue ${args.issueId}:\n\n${lines.join("\n")}`,
+          },
+        ],
+      };
+
+    } else if (name === "sentry_list_event_attachments") {
+      const inst = getInstanceByName(args.instance);
+      if (!inst) throw new Error("No Sentry instance configured. Run: sentry-mcp setup");
+      if (!inst.projectSlug) throw new Error("No projectSlug configured for this instance.");
+      const eventId = await resolveEventId(args, inst);
+      const data = await fetchSentry(
+        `/api/0/projects/${encodeURIComponent(inst.orgSlug)}/${encodeURIComponent(inst.projectSlug)}/events/${encodeURIComponent(eventId)}/attachments/`,
+        inst,
+      );
+      if (!data || !data.length) {
+        return {
+          content: [{ type: "text", text: `No attachments found for event ${eventId}.` }],
+        };
+      }
+      const lines = data.map((a) => {
+        const size = a.size != null ? ` (${(a.size / 1024).toFixed(1)} KB)` : "";
+        const type = a.type ? `, type: ${a.type}` : "";
+        const mime = a.mimetype ? `, mimetype: ${a.mimetype}` : "";
+        return `- ${a.name}${size} [id: ${a.id}${type}${mime}]`;
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Found ${data.length} attachment(s) for event ${eventId}:\n\n${lines.join("\n")}\n\nDownload one with sentry_download_event_attachment (attachmentId + eventId/issueId).`,
+          },
+        ],
+      };
+
+    } else if (name === "sentry_download_event_attachment") {
+      const inst = getInstanceByName(args.instance);
+      if (!inst) throw new Error("No Sentry instance configured. Run: sentry-mcp setup");
+      if (!inst.projectSlug) throw new Error("No projectSlug configured for this instance.");
+      if (!args.attachmentId) throw new Error("attachmentId is required.");
+      const eventId = await resolveEventId(args, inst);
+
+      // Look up metadata (name, size, mimetype) so we save with the real filename.
+      const list = await fetchSentry(
+        `/api/0/projects/${encodeURIComponent(inst.orgSlug)}/${encodeURIComponent(inst.projectSlug)}/events/${encodeURIComponent(eventId)}/attachments/`,
+        inst,
+      );
+      const meta = (list || []).find((a) => String(a.id) === String(args.attachmentId));
+      const safeName = safeAttachmentName(meta && meta.name, `attachment-${args.attachmentId}`);
+
+      const buffer = await fetchSentryRaw(
+        `/api/0/projects/${encodeURIComponent(inst.orgSlug)}/${encodeURIComponent(inst.projectSlug)}/events/${encodeURIComponent(eventId)}/attachments/${encodeURIComponent(args.attachmentId)}/?download`,
+        inst,
+      );
+
+      // Resolve destination: explicit path (file or directory) or default temp dir.
+      let destPath;
+      if (args.outputPath) {
+        const resolved = path.resolve(process.cwd(), args.outputPath);
+        const looksLikeDir =
+          /[\\/]$/.test(args.outputPath) ||
+          (fs.existsSync(resolved) && fs.statSync(resolved).isDirectory());
+        destPath = looksLikeDir ? path.join(resolved, safeName) : resolved;
+      } else {
+        destPath = path.join(
+          os.tmpdir(),
+          "sentry-mcp",
+          "attachments",
+          safePathSegment(eventId, "event"),
+          `${safePathSegment(args.attachmentId, "attachment")}-${safeName}`,
+        );
+      }
+      fs.mkdirSync(path.dirname(destPath), { recursive: true });
+      fs.writeFileSync(destPath, buffer);
+
+      const details = {
+        savedPath: destPath,
+        name: (meta && meta.name) || safeName,
+        attachmentId: args.attachmentId,
+        eventId,
+        size: (meta && meta.size != null ? meta.size : buffer.length),
+        mimetype: meta && meta.mimetype ? meta.mimetype : undefined,
+        sha1: meta && meta.sha1 ? meta.sha1 : undefined,
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Downloaded attachment "${details.name}" (${details.size} bytes) to:\n${destPath}\n\n${JSON.stringify(details, null, 2)}`,
+          },
+        ],
+      };
+
     } else if (name === "sentry_list_instances") {
       if (!instances.length) {
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rui.branco/sentry-mcp",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Sentry MCP server for any MCP-compatible AI client (Claude Code, Codex, Antigravity, Cursor, etc.) - fetch issues, search errors, resolve/ignore issues, get stack traces and breadcrumbs",
   "main": "index.js",
   "bin": {