@bbearai/mcp-server 0.3.0

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@bbearai/mcp-server",
+  "version": "0.3.0",
+  "description": "MCP server for BugBear - allows Claude Code to query bug reports",
+  "main": "dist/index.js",
+  "bin": {
+    "bugbear-mcp": "./dist/index.js",
+    "bugbear-mcp-api": "./dist/index-api.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx watch src/index.ts",
+    "dev:api": "tsx watch src/index-api.ts",
+    "start": "node dist/index.js",
+    "start:api": "node dist/index-api.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.25.3",
+    "@supabase/supabase-js": "^2.39.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/index-api.ts

@@ -0,0 +1,403 @@
+#!/usr/bin/env node
+/**
+ * BugBear MCP Server (API Version)
+ *
+ * This version uses the BugBear API instead of connecting directly to Supabase.
+ * This is the recommended setup for new projects.
+ *
+ * Configuration:
+ *   BUGBEAR_API_KEY - Your project's API key (bb_live_xxx)
+ *   BUGBEAR_API_URL - API URL (optional, defaults to https://bugbear.ai/api/v1)
+ */
+
+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
+const API_KEY = process.env.BUGBEAR_API_KEY || '';
+// Default to production URL, but allow override for local development
+const API_URL = process.env.BUGBEAR_API_URL || 'https://app.bugbear.ai/api/v1';
+
+// Validate configuration
+function validateConfig() {
+  if (!API_KEY) {
+    console.error('BugBear MCP Server: BUGBEAR_API_KEY environment variable is required');
+    console.error('Get your API key from: https://bugbear.ai/settings/projects');
+    process.exit(1);
+  }
+
+  if (!API_KEY.startsWith('bb_live_') && !API_KEY.startsWith('bb_test_')) {
+    console.error('BugBear MCP Server: Invalid API key format');
+    console.error('API keys should start with bb_live_ or bb_test_');
+    process.exit(1);
+  }
+}
+
+// API helper
+async function apiRequest(
+  endpoint: string,
+  method: 'GET' | 'POST' | 'PATCH' = 'GET',
+  body?: Record<string, unknown>
+): Promise<{ data?: unknown; error?: string }> {
+  try {
+    const url = `${API_URL}${endpoint}`;
+    const options: RequestInit = {
+      method,
+      headers: {
+        'Authorization': `Bearer ${API_KEY}`,
+        'Content-Type': 'application/json',
+      },
+    };
+
+    if (body && method !== 'GET') {
+      options.body = JSON.stringify(body);
+    }
+
+    const response = await fetch(url, options);
+    const json = await response.json();
+
+    if (!response.ok) {
+      return { error: json.error || `API error: ${response.status}` };
+    }
+
+    return { data: json.data };
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : 'API request failed' };
+  }
+}
+
+// Tool definitions
+const tools = [
+  {
+    name: 'list_reports',
+    description: 'List recent bug reports for the project',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        limit: {
+          type: 'number',
+          description: 'Maximum reports to return (default: 10, max: 50)',
+        },
+        status: {
+          type: 'string',
+          enum: ['new', 'reviewed', 'in_progress', 'resolved', 'closed'],
+          description: 'Filter by status',
+        },
+        severity: {
+          type: 'string',
+          enum: ['critical', 'high', 'medium', 'low'],
+          description: 'Filter by severity',
+        },
+        report_type: {
+          type: 'string',
+          enum: ['bug', 'test_fail', 'feedback', 'suggestion'],
+          description: 'Filter by type',
+        },
+      },
+    },
+  },
+  {
+    name: 'get_report',
+    description: 'Get detailed information about a specific report',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        report_id: {
+          type: 'string',
+          description: 'The UUID of the report',
+        },
+      },
+      required: ['report_id'],
+    },
+  },
+  {
+    name: 'update_report_status',
+    description: 'Update the status of a report',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        report_id: {
+          type: 'string',
+          description: 'The UUID of the report',
+        },
+        status: {
+          type: 'string',
+          enum: ['new', 'reviewed', 'in_progress', 'resolved', 'closed'],
+          description: 'New status',
+        },
+        resolution: {
+          type: 'string',
+          description: 'Resolution notes (optional)',
+        },
+      },
+      required: ['report_id', 'status'],
+    },
+  },
+  {
+    name: 'create_bug_report',
+    description: 'Create a new bug report from Claude Code',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        description: {
+          type: 'string',
+          description: 'Detailed description of the bug',
+        },
+        severity: {
+          type: 'string',
+          enum: ['critical', 'high', 'medium', 'low'],
+          description: 'Bug severity',
+        },
+        file_path: {
+          type: 'string',
+          description: 'File path where the bug was found',
+        },
+        line_number: {
+          type: 'number',
+          description: 'Line number',
+        },
+        code_snippet: {
+          type: 'string',
+          description: 'Relevant code snippet',
+        },
+        suggested_fix: {
+          type: 'string',
+          description: 'Suggested fix',
+        },
+      },
+      required: ['description', 'severity'],
+    },
+  },
+  {
+    name: 'get_project_info',
+    description: 'Get project information and statistics',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {},
+    },
+  },
+  {
+    name: 'list_test_cases',
+    description: 'List test cases for the project',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        limit: {
+          type: 'number',
+          description: 'Max test cases to return (default: 50)',
+        },
+        priority: {
+          type: 'string',
+          enum: ['P0', 'P1', 'P2', 'P3'],
+          description: 'Filter by priority',
+        },
+      },
+    },
+  },
+  {
+    name: 'create_test_case',
+    description: 'Create a new test case',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        test_key: {
+          type: 'string',
+          description: 'Unique test ID (e.g., TC-001)',
+        },
+        title: {
+          type: 'string',
+          description: 'Test title',
+        },
+        description: {
+          type: 'string',
+          description: 'Test description',
+        },
+        steps: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              stepNumber: { type: 'number' },
+              action: { type: 'string' },
+              expectedResult: { type: 'string' },
+            },
+          },
+          description: 'Test steps',
+        },
+        expected_result: {
+          type: 'string',
+          description: 'Expected outcome',
+        },
+        priority: {
+          type: 'string',
+          enum: ['P0', 'P1', 'P2', 'P3'],
+          description: 'Priority level',
+        },
+      },
+      required: ['test_key', 'title', 'steps', 'expected_result'],
+    },
+  },
+  {
+    name: 'get_qa_tracks',
+    description: 'Get QA tracks for the project',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {},
+    },
+  },
+  {
+    name: 'verify_connection',
+    description: 'Verify the API connection is working',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {},
+    },
+  },
+];
+
+// Tool handlers
+async function handleTool(
+  name: string,
+  args: Record<string, unknown>
+): Promise<{ content: Array<{ type: 'text'; text: string }> }> {
+  let result: { data?: unknown; error?: string };
+
+  switch (name) {
+    case 'list_reports': {
+      const params = new URLSearchParams();
+      if (args.limit) params.set('limit', String(args.limit));
+      if (args.status) params.set('status', String(args.status));
+      if (args.severity) params.set('severity', String(args.severity));
+      if (args.report_type) params.set('report_type', String(args.report_type));
+      result = await apiRequest(`/reports?${params.toString()}`);
+      break;
+    }
+
+    case 'get_report':
+      result = await apiRequest(`/reports/${args.report_id}`);
+      break;
+
+    case 'update_report_status':
+      result = await apiRequest(`/reports/${args.report_id}`, 'PATCH', {
+        status: args.status,
+        resolution: args.resolution,
+      });
+      break;
+
+    case 'create_bug_report': {
+      // Build enhanced description with code context
+      let description = String(args.description);
+      if (args.file_path) {
+        description += `\n\n📁 File: ${args.file_path}`;
+        if (args.line_number) {
+          description += `:${args.line_number}`;
+        }
+      }
+      if (args.code_snippet) {
+        description += `\n\n\`\`\`\n${args.code_snippet}\n\`\`\``;
+      }
+      if (args.suggested_fix) {
+        description += `\n\n💡 Suggested fix: ${args.suggested_fix}`;
+      }
+
+      result = await apiRequest('/reports', 'POST', {
+        report_type: 'bug',
+        description,
+        severity: args.severity,
+        app_context: {
+          source: 'claude_code',
+          file_path: args.file_path,
+          line_number: args.line_number,
+        },
+      });
+      break;
+    }
+
+    case 'get_project_info':
+      result = await apiRequest('/project');
+      break;
+
+    case 'list_test_cases': {
+      const params = new URLSearchParams();
+      if (args.limit) params.set('limit', String(args.limit));
+      if (args.priority) params.set('priority', String(args.priority));
+      result = await apiRequest(`/test-cases?${params.toString()}`);
+      break;
+    }
+
+    case 'create_test_case':
+      result = await apiRequest('/test-cases', 'POST', {
+        test_key: args.test_key,
+        title: args.title,
+        description: args.description,
+        steps: args.steps,
+        expected_result: args.expected_result,
+        priority: args.priority || 'P2',
+      });
+      break;
+
+    case 'get_qa_tracks':
+      result = await apiRequest('/qa-tracks');
+      break;
+
+    case 'verify_connection':
+      result = await apiRequest('/verify');
+      break;
+
+    default:
+      result = { error: `Unknown tool: ${name}` };
+  }
+
+  if (result.error) {
+    return {
+      content: [{ type: 'text', text: `Error: ${result.error}` }],
+    };
+  }
+
+  return {
+    content: [{ type: 'text', text: JSON.stringify(result.data, null, 2) }],
+  };
+}
+
+// Main
+async function main() {
+  validateConfig();
+
+  const server = new Server(
+    {
+      name: 'bugbear',
+      version: '0.2.0',
+    },
+    {
+      capabilities: {
+        tools: {},
+      },
+    }
+  );
+
+  // List tools
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools,
+  }));
+
+  // Handle tool calls
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    return await handleTool(name, (args || {}) as Record<string, unknown>);
+  });
+
+  // Connect via stdio
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+
+  console.error('BugBear MCP Server (API) connected');
+}
+
+main().catch((error) => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});