337 lines
8.7 KiB
TypeScript
337 lines
8.7 KiB
TypeScript
import { NextResponse } from 'next/server';
|
|
import Imap from 'imap';
|
|
import nodemailer from 'nodemailer';
|
|
import { parseEmailHeaders, decodeEmailBody } from '@/lib/email-parser';
|
|
import { cookies } from 'next/headers';
|
|
|
|
interface StoredCredentials {
|
|
email: string;
|
|
password: string;
|
|
host: string;
|
|
port: number;
|
|
}
|
|
|
|
interface Email {
|
|
id: string;
|
|
from: string;
|
|
subject: string;
|
|
date: Date;
|
|
read: boolean;
|
|
starred: boolean;
|
|
body: string;
|
|
to?: string;
|
|
}
|
|
|
|
interface ImapBox {
|
|
messages: {
|
|
total: number;
|
|
};
|
|
}
|
|
|
|
interface ImapMessage {
|
|
on: (event: string, callback: (data: any) => void) => void;
|
|
once: (event: string, callback: (data: any) => void) => void;
|
|
attributes: {
|
|
uid: number;
|
|
flags: string[];
|
|
size: number;
|
|
};
|
|
body: {
|
|
[key: string]: {
|
|
on: (event: string, callback: (data: any) => void) => void;
|
|
};
|
|
};
|
|
}
|
|
|
|
interface ImapConfig {
|
|
user: string;
|
|
password: string;
|
|
host: string;
|
|
port: number;
|
|
tls: boolean;
|
|
authTimeout: number;
|
|
connTimeout: number;
|
|
debug?: (info: string) => void;
|
|
}
|
|
|
|
function getStoredCredentials(): StoredCredentials | null {
|
|
const cookieStore = cookies();
|
|
|
|
const credentialsCookie = cookieStore.get('imap_credentials');
|
|
console.log('Retrieved credentials cookie:', credentialsCookie ? 'Found' : 'Not found');
|
|
|
|
if (!credentialsCookie?.value) {
|
|
console.log('No credentials cookie found');
|
|
return null;
|
|
}
|
|
|
|
try {
|
|
const credentials = JSON.parse(credentialsCookie.value);
|
|
console.log('Parsed credentials:', {
|
|
...credentials,
|
|
password: '***'
|
|
});
|
|
|
|
// Validate required fields
|
|
if (!credentials.email || !credentials.password || !credentials.host || !credentials.port) {
|
|
console.error('Missing required credentials fields');
|
|
return null;
|
|
}
|
|
|
|
return {
|
|
email: credentials.email,
|
|
password: credentials.password,
|
|
host: credentials.host,
|
|
port: credentials.port
|
|
};
|
|
} catch (error) {
|
|
console.error('Error parsing credentials cookie:', error);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
export async function GET() {
|
|
try {
|
|
console.log('GET /api/mail called');
|
|
const credentials = getStoredCredentials();
|
|
if (!credentials) {
|
|
console.log('No credentials found in cookies');
|
|
return NextResponse.json(
|
|
{ error: 'No stored credentials found' },
|
|
{ status: 401 }
|
|
);
|
|
}
|
|
|
|
console.log('Using credentials:', {
|
|
...credentials,
|
|
password: '***'
|
|
});
|
|
|
|
const imapConfig: ImapConfig = {
|
|
user: credentials.email,
|
|
password: credentials.password,
|
|
host: credentials.host,
|
|
port: credentials.port,
|
|
tls: true,
|
|
authTimeout: 10000,
|
|
connTimeout: 10000,
|
|
debug: (info: string) => console.log('IMAP Debug:', info)
|
|
};
|
|
|
|
console.log('Connecting to IMAP server...');
|
|
const imap = new Imap(imapConfig);
|
|
|
|
const connectPromise = new Promise((resolve, reject) => {
|
|
imap.once('ready', () => {
|
|
console.log('IMAP connection ready');
|
|
resolve(true);
|
|
});
|
|
imap.once('error', (err: Error) => {
|
|
console.error('IMAP connection error:', err);
|
|
reject(err);
|
|
});
|
|
imap.connect();
|
|
});
|
|
|
|
await connectPromise;
|
|
|
|
console.log('Opening INBOX...');
|
|
const openBoxPromise = new Promise<ImapBox>((resolve, reject) => {
|
|
imap.openBox('INBOX', false, (err: Error | null, box: ImapBox) => {
|
|
if (err) {
|
|
console.error('Error opening INBOX:', err);
|
|
reject(err);
|
|
} else {
|
|
console.log('INBOX opened successfully');
|
|
resolve(box);
|
|
}
|
|
});
|
|
});
|
|
|
|
const box = await openBoxPromise;
|
|
console.log('Total messages in INBOX:', box.messages.total);
|
|
|
|
const fetchPromise = (imap: Imap, seqno: number): Promise<ImapMessage> => {
|
|
return new Promise((resolve, reject) => {
|
|
const f = imap.fetch(seqno, {
|
|
bodies: ['HEADER', 'TEXT'],
|
|
struct: true,
|
|
markSeen: false
|
|
});
|
|
|
|
f.on('message', (msg: ImapMessage) => {
|
|
resolve(msg);
|
|
});
|
|
|
|
f.once('error', (err: Error) => {
|
|
console.error('Fetch error:', err);
|
|
reject(err);
|
|
});
|
|
});
|
|
};
|
|
|
|
const processMessage = (msg: ImapMessage): Promise<any> => {
|
|
return new Promise((resolve, reject) => {
|
|
let headerContent = '';
|
|
let bodyContent = '';
|
|
let headersParsed = false;
|
|
let bodyParsed = false;
|
|
|
|
// Process headers
|
|
msg.body['HEADER']?.on('data', (chunk: Buffer) => {
|
|
headerContent += chunk.toString('utf8');
|
|
});
|
|
|
|
// Process body
|
|
msg.body['TEXT']?.on('data', (chunk: Buffer) => {
|
|
bodyContent += chunk.toString('utf8');
|
|
});
|
|
|
|
const tryResolve = () => {
|
|
if (headersParsed && bodyParsed) {
|
|
try {
|
|
const headers = parseEmailHeaders(headerContent);
|
|
const contentType = headerContent.match(/Content-Type:\s*([^;\r\n]+)/i)?.[1] || 'text/plain';
|
|
const decodedBody = decodeEmailBody(bodyContent, contentType);
|
|
|
|
resolve({
|
|
uid: msg.attributes.uid,
|
|
flags: msg.attributes.flags,
|
|
size: msg.attributes.size,
|
|
body: decodedBody,
|
|
...headers
|
|
});
|
|
} catch (error) {
|
|
console.error('Error processing message:', error);
|
|
reject(error);
|
|
}
|
|
}
|
|
};
|
|
|
|
msg.body['HEADER']?.on('end', () => {
|
|
headersParsed = true;
|
|
tryResolve();
|
|
});
|
|
|
|
msg.body['TEXT']?.on('end', () => {
|
|
bodyParsed = true;
|
|
tryResolve();
|
|
});
|
|
|
|
msg.body['HEADER']?.on('error', reject);
|
|
msg.body['TEXT']?.on('error', reject);
|
|
});
|
|
};
|
|
|
|
const messages: any[] = [];
|
|
// Fetch the most recent 20 emails
|
|
const start = Math.max(1, box.messages.total - 19); // last 20 emails
|
|
const end = box.messages.total;
|
|
for (let seqno = start; seqno <= end; seqno++) {
|
|
const msg = await fetchPromise(imap, seqno);
|
|
const processedMsg = await processMessage(msg);
|
|
messages.push(processedMsg);
|
|
}
|
|
imap.end();
|
|
|
|
console.log('Raw messages:', messages);
|
|
|
|
const emails: Email[] = messages.map((msg) => {
|
|
return {
|
|
id: msg.uid.toString(),
|
|
from: msg.from,
|
|
subject: msg.subject || '(No subject)',
|
|
date: new Date(msg.date),
|
|
read: !msg.flags?.includes('\\Unseen'),
|
|
starred: msg.flags?.includes('\\Flagged') || false,
|
|
body: msg.body || '',
|
|
to: msg.to
|
|
};
|
|
});
|
|
|
|
return NextResponse.json({
|
|
emails,
|
|
mailUrl: process.env.NEXTCLOUD_URL ? `${process.env.NEXTCLOUD_URL}/apps/mail/` : null
|
|
}, {
|
|
headers: {
|
|
'Content-Type': 'application/json'
|
|
}
|
|
});
|
|
} catch (error) {
|
|
console.error('Error fetching emails:', error);
|
|
const status = error instanceof Error && error.message.includes('Invalid login')
|
|
? 401
|
|
: 500;
|
|
return NextResponse.json(
|
|
{ error: error instanceof Error ? error.message : 'Failed to fetch emails' },
|
|
{ status }
|
|
);
|
|
}
|
|
}
|
|
|
|
export async function POST(request: Request) {
|
|
try {
|
|
const credentials = getStoredCredentials();
|
|
if (!credentials) {
|
|
return NextResponse.json(
|
|
{ error: 'No stored credentials found' },
|
|
{ status: 401 }
|
|
);
|
|
}
|
|
|
|
let body;
|
|
try {
|
|
body = await request.json();
|
|
} catch (error) {
|
|
return NextResponse.json(
|
|
{ error: 'Invalid JSON in request body' },
|
|
{ status: 400 }
|
|
);
|
|
}
|
|
|
|
const { to, subject, body: emailBody, attachments } = body;
|
|
|
|
if (!to || !subject || !emailBody) {
|
|
return NextResponse.json(
|
|
{ error: 'Missing required fields: to, subject, or body' },
|
|
{ status: 400 }
|
|
);
|
|
}
|
|
|
|
const transporter = nodemailer.createTransport({
|
|
host: credentials.host,
|
|
port: credentials.port,
|
|
secure: true,
|
|
auth: {
|
|
user: credentials.email,
|
|
pass: credentials.password,
|
|
},
|
|
});
|
|
|
|
const mailOptions = {
|
|
from: credentials.email,
|
|
to,
|
|
subject,
|
|
text: emailBody,
|
|
attachments: attachments || [],
|
|
};
|
|
|
|
const info = await transporter.sendMail(mailOptions);
|
|
console.log('Email sent:', info.messageId);
|
|
|
|
return NextResponse.json({
|
|
success: true,
|
|
messageId: info.messageId,
|
|
message: 'Email sent successfully'
|
|
});
|
|
} catch (error) {
|
|
console.error('Error sending email:', error);
|
|
return NextResponse.json(
|
|
{
|
|
error: error instanceof Error ? error.message : 'Failed to send email',
|
|
details: error instanceof Error ? error.stack : undefined
|
|
},
|
|
{ status: 500 }
|
|
);
|
|
}
|
|
} |