tempmail

const https = require('https');
const querystring = require('querystring');

class TempMail {
    constructor() {
        this.baseUrl = 'https://generator.email';
        this.userAgent = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36';
        this.cookie = null;
        this.domains = [
            'mailinator.com', 'guerrillamail.com', 'guerrillamail.net',
            'guerrillamail.org', 'guerrillamail.biz', 'mailnator.com',
            'trash2000.com', 'trash2000.net', 'trash2000.org',
            '10minutemail.com', '10minutemail.net', '10minutemail.org',
            'throwaway.email', 'throwawaymail.com', 'throwawaymail.net',
            'temp-mail.org', 'temp-mail.net', 'temp-mail.com',
            'maildrop.cc', 'maildrop.net', 'maildrop.org',
            'spam4.me', 'spam.la', 'spam.su',
            'mailcatch.com', 'mailcatch.net', 'mailcatch.org',
            'discard.email', 'discardmail.com', 'discardmail.net',
            'mintemail.com', 'mintemail.net', 'mintemail.org',
            'fakeinbox.com', 'fakeinbox.net', 'fakeinbox.org',
            'getairmail.com', 'getairmail.net', 'getairmail.org',
            'mailnesia.com', 'mailnesia.net', 'mailnesia.org',
            'mytrashmail.com', 'mytrashmail.net', 'mytrashmail.org',
            'trashmail.com', 'trashmail.net', 'trashmail.org',
            'dudmail.com', 'dudmail.net', 'dudmail.org',
            'mailexpire.com', 'mailexpire.net', 'mailexpire.org',
            'emailfake.com', 'emailfake.net', 'emailfake.org',
            'tempmail.co', 'tempmail.co.uk', 'tempmail.us',
            'samvix.life', 'wildan.tech', 'sentra-premium.com',
            'remahankerupuk.com', 'angiiidayyy.click', 'sekotong.store',
            'fbins001mail.com', 'phamlam.online', 'evoiceeeeee.blog',
            'starcheck.in', 'banri.xyz', 'acqq.dev', 'tools-capcut.com',
            'saovangtiles.site', 'hohohim.com'
        ];
        this.headers = {
            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8',
            'Accept-Language': 'en-US,en;q=0.9,id;q=0.8',
            'Accept-Encoding': 'gzip, deflate, br',
            'Connection': 'close',
            'Cache-Control': 'max-age=0',
            'Upgrade-Insecure-Requests': '1'
        };
    }

    request(method, path, data = null, extraHeaders = {}, redirectCount = 0) {
        return new Promise((resolve, reject) => {
            if (redirectCount > 5) return resolve('');

            const payload = data ? querystring.stringify(data) : null;

            const options = {
                hostname: 'generator.email',
                path: path,
                method: method,
                headers: Object.assign({
                    'User-Agent': this.userAgent,
                    'Accept': this.headers['Accept'],
                    'Accept-Language': this.headers['Accept-Language'],
                    'Accept-Encoding': this.headers['Accept-Encoding'],
                    'Connection': this.headers['Connection'],
                    'Cache-Control': this.headers['Cache-Control'],
                    'Upgrade-Insecure-Requests': this.headers['Upgrade-Insecure-Requests'],
                    'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
                    'X-Requested-With': 'XMLHttpRequest',
                }, extraHeaders),
                timeout: 15000,
                agent: false
            };

            if (this.cookie) {
                options.headers['Cookie'] = this.cookie;
            }

            if (payload) {
                options.headers['Content-Length'] = Buffer.byteLength(payload);
            }

            const req = https.request(options, (res) => {
                if (res.headers['set-cookie']) {
                    const newCookies = res.headers['set-cookie'].map(c => c.split(';')[0]);
                    if (this.cookie) {
                        const existing = this.cookie.split('; ');
                        for (const nc of newCookies) {
                            const key = nc.split('=')[0];
                            const idx = existing.findIndex(e => e.startsWith(key + '='));
                            if (idx >= 0) existing[idx] = nc;
                            else existing.push(nc);
                        }
                        this.cookie = existing.join('; ');
                    } else {
                        this.cookie = newCookies.join('; ');
                    }
                }

                if ((res.statusCode === 301 || res.statusCode === 302) && res.headers.location) {
                    const location = res.headers.location;
                    const newPath = location.startsWith('http')
                        ? new URL(location).pathname
                        : location;
                    resolve(this.request('GET', newPath, null, extraHeaders, redirectCount + 1));
                    return;
                }

                let responseData = '';
                res.on('data', (chunk) => responseData += chunk);
                res.on('end', () => {
                    const contentType = res.headers['content-type'] || '';
                    if (contentType.includes('application/json')) {
                        try {
                            resolve(JSON.parse(responseData));
                        } catch (e) {
                            resolve(responseData);
                        }
                    } else {
                        resolve(responseData);
                    }
                });
                res.on('error', (e) => reject(e));
            });

            req.on('error', (e) => {
                if (e.code === 'ECONNRESET' || e.code === 'ETIMEDOUT') {
                    this.request(method, path, data, extraHeaders, redirectCount + 1)
                        .then(resolve)
                        .catch(reject);
                } else {
                    reject(e);
                }
            });

            req.on('timeout', () => {
                req.destroy();
                this.request(method, path, data, extraHeaders, redirectCount + 1)
                    .then(resolve)
                    .catch(reject);
            });

            if (payload) req.write(payload);
            req.end();
        });
    }

