bugsink-mcp-server 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 neno73
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,116 @@
+# Bugsink MCP Server
+
+MCP (Model Context Protocol) server for querying [Bugsink](https://bugsink.com) error tracking. Allows Claude Code to directly access your error reports.
+
+## Features
+
+- List all projects
+- List issues (errors) for a project
+- Get issue details
+- List events (error occurrences)
+- Get full event data
+- Get formatted stacktraces
+
+## Setup for Claude Code
+
+### 1. Install globally (recommended)
+
+```bash
+cd ~/Code/bugsink-mcp-server
+npm install
+npm link
+```
+
+### 2. Add to Claude Code settings
+
+Edit `~/.claude/settings.json` and add:
+
+```json
+{
+  "mcpServers": {
+    "bugsink": {
+      "type": "stdio",
+      "command": "node",
+      "args": ["/home/neno/Code/bugsink-mcp-server/src/index.js"],
+      "env": {
+        "BUGSINK_URL": "https://bug.sols.mk:8000",
+        "BUGSINK_TOKEN": "your-api-token-here"
+      }
+    }
+  }
+}
+```
+
+Or use npx (no install needed):
+
+```json
+{
+  "mcpServers": {
+    "bugsink": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "/home/neno/Code/bugsink-mcp-server"],
+      "env": {
+        "BUGSINK_URL": "https://bug.sols.mk:8000",
+        "BUGSINK_TOKEN": "your-api-token-here"
+      }
+    }
+  }
+}
+```
+
+### 3. Restart Claude Code
+
+After adding the configuration, restart Claude Code to load the MCP server.
+
+## Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `list_projects` | List all Bugsink projects |
+| `list_issues` | List issues for a project (sorted by last_seen) |
+| `get_issue` | Get details of a specific issue |
+| `list_events` | List events (occurrences) for an issue |
+| `get_event` | Get full event data including context |
+| `get_stacktrace` | Get formatted stacktrace markdown |
+
+## Usage Examples
+
+Once configured, you can ask Claude:
+
+- "Show me recent errors from Bugsink"
+- "Get the stacktrace for the latest error"
+- "What errors happened in project 3?"
+
+## Environment Variables
+
+| Variable | Required | Default | Description |
+|----------|----------|---------|-------------|
+| `BUGSINK_TOKEN` | Yes | - | Your Bugsink API token |
+| `BUGSINK_URL` | No | `https://bug.sols.mk:8000` | Bugsink instance URL |
+
+## Docker Usage (optional)
+
+Build and run with Docker:
+
+```bash
+docker build -t bugsink-mcp .
+docker run -e BUGSINK_TOKEN=your-token bugsink-mcp
+```
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Run in watch mode
+npm run dev
+
+# Test manually
+BUGSINK_TOKEN=your-token node src/index.js
+```
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "bugsink-mcp-server",
+  "version": "1.0.0",
+  "description": "MCP server for querying Bugsink error tracking",
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "bugsink-mcp": "./src/index.js"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "node src/index.js",
+    "dev": "node --watch src/index.js"
+  },
+  "keywords": ["mcp", "bugsink", "sentry", "error-tracking", "claude", "anthropic"],
+  "author": "neno73",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/solsmk/bugsink.git"
+  },
+  "homepage": "https://github.com/solsmk/bugsink#readme",
+  "bugs": {
+    "url": "https://github.com/solsmk/bugsink/issues"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.24.3",
+    "express": "^5.2.1",
+    "zod": "^4.1.13"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/index.js

@@ -0,0 +1,278 @@
+#!/usr/bin/env node
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+
+// Configuration from environment
+const BUGSINK_URL = process.env.BUGSINK_URL || "https://bug.sols.mk:8000";
+const BUGSINK_TOKEN = process.env.BUGSINK_TOKEN;
+
+if (!BUGSINK_TOKEN) {
+  console.error("Error: BUGSINK_TOKEN environment variable is required");
+  process.exit(1);
+}
+
+// Bugsink API client
+class BugsinkClient {
+  constructor(baseUrl, token) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.token = token;
+  }
+
+  async request(endpoint, params = {}) {
+    const url = new URL(`${this.baseUrl}/api/canonical/0${endpoint}`);
+    Object.entries(params).forEach(([key, value]) => {
+      if (value !== undefined) url.searchParams.append(key, value);
+    });
+
+    const response = await fetch(url.toString(), {
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        "Content-Type": "application/json",
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Bugsink API error: ${response.status} ${response.statusText}`);
+    }
+
+    // Check if response is JSON or text (stacktrace endpoint returns markdown)
+    const contentType = response.headers.get("content-type");
+    if (contentType && contentType.includes("application/json")) {
+      return response.json();
+    }
+    return response.text();
+  }
+
+  async listProjects() {
+    return this.request("/projects/");
+  }
+
+  async listIssues(projectId, options = {}) {
+    return this.request("/issues/", {
+      project: projectId,
+      order: options.order || "desc",
+      sort: options.sort || "last_seen",
+    });
+  }
+
+  async getIssue(issueId) {
+    return this.request(`/issues/${issueId}/`);
+  }
+
+  async listEvents(issueId, options = {}) {
+    return this.request("/events/", {
+      issue: issueId,
+      order: options.order || "desc",
+    });
+  }
+
+  async getEvent(eventId) {
+    return this.request(`/events/${eventId}/`);
+  }
+
+  async getStacktrace(eventId) {
+    return this.request(`/events/${eventId}/stacktrace/`);
+  }
+}
+
+// Initialize client
+const client = new BugsinkClient(BUGSINK_URL, BUGSINK_TOKEN);
+
+// Create MCP server
+const server = new Server(
+  {
+    name: "bugsink-mcp-server",
+    version: "1.0.0",
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+// Define tools
+const TOOLS = [
+  {
+    name: "list_projects",
+    description: "List all projects in Bugsink",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: [],
+    },
+  },
+  {
+    name: "list_issues",
+    description: "List issues for a project. Returns recent errors/exceptions.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project_id: {
+          type: "string",
+          description: "The project ID to list issues for",
+        },
+        sort: {
+          type: "string",
+          enum: ["last_seen", "digest_order"],
+          description: "Sort order (default: last_seen)",
+        },
+        order: {
+          type: "string",
+          enum: ["asc", "desc"],
+          description: "Order direction (default: desc)",
+        },
+      },
+      required: ["project_id"],
+    },
+  },
+  {
+    name: "get_issue",
+    description: "Get details of a specific issue including error message and metadata",
+    inputSchema: {
+      type: "object",
+      properties: {
+        issue_id: {
+          type: "string",
+          description: "The issue ID to retrieve",
+        },
+      },
+      required: ["issue_id"],
+    },
+  },
+  {
+    name: "list_events",
+    description: "List events (occurrences) for an issue. Each event is one occurrence of the error.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        issue_id: {
+          type: "string",
+          description: "The issue ID to list events for",
+        },
+        order: {
+          type: "string",
+          enum: ["asc", "desc"],
+          description: "Order direction (default: desc)",
+        },
+      },
+      required: ["issue_id"],
+    },
+  },
+  {
+    name: "get_event",
+    description: "Get full details of a specific event including the complete error data payload",
+    inputSchema: {
+      type: "object",
+      properties: {
+        event_id: {
+          type: "string",
+          description: "The event ID to retrieve",
+        },
+      },
+      required: ["event_id"],
+    },
+  },
+  {
+    name: "get_stacktrace",
+    description: "Get the stacktrace for an event as formatted markdown. Best for understanding where an error occurred.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        event_id: {
+          type: "string",
+          description: "The event ID to get stacktrace for",
+        },
+      },
+      required: ["event_id"],
+    },
+  },
+];
+
+// Handle list tools request
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return { tools: TOOLS };
+});
+
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    let result;
+
+    switch (name) {
+      case "list_projects":
+        result = await client.listProjects();
+        break;
+
+      case "list_issues":
+        result = await client.listIssues(args.project_id, {
+          sort: args.sort,
+          order: args.order,
+        });
+        break;
+
+      case "get_issue":
+        result = await client.getIssue(args.issue_id);
+        break;
+
+      case "list_events":
+        result = await client.listEvents(args.issue_id, {
+          order: args.order,
+        });
+        break;
+
+      case "get_event":
+        result = await client.getEvent(args.event_id);
+        break;
+
+      case "get_stacktrace":
+        result = await client.getStacktrace(args.event_id);
+        // Stacktrace is already markdown text
+        return {
+          content: [{ type: "text", text: result }],
+        };
+
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+
+    // Format JSON result
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(result, null, 2),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error.message}`,
+        },
+      ],
+      isError: true,
+    };
+  }
+});
+
+// Start server
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Bugsink MCP server running on stdio");
+}
+
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});