@bbearai/mcp-server 0.5.0 → 0.5.1

package/src/index.ts

@@ -452,6 +452,10 @@ const tools = [
           items: { type: 'string' },
           description: 'List of files that were modified to fix this bug',
         },
+        notify_tester: {
+          type: 'boolean',
+          description: 'If true, notify the original tester about the fix with a message and verification task. Default: false (silent resolve).',
+        },
       },
       required: ['report_id', 'commit_sha'],
     },
@@ -919,6 +923,125 @@ const tools = [
       },
     },
   },
+  // === TESTER & ASSIGNMENT MANAGEMENT TOOLS ===
+  {
+    name: 'list_testers',
+    description: 'List all QA testers for the project with their status, platforms, and workload counts.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        status: {
+          type: 'string',
+          enum: ['active', 'inactive', 'invited'],
+          description: 'Filter by tester status (default: all)',
+        },
+        platform: {
+          type: 'string',
+          enum: ['ios', 'android', 'web'],
+          description: 'Filter by platform support',
+        },
+      },
+    },
+  },
+  {
+    name: 'list_test_runs',
+    description: 'List testing campaigns (test runs) for the project with pass/fail stats.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        status: {
+          type: 'string',
+          enum: ['draft', 'active', 'paused', 'completed', 'archived'],
+          description: 'Filter by test run status',
+        },
+        limit: {
+          type: 'number',
+          description: 'Maximum number of runs to return (default: 20)',
+        },
+      },
+    },
+  },
+  {
+    name: 'create_test_run',
+    description: 'Create a new testing campaign (test run). Tests can then be assigned to testers within this run.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        name: {
+          type: 'string',
+          description: 'Name for the test run (e.g. "v2.1 QA Pass", "Sprint 5 Testing")',
+        },
+        description: {
+          type: 'string',
+          description: 'Optional description of the test run scope and goals',
+        },
+      },
+      required: ['name'],
+    },
+  },
+  {
+    name: 'list_test_assignments',
+    description: 'List test assignments showing which tests are assigned to which testers, with status tracking. Joins test case and tester info.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        tester_id: {
+          type: 'string',
+          description: 'Filter by tester UUID',
+        },
+        test_run_id: {
+          type: 'string',
+          description: 'Filter by test run UUID',
+        },
+        status: {
+          type: 'string',
+          enum: ['pending', 'in_progress', 'passed', 'failed', 'blocked', 'skipped'],
+          description: 'Filter by assignment status',
+        },
+        limit: {
+          type: 'number',
+          description: 'Maximum number of assignments to return (default: 50, max: 200)',
+        },
+      },
+    },
+  },
+  {
+    name: 'assign_tests',
+    description: 'Assign one or more test cases to a tester. Optionally assign within a test run. Skips duplicates gracefully.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        tester_id: {
+          type: 'string',
+          description: 'UUID of the tester to assign tests to (required)',
+        },
+        test_case_ids: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Array of test case UUIDs to assign (required)',
+        },
+        test_run_id: {
+          type: 'string',
+          description: 'Optional test run UUID to group assignments under',
+        },
+      },
+      required: ['tester_id', 'test_case_ids'],
+    },
+  },
+  {
+    name: 'get_tester_workload',
+    description: 'View a specific tester\'s current workload — assignment counts by status and recent assignments.',
+    inputSchema: {
+      type: 'object' as const,
+      properties: {
+        tester_id: {
+          type: 'string',
+          description: 'UUID of the tester (required)',
+        },
+      },
+      required: ['tester_id'],
+    },
+  },
 ];
 
 // Tool handlers
