feat: Introduce a utility to correct YouTube channel types, add a full video sync trigger, and refine dashboard channel management.

fix-channel-types.ts

@@ -0,0 +1,58 @@
+/**
+ * Quick fix script to correct channel_type for external channels
+ * Run this once to fix existing data
+ */
+
+import { db } from './src/lib/db';
+import { youtubeChannels } from './src/lib/db/schema';
+import { eq, and, ne } from 'drizzle-orm';
+
+async function fixChannelTypes() {
+    console.log('🔍 Checking channel types...');
+
+    // Get all channels
+    const allChannels = await db.query.youtubeChannels.findMany({
+        columns: {
+            id: true,
+            channelId: true,
+            channelName: true,
+            channelType: true,
+            creatorId: true,
+        }
+    });
+
+    console.log(`\nFound ${allChannels.length} total channels:`);
+    allChannels.forEach(ch => {
+        console.log(`  - ${ch.channelName} (${ch.channelId}): type=${ch.channelType}`);
+    });
+
+    // The rule: Only the channel "Vijay Krishnan" should be 'verified'
+    // All others from Quick Analyze should be 'external'
+
+    // Update all channels that are NOT "Vijay Krishnan" to be 'external'
+    const vijayChannelId = 'UCvBl96kCwiVqjEL-3Z7o_rw'; // Your actual channel ID
+
+    const updated = await db
+        .update(youtubeChannels)
+        .set({ channelType: 'external' })
+        .where(
+            and(
+                ne(youtubeChannels.channelId, vijayChannelId),
+                eq(youtubeChannels.channelType, 'verified')
+            )
+        )
+        .returning({ id: youtubeChannels.id, channelName: youtubeChannels.channelName });
+
+    console.log(`\n✅ Updated ${updated.length} channels to 'external':`);
+    updated.forEach(ch => {
+        console.log(`  - ${ch.channelName}`);
+    });
+
+    console.log('\n✨ Done! Refresh your dashboard to see the changes.');
+    process.exit(0);
+}
+
+fixChannelTypes().catch(err => {
+    console.error('❌ Error:', err);
+    process.exit(1);
+});

src/app/api/youtube/callback/route.ts

@@ -37,8 +37,16 @@ export async function GET(request: NextRequest) {
         });
 
         const tokens = await tokenResponse.json();
+        console.log("[YouTube callback] Tokens received:", {
+            has_access_token: !!tokens.access_token,
+            has_refresh_token: !!tokens.refresh_token,
+            expires_in: tokens.expires_in,
+            scope: tokens.scope,
+        });
+
         if (!tokens.access_token) {
-            throw new Error(`Token exchange failed: ${JSON.stringify(tokens)}`);
+            console.error("[YouTube callback] Token exchange failed:", tokens);
+            throw new Error(`Token exchange failed: ${tokens.error_description || tokens.error || JSON.stringify(tokens)}`);
         }
 
         // Extract Google account ID from id_token (JWT sub claim)
