cowork-os 0.3.21

package/dist/electron/electron/gateway/channels/email-client.js

@@ -0,0 +1,593 @@
+"use strict";
+/**
+ * Email Client (IMAP/SMTP)
+ *
+ * Email client using IMAP for receiving and SMTP for sending.
+ * Provides a unified interface for email communication.
+ *
+ * Features:
+ * - Real-time email receiving via IMAP IDLE
+ * - Email sending via SMTP
+ * - HTML and plain text support
+ * - Attachment support
+ * - Reply threading
+ *
+ * Requirements:
+ * - IMAP server credentials
+ * - SMTP server credentials
+ * - Usually both use the same email/password
+ *
+ * Common Providers:
+ * - Gmail: imap.gmail.com:993, smtp.gmail.com:587 (use App Password)
+ * - Outlook: outlook.office365.com:993, smtp.office365.com:587
+ * - Yahoo: imap.mail.yahoo.com:993, smtp.mail.yahoo.com:465
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailClient = void 0;
+const events_1 = require("events");
+const tls = __importStar(require("tls"));
+const net = __importStar(require("net"));
+/**
+ * IMAP/SMTP Email Client
+ *
+ * Note: This is a simplified implementation. For production use,
+ * consider using libraries like 'imap' and 'nodemailer'.
+ */
+class EmailClient extends events_1.EventEmitter {
+    constructor(options) {
+        super();
+        this.connected = false;
+        this.lastSeenUid = 0;
+        this.commandTag = 0;
+        this.responseBuffer = '';
+        this.options = options;
+    }
+    /**
+     * Check IMAP connection
+     */
+    async checkConnection() {
+        try {
+            await this.connectImap();
+            await this.disconnectImap();
+            return { success: true, email: this.options.email };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    }
+    /**
+     * Start receiving emails
+     */
+    async startReceiving() {
+        if (this.connected) {
+            return;
+        }
+        try {
+            await this.connectImap();
+            await this.selectMailbox();
+            this.connected = true;
+            this.emit('connected');
+            // Start polling (IDLE requires more complex handling)
+            this.startPolling();
+        }
+        catch (error) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
+    /**
+     * Connect to IMAP server
+     */
+    async connectImap() {
+        return new Promise((resolve, reject) => {
+            const connect = () => {
+                if (this.options.imapSecure) {
+                    this.imapSocket = tls.connect({
+                        host: this.options.imapHost,
+                        port: this.options.imapPort,
+                        rejectUnauthorized: true,
+                    });
+                }
+                else {
+                    this.imapSocket = net.connect({
+                        host: this.options.imapHost,
+                        port: this.options.imapPort,
+                    });
+                }
+                const timeout = setTimeout(() => {
+                    reject(new Error('IMAP connection timeout'));
+                }, 30000);
+                this.imapSocket.on('error', (error) => {
+                    clearTimeout(timeout);
+                    reject(error);
+                });
+                this.imapSocket.on('data', (data) => {
+                    this.handleImapData(data.toString());
+                });
+                this.imapSocket.once('connect', async () => {
+                    // Wait for server greeting
+                    await this.waitForResponse('OK');
+                    // Login
+                    try {
+                        await this.imapCommand(`LOGIN "${this.options.email}" "${this.options.password}"`);
+                        clearTimeout(timeout);
+                        resolve();
+                    }
+                    catch (error) {
+                        clearTimeout(timeout);
+                        reject(error);
+                    }
+                });
+                if (!this.options.imapSecure) {
+                    this.imapSocket.once('connect', () => {
+                        this.imapSocket.emit('connect');
+                    });
+                }
+            };
+            connect();
+        });
+    }
+    /**
+     * Handle IMAP data
+     */
+    handleImapData(data) {
+        this.responseBuffer += data;
+        if (this.currentCallback) {
+            // Check for complete response
+            if (this.responseBuffer.includes('\r\n') &&
+                (this.responseBuffer.includes('OK') ||
+                    this.responseBuffer.includes('NO') ||
+                    this.responseBuffer.includes('BAD'))) {
+                const response = this.responseBuffer;
+                this.responseBuffer = '';
+                this.currentCallback(response);
+                this.currentCallback = undefined;
+            }
+        }
+    }
+    /**
+     * Wait for server response
+     */
+    async waitForResponse(expectedType) {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.currentCallback = undefined;
+                reject(new Error('IMAP response timeout'));
+            }, 10000);
+            this.currentCallback = (response) => {
+                clearTimeout(timeout);
+                if (response.includes(expectedType)) {
+                    resolve(response);
+                }
+                else if (response.includes('NO') || response.includes('BAD')) {
+                    reject(new Error(`IMAP error: ${response}`));
+                }
+                else {
+                    resolve(response);
+                }
+            };
+        });
+    }
+    /**
+     * Send IMAP command
+     */
+    async imapCommand(command) {
+        return new Promise((resolve, reject) => {
+            if (!this.imapSocket) {
+                reject(new Error('Not connected'));
+                return;
+            }
+            const tag = `A${++this.commandTag}`;
+            const fullCommand = `${tag} ${command}\r\n`;
+            const timeout = setTimeout(() => {
+                this.currentCallback = undefined;
+                reject(new Error('IMAP command timeout'));
+            }, 30000);
+            this.currentCallback = (response) => {
+                clearTimeout(timeout);
+                if (response.includes(`${tag} OK`)) {
+                    resolve(response);
+                }
+                else if (response.includes(`${tag} NO`) || response.includes(`${tag} BAD`)) {
+                    reject(new Error(`IMAP error: ${response}`));
+                }
+                else {
+                    // Partial response, keep waiting
+                }
+            };
+            this.imapSocket.write(fullCommand);
+        });
+    }
+    /**
+     * Select mailbox
+     */
+    async selectMailbox() {
+        const response = await this.imapCommand(`SELECT "${this.options.mailbox}"`);
+        // Parse UIDNEXT from response to get last UID
+        const uidMatch = response.match(/UIDNEXT\s+(\d+)/i);
+        if (uidMatch) {
+            this.lastSeenUid = parseInt(uidMatch[1], 10) - 1;
+        }
+    }
+    /**
+     * Start polling for new emails
+     */
+    startPolling() {
+        this.pollTimer = setInterval(async () => {
+            try {
+                await this.checkNewEmails();
+            }
+            catch (error) {
+                if (this.options.verbose) {
+                    console.error('Email poll error:', error);
+                }
+            }
+        }, this.options.pollInterval);
+    }
+    /**
+     * Check for new emails
+     */
+    async checkNewEmails() {
+        try {
+            // Search for new emails
+            const response = await this.imapCommand(`UID SEARCH UID ${this.lastSeenUid + 1}:*`);
+            const uidMatch = response.match(/SEARCH\s+([\d\s]+)/i);
+            if (uidMatch) {
+                const uids = uidMatch[1]
+                    .trim()
+                    .split(/\s+/)
+                    .filter((u) => u)
+                    .map((u) => parseInt(u, 10))
+                    .filter((u) => u > this.lastSeenUid);
+                for (const uid of uids) {
+                    try {
+                        const email = await this.fetchEmail(uid);
+                        if (email) {
+                            this.emit('message', email);
+                            this.lastSeenUid = Math.max(this.lastSeenUid, uid);
+                        }
+                    }
+                    catch (error) {
+                        if (this.options.verbose) {
+                            console.error(`Error fetching email ${uid}:`, error);
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Reconnect if needed
+            if (!this.imapSocket || this.imapSocket.destroyed) {
+                try {
+                    await this.connectImap();
+                    await this.selectMailbox();
+                }
+                catch {
+                    // Will retry on next poll
+                }
+            }
+        }
+    }
+    /**
+     * Fetch email by UID
+     */
+    async fetchEmail(uid) {
+        try {
+            const response = await this.imapCommand(`UID FETCH ${uid} (FLAGS BODY[HEADER] BODY[TEXT])`);
+            // Parse email from response (simplified)
+            const email = this.parseEmailResponse(response, uid);
+            return email;
+        }
+        catch (error) {
+            if (this.options.verbose) {
+                console.error(`Error fetching email ${uid}:`, error);
+            }
+            return null;
+        }
+    }
+    /**
+     * Parse email from IMAP response (simplified)
+     */
+    parseEmailResponse(response, uid) {
+        const headers = new Map();
+        // Extract headers (simplified parsing)
+        const headerMatch = response.match(/BODY\[HEADER\]\s*\{(\d+)\}\r\n([\s\S]*?)\r\n\r\n/i);
+        if (headerMatch) {
+            const headerText = headerMatch[2];
+            const headerLines = headerText.split(/\r\n(?=[^\s])/);
+            for (const line of headerLines) {
+                const colonIndex = line.indexOf(':');
+                if (colonIndex > 0) {
+                    const key = line.substring(0, colonIndex).trim().toLowerCase();
+                    const value = line
+                        .substring(colonIndex + 1)
+                        .replace(/\r\n\s+/g, ' ')
+                        .trim();
+                    headers.set(key, value);
+                }
+            }
+        }
+        // Extract text body (simplified)
+        let text = '';
+        const textMatch = response.match(/BODY\[TEXT\]\s*\{(\d+)\}\r\n([\s\S]*?)(?=\)|\*)/i);
+        if (textMatch) {
+            text = textMatch[2].trim();
+        }
+        // Parse From address
+        const fromHeader = headers.get('from') || '';
+        const from = this.parseEmailAddress(fromHeader);
+        // Parse To addresses
+        const toHeader = headers.get('to') || '';
+        const to = this.parseEmailAddresses(toHeader);
+        // Parse Message-ID
+        const messageId = headers.get('message-id') || `${uid}@${this.options.imapHost}`;
+        // Parse Date
+        const dateHeader = headers.get('date') || '';
+        const date = dateHeader ? new Date(dateHeader) : new Date();
+        // Check if read
+        const isRead = response.toLowerCase().includes('\\seen');
+        return {
+            messageId: messageId.replace(/[<>]/g, ''),
+            uid,
+            from,
+            to,
+            subject: this.decodeHeader(headers.get('subject') || '(No Subject)'),
+            text: this.decodeBody(text),
+            date,
+            inReplyTo: headers.get('in-reply-to')?.replace(/[<>]/g, ''),
+            references: headers
+                .get('references')
+                ?.split(/\s+/)
+                .map((r) => r.replace(/[<>]/g, '')),
+            isRead,
+            headers,
+        };
+    }
+    /**
+     * Parse single email address
+     */
+    parseEmailAddress(header) {
+        const match = header.match(/^(?:"?([^"]*)"?\s+)?<?([^>]+)>?$/);
+        if (match) {
+            return {
+                name: match[1]?.trim(),
+                address: match[2].trim(),
+            };
+        }
+        return { address: header.trim() };
+    }
+    /**
+     * Parse multiple email addresses
+     */
+    parseEmailAddresses(header) {
+        return header.split(',').map((addr) => this.parseEmailAddress(addr.trim()));
+    }
+    /**
+     * Decode MIME header
+     */
+    decodeHeader(header) {
+        // Handle =?charset?encoding?text?= format
+        return header.replace(/=\?([^?]+)\?([BQ])\?([^?]+)\?=/gi, (_, charset, encoding, text) => {
+            if (encoding.toUpperCase() === 'B') {
+                return Buffer.from(text, 'base64').toString('utf8');
+            }
+            else {
+                return text.replace(/_/g, ' ').replace(/=([0-9A-F]{2})/gi, (__, hex) => String.fromCharCode(parseInt(hex, 16)));
+            }
+        });
+    }
+    /**
+     * Decode body content
+     */
+    decodeBody(text) {
+        // Handle quoted-printable
+        return text
+            .replace(/=\r?\n/g, '')
+            .replace(/=([0-9A-F]{2})/gi, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
+    }
+    /**
+     * Disconnect IMAP
+     */
+    async disconnectImap() {
+        if (this.imapSocket) {
+            try {
+                await this.imapCommand('LOGOUT');
+            }
+            catch {
+                // Ignore logout errors
+            }
+            this.imapSocket.destroy();
+            this.imapSocket = undefined;
+        }
+    }
+    /**
+     * Stop receiving
+     */
+    async stopReceiving() {
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+            this.pollTimer = undefined;
+        }
+        await this.disconnectImap();
+        this.connected = false;
+        this.emit('disconnected');
+    }
+    /**
+     * Send email via SMTP
+     */
+    async sendEmail(options) {
+        return new Promise((resolve, reject) => {
+            const toAddresses = Array.isArray(options.to) ? options.to : [options.to];
+            const messageId = `<${Date.now()}.${Math.random().toString(36).substring(2)}@${this.options.smtpHost}>`;
+            // Build email
+            const headers = [
+                `From: ${this.options.displayName ? `"${this.options.displayName}" ` : ''}<${this.options.email}>`,
+                `To: ${toAddresses.join(', ')}`,
+                `Subject: ${options.subject}`,
+                `Message-ID: ${messageId}`,
+                `Date: ${new Date().toUTCString()}`,
+                'MIME-Version: 1.0',
+                'Content-Type: text/plain; charset=UTF-8',
+            ];
+            if (options.inReplyTo) {
+                headers.push(`In-Reply-To: <${options.inReplyTo}>`);
+            }
+            if (options.references && options.references.length > 0) {
+                headers.push(`References: ${options.references.map((r) => `<${r}>`).join(' ')}`);
+            }
+            const body = options.text || '';
+            const email = headers.join('\r\n') + '\r\n\r\n' + body + '\r\n.\r\n';
+            // Connect to SMTP
+            const connectSmtp = () => {
+                let socket;
+                if (this.options.smtpSecure) {
+                    socket = tls.connect({
+                        host: this.options.smtpHost,
+                        port: this.options.smtpPort,
+                        rejectUnauthorized: true,
+                    });
+                }
+                else {
+                    socket = net.connect({
+                        host: this.options.smtpHost,
+                        port: this.options.smtpPort,
+                    });
+                }
+                let step = 0;
+                let responseBuffer = '';
+                socket.on('data', (data) => {
+                    responseBuffer += data.toString();
+                    // Check for complete response
+                    if (!responseBuffer.includes('\r\n'))
+                        return;
+                    const lines = responseBuffer.split('\r\n');
+                    responseBuffer = lines.pop() || '';
+                    for (const line of lines) {
+                        if (this.options.verbose) {
+                            console.log('SMTP <', line);
+                        }
+                        const code = parseInt(line.substring(0, 3), 10);
+                        // Handle multi-line responses
+                        if (line[3] === '-')
+                            continue;
+                        if (code >= 400) {
+                            socket.destroy();
+                            reject(new Error(`SMTP error: ${line}`));
+                            return;
+                        }
+                        step++;
+                        switch (step) {
+                            case 1: // After greeting
+                                socket.write(`EHLO ${this.options.smtpHost}\r\n`);
+                                break;
+                            case 2: // After EHLO
+                                if (!this.options.smtpSecure && line.includes('STARTTLS')) {
+                                    socket.write('STARTTLS\r\n');
+                                }
+                                else {
+                                    socket.write(`AUTH PLAIN ${Buffer.from(`\0${this.options.email}\0${this.options.password}`).toString('base64')}\r\n`);
+                                }
+                                break;
+                            case 3: // After STARTTLS or AUTH
+                                if (line.includes('220') && !this.options.smtpSecure) {
+                                    // Upgrade to TLS
+                                    const tlsSocket = tls.connect({
+                                        socket: socket,
+                                        host: this.options.smtpHost,
+                                        rejectUnauthorized: true,
+                                    });
+                                    socket = tlsSocket;
+                                    socket.write(`EHLO ${this.options.smtpHost}\r\n`);
+                                    step = 1;
+                                }
+                                else {
+                                    socket.write(`MAIL FROM:<${this.options.email}>\r\n`);
+                                }
+                                break;
+                            case 4: // After MAIL FROM
+                                socket.write(`RCPT TO:<${toAddresses[0]}>\r\n`);
+                                break;
+                            case 5: // After RCPT TO
+                                socket.write('DATA\r\n');
+                                break;
+                            case 6: // After DATA
+                                socket.write(email);
+                                break;
+                            case 7: // After email sent
+                                socket.write('QUIT\r\n');
+                                socket.end();
+                                resolve(messageId.replace(/[<>]/g, ''));
+                                break;
+                        }
+                    }
+                });
+                socket.on('error', (error) => {
+                    reject(error);
+                });
+                const timeout = setTimeout(() => {
+                    socket.destroy();
+                    reject(new Error('SMTP connection timeout'));
+                }, 30000);
+                socket.on('close', () => {
+                    clearTimeout(timeout);
+                });
+            };
+            connectSmtp();
+        });
+    }
+    /**
+     * Mark email as read
+     */
+    async markAsRead(uid) {
+        await this.imapCommand(`UID STORE ${uid} +FLAGS (\\Seen)`);
+    }
+    /**
+     * Check if connected
+     */
+    isConnected() {
+        return this.connected;
+    }
+    /**
+     * Get email address
+     */
+    getEmail() {
+        return this.options.email;
+    }
+}
+exports.EmailClient = EmailClient;