@@ -930,7 +1053,7 @@ async function listReports(args: {
 }) {
   let query = supabase
     .from('reports')
-    .select('id, report_type, severity, status, description, app_context, created_at, reporter_name, reporter_email, tester:testers(name, email)')
+    .select('id, report_type, severity, status, description, app_context, created_at, reporter_name, tester:testers(name)')
     .eq('project_id', PROJECT_ID)
     .order('created_at', { ascending: false })
     .limit(Math.min(args.limit || 10, 50));
@@ -991,10 +1114,8 @@ async function getReport(args: { report_id: string }) {
       created_at: data.created_at,
       reporter: data.tester ? {
         name: data.tester.name,
-        email: data.tester.email,
       } : (data.reporter_name ? {
         name: data.reporter_name,
-        email: data.reporter_email,
       } : null),
       track: data.track ? {
         name: data.track.name,
@@ -1194,13 +1315,16 @@ async function createTestCase(args: {
   // Find track ID if track name provided
   let trackId: string | null = null;
   if (args.track) {
-    const { data: trackData } = await supabase
-      .from('qa_tracks')
-      .select('id')
-      .eq('project_id', PROJECT_ID)
-      .ilike('name', `%${args.track}%`)
-      .single();
-    trackId = trackData?.id || null;
+    const sanitizedTrack = sanitizeSearchQuery(args.track);
+    if (sanitizedTrack) {
+      const { data: trackData } = await supabase
+        .from('qa_tracks')
+        .select('id')
+        .eq('project_id', PROJECT_ID)
+        .ilike('name', `%${sanitizedTrack}%`)
+        .single();
+      trackId = trackData?.id || null;
+    }
   }
 
   const testCase = {
@@ -1674,7 +1798,11 @@ async function getTestPriorities(args: {
   const includeFactors = args.include_factors !== false;
 
   // First, refresh the route stats
-  await supabase.rpc('refresh_route_test_stats', { p_project_id: PROJECT_ID });
+  const { error: refreshError } = await supabase.rpc('refresh_route_test_stats', { p_project_id: PROJECT_ID });
+  if (refreshError) {
+    // Non-fatal: proceed with potentially stale data but warn
+    console.warn('Failed to refresh route stats:', refreshError.message);
+  }
 
   // Get prioritized routes
   const { data: routes, error } = await supabase
@@ -2114,7 +2242,9 @@ async function getCoverageMatrix(args: {
       .from('test_assignments')
       .select('test_case_id, status, completed_at')
       .eq('project_id', PROJECT_ID)
-      .in('status', ['passed', 'failed']);
+      .in('status', ['passed', 'failed'])
+      .order('completed_at', { ascending: false })
+      .limit(2000);
     assignments = data || [];
   }
 
@@ -2286,7 +2416,11 @@ async function getStaleCoverage(args: {
   const limit = args.limit || 20;
 
   // Refresh stats first
-  await supabase.rpc('refresh_route_test_stats', { p_project_id: PROJECT_ID });
+  const { error: refreshError } = await supabase.rpc('refresh_route_test_stats', { p_project_id: PROJECT_ID });
+  if (refreshError) {
+    // Non-fatal: proceed with potentially stale data but warn
+    console.warn('Failed to refresh route stats:', refreshError.message);
+  }
 
   // Get routes ordered by staleness and risk
   const { data: routes, error } = await supabase
@@ -2382,12 +2516,30 @@ async function generateDeployChecklist(args: {
     });
   }
 
-  // Get test cases for these routes
-  const { data: testCases } = await supabase
-    .from('test_cases')
-    .select('id, test_key, title, target_route, category, priority, track:qa_tracks(name)')
-    .eq('project_id', PROJECT_ID)
-    .or(routes.map(r => `target_route.eq.${r}`).join(',') + ',' + routes.map(r => `category.eq.${r}`).join(','));
+  // Limit routes array to prevent query explosion
+  const safeRoutes = routes.slice(0, 100);
+
+  // Get test cases for these routes (use separate queries to avoid filter injection)
+  const [{ data: byRoute }, { data: byCategory }] = await Promise.all([
+    supabase
+      .from('test_cases')
+      .select('id, test_key, title, target_route, category, priority, track:qa_tracks(name)')
+      .eq('project_id', PROJECT_ID)
+      .in('target_route', safeRoutes),
+    supabase
+      .from('test_cases')
+      .select('id, test_key, title, target_route, category, priority, track:qa_tracks(name)')
+      .eq('project_id', PROJECT_ID)
+      .in('category', safeRoutes),
+  ]);
+
+  // Deduplicate by id
+  const seenIds = new Set<string>();
+  const testCases = [...(byRoute || []), ...(byCategory || [])].filter(tc => {
+    if (seenIds.has(tc.id)) return false;
+    seenIds.add(tc.id);
+    return true;
+  });
 
   // Get route stats for risk assessment
   const { data: routeStats } = await supabase
@@ -2988,10 +3140,17 @@ async function analyzeCommitForTesting(args: {
 
   for (const mapping of mappings || []) {
     const matchedFiles = filesChanged.filter(file => {
-      const pattern = mapping.file_pattern
-        .replace(/\*\*/g, '.*')
-        .replace(/\*/g, '[^/]*');
-      return new RegExp(pattern).test(file);
+      try {
+        // Validate pattern complexity to prevent ReDoS
+        if (mapping.file_pattern.length > 200) return false;
+        const pattern = mapping.file_pattern
+          .replace(/[.+?^${}()|[\]\\]/g, '\\$&') // Escape regex special chars first
+          .replace(/\\\*\\\*/g, '.*')              // Then convert glob ** to .*
+          .replace(/\\\*/g, '[^/]*');               // And glob * to [^/]*
+        return new RegExp(`^${pattern}$`).test(file);
+      } catch {
+        return false; // Skip malformed patterns
+      }
     });
 
     if (matchedFiles.length > 0) {
@@ -3736,6 +3895,7 @@ async function markFixedWithCommit(args: {
   commit_message?: string;
   resolution_notes?: string;
   files_changed?: string[];
+  notify_tester?: boolean;
 }) {
   if (!isValidUUID(args.report_id)) {
     return { error: 'Invalid report_id format' };
@@ -3759,6 +3919,7 @@ async function markFixedWithCommit(args: {
     status: 'resolved',
     resolved_at: new Date().toISOString(),
     resolution_notes: args.resolution_notes || `Fixed in commit ${args.commit_sha.slice(0, 7)}`,
+    notify_tester: args.notify_tester === true, // Opt-in: only notify if explicitly requested
     code_context: {
       ...existingContext,
       fix: {
@@ -3781,11 +3942,16 @@ async function markFixedWithCommit(args: {
     return { error: error.message };
   }
 
+  const notificationStatus = args.notify_tester
+    ? 'The original tester will be notified and assigned a verification task.'
+    : 'No notification sent (silent resolve). A verification task was created.';
+
   return {
     success: true,
-    message: `Bug marked as fixed in commit ${args.commit_sha.slice(0, 7)}`,
+    message: `Bug marked as fixed in commit ${args.commit_sha.slice(0, 7)}. ${notificationStatus}`,
     report_id: args.report_id,
     commit: args.commit_sha,
+    tester_notified: args.notify_tester === true,
     next_steps: [
       'Consider running create_regression_test to prevent this bug from recurring',
       'Push your changes to trigger CI/CD',
@@ -4620,6 +4786,423 @@ Which files or areas would you like me to analyze?`;
   }
 }
 
+// === TESTER & ASSIGNMENT MANAGEMENT HANDLERS ===
+
+async function listTesters(args: {
+  status?: string;
+  platform?: string;
+}) {
+  let query = supabase
+    .from('testers')
+    .select('id, name, email, status, platforms, tier, assigned_count, completed_count, notes, created_at')
+    .eq('project_id', PROJECT_ID)
+    .order('name', { ascending: true });
+
+  if (args.status) {
+    query = query.eq('status', args.status);
+  }
+
+  const { data, error } = await query;
+
+  if (error) {
+    return { error: error.message };
+  }
+
+  let testers = data || [];
+
+  // Filter by platform if specified (platforms is an array column)
+  if (args.platform) {
+    testers = testers.filter((t: any) =>
+      t.platforms && t.platforms.includes(args.platform)
+    );
+  }
+
+  return {
+    count: testers.length,
+    testers: testers.map((t: any) => ({
+      id: t.id,
+      name: t.name,
+      email: t.email,
+      status: t.status,
+      platforms: t.platforms,
+      tier: t.tier,
+      assignedCount: t.assigned_count,
+      completedCount: t.completed_count,
+      notes: t.notes,
+    })),
+  };
+}
+
+async function listTestRuns(args: {
+  status?: string;
+  limit?: number;
+}) {
+  const limit = Math.min(args.limit || 20, 50);
+
+  let query = supabase
+    .from('test_runs')
+    .select('id, name, description, status, total_tests, passed_tests, failed_tests, started_at, completed_at, created_at')
+    .eq('project_id', PROJECT_ID)
+    .order('created_at', { ascending: false })
+    .limit(limit);
+
+  if (args.status) {
+    query = query.eq('status', args.status);
+  }
+
+  const { data, error } = await query;
+
+  if (error) {
+    return { error: error.message };
+  }
+
+  return {
+    count: (data || []).length,
+    testRuns: (data || []).map((r: any) => ({
+      id: r.id,
+      name: r.name,
+      description: r.description,
+      status: r.status,
+      totalTests: r.total_tests,
+      passedTests: r.passed_tests,
+      failedTests: r.failed_tests,
+      passRate: r.total_tests > 0 ? Math.round((r.passed_tests / r.total_tests) * 100) : 0,
+      startedAt: r.started_at,
+      completedAt: r.completed_at,
+      createdAt: r.created_at,
+    })),
+  };
+}
+
+async function createTestRun(args: {
+  name: string;
+  description?: string;
+}) {
+  if (!args.name || args.name.trim().length === 0) {
+    return { error: 'Test run name is required' };
+  }
+
+  const { data, error } = await supabase
+    .from('test_runs')
+    .insert({
+      project_id: PROJECT_ID,
+      name: args.name.trim(),
+      description: args.description?.trim() || null,
+      status: 'draft',
+    })
+    .select('id, name, description, status, created_at')
+    .single();
+
+  if (error) {
+    return { error: error.message };
+  }
+
+  return {
+    success: true,
+    testRun: {
+      id: data.id,
+      name: data.name,
+      description: data.description,
+      status: data.status,
+      createdAt: data.created_at,
+    },
+    message: `Test run "${data.name}" created. Use assign_tests to add test assignments.`,
+  };
+}
+
+async function listTestAssignments(args: {
+  tester_id?: string;
+  test_run_id?: string;
+  status?: string;
+  limit?: number;
+}) {
+  const limit = Math.min(args.limit || 50, 200);
+
+  if (args.tester_id && !isValidUUID(args.tester_id)) {
+    return { error: 'Invalid tester_id format' };
+  }
+  if (args.test_run_id && !isValidUUID(args.test_run_id)) {
+    return { error: 'Invalid test_run_id format' };
+  }
+
+  let query = supabase
+    .from('test_assignments')
+    .select(`
+      id,
+      status,
+      assigned_at,
+      started_at,
+      completed_at,
+      duration_seconds,
+      is_verification,
+      notes,
+      test_case:test_cases(id, test_key, title, priority, target_route),
+      tester:testers(id, name, email),
+      test_run:test_runs(id, name)
+    `)
+    .eq('project_id', PROJECT_ID)
+    .order('assigned_at', { ascending: false })
+    .limit(limit);
+
+  if (args.tester_id) {
+    query = query.eq('tester_id', args.tester_id);
+  }
+  if (args.test_run_id) {
+    query = query.eq('test_run_id', args.test_run_id);
+  }
+  if (args.status) {
+    query = query.eq('status', args.status);
+  }
+
+  const { data, error } = await query;
+
+  if (error) {
+    return { error: error.message };
+  }
+
+  return {
+    count: (data || []).length,
+    assignments: (data || []).map((a: any) => ({
+      id: a.id,
+      status: a.status,
+      assignedAt: a.assigned_at,
+      startedAt: a.started_at,
+      completedAt: a.completed_at,
+      durationSeconds: a.duration_seconds,
+      isVerification: a.is_verification,
+      notes: a.notes,
+      testCase: a.test_case ? {
+        id: a.test_case.id,
+        testKey: a.test_case.test_key,
+        title: a.test_case.title,
+        priority: a.test_case.priority,
+        targetRoute: a.test_case.target_route,
+      } : null,
+      tester: a.tester ? {
+        id: a.tester.id,
+        name: a.tester.name,
+        email: a.tester.email,
+      } : null,
+      testRun: a.test_run ? {
+        id: a.test_run.id,
+        name: a.test_run.name,
+      } : null,
+    })),
+  };
+}
+
+async function assignTests(args: {
+  tester_id: string;
+  test_case_ids: string[];
+  test_run_id?: string;
+}) {
+  // Validate inputs
+  if (!isValidUUID(args.tester_id)) {
+    return { error: 'Invalid tester_id format' };
+  }
+  if (!args.test_case_ids || args.test_case_ids.length === 0) {
+    return { error: 'At least one test_case_id is required' };
+  }
+  if (args.test_case_ids.length > 50) {
+    return { error: 'Maximum 50 test cases per assignment batch' };
+  }
+  for (const id of args.test_case_ids) {
+    if (!isValidUUID(id)) {
+      return { error: `Invalid test_case_id format: ${id}` };
+    }
+  }
+  if (args.test_run_id && !isValidUUID(args.test_run_id)) {
+    return { error: 'Invalid test_run_id format' };
+  }
+
+  // Verify tester exists and is active
+  const { data: tester, error: testerErr } = await supabase
+    .from('testers')
+    .select('id, name, email, status')
+    .eq('id', args.tester_id)
+    .eq('project_id', PROJECT_ID)
+    .single();
+
+  if (testerErr || !tester) {
+    return { error: 'Tester not found in this project' };
+  }
+  if (tester.status !== 'active') {
+    return { error: `Tester "${tester.name}" is ${tester.status}, not active` };
+  }
+
+  // Verify test cases exist for this project
+  const { data: testCases, error: tcErr } = await supabase
+    .from('test_cases')
+    .select('id, test_key, title')
+    .eq('project_id', PROJECT_ID)
+    .in('id', args.test_case_ids);
+
+  if (tcErr) {
+    return { error: tcErr.message };
+  }
+
+  const foundIds = new Set((testCases || []).map((tc: any) => tc.id));
+  const missingIds = args.test_case_ids.filter(id => !foundIds.has(id));
+
+  if (missingIds.length > 0) {
+    return {
+      error: `Test cases not found in this project: ${missingIds.join(', ')}`,
+    };
+  }
+
+  // Verify test run exists if provided
+  if (args.test_run_id) {
+    const { data: run, error: runErr } = await supabase
+      .from('test_runs')
+      .select('id')
+      .eq('id', args.test_run_id)
+      .eq('project_id', PROJECT_ID)
+      .single();
+
+    if (runErr || !run) {
+      return { error: 'Test run not found in this project' };
+    }
+  }
+
+  // Build assignment rows
+  const rows = args.test_case_ids.map(tcId => ({
+    project_id: PROJECT_ID,
+    test_case_id: tcId,
+    tester_id: args.tester_id,
+    test_run_id: args.test_run_id || null,
+    status: 'pending',
+  }));
+
+  // Insert — use upsert-like approach: insert and handle conflicts
+  const { data: inserted, error: insertErr } = await supabase
+    .from('test_assignments')
+    .insert(rows)
+    .select('id, test_case_id');
+
+  if (insertErr) {
+    // Check if it's a unique constraint violation
+    if (insertErr.message.includes('duplicate') || insertErr.message.includes('unique')) {
+      // Try inserting one by one to find duplicates
+      const created: any[] = [];
+      const skipped: string[] = [];
+
+      for (const row of rows) {
+        const { data: single, error: singleErr } = await supabase
+          .from('test_assignments')
+          .insert(row)
+          .select('id, test_case_id')
+          .single();
+
+        if (singleErr) {
+          const tc = testCases?.find((t: any) => t.id === row.test_case_id);
+          skipped.push(tc?.test_key || row.test_case_id);
+        } else if (single) {
+          created.push(single);
+        }
+      }
+
+      return {
+        success: true,
+        created: created.length,
+        skipped: skipped.length,
+        skippedTests: skipped,
+        tester: { id: tester.id, name: tester.name },
+        message: `Assigned ${created.length} test(s) to ${tester.name}. ${skipped.length} skipped (already assigned).`,
+      };
+    }
+    return { error: insertErr.message };
+  }
+
+  return {
+    success: true,
+    created: (inserted || []).length,
+    skipped: 0,
+    tester: { id: tester.id, name: tester.name },
+    testRun: args.test_run_id || null,
+    message: `Assigned ${(inserted || []).length} test(s) to ${tester.name}.`,
+  };
+}
+
+async function getTesterWorkload(args: {
+  tester_id: string;
+}) {
+  if (!isValidUUID(args.tester_id)) {
+    return { error: 'Invalid tester_id format' };
+  }
+
+  // Get tester info
+  const { data: tester, error: testerErr } = await supabase
+    .from('testers')
+    .select('id, name, email, status, platforms, tier')
+    .eq('id', args.tester_id)
+    .eq('project_id', PROJECT_ID)
+    .single();
+
+  if (testerErr || !tester) {
+    return { error: 'Tester not found in this project' };
+  }
+
+  // Get all assignments for this tester in this project
+  const { data: assignments, error: assignErr } = await supabase
+    .from('test_assignments')
+    .select(`
+      id,
+      status,
+      assigned_at,
+      completed_at,
+      test_case:test_cases(test_key, title, priority),
+      test_run:test_runs(name)
+    `)
+    .eq('project_id', PROJECT_ID)
+    .eq('tester_id', args.tester_id)
+    .order('assigned_at', { ascending: false });
+
+  if (assignErr) {
+    return { error: assignErr.message };
+  }
+
+  const all = assignments || [];
+
+  // Count by status
+  const counts: Record<string, number> = {
+    pending: 0,
+    in_progress: 0,
+    passed: 0,
+    failed: 0,
+    blocked: 0,
+    skipped: 0,
+  };
+  for (const a of all) {
+    counts[a.status] = (counts[a.status] || 0) + 1;
+  }
+
+  return {
+    tester: {
+      id: tester.id,
+      name: tester.name,
+      email: tester.email,
+      status: tester.status,
+      platforms: tester.platforms,
+      tier: tester.tier,
+    },
+    totalAssignments: all.length,
+    counts,
+    activeLoad: counts.pending + counts.in_progress,
+    recentAssignments: all.slice(0, 10).map((a: any) => ({
+      id: a.id,
+      status: a.status,
+      assignedAt: a.assigned_at,
+      completedAt: a.completed_at,
+      testCase: a.test_case ? {
+        testKey: a.test_case.test_key,
+        title: a.test_case.title,
+        priority: a.test_case.priority,
+      } : null,
+      testRun: a.test_run?.name || null,
+    })),
+  };
+}
+
 // Main server setup
 async function main() {
   initSupabase();
@@ -4763,6 +5346,25 @@ async function main() {
         case 'get_testing_patterns':
           result = await getTestingPatterns(args as any);
           break;
+        // === TESTER & ASSIGNMENT MANAGEMENT ===
+        case 'list_testers':
+          result = await listTesters(args as any);
+          break;
+        case 'list_test_runs':
+          result = await listTestRuns(args as any);
+          break;
+        case 'create_test_run':
+          result = await createTestRun(args as any);
+          break;
+        case 'list_test_assignments':
+          result = await listTestAssignments(args as any);
+          break;
+        case 'assign_tests':
+          result = await assignTests(args as any);
+          break;
+        case 'get_tester_workload':
+          result = await getTesterWorkload(args as any);
+          break;
         default:
           return {
             content: [{ type: 'text', text: `Unknown tool: ${name}` }],
@@ -4783,7 +5385,7 @@ async function main() {
 
   // Handle resource listing (reports as resources)
   server.setRequestHandler(ListResourcesRequestSchema, async () => {
-    const { data } = await supabase
+    const { data, error } = await supabase
       .from('reports')
       .select('id, description, report_type, severity')
       .eq('project_id', PROJECT_ID)
@@ -4791,6 +5393,11 @@ async function main() {
       .order('created_at', { ascending: false })
       .limit(10);
 
+    if (error) {
+      console.error('Failed to list resources:', error.message);
+      return { resources: [] };
+    }
+
     return {
       resources: (data || []).map(r => ({
         uri: `bugbear://reports/${r.id}`,