    generateUsername() {
        const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
        let result = '';
        for (let i = 0; i < 8; i++) {
            result += chars.charAt(Math.floor(Math.random() * chars.length));
        }
        return result;
    }

    getRandomDomain() {
        return this.domains[Math.floor(Math.random() * this.domains.length)];
    }

    async createEmail(username = null, domain = null) {
        const usr = username || this.generateUsername();
        const dmn = domain || this.getRandomDomain();
        const email = `${usr}@${dmn}`;

        const punycode = await this.request('POST', '/dom_to_punycode.php', { dmn: dmn });
        let punyDomain = dmn;
        if (typeof punycode === 'string' && punycode.length < 50 && punycode.includes('.')) {
            punyDomain = punycode;
        }

        await this.request('POST', '/check_mail.php', { usr: usr, dmn: punyDomain });
        const validation = await this.request('POST', '/check_adres_validation3.php', { usr: usr, dmn: punyDomain });

        return {
            success: true,
            author: 'rynaqrtz',
            creator: 'rynaqrtz',
            data: {
                email,
                username: usr,
                domain: dmn,
                punycode_domain: punyDomain,
                validation: typeof validation === 'number' ? validation : 1,
                cek_inbox: `node tempmail.js ${email}`
            }
        };
    }

    parseEmails(html, email) {
        const emails = [];

        const headerPattern = /<div class="e7m list-group-item list-group-item-info">([\s\S]*?)(?=<script|<div class="e7m row list-group-item")/g;
        let headerMatch;

        while ((headerMatch = headerPattern.exec(html)) !== null) {
            const chunk = headerMatch[1];

            const fromMatch = chunk.match(/<div class="e7m from_div_45g45gg">([^<]+)<\/div>/);
            const subjectMatch = chunk.match(/<div class="e7m subj_div_45g45gg">([^<]*)<\/div>/);
            const timeMatch = chunk.match(/<div class="e7m time_div_45g45gg">([^<]+)<\/div>/);

            const from = fromMatch ? fromMatch[1].trim() : '';
            const subject = subjectMatch ? subjectMatch[1].trim() : '';
            const time = timeMatch ? timeMatch[1].trim() : '';

            if (from && from !== 'From') {
                emails.push({
                    from,
                    subject: subject || '(no subject)',
                    to: email,
                    time,
                    body: ''
                });
            }
        }

        const rowSplit = html.split(/<div class="e7m row list-group-item"/);
        const detailRows = [];

        for (let i = 1; i < rowSplit.length; i++) {
            const chunk = rowSplit[i];

            const fromMatch = chunk.match(/<span>From: <\/span><span>([^<]+)/);
            const toMatch = chunk.match(/<span>To: <\/span><span>([^<]+)<\/span>/);
            const timeMatch = chunk.match(/<span>Received: <\/span><span>([^<]+)<span/);
            const bodyMatch = chunk.match(/<div class="e7m mess_bodiyy"><div dir="auto">([\s\S]*?)<\/div><\/div>/);

            if (fromMatch || bodyMatch) {
                detailRows.push({
                    from: fromMatch ? fromMatch[1].trim() : '',
                    to: toMatch ? toMatch[1].trim() : email,
                    time: timeMatch ? timeMatch[1].trim() : '',
                    body: bodyMatch ? bodyMatch[1].trim() : ''
                });
            }
        }

        for (let i = 0; i < emails.length && i < detailRows.length; i++) {
            if (detailRows[i]) {
                emails[i].to = detailRows[i].to || email;
                emails[i].body = detailRows[i].body || '';
                if (detailRows[i].time) emails[i].time = detailRows[i].time;
            }
        }

        if (emails.length === 0 && detailRows.length > 0) {
            for (const row of detailRows) {
                if (row.from) {
                    emails.push({
                        from: row.from,
                        subject: '(no subject)',
                        to: row.to || email,
                        time: row.time || '',
                        body: row.body || ''
                    });
                }
            }
        }

        return emails;
    }

