apply changes

src/app/api/explore/tickets/route.ts

@@ -0,0 +1,101 @@
+/**
+ * Explore Tickets API Route (Renamed from Discover Issues)
+ * 
+ * GET /api/explore/tickets
+ * Search GitHub for open source issues using authenticated requests
+ * to avoid rate limits
+ * 
+ * RENAMED TO AVOID ADBLOCKER DETECTION
+ * Old: /api/discover/issues
+ * New: /api/explore/tickets
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+import { Octokit } from "@octokit/rest";
+
+export async function GET(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+
+        const { searchParams } = new URL(request.url);
+        const labels = searchParams.get("labels") || "good first issue";
+        const language = searchParams.get("language") || "";
+        const sort = searchParams.get("sort") || "created";
+        const perPage = parseInt(searchParams.get("per_page") || "30");
+
+        // Use user's GitHub token if available, otherwise use app token
+        const token = user?.githubAccessToken || process.env.GITHUB_TOKEN;
+
+        if (!token) {
+            return NextResponse.json({
+                error: "No GitHub token available",
+                items: [],
+                total_count: 0
+            }, { status: 200 });
+        }
+
+        const octokit = new Octokit({ auth: token });
+
+        // Build search query
+        let query = "is:issue is:open";
+
+        // Add labels (support multiple labels)
+        const labelList = labels.split(",").filter(l => l.trim());
+        for (const label of labelList) {
+            query += ` label:"${label.trim()}"`;
+        }
+
+        // Add language filter
+        if (language && language !== "all") {
+            query += ` language:${language}`;
+        }
+
+        // Map sort options
+        const sortMap: Record<string, "created" | "updated" | "comments" | "reactions-+1"> = {
+            created: "created",
+            updated: "updated",
+            comments: "comments",
+            reactions: "reactions-+1"
+        };
+
+        const response = await octokit.search.issuesAndPullRequests({
+            q: query,
+            sort: sortMap[sort] || "created",
+            order: "desc",
+            per_page: Math.min(perPage, 100),
+        });
+
+        // Add rate limit info to response
+        const rateLimit = {
+            remaining: response.headers["x-ratelimit-remaining"],
+            limit: response.headers["x-ratelimit-limit"],
+            reset: response.headers["x-ratelimit-reset"],
+        };
+
+        return NextResponse.json({
+            items: response.data.items,
+            total_count: response.data.total_count,
+            rate_limit: rateLimit,
+        });
+
+    } catch (error: any) {
+        console.error("Explore tickets error:", error);
+
+        // Handle rate limit specifically
+        if (error.status === 403) {
+            return NextResponse.json({
+                error: "Rate limit exceeded. Please try again later.",
+                items: [],
+                total_count: 0,
+                rate_limited: true
+            }, { status: 200 }); // Return 200 so frontend handles gracefully
+        }
+
+        return NextResponse.json({
+            error: error.message || "Failed to fetch tickets",
+            items: [],
+            total_count: 0
+        }, { status: 200 });
+    }
+}

src/app/api/realtime/connect/route.ts

@@ -0,0 +1,84 @@
+/**
+ * Real-time Connection API Route (Renamed from WebSocket)
+ * 
+ * GET /api/realtime/connect
+ * Establishes a Server-Sent Events (SSE) connection for real-time message delivery
+ * 
+ * RENAMED TO AVOID ADBLOCKER DETECTION
+ * Old:  /api/messaging/ws
+ * New: /api/realtime/connect
+ */
+
+import { NextRequest } from 'next/server';
+import { getCurrentUser } from '@/lib/auth';
+import { realtimeMessaging } from '@/lib/realtime-messaging';
+
+interface WebSocketMessage {
+    type: string;
+    [key: string]: any;
+}
+
+export async function GET(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return new Response(JSON.stringify({ error: 'Unauthorized' }), {
+                status: 401,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        }
+
+        // Setup SSE connection
+        const encoder = new TextEncoder();
+        let isConnected = true;
+
+        const customReadable = new ReadableStream({
+            start(controller) {
+                // Send initial connection message
+                const message = `data: ${JSON.stringify({
+                    type: 'connected',
+                    userId: user.id,
+                    timestamp: new Date().toISOString(),
+                })}\n\n`;
+
+                controller.enqueue(encoder.encode(message));
+
+                // Register this connection with the realtime service
+                const unsubscribe = realtimeMessaging.registerConnection(user.id, (event) => {
+                    if (isConnected) {
+                        const eventMessage = `data: ${JSON.stringify(event)}\n\n`;
+                        try {
+                            controller.enqueue(encoder.encode(eventMessage));
+                        } catch (error) {
+                            console.error('Error sending SSE event:', error);
+                            isConnected = false;
+                            controller.close();
+                        }
+                    }
+                });
+
+                // Cleanup on connection close
+                request.signal?.addEventListener('abort', () => {
+                    isConnected = false;
+                    unsubscribe();
+                    controller.close();
+                });
+            },
+        });
+
+        return new Response(customReadable, {
+            headers: {
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                'Connection': 'keep-alive',
+                'X-Accel-Buffering': 'no',
+            },
+        });
+    } catch (error) {
+        console.error('Real-time connection error:', error);
+        return new Response(JSON.stringify({ error: 'Internal server error' }), {
+            status: 500,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    }
+}