apply changes

src/app/api/sync/run/route.ts

@@ -8,6 +8,9 @@
 import { NextRequest, NextResponse } from "next/server";
 import { getCurrentUser } from "@/lib/auth";
 import { runFullSync, runMaintainerSync, runContributorSync, reconcileOpenTriageIssue1, syncContributorPRsDirect, SYNC_INTERVAL_MS } from "@/lib/sync/github-sync";
+import { db } from "@/db";
+import { users } from "@/db/schema";
+import { eq } from "drizzle-orm";
 
 export async function POST(request: NextRequest) {
     try {
@@ -20,37 +23,107 @@ export async function POST(request: NextRequest) {
             return NextResponse.json({ error: "GitHub access token not found" }, { status: 400 });
         }
 
-        // Determine sync type based on user role
-        const userRole = user.role?.toUpperCase();
-        let stats;
-        let directSync = null;
-
-        if (userRole === "MAINTAINER") {
-            // Maintainers sync all open issues/PRs
-            stats = await runMaintainerSync(user.id, user.githubAccessToken);
-        } else {
-            // Contributors sync only their authored PRs
-            // First: Run search-based sync (may have indexing delay)
-            stats = await runContributorSync(user.id, user.username, user.githubAccessToken);
-            
-            // Second: Direct fetch from repos where user has existing PRs (bypasses search delay)
-            directSync = await syncContributorPRsDirect(user.id, user.username, user.githubAccessToken);
+        // Get current user record to check sync status
+        const userRecord = await db.select()
+            .from(users)
+            .where(eq(users.id, user.id))
+            .limit(1);
+
+        if (!userRecord || userRecord.length === 0) {
+            return NextResponse.json({ error: "User not found" }, { status: 404 });
         }
 
-        // Always reconcile the critical openTriage#1 issue to ensure immediate state sync
-        const reconcileResult = await reconcileOpenTriageIssue1(user.githubAccessToken);
-
-        return NextResponse.json({
-            success: true,
-            message: "Sync completed",
-            role: userRole,
-            stats,
-            directSync,  // Include direct sync results for contributors
-            reconcile: {
-                openTriageIssue1: reconcileResult,
-            },
-            nextSyncIntervalMs: SYNC_INTERVAL_MS,
-        });
+        const currentSyncStatus = userRecord[0].syncStatus;
+
+        // Circuit breaker: Check if sync already in progress
+        if (currentSyncStatus === 'SYNCING') {
+            console.log(`[SyncRun] User ${user.id} sync already in progress`);
+            return NextResponse.json({
+                error: "Sync already in progress",
+                status: "SYNCING",
+                message: "Please wait for the current sync to complete"
+            }, { status: 429 });
+        }
+
+        if (currentSyncStatus === 'PENDING') {
+            console.log(`[SyncRun] User ${user.id} sync is pending`);
+            return NextResponse.json({
+                error: "Sync is queued",
+                status: "PENDING",
+                message: "Sync request is queued and will start shortly"
+            }, { status: 202 });
+        }
+
+        // Set status to SYNCING before starting
+        await db.update(users)
+            .set({
+                syncStatus: 'SYNCING',
+                syncError: null
+            })
+            .where(eq(users.id, user.id));
+
+        console.log(`[SyncRun] Starting sync for user ${user.id}`);
+
+        try {
+            // Determine sync type based on user role
+            const userRole = user.role?.toUpperCase();
+            let stats;
+            let directSync = null;
+
+            if (userRole === "MAINTAINER") {
+                // Maintainers sync all open issues/PRs
+                stats = await runMaintainerSync(user.id, user.githubAccessToken);
+            } else {
+                // Contributors sync only their authored PRs
+                // First: Run search-based sync (may have indexing delay)
+                stats = await runContributorSync(user.id, user.username, user.githubAccessToken);
+
+                // Second: Direct fetch from repos where user has existing PRs (bypasses search delay)
+                directSync = await syncContributorPRsDirect(user.id, user.username, user.githubAccessToken);
+            }
+
+            // Always reconcile the critical openTriage#1 issue to ensure immediate state sync
+            const reconcileResult = await reconcileOpenTriageIssue1(user.githubAccessToken);
+
+            // Mark sync as COMPLETED
+            await db.update(users)
+                .set({
+                    syncStatus: 'COMPLETED',
+                    lastSyncAt: new Date().toISOString(),
+                    syncError: null
+                })
+                .where(eq(users.id, user.id));
+
+            console.log(`[SyncRun] Sync completed for user ${user.id}`);
+
+            return NextResponse.json({
+                success: true,
+                message: "Sync completed",
+                role: userRole,
+                stats,
+                directSync,  // Include direct sync results for contributors
+                reconcile: {
+                    openTriageIssue1: reconcileResult,
+                },
+                nextSyncIntervalMs: SYNC_INTERVAL_MS,
+            });
+
+        } catch (syncError: any) {
+            // Mark sync as FAILED with error message
+            await db.update(users)
+                .set({
+                    syncStatus: 'FAILED',
+                    syncError: syncError.message || 'Unknown error'
+                })
+                .where(eq(users.id, user.id));
+
+            console.error(`[SyncRun] Sync failed for user ${user.id}:`, syncError);
+
+            return NextResponse.json({
+                error: "Sync failed",
+                message: syncError.message || "Internal server error"
+            }, { status: 500 });
+        }
     } catch (error) {
         console.error("POST /api/sync/run error:", error);
         return NextResponse.json({ error: "Internal server error" }, { status: 500 });

src/app/api/sync/status/route.ts

@@ -0,0 +1,51 @@
+/**
+ * Sync Status API Route
+ * 
+ * GET /api/sync/status - Check current sync status for the authenticated user
+ * Used by frontend to poll sync progress without triggering new syncs
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+import { getCurrentUser } from "@/lib/auth";
+import { db } from "@/db";
+import { users } from "@/db/schema";
+import { eq } from "drizzle-orm";
+
+export async function GET(request: NextRequest) {
+    try {
+        const user = await getCurrentUser(request);
+        if (!user) {
+            return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+        }
+
+        // Get user's sync status
+        const userRecord = await db.select({
+            syncStatus: users.syncStatus,
+            lastSyncAt: users.lastSyncAt,
+            syncError: users.syncError,
+        })
+            .from(users)
+            .where(eq(users.id, user.id))
+            .limit(1);
+
+        if (!userRecord || userRecord.length === 0) {
+            return NextResponse.json({ error: "User not found" }, { status: 404 });
+        }
+
+        const { syncStatus, lastSyncAt, syncError } = userRecord[0];
+
+        return NextResponse.json({
+            status: syncStatus || 'IDLE',
+            lastSyncAt: lastSyncAt || null,
+            error: syncError || null,
+            isIdl: syncStatus === 'IDLE' || syncStatus === 'COMPLETED',
+            isSyncing: syncStatus === 'SYNCING',
+            isPending: syncStatus === 'PENDING',
+            hasFailed: syncStatus === 'FAILED',
+        });
+
+    } catch (error) {
+        console.error("GET /api/sync/status error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}

src/db/migrations/add_sync_status.sql

@@ -0,0 +1,16 @@
+-- Migration: Add sync status tracking to users table
+-- Date: 2026-02-12
+-- Purpose: Prevent concurrent sync requests and track sync history
+
+-- Add sync status columns to users table
+ALTER TABLE users ADD COLUMN sync_status TEXT DEFAULT 'IDLE';
+ALTER TABLE users ADD COLUMN last_sync_at TEXT;
+ALTER TABLE users ADD COLUMN sync_error TEXT;
+
+-- Create index for faster sync status queries
+CREATE INDEX IF NOT EXISTS idx_users_sync_status ON users(sync_status);
+
+-- Comments
+-- sync_status: IDLE | PENDING | SYNCING | COMPLETED | FAILED
+-- last_sync_at: ISO 8601 timestamp of last successful sync
+-- sync_error: Error message if last sync failed

src/db/schema.ts

@@ -38,6 +38,9 @@ export const users = sqliteTable("users", {
     avatarUrl: text("avatar_url").notNull(),
     role: text("role"),  // UserRole enum
     githubAccessToken: text("github_access_token"),
+    syncStatus: text("sync_status").default("IDLE"),  // IDLE, PENDING, SYNCING, COMPLETED, FAILED
+    lastSyncAt: text("last_sync_at"),  // Timestamp of last successful sync
+    syncError: text("sync_error"),  // Error message if sync failed
     createdAt: text("created_at").notNull(),
     updatedAt: text("updated_at").notNull(),
 });