@@ -58,6 +66,7 @@ export async function GET(request: NextRequest) {
         const tokenFields = {
             accessToken: tokens.access_token,
             refreshToken: tokens.refresh_token || null,
+            scope: tokens.scope || null,
             accessTokenExpiresAt: tokens.expires_in
                 ? new Date(Date.now() + tokens.expires_in * 1000)
                 : null,
@@ -69,11 +78,13 @@ export async function GET(request: NextRequest) {
         });
 
         if (existing) {
+            console.log("[YouTube callback] Updating existing account record for user:", userId);
             await db
                 .update(accounts)
                 .set({ ...tokenFields, updatedAt: now })
                 .where(eq(accounts.id, existing.id));
         } else {
+            console.log("[YouTube callback] Creating new account record for user:", userId);
             await db.insert(accounts).values({
                 id: crypto.randomUUID(),
                 accountId: googleAccountId,

src/app/api/youtube/disconnect/route.ts

@@ -0,0 +1,15 @@
+import { disconnectYouTubeAction } from "@/features/discovery/actions/disconnect-youtube";
+import { NextResponse } from "next/server";
+
+export async function GET() {
+    const result = await disconnectYouTubeAction();
+
+    if (result.success) {
+        return NextResponse.redirect(new URL('/dashboard', process.env.NEXT_PUBLIC_APP_URL || 'http://localhost:3000'));
+    }
+
+    return NextResponse.redirect(
+        new URL(`/dashboard?error=${encodeURIComponent(result.error || 'Failed to disconnect')}`,
+            process.env.NEXT_PUBLIC_APP_URL || 'http://localhost:3000')
+    );
+}

src/app/dashboard/fix-channels-action.ts

@@ -0,0 +1,61 @@
+"use server";
+
+import { db } from "@/lib/db";
+import { youtubeChannels } from "@/lib/db/schema";
+import { eq, ne, and } from "drizzle-orm";
+import { revalidatePath } from "next/cache";
+
+/**
+ * Server action to correct channel types in the database.
+ * Marks the main Vijay Krishnan channel as 'verified' and others as 'external'.
+ */
+export async function fixChannelTypesAction() {
+    const vijayChannelId = 'UC_2QSXGUe_L6KKz7rLHA-7Q';
+
+    try {
+        // 0. Get the current session to associate channels correctly
+        const { auth } = await import("@/lib/auth");
+        const { headers } = await import("next/headers");
+        const session = await auth.api.getSession({ headers: await headers() });
+
+        if (!session || !session.user) {
+            return { success: false, error: "Unauthorized" };
+        }
+
+        const currentUserId = session.user.id;
+        console.log(`🔍 [fixChannelTypesAction] Applying fix for user: ${currentUserId}`);
+
+        // 1. Mark the main channel as 'verified' AND associate with current user
+        const verifiedUpdate = await db
+            .update(youtubeChannels)
+            .set({
+                channelType: 'verified',
+                creatorId: currentUserId // Critical fix: associate with current user!
+            })
+            .where(eq(youtubeChannels.channelId, vijayChannelId))
+            .returning({ id: youtubeChannels.id, channelName: youtubeChannels.channelName });
+
+        // 2. Mark all other channels as 'external'
+        const externalUpdate = await db
+            .update(youtubeChannels)
+            .set({ channelType: 'external' })
+            .where(ne(youtubeChannels.channelId, vijayChannelId))
+            .returning({ id: youtubeChannels.id, channelName: youtubeChannels.channelName });
+
+        console.log(`✅ [fixChannelTypesAction] Marked ${verifiedUpdate.length} channel(s) as verified for ${currentUserId}`);
+
+        revalidatePath("/dashboard");
+
+        return {
+            success: true,
+            verifiedCount: verifiedUpdate.length,
+            externalCount: externalUpdate.length,
+        };
+    } catch (error) {
+        console.error("[fixChannelTypesAction] Error:", error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Failed to fix channel types"
+        };
+    }
+}

src/app/dashboard/fix-channels/debug-action.ts

@@ -0,0 +1,32 @@
+"use server";
+
+import { db } from "@/lib/db";
+
+/**
+ * Debug action to see all channels and their types
+ */
+export async function debugChannelsAction() {
+    const allChannels = await db.query.youtubeChannels.findMany({
+        columns: {
+            id: true,
+            channelId: true,
+            channelName: true,
+            channelType: true,
+            creatorId: true,
+        }
+    });
+
+    console.log('\n=== ALL CHANNELS IN DATABASE ===');
+    allChannels.forEach(ch => {
+        console.log(`  Channel: ${ch.channelName}`);
+        console.log(`    YouTube ID: ${ch.channelId}`);
+        console.log(`    Type: ${ch.channelType}`);
+        console.log(`    DB ID: ${ch.id}`);
+        console.log('');
+    });
+
+    return {
+        success: true,
+        channels: allChannels,
+    };
+}

src/app/dashboard/fix-channels/page.tsx

@@ -0,0 +1,78 @@
+"use client";
+
+import { fixChannelTypesAction } from "../fix-channels-action";
+import { useState } from "react";
+import { Button } from "@/components/ui/button";
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card";
+import { toast } from "sonner";
+import { Loader2 } from "lucide-react";
+
+export default function FixChannelsPage() {
+    const [isLoading, setIsLoading] = useState(false);
+    const [result, setResult] = useState<{ verifiedCount: number; externalCount: number } | null>(null);
+
+    const handleFix = async () => {
+        setIsLoading(true);
+        try {
+            const res = await fixChannelTypesAction();
+            if (res.success) {
+                setResult({
+                    verifiedCount: res.verifiedCount || 0,
+                    externalCount: res.externalCount || 0
+                });
+                toast.success("Channel types corrected!");
+            } else {
+                toast.error(res.error || "Failed to fix channel types");
+            }
+        } catch (error) {
+            toast.error("An unexpected error occurred");
+        } finally {
+            setIsLoading(false);
+        }
+    };
+
+    return (
+        <div className="max-w-2xl mx-auto py-12 px-4">
+            <Card className="glass">
+                <CardHeader>
+                    <CardTitle>Repair Channel Types</CardTitle>
+                    <CardDescription>
+                        This utility corrects the <code>channel_type</code> for all synced YouTube channels.
+                        It ensures only your primary channel is marked as <strong>verified</strong> for the Account Connections modal.
+                    </CardDescription>
+                </CardHeader>
+                <CardContent className="space-y-6">
+                    <p className="text-sm text-muted-foreground">
+                        After running this fix, go back to your dashboard and refresh.
+                        The Account Connections modal will be filtered correctly.
+                    </p>
+
+                    {result ? (
+                        <div className="p-4 bg-primary/10 rounded-lg border border-primary/20 space-y-2">
+                            <p className="font-medium text-primary">Fix Applied Successfully!</p>
+                            <ul className="text-sm space-y-1">
+                                <li>• Marked <strong>{result.verifiedCount}</strong> channels as verified</li>
+                                <li>• Marked <strong>{result.externalCount}</strong> channels as external</li>
+                            </ul>
+                            <Button variant="outline" size="sm" className="mt-2" asChild>
+                                <a href="/dashboard">Return to Dashboard</a>
+                            </Button>
+                        </div>
+                    ) : (
+                        <Button
+                            onClick={handleFix}
+                            disabled={isLoading}
+                            className="w-full"
+                        >
+                            {isLoading ? (
+                                <><Loader2 className="mr-2 h-4 w-4 animate-spin" /> Fixing...</>
+                            ) : (
+                                "Apply Data Correction"
+                            )}
+                        </Button>
+                    )}
+                </CardContent>
+            </Card>
+        </div>
+    );
+}

src/app/dashboard/page.tsx

@@ -33,7 +33,7 @@ export default async function DashboardPage({
         redirect('/login')
     }
 
-    const { sync_youtube } = await searchParams;
+    const { sync_youtube, error } = await searchParams;
 
     if (sync_youtube === "true") {
         try {
@@ -41,15 +41,33 @@ export default async function DashboardPage({
             if (!result.success) {
                 redirect(`/dashboard?error=${encodeURIComponent(result.error || "Failed to sync YouTube account")}`);
             }
-            // Redirect to same page but without the query param to avoid re-syncing on refresh
             redirect("/dashboard");
-        } catch (error) {
-            if (error instanceof Error && error.message === "NEXT_REDIRECT") throw error;
-            redirect(`/dashboard?error=${encodeURIComponent(error instanceof Error ? error.message : "An unexpected error occurred")}`);
+        } catch (error: any) {
+            if (error.digest?.includes('NEXT_REDIRECT')) throw error;
+            redirect(`/dashboard?error=${encodeURIComponent(error.message || "An unexpected error occurred")}`);
         }
     }
 
-    const [channels, googleAccount, pendingCount, requestCount] = await Promise.all([
+    const [channels, allChannels, googleAccount, pendingCount, requestCount] = await Promise.all([
+        // Only fetch OAuth-verified channels (not external channels from Quick Analyze)
+        db.query.youtubeChannels.findMany({
+            where: (channels, { eq, and }) => and(
+                eq(channels.creatorId, session.user.id),
+                eq(channels.channelType, 'verified')
+            ),
+            columns: {
+                id: true,
+                channelId: true,
+                channelName: true,
+                subscriberCount: true,
+                thumbnailUrl: true,
+                syncStatus: true,
+                connectedAt: true,
+                channelType: true,
+                creatorSlug: true,
+            }
+        }),
+        // Fetch ALL channels (verified + external) for video filtering and display
         db.query.youtubeChannels.findMany({
             where: (channels, { eq }) => eq(channels.creatorId, session.user.id),
             columns: {
@@ -94,10 +112,10 @@ export default async function DashboardPage({
             .then((rows) => Number(rows[0].count)),
     ]);
 
-    // Fetch ALL videos with aggregate engagement metrics
+    // Fetch ALL videos using allChannels
     let allVideos: any[] = [];
-    if (channels.length > 0) {
-        const channelIds = channels.map(c => c.id);
+    if (allChannels.length > 0) {
+        const channelIds = allChannels.map(c => c.id);
 
         // This query joins videos with their various engagement signals
         allVideos = await db
@@ -140,17 +158,16 @@ export default async function DashboardPage({
 
     // AUTO-SYNC LOGIC: If user has a Google account but NO verified channels yet, 
     // trigger the sync automatically for a seamless "one-click" experience.
-    if (verifiedChannels.length === 0 && googleAccount?.accessToken && !sync_youtube) {
+    if (verifiedChannels.length === 0 && googleAccount?.accessToken && !sync_youtube && !error) {
         console.log(`[DashboardPage] Triggering AUTO-SYNC for user: ${session.user.id}`);
         try {
             const result = await connectYouTubeAction();
             if (result.success) {
-                // Refresh the page to show the new channels
                 redirect("/dashboard");
             }
-        } catch (error) {
+        } catch (error: any) {
+            if (error.digest?.includes('NEXT_REDIRECT')) throw error;
             console.error("[DashboardPage] Auto-sync failed:", error);
-            // Don't redirect on fail, just show the manual connect button
         }
     }
 
@@ -218,8 +235,13 @@ export default async function DashboardPage({
 
                 <VideoWorkbench
                     initialVideos={allVideos}
-                    channels={channels}
+                    channels={allChannels}
                     isGoogleLinked={!!googleAccount?.accessToken}
+                    hasYouTubeScope={
+                        !!googleAccount?.scope &&
+                        (googleAccount.scope.includes('https://www.googleapis.com/auth/youtube.readonly') ||
+                            googleAccount.scope.includes('https://www.googleapis.com/auth/youtube'))
+                    }
                 />
             </div>
 

src/features/dashboard/components/video-workbench.tsx

@@ -41,13 +41,14 @@ interface VideoWorkbenchProps {
     initialVideos: any[];
     channels: any[];
     isGoogleLinked: boolean;
+    hasYouTubeScope: boolean;
 }
 
 type Tab = "all" | "active" | "opportunities" | "requested";
 type SortField = "publishedAt" | "viewCount" | "clickCount" | "pledgeCount" | "requestCount";
 type SortDir = "asc" | "desc";
 
-export function VideoWorkbench({ initialVideos, channels, isGoogleLinked }: VideoWorkbenchProps) {
+export function VideoWorkbench({ initialVideos, channels, isGoogleLinked, hasYouTubeScope }: VideoWorkbenchProps) {
     const [tab, setTab] = useState<Tab>("all");
     const [sortBy, setSortBy] = useState<SortField>("publishedAt");
     const [sortDir, setSortDir] = useState<SortDir>("desc");
@@ -71,6 +72,8 @@ export function VideoWorkbench({ initialVideos, channels, isGoogleLinked }: Vide
         }
     };
 
+    const [isSyncing, setIsSyncing] = useState(false);
+
     const stats = useMemo(() => {
         return {
             totalClicks: initialVideos.reduce((acc, v) => acc + (v.clickCount || 0), 0),
@@ -80,6 +83,29 @@ export function VideoWorkbench({ initialVideos, channels, isGoogleLinked }: Vide
         };
     }, [initialVideos]);
 
+    const handleSync = async () => {
+        console.log("[VideoWorkbench] Starting full video sync...");
+        setIsSyncing(true);
+        try {
+            const { triggerFullVideoSync } = await import('@/features/discovery/actions/trigger-full-video-sync');
+            console.log("[VideoWorkbench] Calling triggerFullVideoSync...");
+            const result = await triggerFullVideoSync();
+            console.log("[VideoWorkbench] Sync result:", result);
+            if (result.success) {
+                toast.success(`Video sync started for ${result.channelName}!`);
+                // Reload after a short delay to allow the scan to start
+                setTimeout(() => window.location.reload(), 2000);
+            } else {
+                toast.error(result.error || "Failed to start video sync");
+            }
+        } catch (err) {
+            console.error("[VideoWorkbench] Sync error:", err);
+            toast.error("An unexpected error occurred during sync");
+        } finally {
+            setIsSyncing(false);
+        }
+    };
+
     const filteredAndSortedVideos = useMemo(() => {
         let result = [...initialVideos];
 
@@ -118,33 +144,6 @@ export function VideoWorkbench({ initialVideos, channels, isGoogleLinked }: Vide
         }
     };
 
-    if (initialVideos.length === 0) {
-        return (
-            <Card className="border-dashed glass">
-                <CardContent className="flex flex-col items-center justify-center p-12 text-center">
-                    <div className="w-16 h-16 rounded-full bg-secondary flex items-center justify-center mb-6 border border-border">
-                        <Youtube className="h-8 w-8 text-muted-foreground" />
-                    </div>
-                    <CardTitle className="text-2xl">No Videos Found</CardTitle>
-                    <CardDescription className="max-w-xs mx-auto mt-2">
-                        {isGoogleLinked
-                            ? "We couldn't find any videos on your connected channel. Try fetching them below."
-                            : "Connect your YouTube channel to start managing your videos and products."}
-                    </CardDescription>
-                    <div className="mt-8">
-                        {isGoogleLinked ? (
-                            <Button>Fetch Videos</Button>
-                        ) : (
-                            <Button asChild>
-                                <a href="/api/youtube/connect">Connect YouTube</a>
-                            </Button>
-                        )}
-                    </div>
-                </CardContent>
-            </Card>
-        );
-    }
-
     return (
         <div className="space-y-6">
             {/* Workbench Header & Stats Quick-look */}
@@ -167,145 +166,216 @@ export function VideoWorkbench({ initialVideos, channels, isGoogleLinked }: Vide
                         <p className="text-[10px] uppercase font-bold text-muted-foreground tracking-widest mb-0.5">Monetized</p>
                         <p className="text-lg font-bold text-green-400 dark:text-green-400">{stats.monetizedVideos} <span className="text-xs font-normal text-muted-foreground">/ {initialVideos.length}</span></p>
                     </div>
+                </div>
+            </div>
 
-                    <div className="px-2 border-l border-border ml-2">
-                        <AlertDialog>
-                            <AlertDialogTrigger asChild>
-                                <Button variant="ghost" size="icon" className="h-9 w-9 text-muted-foreground hover:bg-secondary rounded-full">
-                                    <Settings2 className="h-4 w-4" />
-                                </Button>
-                            </AlertDialogTrigger>
-                            <AlertDialogContent className="glass-panel backdrop-blur-xl">
-                                <AlertDialogHeader>
-                                    <AlertDialogTitle>Account Connections</AlertDialogTitle>
-                                    <AlertDialogDescription>
-                                        Manage your connected YouTube channels and synchronization settings.
-                                    </AlertDialogDescription>
-                                </AlertDialogHeader>
+            {/* Channel Control Bar */}
+            <div className="flex flex-col sm:flex-row items-center justify-between gap-4 p-4 glass rounded-xl border border-border">
+                {channels.length > 0 ? (
+                    <div className="flex items-center gap-4 w-full sm:w-auto">
+                        {channels[0].thumbnailUrl && (
+                            <img src={channels[0].thumbnailUrl} alt="" className="w-12 h-12 rounded-full border-2 border-border shadow-sm" />
+                        )}
+                        <div>
+                            <div className="flex items-center gap-2">
+                                <h3 className="font-bold text-lg">{channels[0].channelName}</h3>
+                                <Badge variant="secondary" className="bg-green-500/10 text-green-500 border-green-500/20 text-[10px]">
+                                    {channels[0].channelType === 'verified' ? 'Connected' : 'External'}
+                                </Badge>
+                            </div>
+                            <p className="text-sm text-muted-foreground flex items-center gap-2">
+                                {channels[0].subscriberCount?.toLocaleString() || 0} subscribers
+                            </p>
+                        </div>
+                    </div>
+                ) : (
+                    <div className="text-muted-foreground text-sm">No channel connected</div>
+                )}
 
-                                <div className="space-y-4 my-4">
-                                    {channels.map(channel => (
-                                        <div key={channel.id} className="flex items-center gap-3 p-3 rounded-xl bg-secondary border border-border">
-                                            {channel.thumbnailUrl && (
-                                                <img src={channel.thumbnailUrl} alt="" className="w-10 h-10 rounded-full border border-border" />
-                                            )}
-                                            <div className="flex-1 min-w-0">
-                                                <p className="text-sm font-bold truncate">{channel.channelName}</p>
-                                                <p className="text-xs text-muted-foreground">{channel.subscriberCount?.toLocaleString()} subscribers</p>
-                                            </div>
-                                            <Badge variant="secondary" className="bg-green-500/10 text-green-500 border-green-500/20 text-[10px]">
-                                                Connected
-                                            </Badge>
-                                        </div>
-                                    ))}
-                                </div>
+                <div className="flex items-center gap-2 w-full sm:w-auto justify-end">
+                    {/* YouTube Scope Warning - Inline */}
+                    {!hasYouTubeScope && isGoogleLinked && (
+                        <Button
+                            asChild
+                            variant="outline"
+                            size="sm"
+                            className="bg-yellow-500/10 border-yellow-500/30 hover:bg-yellow-500/20 text-yellow-500 gap-2"
+                        >
+                            <a href="/api/youtube/connect">
+                                <AlertCircle className="h-4 w-4" />
+                                Re-authorize Access
+                            </a>
+                        </Button>
+                    )}
 
-                                <AlertDialogFooter className="flex-col sm:flex-row gap-2">
-                                    <div className="flex-1">
-                                        <Button
-                                            variant="ghost"
-                                            size="sm"
-                                            className="text-muted-foreground hover:text-destructive gap-2 transition-colors px-0"
-                                            onClick={handleDisconnect}
-                                            disabled={isDisconnecting}
-                                        >
-                                            <Trash2 className="h-4 w-4" />
-                                            Disconnect YouTube Account
-                                        </Button>
-                                    </div>
-                                    <AlertDialogCancel className="bg-secondary border-border hover:bg-muted transition-colors">Close</AlertDialogCancel>
-                                </AlertDialogFooter>
-                            </AlertDialogContent>
-                        </AlertDialog>
-                    </div>
+                    {/* Sync Button */}
+                    <Button
+                        variant="default"
+                        size="sm"
+                        onClick={handleSync}
+                        disabled={isSyncing}
+                        className="gap-2"
+                    >
+                        {isSyncing ? (
+                            <Loader2 className="h-4 w-4 animate-spin" />
+                        ) : (
+                            <Youtube className="h-4 w-4" />
+                        )}
+                        {isSyncing ? "Syncing..." : "Sync Videos"}
+                    </Button>
+
+                    {/* Disconnect with Confirmation */}
+                    <AlertDialog>
+                        <AlertDialogTrigger asChild>
+                            <Button variant="ghost" size="sm" className="text-muted-foreground hover:text-destructive gap-2">
+                                <Trash2 className="h-4 w-4" />
+                                <span className="hidden sm:inline">Disconnect</span>
+                            </Button>
+                        </AlertDialogTrigger>
+                        <AlertDialogContent>
+                            <AlertDialogHeader>
+                                <AlertDialogTitle>Disconnect YouTube Channel?</AlertDialogTitle>
+                                <AlertDialogDescription>
+                                    Are you sure you want to disconnect <strong>{channels[0]?.channelName}</strong>?
+                                    This will stop video synchronization. Your existing data will be preserved.
+                                </AlertDialogDescription>
+                            </AlertDialogHeader>
+                            <AlertDialogFooter>
+                                <AlertDialogCancel>Cancel</AlertDialogCancel>
+                                <Button
+                                    variant="destructive"
+                                    onClick={handleDisconnect}
+                                    disabled={isDisconnecting}
+                                >
+                                    {isDisconnecting ? "Disconnecting..." : "Disconnect"}
+                                </Button>
+                            </AlertDialogFooter>
+                        </AlertDialogContent>
+                    </AlertDialog>
                 </div>
             </div>
 
-            {/* Controls Bar */}
-            <div className="flex flex-col lg:flex-row lg:items-center justify-between gap-4 py-2">
-                {/* Tabs */}
-                <div className="flex items-center gap-1 bg-secondary p-1 rounded-xl border border-border">
-                    {(["all", "active", "opportunities", "requested"] as Tab[]).map(t => (
-                        <button
-                            key={t}
-                            onClick={() => setTab(t)}
-                            className={cn(
-                                "px-4 py-1.5 rounded-lg text-sm font-medium capitalize transition-all",
-                                tab === t
-                                    ? "bg-background text-foreground shadow-sm border border-border/50"
-                                    : "text-muted-foreground hover:text-foreground"
+            {initialVideos.length === 0 ? (
+                <Card className="border-dashed glass">
+                    <CardContent className="flex flex-col items-center justify-center p-12 text-center">
+                        <div className="w-16 h-16 rounded-full bg-secondary flex items-center justify-center mb-6 border border-border">
+                            <Youtube className="h-8 w-8 text-muted-foreground" />
+                        </div>
+                        <CardTitle className="text-2xl">No Videos Found</CardTitle>
+                        <CardDescription className="max-w-xs mx-auto mt-2">
+                            {isGoogleLinked
+                                ? "We couldn't find any videos on your connected channel. Try fetching them below."
+                                : "Connect your YouTube channel to start managing your videos and products."}
+                        </CardDescription>
+                        <div className="mt-8">
+                            {isGoogleLinked ? (
+                                <Button
+                                    onClick={handleSync}
+                                    disabled={isSyncing}
+                                >
+                                    {isSyncing ? (
+                                        <><Loader2 className="mr-2 h-4 w-4 animate-spin" /> Fetching...</>
+                                    ) : (
+                                        "Fetch Videos"
+                                    )}
+                                </Button>
+                            ) : (
+                                <Button asChild>
+                                    <a href="/api/youtube/connect">Connect YouTube</a>
+                                </Button>
                             )}
-                        >
-                            {t === "active" ? "Monetized" : t === "requested" ? "Requests" : t}
-                        </button>
-                    ))}
-                </div>
+                        </div>
+                    </CardContent>
+                </Card>
+            ) : (
+                <>
+                    {/* Controls Bar */}
+                    <div className="flex flex-col lg:flex-row lg:items-center justify-between gap-4 py-2">
+                        {/* Tabs */}
+                        <div className="flex items-center gap-1 bg-secondary p-1 rounded-xl border border-border">
+                            {(["all", "active", "opportunities", "requested"] as Tab[]).map(t => (
+                                <button
+                                    key={t}
+                                    onClick={() => setTab(t)}
+                                    className={cn(
+                                        "px-4 py-1.5 rounded-lg text-sm font-medium capitalize transition-all",
+                                        tab === t
+                                            ? "bg-background text-foreground shadow-sm border border-border/50"
+                                            : "text-muted-foreground hover:text-foreground"
+                                    )}
+                                >
+                                    {t === "active" ? "Monetized" : t === "requested" ? "Requests" : t}
+                                </button>
+                            ))}
+                        </div>
 
-                <div className="flex flex-wrap items-center gap-3">
-                    {/* Channel Filter (if multiple) */}
-                    {channels.length > 1 && (
-                        <div className="hidden sm:flex items-center gap-2 px-3 py-1.5 rounded-xl bg-secondary border border-border">
-                            <Filter className="h-3.5 w-3.5 text-muted-foreground" />
-                            <select
-                                value={filterChannel}
-                                onChange={(e) => setFilterChannel(e.target.value)}
-                                className="bg-transparent text-sm font-medium outline-none focus:ring-0 appearance-none pr-4"
-                            >
-                                <option value="all">All Channels</option>
-                                {channels.map(c => (
-                                    <option key={c.id} value={c.id}>{c.channelName}</option>
+                        <div className="flex flex-wrap items-center gap-3">
+                            {/* Channel Filter (if multiple) */}
+                            {channels.length > 1 && (
+                                <div className="hidden sm:flex items-center gap-2 px-3 py-1.5 rounded-xl bg-secondary border border-border">
+                                    <Filter className="h-3.5 w-3.5 text-muted-foreground" />
+                                    <select
+                                        value={filterChannel}
+                                        onChange={(e) => setFilterChannel(e.target.value)}
+                                        className="bg-transparent text-sm font-medium outline-none focus:ring-0 appearance-none pr-4"
+                                    >
+                                        <option value="all">All Channels</option>
+                                        {channels.map(c => (
+                                            <option key={c.id} value={c.id}>{c.channelName}</option>
+                                        ))}
+                                    </select>
+                                </div>
+                            )}
+
+                            {/* Desktop Sort Labels */}
+                            <div className="hidden lg:flex items-center gap-1 text-[11px] font-bold text-muted-foreground uppercase tracking-widest mr-2">
+                                Sort by:
+                            </div>
+                            <div className="flex flex-wrap gap-2">
+                                {[
+                                    { id: "publishedAt", label: "Date", icon: <Clock className="h-3 w-3" /> },
+                                    { id: "viewCount", label: "Views", icon: <ArrowUp className="h-3 w-3" /> },
+                                    { id: "clickCount", label: "Clicks", icon: <MousePointerClick className="h-3 w-3" /> },
+                                    { id: "pledgeCount", label: "Pledges", icon: <Heart className="h-3 w-3" /> },
+                                    { id: "requestCount", label: "Requests", icon: <MessageSquare className="h-3 w-3" /> },
+                                ].map(f => (
+                                    <button
+                                        key={f.id}
+                                        onClick={() => toggleSort(f.id as SortField)}
+                                        className={cn(
+                                            "flex items-center gap-1.5 px-3 py-1.5 rounded-xl text-xs font-semibold transition-all border",
+                                            sortBy === f.id
+                                                ? "bg-primary/10 border-primary/20 text-primary"
+                                                : "bg-secondary border-border text-muted-foreground hover:border-muted-foreground/30"
+                                        )}
+                                    >
+                                        {f.icon}
+                                        {f.label}
+                                        {sortBy === f.id && (
+                                            sortDir === "desc" ? <ArrowDown className="h-3 w-3" /> : <ArrowUp className="h-3 w-3" />
+                                        )}
+                                    </button>
                                 ))}
-                            </select>
+                            </div>
                         </div>
-                    )}
-
-                    {/* Desktop Sort Labels */}
-                    <div className="hidden lg:flex items-center gap-1 text-[11px] font-bold text-muted-foreground uppercase tracking-widest mr-2">
-                        Sort by:
-                    </div>
-                    <div className="flex flex-wrap gap-2">
-                        {[
-                            { id: "publishedAt", label: "Date", icon: <Clock className="h-3 w-3" /> },
-                            { id: "viewCount", label: "Views", icon: <ArrowUp className="h-3 w-3" /> },
-                            { id: "clickCount", label: "Clicks", icon: <MousePointerClick className="h-3 w-3" /> },
-                            { id: "pledgeCount", label: "Pledges", icon: <Heart className="h-3 w-3" /> },
-                            { id: "requestCount", label: "Requests", icon: <MessageSquare className="h-3 w-3" /> },
-                        ].map(f => (
-                            <button
-                                key={f.id}
-                                onClick={() => toggleSort(f.id as SortField)}
-                                className={cn(
-                                    "flex items-center gap-1.5 px-3 py-1.5 rounded-xl text-xs font-semibold transition-all border",
-                                    sortBy === f.id
-                                        ? "bg-primary/10 border-primary/20 text-primary"
-                                        : "bg-secondary border-border text-muted-foreground hover:border-muted-foreground/30"
-                                )}
-                            >
-                                {f.icon}
-                                {f.label}
-                                {sortBy === f.id && (
-                                    sortDir === "desc" ? <ArrowDown className="h-3 w-3" /> : <ArrowUp className="h-3 w-3" />
-                                )}
-                            </button>
-                        ))}
                     </div>
-                </div>
-            </div>
 
-            {/* Video List */}
-            <Card className="glass overflow-hidden shadow-sm">
-                <div className="divide-y divide-border/30">
-                    {filteredAndSortedVideos.length > 0 ? (
-                        filteredAndSortedVideos.map(video => (
-                            <VideoListRow key={video.id} video={video} />
-                        ))
-                    ) : (
-                        <div className="p-20 text-center">
-                            <p className="text-muted-foreground">No videos match your current filters.</p>
+                    {/* Video List */}
+                    <Card className="glass overflow-hidden shadow-sm">
+                        <div className="divide-y divide-border/30">
+                            {filteredAndSortedVideos.length > 0 ? (
+                                filteredAndSortedVideos.map(video => (
+                                    <VideoListRow key={video.id} video={video} />
+                                ))
+                            ) : (
+                                <div className="p-20 text-center">
+                                    <p className="text-muted-foreground">No videos match your current filters.</p>
+                                </div>
+                            )}
                         </div>
-                    )}
-                </div>
-            </Card>
+                    </Card>
+                </>
+            )}
         </div>
     );
 }

src/features/discovery/actions/trigger-full-video-sync.ts

@@ -0,0 +1,74 @@
+'use server';
+
+import { auth } from '@/lib/auth';
+import { headers } from 'next/headers';
+import { db } from '@/lib/db';
+import { youtubeChannels, videoScanJobs } from '@/lib/db/schema';
+import { eq } from 'drizzle-orm';
+import { inngest } from '@/inngest/client';
+import crypto from 'crypto';
+
+/**
+ * Server action to trigger a full YouTube video archive scan.
+ * This fetches ALL videos from the user's YouTube channel.
+ */
+export async function triggerFullVideoSync() {
+    const session = await auth.api.getSession({
+        headers: await headers(),
+    });
+
+    if (!session || !session.user) {
+        return { success: false, error: 'Unauthorized. Please log in first.' };
+    }
+
+    try {
+        // Get the user's verified channel
+        const channel = await db.query.youtubeChannels.findFirst({
+            where: (channels, { and, eq }) => and(
+                eq(channels.creatorId, session.user.id),
+                eq(channels.channelType, 'verified')
+            ),
+        });
+
+        if (!channel) {
+            return {
+                success: false,
+                error: 'No verified YouTube channel found. Please connect your channel first.'
+            };
+        }
+
+        // Create a scan job
+        const scanJobId = crypto.randomUUID();
+        await db.insert(videoScanJobs).values({
+            id: scanJobId,
+            userId: session.user.id,
+            channelId: channel.id,
+            status: 'pending',
+            totalVideos: 0,
+            scannedVideos: 0,
+            progress: 0,
+        });
+
+        // Trigger the Inngest scan-video-archive function
+        await inngest.send({
+            name: 'youtube/video-archive.scan',
+            data: {
+                channelId: channel.id,
+                userId: session.user.id,
+                scanJobId,
+            },
+        });
+
+        return {
+            success: true,
+            jobId: scanJobId,
+            channelName: channel.channelName,
+        };
+    } catch (error) {
+        console.error('[triggerFullVideoSync] Error:', error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'An unexpected error occurred while starting video sync.'
+        };
+    }
+}

src/inngest/functions/scan-video-archive.ts

@@ -351,6 +351,8 @@ async function processVideoBatch(
 ): Promise<void> {
   if (videoIds.length === 0) return;
 
+  if (videoIds.length === 0) return;
+
   try {
     // Fetch video metadata
     const videosMetadata = await getVideosMetadata(videoIds, accessToken);
@@ -359,20 +361,28 @@ async function processVideoBatch(
     const insertedVideos = await db
       .insert(youtubeVideos)
       .values(
-        videosMetadata.map(video => ({
-          channelId,
-          videoId: video.videoId,
-          title: video.title,
-          description: video.description,
-          thumbnailUrl: video.thumbnailUrl,
-          duration: video.duration,
-          viewCount: video.viewCount,
-          publishedAt: video.publishedAt,
-          availabilityStatus: video.privacyStatus,
-        }))
+        videosMetadata.map(video => {
+          // Map YouTube's privacyStatus to our database availabilityStatus
+          // 'public' and 'unlisted' videos should be 'available' in our system
+          // 'private' videos should be 'private' (filtered out from dashboard)
+          const availabilityStatus =
+            video.privacyStatus === 'private' ? 'private' : 'available';
+
+          return {
+            channelId,
+            videoId: video.videoId,
+            title: video.title,
+            description: video.description,
+            thumbnailUrl: video.thumbnailUrl,
+            duration: video.duration,
+            viewCount: video.viewCount,
+            publishedAt: video.publishedAt,
+            availabilityStatus,
+          };
+        })
       )
       .onConflictDoUpdate({
-        target: youtubeVideos.videoId,
+        target: [youtubeVideos.channelId, youtubeVideos.videoId],
         set: {
           title: sql`EXCLUDED.title`,
           description: sql`EXCLUDED.description`,
@@ -396,6 +406,8 @@ async function processVideoBatch(
     }
 
     // Trigger object detection for each video in the batch
+    // REMOVED: User request - only list videos, do not auto-scan.
+    /*
     if (insertedVideos.length > 0) {
       await inngest.send(
         insertedVideos.map((v) => ({
@@ -407,6 +419,7 @@ async function processVideoBatch(
         }))
       );
     }
+    */
 
     // Update progress
     const newScanned = currentScanned + videoIds.length;

src/lib/db/schema.ts

@@ -152,7 +152,7 @@ export const youtubeVideos = pgTable('youtube_videos', {
   thumbnailUrl: text('thumbnail_url'),
   duration: text('duration'), // ISO 8601 format (PT15M33S)
   viewCount: integer('view_count'),
-  availabilityStatus: text('availability_status').notNull().default('unknown'), // 'unknown' | 'available' | 'private'
+  availabilityStatus: text('availability_status').notNull().default('unknown'), // 'available' (public/unlisted) | 'private' | 'unknown'
   scanStatus: videoScanStatusEnum('scan_status').default('pending').notNull(),
   publishedAt: timestamp('published_at', {
     mode: 'date',