diff --git a/app/api/courrier/login/route.ts b/app/api/courrier/login/route.ts
index 6f153ef4..a4b9e47f 100644
--- a/app/api/courrier/login/route.ts
+++ b/app/api/courrier/login/route.ts
@@ -3,129 +3,147 @@ import { ImapFlow } from 'imapflow';
 import { getServerSession } from 'next-auth';
 import { authOptions } from '@/app/api/auth/[...nextauth]/route';
 import { prisma } from '@/lib/prisma';
-import { LRUCache } from 'lru-cache';
 
-// Simple in-memory cache for email content
-const emailContentCache = new LRUCache<string, any>({
-  max: 100, 
-  ttl: 1000 * 60 * 15, // 15 minutes
-});
-
-export async function GET(
-  request: Request,
-  { params }: { params: { id: string } }
-) {
+export async function POST(request: Request) {
   try {
-    // 1. Properly await params to avoid Next.js error
-    const { id } = await Promise.resolve(params);
-    
-    // 2. Authentication check
+    console.log('Processing login POST request');
     const session = await getServerSession(authOptions);
     if (!session?.user?.id) {
+      console.log('No authenticated session found');
       return NextResponse.json(
         { error: 'Unauthorized' },
         { status: 401 }
       );
     }
 
-    // 3. Check cache first
-    const cacheKey = `email:${session.user.id}:${id}`;
-    const cachedEmail = emailContentCache.get(cacheKey);
-    if (cachedEmail) {
-      return NextResponse.json(cachedEmail);
-    }
+    const { email, password, host, port } = await request.json();
+    console.log('Login attempt for:', email, 'to server:', host);
 
-    // 4. Get credentials from database
-    const credentials = await prisma.mailCredentials.findUnique({
-      where: {
-        userId: session.user.id
-      }
-    });
-
-    if (!credentials) {
+    if (!email || !password || !host || !port) {
+      console.log('Missing required login fields');
       return NextResponse.json(
-        { error: 'No mail credentials found. Please configure your email account.' },
-        { status: 401 }
+        { error: 'Missing required fields' },
+        { status: 400 }
       );
     }
 
-    // 5. Create IMAP client
+    // Test IMAP connection
+    console.log('Testing IMAP connection to:', host, port);
     const client = new ImapFlow({
-      host: credentials.host,
-      port: credentials.port,
+      host: host,
+      port: parseInt(port),
       secure: true,
       auth: {
-        user: credentials.email,
-        pass: credentials.password,
+        user: email,
+        pass: password,
       },
       logger: false,
       emitLogs: false,
       tls: {
         rejectUnauthorized: false
-      },
-      disableAutoIdle: true
+      }
     });
-    
+
     try {
       await client.connect();
-      
-      // 6. Open INBOX
+      console.log('IMAP connection successful');
       await client.mailboxOpen('INBOX');
+      console.log('INBOX opened successfully');
       
-      // 7. Fetch the email with UID search
-      const options = {
-        uid: true,  // This is crucial - we must specify uid:true to fetch by UID
-        source: true,
-        envelope: true,
-        bodyStructure: true,
-        flags: true
-      };
-      
-      // Fetch by UID
-      console.log('Fetching email with UID:', id);
-      const message = await client.fetchOne(id, options);
-      
-      if (!message) {
-        console.error('Email not found with UID:', id);
+      // Store or update credentials in database
+      await prisma.mailCredentials.upsert({
+        where: {
+          userId: session.user.id
+        },
+        update: {
+          email,
+          password,
+          host,
+          port: parseInt(port)
+        },
+        create: {
+          userId: session.user.id,
+          email,
+          password,
+          host,
+          port: parseInt(port)
+        }
+      });
+      console.log('Credentials stored in database');
+
+      return NextResponse.json({ success: true });
+    } catch (error) {
+      console.error('IMAP connection error:', error);
+      if (error instanceof Error) {
+        if (error.message.includes('Invalid login')) {
+          return NextResponse.json(
+            { error: 'Invalid login or password' },
+            { status: 401 }
+          );
+        }
         return NextResponse.json(
-          { error: 'Email not found' },
-          { status: 404 }
+          { error: `IMAP connection error: ${error.message}` },
+          { status: 500 }
         );
       }
-
-      // 8. Parse the email content
-      const emailContent = {
-        id: message.uid.toString(),
-        from: message.envelope.from?.[0]?.address || '',
-        fromName: message.envelope.from?.[0]?.name || 
-                 message.envelope.from?.[0]?.address?.split('@')[0] || '',
-        to: message.envelope.to?.map((addr: any) => addr.address).join(', ') || '',
-        subject: message.envelope.subject || '(No subject)',
-        date: message.envelope.date?.toISOString() || new Date().toISOString(),
-        content: message.source?.toString() || '',
-        read: message.flags.has('\\Seen'),
-        starred: message.flags.has('\\Flagged'),
-        flags: Array.from(message.flags),
-        hasAttachments: message.bodyStructure?.type === 'multipart'
-      };
-
-      // 9. Cache the email content
-      emailContentCache.set(cacheKey, emailContent);
-
-      // 10. Return the email content
-      return NextResponse.json(emailContent);
+      return NextResponse.json(
+        { error: 'Failed to connect to email server' },
+        { status: 500 }
+      );
     } finally {
-      // 11. Close the connection
       try {
         await client.logout();
+        console.log('IMAP client logged out');
       } catch (e) {
-        console.error('Error during IMAP logout:', e);
+        console.error('Error during logout:', e);
       }
     }
   } catch (error) {
-    console.error('Error fetching email:', error);
+    console.error('Error in login handler:', error);
     return NextResponse.json(
-      { error: 'Failed to fetch email content' },
+      { error: 'An unexpected error occurred' },
+      { status: 500 }
+    );
+  }
+}
+
+export async function GET() {
+  try {
+    console.log('Fetching mail credentials');
+    const session = await getServerSession(authOptions);
+    if (!session?.user?.id) {
+      console.log('No authenticated session found');
+      return NextResponse.json(
+        { error: 'Unauthorized' },
+        { status: 401 }
+      );
+    }
+
+    const credentials = await prisma.mailCredentials.findUnique({
+      where: {
+        userId: session.user.id
+      },
+      select: {
+        email: true,
+        host: true,
+        port: true
+      }
+    });
+
+    if (!credentials) {
+      console.log('No mail credentials found for user');
+      return NextResponse.json(
+        { error: 'No stored credentials found' },
+        { status: 404 }
+      );
+    }
+
+    console.log('Credentials found for:', credentials.email);
+    return NextResponse.json(credentials);
+  } catch (error) {
+    console.error('Error fetching credentials:', error);
+    return NextResponse.json(
+      { error: 'Failed to retrieve credentials' },
       { status: 500 }
     );
   }