@rui.branco/sentry-mcp 1.0.0

package/index.js

@@ -0,0 +1,793 @@
+#!/usr/bin/env node
+
+// Handle setup command
+if (process.argv[2] === "setup") {
+  require("./setup.js");
+  return;
+}
+
+const { Server } = require("@modelcontextprotocol/sdk/server/index.js");
+const {
+  StdioServerTransport,
+} = require("@modelcontextprotocol/sdk/server/stdio.js");
+const {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} = require("@modelcontextprotocol/sdk/types.js");
+const fs = require("fs");
+const path = require("path");
+const fetch = require("node-fetch");
+const { spawn, execSync } = require("child_process");
+
+// Auto-update: check GitHub for new commits, install in background
+const GITHUB_REPO = "rui-branco/sentry-mcp";
+const INSTALLED_SHA_FILE = path.join(__dirname, ".installed-sha");
+try {
+  const localSha = fs.existsSync(INSTALLED_SHA_FILE)
+    ? fs.readFileSync(INSTALLED_SHA_FILE, "utf-8").trim()
+    : "";
+  const remoteSha = execSync(
+    `git ls-remote https://github.com/${GITHUB_REPO}.git HEAD`,
+    { stdio: "pipe", timeout: 5000 },
+  )
+    .toString()
+    .split("\t")[0]
+    .trim();
+  if (remoteSha && remoteSha !== localSha) {
+    const child = spawn(
+      "sh",
+      [
+        "-c",
+        `npm install -g git+ssh://git@github.com/${GITHUB_REPO}.git && echo "${remoteSha}" > "${INSTALLED_SHA_FILE}"`,
+      ],
+      { stdio: "ignore", detached: true },
+    );
+    child.unref();
+  }
+} catch {}
+
+// ── Config ──────────────────────────────────────────────────────────────────
+
+const configDir = path.join(process.env.HOME, ".config/sentry-mcp");
+const configPath = path.join(configDir, "config.json");
+
+function loadConfigFile() {
+  try {
+    return JSON.parse(fs.readFileSync(configPath, "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+// Load config (supports single-instance and multi-instance formats)
+const rawConfig = loadConfigFile();
+
+// Normalize config to multi-instance format
+let instances;
+if (rawConfig.instances) {
+  instances = rawConfig.instances.map((inst) => ({
+    ...inst,
+    projects: (inst.projects || []).map((p) => p.toLowerCase()),
+  }));
+} else if (rawConfig.token) {
+  // Old single-instance format — wrap as array
+  instances = [
+    {
+      name: "default",
+      token: rawConfig.token,
+      baseUrl: (rawConfig.baseUrl || "https://sentry.io").replace(/\/+$/, ""),
+      orgSlug: rawConfig.orgSlug,
+      projectSlug: rawConfig.projectSlug || "",
+      projects: [],
+    },
+  ];
+} else {
+  instances = [];
+}
+
+// Resolve default instance
+const defaultInstance =
+  (rawConfig.defaultInstance &&
+    instances.find((i) => i.name === rawConfig.defaultInstance)) ||
+  instances[0] ||
+  null;
+
+// Instance resolution helpers
+function getInstanceForProject(projectSlug) {
+  if (!projectSlug) return defaultInstance;
+  const lower = projectSlug.toLowerCase();
+  return (
+    instances.find((i) => i.projects.includes(lower)) ||
+    instances.find((i) => i.projectSlug === projectSlug) ||
+    defaultInstance
+  );
+}
+
+function getInstanceByName(name) {
+  if (!name) return defaultInstance;
+  return instances.find((i) => i.name === name) || defaultInstance;
+}
+
+// ── Sentry API ──────────────────────────────────────────────────────────────
+
+async function fetchSentry(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", body } = options;
+
+  const headers = {
+    Authorization: `Bearer ${inst.token}`,
+    Accept: "application/json",
+  };
+  if (body) {
+    headers["Content-Type"] = "application/json";
+  }
+
+  const response = await fetch(url, {
+    method,
+    headers,
+    body: body ? JSON.stringify(body) : undefined,
+  });
+
+  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);
+  }
+
+  const text = await response.text();
+  return text ? JSON.parse(text) : {};
+}
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+function formatIssue(issue) {
+  const meta = issue.metadata || {};
+  const lines = [];
+  lines.push(`**${issue.title}**`);
+  lines.push(`- ID: ${issue.id} | Short ID: ${issue.shortId || "N/A"}`);
+  lines.push(`- Level: ${issue.level || "error"} | Status: ${issue.status || "unresolved"}`);
+  lines.push(`- Events: ${issue.count || 0} | Users: ${issue.userCount || 0}`);
+  if (issue.culprit) lines.push(`- Culprit: ${issue.culprit}`);
+  if (meta.filename) lines.push(`- File: ${meta.filename}${meta.function ? " in " + meta.function : ""}`);
+  if (issue.firstSeen) lines.push(`- First seen: ${issue.firstSeen}`);
+  if (issue.lastSeen) lines.push(`- Last seen: ${issue.lastSeen}`);
+  if (issue.permalink) lines.push(`- URL: ${issue.permalink}`);
+  if (issue.assignedTo) {
+    const a = issue.assignedTo;
+    lines.push(`- Assigned to: ${a.name || a.email || a.id || "unknown"}`);
+  }
+  return lines.join("\n");
+}
+
+function formatEvent(event) {
+  const lines = [];
+
+  // Stack traces
+  const exceptions =
+    event.entries?.find((e) => e.type === "exception")?.data?.values || [];
+  if (exceptions.length) {
+    lines.push("## Stack Trace\n");
+    for (const ex of exceptions) {
+      if (ex.type || ex.value) lines.push(`**${ex.type || "Exception"}:** ${ex.value || ""}\n`);
+      const frames = ex.stacktrace?.frames;
+      if (frames?.length) {
+        lines.push("```");
+        for (const f of frames) {
+          const loc = f.lineNo ? `:${f.lineNo}${f.colNo ? ":" + f.colNo : ""}` : "";
+          const marker = f.inApp ? "-> " : "   ";
+          lines.push(`${marker}${f.function || "?"} (${f.filename || "?"}${loc})`);
+        }
+        lines.push("```\n");
+      }
+    }
+  }
+
+  // Breadcrumbs
+  const breadcrumbs =
+    event.entries?.find((e) => e.type === "breadcrumbs")?.data?.values || [];
+  if (breadcrumbs.length) {
+    const last = breadcrumbs.slice(-20);
+    lines.push(`## Breadcrumbs (last ${last.length})\n`);
+    for (const bc of last) {
+      const msg = bc.message || bc.data?.url || bc.data?.to || "";
+      lines.push(`- **${bc.category || "?"}** [${bc.level || "info"}] ${msg}`);
+    }
+    lines.push("");
+  }
+
+  // HTTP Request
+  const httpReq =
+    event.entries?.find((e) => e.type === "request")?.data;
+  if (httpReq) {
+    lines.push("## HTTP Request\n");
+    lines.push(`\`${httpReq.method || "GET"} ${httpReq.url || ""}\``);
+    if (httpReq.headers) {
+      lines.push("\n```");
+      for (const [k, v] of httpReq.headers) {
+        lines.push(`${k}: ${v}`);
+      }
+      lines.push("```");
+    }
+    lines.push("");
+  }
+
+  // Tags
+  if (event.tags?.length) {
+    lines.push("## Tags\n");
+    lines.push("| Key | Value |");
+    lines.push("|-----|-------|");
+    for (const t of event.tags) {
+      lines.push(`| ${t.key} | ${t.value} |`);
+    }
+    lines.push("");
+  }
+
+  // Contexts
+  if (event.contexts) {
+    lines.push("## Contexts\n");
+    for (const [name, ctx] of Object.entries(event.contexts)) {
+      if (name === "trace" || name === "replay" || !ctx || typeof ctx !== "object") continue;
+      const entries = Object.entries(ctx).filter(([k, v]) => k !== "type" && v != null && v !== "");
+      if (!entries.length) continue;
+      const title = name.charAt(0).toUpperCase() + name.slice(1).replace(/_/g, " ");
+      lines.push(`**${title}:**`);
+      for (const [k, v] of entries.slice(0, 15)) {
+        const display = typeof v === "object" ? JSON.stringify(v) : String(v);
+        lines.push(`- ${k}: ${display}`);
+      }
+      lines.push("");
+    }
+  }
+
+  // User
+  if (event.user) {
+    const u = event.user;
+    lines.push("## User\n");
+    lines.push(`${u.username || u.name || u.email || u.id || "unknown"}${u.email ? " (" + u.email + ")" : ""}`);
+    if (u.ip_address) lines.push(`IP: ${u.ip_address}`);
+    lines.push("");
+  }
+
+  return lines.join("\n") || "No event data available.";
+}
+
+// ── MCP Server ──────────────────────────────────────────────────────────────
+
+const server = new Server(
+  { name: "sentry-mcp", version: "1.0.0" },
+  { capabilities: { tools: {} } },
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: "sentry_list_projects",
+        description:
+          "List all Sentry projects accessible by the configured token. When multiple instances are configured, lists projects from each.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            instance: {
+              type: "string",
+              description:
+                "Instance name (for multi-instance setups). Uses default instance if omitted.",
+            },
+          },
+          required: [],
+        },
+      },
+      {
+        name: "sentry_get_issues",
+        description:
+          "Get unresolved issues for a Sentry project. Returns a list of issues with their metadata.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description:
+                'Sentry search query (default: "is:unresolved"). Supports Sentry search syntax.',
+            },
+            instance: {
+              type: "string",
+              description:
+                "Instance name (for multi-instance setups). Uses default instance if omitted.",
+            },
+          },
+          required: [],
+        },
+      },
+      {
+        name: "sentry_get_issue",
+        description:
+          "Get full details for a specific Sentry issue by its numeric ID.",
+        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_get_latest_event",
+        description:
+          "Get the latest event for a Sentry issue — includes full stack trace, breadcrumbs, HTTP request, contexts, and tags.",
+        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_resolve_issue",
+        description: "Mark a Sentry issue as resolved.",
+        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_unresolve_issue",
+        description: "Reopen a resolved Sentry issue.",
+        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_ignore_issue",
+        description: "Ignore/snooze a Sentry issue.",
+        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_search_issues",
+        description:
+          "Search Sentry issues with a custom query. Supports full Sentry search syntax.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description:
+                'Sentry search query (e.g. "is:unresolved level:error", "TypeError", "assigned:me").',
+            },
+            instance: {
+              type: "string",
+              description:
+                "Instance name (for multi-instance setups). Uses default instance if omitted.",
+            },
+          },
+          required: ["query"],
+        },
+      },
+      {
+        name: "sentry_assign_issue",
+        description: "Assign a Sentry issue to a user or team.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            issueId: {
+              type: "string",
+              description: "Sentry issue ID (numeric).",
+            },
+            assignee: {
+              type: "string",
+              description:
+                'Username, email, or team identifier to assign to (e.g. "username:john", "team:backend").',
+            },
+            instance: {
+              type: "string",
+              description:
+                "Instance name (for multi-instance setups). Uses default instance if omitted.",
+            },
+          },
+          required: ["issueId", "assignee"],
+        },
+      },
+      {
+        name: "sentry_list_instances",
+        description:
+          "List all configured Sentry instances and which is the default.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: [],
+        },
+      },
+      {
+        name: "sentry_add_instance",
+        description:
+          "Add or update a Sentry instance at runtime. Persists to config file.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+              description: "Instance name (e.g. 'work', 'personal').",
+            },
+            token: {
+              type: "string",
+              description: "Sentry API auth token (Bearer token).",
+            },
+            baseUrl: {
+              type: "string",
+              description:
+                "Sentry base URL (e.g. 'https://sentry.io' or 'https://my-org.sentry.io').",
+            },
+            orgSlug: {
+              type: "string",
+              description: "Sentry organization slug.",
+            },
+            projectSlug: {
+              type: "string",
+              description:
+                "Default Sentry project slug for this instance (optional).",
+            },
+            projects: {
+              type: "array",
+              items: { type: "string" },
+              description:
+                "Project slugs to route to this instance (for multi-instance resolution).",
+            },
+            setDefault: {
+              type: "boolean",
+              description: "Set this as the default instance.",
+            },
+          },
+          required: ["name", "token", "baseUrl", "orgSlug"],
+        },
+      },
+      {
+        name: "sentry_remove_instance",
+        description: "Remove a Sentry instance from the configuration.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            name: {
+              type: "string",
+              description: "Instance name to remove.",
+            },
+          },
+          required: ["name"],
+        },
+      },
+    ],
+  };
+});
+
+// ── Tool handler ────────────────────────────────────────────────────────────
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    if (name === "sentry_list_projects") {
+      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)}/projects/`,
+        inst,
+      );
+      if (!data || !data.length) {
+        return {
+          content: [{ type: "text", text: "No projects found." }],
+        };
+      }
+      const lines = data.map(
+        (p) =>
+          `- **${p.name}** (slug: ${p.slug}, platform: ${p.platform || "N/A"}, id: ${p.id})`,
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Found ${data.length} project(s) in org "${inst.orgSlug}":\n\n${lines.join("\n")}`,
+          },
+        ],
+      };
+
+    } else if (name === "sentry_get_issues") {
+      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. Use sentry_search_issues with org-level search, or configure a projectSlug.");
+      const query = args.query || "is:unresolved";
+      const params = new URLSearchParams({ query });
+      const data = await fetchSentry(
+        `/api/0/projects/${encodeURIComponent(inst.orgSlug)}/${encodeURIComponent(inst.projectSlug)}/issues/?${params}`,
+        inst,
+      );
+      if (!data || !data.length) {
+        return {
+          content: [{ type: "text", text: `No issues found for query: ${query}` }],
+        };
+      }
+      const formatted = data.map(formatIssue);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Found ${data.length} issue(s) for "${query}":\n\n${formatted.join("\n\n---\n\n")}`,
+          },
+        ],
+      };
+
+    } else if (name === "sentry_get_issue") {
+      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)}/`,
+        inst,
+      );
+      return {
+        content: [{ type: "text", text: formatIssue(data) }],
+      };
+
+    } else if (name === "sentry_get_latest_event") {
+      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/latest/`,
+        inst,
+      );
+      return {
+        content: [{ type: "text", text: formatEvent(data) }],
+      };
+
+    } else if (name === "sentry_resolve_issue") {
+      const inst = getInstanceByName(args.instance);
+      if (!inst) throw new Error("No Sentry instance configured. Run: sentry-mcp setup");
+      await fetchSentry(
+        `/api/0/organizations/${encodeURIComponent(inst.orgSlug)}/issues/${encodeURIComponent(args.issueId)}/`,
+        inst,
+        { method: "PUT", body: { status: "resolved" } },
+      );
+      return {
+        content: [{ type: "text", text: `Issue ${args.issueId} marked as resolved.` }],
+      };
+
+    } else if (name === "sentry_unresolve_issue") {
+      const inst = getInstanceByName(args.instance);
+      if (!inst) throw new Error("No Sentry instance configured. Run: sentry-mcp setup");
+      await fetchSentry(
+        `/api/0/organizations/${encodeURIComponent(inst.orgSlug)}/issues/${encodeURIComponent(args.issueId)}/`,
+        inst,
+        { method: "PUT", body: { status: "unresolved" } },
+      );
+      return {
+        content: [{ type: "text", text: `Issue ${args.issueId} reopened (unresolved).` }],
+      };
+
+    } else if (name === "sentry_ignore_issue") {
+      const inst = getInstanceByName(args.instance);
+      if (!inst) throw new Error("No Sentry instance configured. Run: sentry-mcp setup");
+      await fetchSentry(
+        `/api/0/organizations/${encodeURIComponent(inst.orgSlug)}/issues/${encodeURIComponent(args.issueId)}/`,
+        inst,
+        { method: "PUT", body: { status: "ignored" } },
+      );
+      return {
+        content: [{ type: "text", text: `Issue ${args.issueId} ignored.` }],
+      };
+
+    } else if (name === "sentry_search_issues") {
+      const inst = getInstanceByName(args.instance);
+      if (!inst) throw new Error("No Sentry instance configured. Run: sentry-mcp setup");
+      // Use project-scoped if projectSlug is available, otherwise org-scoped
+      let apiPath;
+      if (inst.projectSlug) {
+        const params = new URLSearchParams({ query: args.query });
+        apiPath = `/api/0/projects/${encodeURIComponent(inst.orgSlug)}/${encodeURIComponent(inst.projectSlug)}/issues/?${params}`;
+      } else {
+        const params = new URLSearchParams({ query: args.query });
+        apiPath = `/api/0/organizations/${encodeURIComponent(inst.orgSlug)}/issues/?${params}`;
+      }
+      const data = await fetchSentry(apiPath, inst);
+      if (!data || !data.length) {
+        return {
+          content: [{ type: "text", text: `No issues found for query: ${args.query}` }],
+        };
+      }
+      const formatted = data.map(formatIssue);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Found ${data.length} issue(s) for "${args.query}":\n\n${formatted.join("\n\n---\n\n")}`,
+          },
+        ],
+      };
+
+    } else if (name === "sentry_assign_issue") {
+      const inst = getInstanceByName(args.instance);
+      if (!inst) throw new Error("No Sentry instance configured. Run: sentry-mcp setup");
+      await fetchSentry(
+        `/api/0/organizations/${encodeURIComponent(inst.orgSlug)}/issues/${encodeURIComponent(args.issueId)}/`,
+        inst,
+        { method: "PUT", body: { assignedTo: args.assignee } },
+      );
+      return {
+        content: [
+          { type: "text", text: `Issue ${args.issueId} assigned to ${args.assignee}.` },
+        ],
+      };
+
+    } else if (name === "sentry_list_instances") {
+      if (!instances.length) {
+        return {
+          content: [{ type: "text", text: "No Sentry instances configured. Run: sentry-mcp setup" }],
+        };
+      }
+      const lines = instances.map((inst) => {
+        const isDefault = defaultInstance && inst.name === defaultInstance.name ? " (default)" : "";
+        const projs = inst.projects?.length ? ` [${inst.projects.join(", ")}]` : "";
+        return `- **${inst.name}**${isDefault}: ${inst.baseUrl} (org: ${inst.orgSlug}${inst.projectSlug ? ", project: " + inst.projectSlug : ""})${projs}`;
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `${instances.length} instance(s) configured:\n\n${lines.join("\n")}`,
+          },
+        ],
+      };
+
+    } else if (name === "sentry_add_instance") {
+      const config = loadConfigFile();
+      if (!config.instances) config.instances = [];
+
+      const instance = {
+        name: args.name,
+        token: args.token,
+        baseUrl: (args.baseUrl || "https://sentry.io").replace(/\/+$/, ""),
+        orgSlug: args.orgSlug,
+        projectSlug: args.projectSlug || "",
+        projects: (args.projects || []).map((p) => p.toLowerCase()),
+      };
+
+      const idx = config.instances.findIndex((i) => i.name === args.name);
+      if (idx >= 0) {
+        config.instances[idx] = instance;
+      } else {
+        config.instances.push(instance);
+      }
+
+      if (args.setDefault || !config.defaultInstance) {
+        config.defaultInstance = args.name;
+      }
+
+      if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+      }
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+
+      // Update runtime state
+      const normalized = { ...instance, projects: instance.projects };
+      const runtimeIdx = instances.findIndex((i) => i.name === args.name);
+      if (runtimeIdx >= 0) {
+        instances[runtimeIdx] = normalized;
+      } else {
+        instances.push(normalized);
+      }
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Instance "${args.name}" saved.${args.setDefault ? " Set as default." : ""}`,
+          },
+        ],
+      };
+
+    } else if (name === "sentry_remove_instance") {
+      const config = loadConfigFile();
+      if (!config.instances) {
+        return {
+          content: [{ type: "text", text: "No instances configured." }],
+        };
+      }
+
+      config.instances = config.instances.filter((i) => i.name !== args.name);
+      if (config.defaultInstance === args.name) {
+        config.defaultInstance = config.instances[0]?.name || null;
+      }
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+
+      // Update runtime state
+      const runtimeIdx = instances.findIndex((i) => i.name === args.name);
+      if (runtimeIdx >= 0) instances.splice(runtimeIdx, 1);
+
+      return {
+        content: [
+          { type: "text", text: `Instance "${args.name}" removed.` },
+        ],
+      };
+
+    } else {
+      throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error) {
+    return {
+      content: [{ type: "text", text: `Error: ${error.message}` }],
+      isError: true,
+    };
+  }
+});
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch(console.error);

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@rui.branco/sentry-mcp",
+  "version": "1.0.0",
+  "description": "Sentry MCP server for Claude Code - fetch issues, search errors, resolve/ignore issues, get stack traces and breadcrumbs",
+  "main": "index.js",
+  "bin": {
+    "sentry-mcp": "./index.js"
+  },
+  "files": [
+    "index.js",
+    "setup.js"
+  ],
+  "scripts": {
+    "setup": "node setup.js"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "sentry",
+    "claude",
+    "claude-code",
+    "error-tracking"
+  ],
+  "author": "Rui Branco",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.25.3",
+    "node-fetch": "^2.7.0"
+  }
+}

package/setup.js

@@ -0,0 +1,266 @@
+#!/usr/bin/env node
+
+const readline = require("readline");
+const fs = require("fs");
+const path = require("path");
+
+const configDir = path.join(process.env.HOME, ".config/sentry-mcp");
+const configPath = path.join(configDir, "config.json");
+
+// Check for command line arguments
+let args = process.argv.slice(2);
+// Skip "setup" arg if called via index.js
+if (args[0] === "setup") args = args.slice(1);
+
+// Load existing config if present
+function loadConfig() {
+  try {
+    if (fs.existsSync(configPath)) {
+      return JSON.parse(fs.readFileSync(configPath, "utf8"));
+    }
+  } catch {}
+  return null;
+}
+
+function saveConfig(config) {
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+
+// Non-interactive: setup add <name> <token> <baseUrl> <orgSlug> [projectSlug] [projects...]
+if (args[0] === "add" && args.length >= 4) {
+  const [, name, token, baseUrl, orgSlug, projectSlug, ...projectArgs] = args;
+  const projects = projectArgs.length > 0
+    ? projectArgs.join(",").split(",").map((p) => p.trim().toLowerCase()).filter(Boolean)
+    : [];
+
+  const config = loadConfig() || {};
+
+  // Migrate old format if needed
+  if (config.token && !config.instances) {
+    config.instances = [{
+      name: "default",
+      token: config.token,
+      baseUrl: config.baseUrl,
+      orgSlug: config.orgSlug,
+      projectSlug: config.projectSlug || "",
+      projects: [],
+    }];
+    config.defaultInstance = "default";
+    delete config.token;
+    delete config.baseUrl;
+    delete config.orgSlug;
+    delete config.projectSlug;
+  }
+
+  if (!config.instances) config.instances = [];
+
+  // Replace or add instance
+  const existing = config.instances.findIndex((i) => i.name === name);
+  const instance = {
+    name,
+    token,
+    baseUrl: baseUrl.replace(/\/+$/, ""),
+    orgSlug,
+    projectSlug: projectSlug || "",
+    projects,
+  };
+  if (existing >= 0) {
+    config.instances[existing] = instance;
+  } else {
+    config.instances.push(instance);
+  }
+
+  if (!config.defaultInstance) config.defaultInstance = name;
+
+  saveConfig(config);
+  console.log(`Instance "${name}" saved to ${configPath}`);
+  if (projects.length > 0) {
+    console.log(`Projects: ${projects.join(", ")}`);
+  }
+  process.exit(0);
+}
+
+// Non-interactive: setup remove <name>
+if (args[0] === "remove" && args.length >= 2) {
+  const name = args[1];
+  const config = loadConfig();
+
+  if (!config || !config.instances) {
+    console.error("No multi-instance config found.");
+    process.exit(1);
+  }
+
+  config.instances = config.instances.filter((i) => i.name !== name);
+  if (config.defaultInstance === name) {
+    config.defaultInstance = config.instances[0]?.name || null;
+  }
+
+  saveConfig(config);
+  console.log(`Instance "${name}" removed.`);
+  process.exit(0);
+}
+
+// Non-interactive: setup <token> <baseUrl> <orgSlug> [projectSlug]
+if (args.length >= 3 && args[0] !== "add" && args[0] !== "remove") {
+  const [token, baseUrl, orgSlug, projectSlug] = args;
+  saveConfig({
+    token,
+    baseUrl: baseUrl.replace(/\/+$/, ""),
+    orgSlug,
+    projectSlug: projectSlug || "",
+  });
+  console.log(`Config saved to ${configPath}`);
+  process.exit(0);
+}
+
+// Interactive mode
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+function ask(question) {
+  return new Promise((resolve) => {
+    rl.question(question, resolve);
+  });
+}
+
+async function setup() {
+  const existing = loadConfig();
+  const hasInstances = existing?.instances?.length > 0;
+  const isOldFormat = existing?.token && !existing?.instances;
+
+  console.log("\n=== Sentry MCP Setup ===\n");
+
+  if (hasInstances || isOldFormat) {
+    if (isOldFormat) {
+      console.log(`Existing single-instance config found (${existing.baseUrl})\n`);
+    } else {
+      console.log("Existing instances:");
+      for (const inst of existing.instances) {
+        const isDefault = inst.name === existing.defaultInstance ? " (default)" : "";
+        const projs = inst.projects?.length > 0 ? ` [${inst.projects.join(", ")}]` : "";
+        console.log(`  - ${inst.name}${isDefault}: ${inst.baseUrl} (org: ${inst.orgSlug})${projs}`);
+      }
+      console.log();
+    }
+
+    const action = await ask("Add new instance, or fresh setup? (add/fresh): ");
+    if (action.trim().toLowerCase() === "fresh") {
+      // Fall through to single setup
+    } else {
+      return await addInstance(existing);
+    }
+  }
+
+  console.log("To get your Sentry API token:");
+  console.log("1. Go to https://sentry.io/settings/account/api/auth-tokens/");
+  console.log("   (or your self-hosted Sentry Settings > API > Auth Tokens)");
+  console.log("2. Create a new token with scopes: event:read, project:read, org:read, member:read");
+  console.log("3. Copy the token\n");
+
+  const token = await ask("Sentry API token: ");
+  const baseUrl = await ask("Sentry base URL (e.g., https://sentry.io or https://my-org.sentry.io): ");
+  const orgSlug = await ask("Organization slug: ");
+  const projectSlug = await ask("Default project slug (optional, press Enter to skip): ");
+
+  saveConfig({
+    token: token.trim(),
+    baseUrl: baseUrl.trim().replace(/\/+$/, ""),
+    orgSlug: orgSlug.trim(),
+    projectSlug: projectSlug.trim() || "",
+  });
+  console.log(`\nConfig saved to ${configPath}`);
+
+  printSetupComplete();
+  rl.close();
+}
+
+async function addInstance(config) {
+  // Migrate old format if needed
+  if (config.token && !config.instances) {
+    const oldName = await ask("Name for your existing instance (e.g., work): ");
+    const oldProjects = await ask("Project slugs for existing instance (comma-separated): ");
+    config = {
+      instances: [{
+        name: oldName.trim() || "default",
+        token: config.token,
+        baseUrl: config.baseUrl,
+        orgSlug: config.orgSlug,
+        projectSlug: config.projectSlug || "",
+        projects: oldProjects.split(",").map((p) => p.trim().toLowerCase()).filter(Boolean),
+      }],
+      defaultInstance: oldName.trim() || "default",
+    };
+  }
+
+  if (!config.instances) config.instances = [];
+
+  console.log("\n--- Add New Instance ---\n");
+  console.log("To get your Sentry API token:");
+  console.log("1. Go to https://sentry.io/settings/account/api/auth-tokens/");
+  console.log("   (or your self-hosted Sentry Settings > API > Auth Tokens)");
+  console.log("2. Create a new token with scopes: event:read, project:read, org:read, member:read");
+  console.log("3. Copy the token\n");
+
+  const name = await ask("Instance name (e.g., personal): ");
+  const token = await ask("Sentry API token: ");
+  const baseUrl = await ask("Sentry base URL (e.g., https://sentry.io or https://my-org.sentry.io): ");
+  const orgSlug = await ask("Organization slug: ");
+  const projectSlug = await ask("Default project slug (optional, press Enter to skip): ");
+  const projectsInput = await ask("Project slugs to route to this instance (comma-separated, optional): ");
+  const projects = projectsInput.split(",").map((p) => p.trim().toLowerCase()).filter(Boolean);
+
+  const instance = {
+    name: name.trim(),
+    token: token.trim(),
+    baseUrl: baseUrl.trim().replace(/\/+$/, ""),
+    orgSlug: orgSlug.trim(),
+    projectSlug: projectSlug.trim() || "",
+    projects,
+  };
+
+  // Replace or add
+  const idx = config.instances.findIndex((i) => i.name === instance.name);
+  if (idx >= 0) {
+    config.instances[idx] = instance;
+  } else {
+    config.instances.push(instance);
+  }
+
+  if (!config.defaultInstance) config.defaultInstance = instance.name;
+
+  const setDefault = await ask(`Set "${instance.name}" as default? (y/N): `);
+  if (setDefault.trim().toLowerCase() === "y") {
+    config.defaultInstance = instance.name;
+  }
+
+  saveConfig(config);
+  console.log(`\nInstance "${instance.name}" saved to ${configPath}`);
+
+  console.log("\nAll instances:");
+  for (const inst of config.instances) {
+    const isDefault = inst.name === config.defaultInstance ? " (default)" : "";
+    const projs = inst.projects?.length > 0 ? ` [${inst.projects.join(", ")}]` : "";
+    console.log(`  - ${inst.name}${isDefault}: ${inst.baseUrl} (org: ${inst.orgSlug})${projs}`);
+  }
+
+  printSetupComplete();
+  rl.close();
+}
+
+function printSetupComplete() {
+  console.log("\n=== Setup Complete ===");
+  console.log("\nIf you haven't already, add to Claude Code with:\n");
+  console.log("  claude mcp add --transport stdio sentry -- npx -y @rui.branco/sentry-mcp");
+  console.log("\nThen restart Claude Code and run /mcp to verify.");
+}
+
+setup().catch((e) => {
+  console.error("Setup failed:", e.message);
+  rl.close();
+  process.exit(1);
+});