    async getInboxByUrl(inboxUrl) {
        try {
            const urlParts = inboxUrl.replace('https://', '').split('/');
            const domain = urlParts[1] || '';
            const username = urlParts[2] || '';
            const email = `${username}@${domain}`;

            await this.request('GET', '/');

            const surlValue = `${domain}/${username}/f73f0754a89555693e22f70a619b772c`;
            if (this.cookie) {
                const existing = this.cookie.split('; ');
                const idx = existing.findIndex(e => e.startsWith('surl='));
                if (idx >= 0) existing[idx] = `surl=${surlValue}`;
                else existing.push(`surl=${surlValue}`);
                this.cookie = existing.join('; ');
            } else {
                this.cookie = `surl=${surlValue}`;
            }

            await this.request('POST', '/check_mail.php', {
                usr: username,
                dmn: domain
            });

            const html = await this.request('GET', `/${domain}/${username}`, null, {
                'Accept': this.headers['Accept'],
                'Referer': `https://generator.email/${domain}/${username}`
            });

            if (typeof html !== 'string' || html.length < 500) {
                return {
                    success: false,
                    author: 'rynaqrtz',
                    creator: 'rynaqrtz',
                    error: 'Response gagal'
                };
            }

            const emails = this.parseEmails(html, email);

            const totalMatch = html.match(/<span id="mess_number">(\d+)<\/span>/);
            const totalFromSite = totalMatch ? parseInt(totalMatch[1]) : emails.length;

            return {
                success: true,
                author: 'rynaqrtz',
                creator: 'rynaqrtz',
                data: {
                    email,
                    username,
                    domain,
                    total_emails: emails.length,
                    total_from_site: totalFromSite,
                    emails
                }
            };

        } catch (error) {
            return {
                success: false,
                author: 'rynaqrtz',
                creator: 'rynaqrtz',
                error: error.message
            };
        }
    }

    async getInbox(emailAddress) {
        const parts = emailAddress.split('@');
        if (parts.length !== 2) {
            return {
                success: false,
                author: 'rynaqrtz',
                creator: 'rynaqrtz',
                error: 'Format email tidak valid'
            };
        }
        return this.getInboxByUrl(`https://generator.email/${parts[1]}/${parts[0]}`);
    }

    async getDomains() {
        return {
            success: true,
            author: 'rynaqrtz',
            creator: 'rynaqrtz',
            data: {
                total: this.domains.length,
                domains: this.domains
            }
        };
    }
}

async function main() {
    const args = process.argv.slice(2);
    const tm = new TempMail();

    if (args.length === 0) {
        const result = await tm.createEmail();
        console.log(JSON.stringify(result, null, 2));
        return;
    }

    const firstArg = args[0];

    if (firstArg === '--list') {
        const result = await tm.getDomains();
        console.log(JSON.stringify(result, null, 2));
        return;
    }

    if (firstArg === '--create' && args[1]) {
        const parts = args[1].split('@');
        if (parts.length !== 2) {
            console.log(JSON.stringify({
                success: false,
                author: 'rynaqrtz',
                creator: 'rynaqrtz',
                error: 'Format: --create username@domain'
            }, null, 2));
            return;
        }
        const result = await tm.createEmail(parts[0], parts[1]);
        console.log(JSON.stringify(result, null, 2));
        return;
    }

    if (firstArg.includes('@') || firstArg.startsWith('http')) {
        const arg = firstArg;
        const result = arg.startsWith('http')
            ? await tm.getInboxByUrl(arg)
            : await tm.getInbox(arg);
        console.log(JSON.stringify(result, null, 2));
        return;
    }

    console.log(JSON.stringify({
        success: false,
        author: 'rynaqrtz',
        creator: 'rynaqrtz',
        error: 'Perintah tidak dikenal',
        usage: {
            create_random: 'node tempmail.js',
            create_custom: 'node tempmail.js --create user@domain.com',
            check_email: 'node tempmail.js user@domain.com',
            check_url: 'node tempmail.js "https://generator.email/domain/user"',
            list_domains: 'node tempmail.js --list'
        }
    }, null, 2));
}

main()
    .then(() => process.exit(0))
    .catch(() => process.exit(1));