@bbearai/mcp-server 0.5.0 → 0.5.1

package/dist/index.js

@@ -435,6 +435,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'],
         },
@@ -902,12 +906,131 @@ 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',
+            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',
+            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',
+            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',
+            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',
+            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',
+            properties: {
+                tester_id: {
+                    type: 'string',
+                    description: 'UUID of the tester (required)',
+                },
+            },
+            required: ['tester_id'],
+        },
+    },
 ];
 // Tool handlers
 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));
@@ -963,10 +1086,8 @@ async function getReport(args) {
             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,
@@ -1126,13 +1247,16 @@ async function createTestCase(args) {
     // Find track ID if track name provided
     let trackId = 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 = {
         project_id: PROJECT_ID,
@@ -1511,7 +1635,11 @@ async function getTestPriorities(args) {
     const minScore = args.min_score || 0;
     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
         .from('route_test_stats')
@@ -1890,7 +2018,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 || [];
     }
     // Get route stats for bug counts
@@ -2038,7 +2168,11 @@ async function getStaleCoverage(args) {
     const daysThreshold = args.days_threshold || 14;
     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
         .from('route_test_stats')
@@ -2123,12 +2257,29 @@ 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();
+    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
         .from('route_test_stats')
@@ -2631,10 +2782,19 @@ async function analyzeCommitForTesting(args) {
     const affectedRoutes = [];
     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) {
             affectedRoutes.push({
@@ -3292,6 +3452,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: {
@@ -3311,11 +3472,15 @@ async function markFixedWithCommit(args) {
     if (error) {
         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',
@@ -4036,6 +4201,353 @@ Which files or areas would you like me to analyze?`;
             return 'Unknown prompt';
     }
 }
+// === TESTER & ASSIGNMENT MANAGEMENT HANDLERS ===
+async function listTesters(args) {
+    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) => t.platforms && t.platforms.includes(args.platform));
+    }
+    return {
+        count: testers.length,
+        testers: testers.map((t) => ({
+            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) {
+    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) => ({
+            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) {
+    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) {
+    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) => ({
+            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) {
+    // 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) => 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 = [];
+            const skipped = [];
+            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) => 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) {
+    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 = {
+        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) => ({
+            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();
@@ -4171,6 +4683,25 @@ async function main() {
                 case 'get_testing_patterns':
                     result = await getTestingPatterns(args);
                     break;
+                // === TESTER & ASSIGNMENT MANAGEMENT ===
+                case 'list_testers':
+                    result = await listTesters(args);
+                    break;
+                case 'list_test_runs':
+                    result = await listTestRuns(args);
+                    break;
+                case 'create_test_run':
+                    result = await createTestRun(args);
+                    break;
+                case 'list_test_assignments':
+                    result = await listTestAssignments(args);
+                    break;
+                case 'assign_tests':
+                    result = await assignTests(args);
+                    break;
+                case 'get_tester_workload':
+                    result = await getTesterWorkload(args);
+                    break;
                 default:
                     return {
                         content: [{ type: 'text', text: `Unknown tool: ${name}` }],
@@ -4190,13 +4721,17 @@ async function main() {
     });
     // Handle resource listing (reports as resources)
     server.setRequestHandler(types_js_1.ListResourcesRequestSchema, async () => {
-        const { data } = await supabase
+        const { data, error } = await supabase
             .from('reports')
             .select('id, description, report_type, severity')
             .eq('project_id', PROJECT_ID)
             .eq('status', 'new')
             .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}`,