opc-agent 2.0.0 → 2.0.2

package/dist/channels/email.d.ts

@@ -1,31 +1,36 @@
 import { BaseChannel } from './index';
-import type { Message } from '../core/types';
 /**
- * Email Channel — v0.8.0
- * IMAP polling for incoming emails, SMTP for sending replies.
- * Parses email threads as conversations.
+ * Email Channel — v1.0.0
+ *
+ * Supports two modes:
+ * - webhook: Receives emails via HTTP POST (works with email forwarding services)
+ * - imap: TODO - Full IMAP polling (complex, requires raw socket IMAP protocol)
+ *
+ * Sends via SMTP with STARTTLS support using Node.js built-in tls module.
+ * No external dependencies (no nodemailer).
  */
 export interface EmailChannelConfig {
-    imap: {
+    /** Mode: 'webhook' (recommended) or 'imap' (TODO) */
+    mode?: 'webhook' | 'imap';
+    smtp?: {
         host: string;
         port: number;
         user: string;
-        password: string;
-        tls?: boolean;
-        /** Mailbox to monitor (default: INBOX) */
-        mailbox?: string;
-        /** Poll interval in ms (default: 30000) */
-        pollInterval?: number;
+        pass: string;
+        from?: string;
     };
-    smtp: {
+    imap?: {
         host: string;
         port: number;
         user: string;
         password: string;
         tls?: boolean;
-        from: string;
+        mailbox?: string;
+        pollInterval?: number;
     };
-    /** Filter: only process emails matching these patterns */
+    /** Webhook server port (default: 8082) */
+    webhookPort?: number;
+    /** Filter: only process emails from these addresses */
     filters?: {
         from?: string[];
         subject?: string[];
@@ -47,23 +52,24 @@ export interface EmailMessage {
 export declare class EmailChannel extends BaseChannel {
     type: string;
     private config;
-    private pollTimer;
-    private running;
+    private server;
     private processedIds;
     constructor(config: EmailChannelConfig);
     start(): Promise<void>;
     stop(): Promise<void>;
-    /** Poll IMAP for new emails */
-    private poll;
-    /** Convert email to Message format */
+    /** Start webhook HTTP server */
+    private startWebhook;
+    /** Parse webhook payload into EmailMessage */
+    static parseWebhookPayload(payload: any): EmailMessage | null;
+    /** Convert email to internal Message */
     private emailToMessage;
     /** Check if email matches configured filters */
-    private matchesFilters;
-    /** Fetch emails via IMAP — stub for actual implementation */
-    private fetchEmails;
-    /** Send reply via SMTP — stub for actual implementation */
-    sendReply(originalEmail: EmailMessage, reply: Message): Promise<void>;
-    /** Send a standalone email */
-    send(to: string, subject: string, body: string): Promise<void>;
+    matchesFilters(email: EmailMessage): boolean;
+    /** Send email via SMTP with STARTTLS */
+    sendEmail(to: string, subject: string, body: string, inReplyTo?: string): Promise<void>;
+    /** Raw SMTP send with STARTTLS */
+    private smtpSend;
+    /** Read request body */
+    private readBody;
 }
 //# sourceMappingURL=email.d.ts.map

package/dist/channels/email.js

@@ -1,54 +1,163 @@
 "use strict";
+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.EmailChannel = void 0;
 const index_1 = require("./index");
+const http = __importStar(require("http"));
+const net = __importStar(require("net"));
+const tls = __importStar(require("tls"));
+const crypto = __importStar(require("crypto"));
 class EmailChannel extends index_1.BaseChannel {
     type = 'email';
     config;
-    pollTimer = null;
-    running = false;
+    server = null;
     processedIds = new Set();
     constructor(config) {
         super();
         this.config = config;
     }
     async start() {
-        this.running = true;
-        const interval = this.config.imap.pollInterval ?? 30000;
-        // Initial poll
-        await this.poll();
-        // Set up recurring poll
-        this.pollTimer = setInterval(() => {
-            if (this.running)
-                this.poll().catch(console.error);
-        }, interval);
+        const mode = this.config.mode ?? 'webhook';
+        if (mode === 'webhook') {
+            await this.startWebhook();
+        }
+        else {
+            console.warn('[EmailChannel] IMAP mode is not yet implemented. Use webhook mode.');
+        }
     }
     async stop() {
-        this.running = false;
-        if (this.pollTimer) {
-            clearInterval(this.pollTimer);
-            this.pollTimer = null;
-        }
+        return new Promise((resolve, reject) => {
+            if (!this.server)
+                return resolve();
+            this.server.close((err) => (err ? reject(err) : resolve()));
+            this.server = null;
+        });
     }
-    /** Poll IMAP for new emails */
-    async poll() {
-        // In production, use a library like `imapflow` or `imap-simple`
-        // This is the integration point — actual IMAP connection logic goes here
-        const emails = await this.fetchEmails();
-        for (const email of emails) {
-            if (this.processedIds.has(email.messageId))
-                continue;
-            this.processedIds.add(email.messageId);
-            if (!this.matchesFilters(email))
-                continue;
-            const message = this.emailToMessage(email);
-            if (this.handler) {
-                const reply = await this.handler(message);
-                await this.sendReply(email, reply);
+    /** Start webhook HTTP server */
+    async startWebhook() {
+        const port = this.config.webhookPort ?? 8082;
+        this.server = http.createServer(async (req, res) => {
+            if (req.method === 'GET' && req.url === '/health') {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ status: 'ok', channel: 'email', mode: 'webhook' }));
+                return;
             }
-        }
+            if (req.method === 'POST' && (req.url === '/email/incoming' || req.url === '/')) {
+                try {
+                    const body = await this.readBody(req);
+                    const parsed = JSON.parse(body);
+                    const email = EmailChannel.parseWebhookPayload(parsed);
+                    if (!email) {
+                        res.writeHead(400, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ error: 'Invalid email payload' }));
+                        return;
+                    }
+                    // Deduplicate
+                    if (this.processedIds.has(email.messageId)) {
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ ok: true, duplicate: true }));
+                        return;
+                    }
+                    this.processedIds.add(email.messageId);
+                    if (this.processedIds.size > 5000) {
+                        const arr = [...this.processedIds];
+                        this.processedIds = new Set(arr.slice(-2500));
+                    }
+                    // Apply filters
+                    if (!this.matchesFilters(email)) {
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ ok: true, filtered: true }));
+                        return;
+                    }
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: true }));
+                    // Process async
+                    if (this.handler) {
+                        const msg = this.emailToMessage(email);
+                        try {
+                            const reply = await this.handler(msg);
+                            if (this.config.smtp) {
+                                await this.sendEmail(email.from, `Re: ${email.subject}`, reply.content, email.messageId);
+                            }
+                        }
+                        catch (err) {
+                            console.error('[EmailChannel] Handler error:', err);
+                        }
+                    }
+                }
+                catch (err) {
+                    console.error('[EmailChannel] Webhook error:', err);
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Internal error' }));
+                }
+                return;
+            }
+            res.writeHead(404);
+            res.end('Not Found');
+        });
+        return new Promise((resolve) => {
+            this.server.listen(port, () => {
+                console.log(`[EmailChannel] Webhook listening on port ${port}`);
+                resolve();
+            });
+        });
     }
-    /** Convert email to Message format */
+    /** Parse webhook payload into EmailMessage */
+    static parseWebhookPayload(payload) {
+        // Support common email webhook formats (SendGrid, Mailgun, generic)
+        const from = payload.from ?? payload.sender ?? payload.envelope?.from;
+        const subject = payload.subject ?? '(no subject)';
+        const body = payload.body ?? payload.text ?? payload['body-plain'] ?? payload.content ?? '';
+        const to = payload.to ?? payload.recipient ?? payload.envelope?.to;
+        if (!from)
+            return null;
+        return {
+            messageId: payload.messageId ?? payload['Message-Id'] ?? payload.id ?? `email-${Date.now()}-${crypto.randomBytes(4).toString('hex')}`,
+            from: typeof from === 'string' ? from : String(from),
+            to: Array.isArray(to) ? to : (typeof to === 'string' ? [to] : []),
+            cc: payload.cc ? (Array.isArray(payload.cc) ? payload.cc : [payload.cc]) : undefined,
+            subject,
+            body,
+            html: payload.html ?? payload['body-html'],
+            date: payload.date ? new Date(payload.date) : new Date(),
+            inReplyTo: payload.inReplyTo ?? payload['In-Reply-To'],
+            references: payload.references ? (Array.isArray(payload.references) ? payload.references : [payload.references]) : undefined,
+            threadId: payload.threadId,
+        };
+    }
+    /** Convert email to internal Message */
     emailToMessage(email) {
         return {
             id: email.messageId,
@@ -81,37 +190,105 @@ class EmailChannel extends index_1.BaseChannel {
         }
         return true;
     }
-    /** Fetch emails via IMAP — stub for actual implementation */
-    async fetchEmails() {
-        // TODO: Implement with imapflow or similar library
-        // const { ImapFlow } = await import('imapflow');
-        // const client = new ImapFlow({ ...this.config.imap });
-        // await client.connect();
-        // ...
-        return [];
+    /** Send email via SMTP with STARTTLS */
+    async sendEmail(to, subject, body, inReplyTo) {
+        const smtp = this.config.smtp;
+        if (!smtp)
+            throw new Error('[EmailChannel] SMTP not configured');
+        const from = smtp.from ?? smtp.user;
+        const messageId = `<${crypto.randomBytes(16).toString('hex')}@opc-agent>`;
+        let headers = `From: ${from}\r\n`;
+        headers += `To: ${to}\r\n`;
+        headers += `Subject: ${subject}\r\n`;
+        headers += `Message-ID: ${messageId}\r\n`;
+        headers += `Date: ${new Date().toUTCString()}\r\n`;
+        if (inReplyTo) {
+            headers += `In-Reply-To: ${inReplyTo}\r\n`;
+            headers += `References: ${inReplyTo}\r\n`;
+        }
+        headers += `MIME-Version: 1.0\r\n`;
+        headers += `Content-Type: text/plain; charset=UTF-8\r\n`;
+        headers += `\r\n`;
+        headers += body;
+        await this.smtpSend(smtp.host, smtp.port, smtp.user, smtp.pass, from, to, headers);
     }
-    /** Send reply via SMTP — stub for actual implementation */
-    async sendReply(originalEmail, reply) {
-        // TODO: Implement with nodemailer or similar library
-        // const nodemailer = await import('nodemailer');
-        // const transport = nodemailer.createTransport({ ...this.config.smtp });
-        // await transport.sendMail({
-        //   from: this.config.smtp.from,
-        //   to: originalEmail.from,
-        //   subject: `Re: ${originalEmail.subject}`,
-        //   text: reply.content,
-        //   inReplyTo: originalEmail.messageId,
-        //   references: [originalEmail.messageId],
-        // });
-        void originalEmail;
-        void reply;
+    /** Raw SMTP send with STARTTLS */
+    smtpSend(host, port, user, pass, from, to, message) {
+        return new Promise((resolve, reject) => {
+            let socket = net.createConnection(port, host);
+            let upgraded = false;
+            let step = 0;
+            const commands = [
+                `EHLO opc-agent\r\n`,
+                `STARTTLS\r\n`,
+                // After TLS upgrade:
+                `EHLO opc-agent\r\n`,
+                `AUTH LOGIN\r\n`,
+                `${Buffer.from(user).toString('base64')}\r\n`,
+                `${Buffer.from(pass).toString('base64')}\r\n`,
+                `MAIL FROM:<${from}>\r\n`,
+                `RCPT TO:<${to}>\r\n`,
+                `DATA\r\n`,
+                `${message}\r\n.\r\n`,
+                `QUIT\r\n`,
+            ];
+            const sendNext = () => {
+                if (step < commands.length) {
+                    socket.write(commands[step]);
+                    step++;
+                }
+            };
+            socket.on('data', (data) => {
+                const response = data.toString();
+                const code = parseInt(response.substring(0, 3), 10);
+                if (code >= 400) {
+                    socket.destroy();
+                    reject(new Error(`SMTP error: ${response.trim()}`));
+                    return;
+                }
+                // After STARTTLS response (220), upgrade to TLS
+                if (step === 2 && !upgraded && response.startsWith('220')) {
+                    upgraded = true;
+                    const tlsSocket = tls.connect({ socket, host, servername: host }, () => {
+                        socket = tlsSocket;
+                        sendNext(); // EHLO again after TLS
+                    });
+                    tlsSocket.on('data', (d) => {
+                        const resp = d.toString();
+                        const c = parseInt(resp.substring(0, 3), 10);
+                        if (c >= 400) {
+                            tlsSocket.destroy();
+                            reject(new Error(`SMTP error: ${resp.trim()}`));
+                            return;
+                        }
+                        if (step === commands.length && resp.startsWith('221')) {
+                            tlsSocket.destroy();
+                            resolve();
+                            return;
+                        }
+                        sendNext();
+                    });
+                    tlsSocket.on('error', reject);
+                    return;
+                }
+                sendNext();
+            });
+            socket.on('error', reject);
+            socket.on('timeout', () => {
+                socket.destroy();
+                reject(new Error('SMTP connection timeout'));
+            });
+            socket.setTimeout(30000);
+        });
     }
-    /** Send a standalone email */
-    async send(to, subject, body) {
-        void to;
-        void subject;
-        void body;
-        // TODO: Implement with nodemailer
+    /** Read request body */
+    readBody(req) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            req.on('data', (chunk) => chunks.push(chunk));
+            req.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
+            req.on('error', reject);
+        });
     }
 }
 exports.EmailChannel = EmailChannel;

package/dist/channels/feishu.d.ts

@@ -8,11 +8,8 @@ import { BaseChannel } from './index';
  * - URL verification challenge
  * - Message card (interactive) responses
  * - Group chat & P2P messaging
- *
- * Env vars:
- *   FEISHU_APP_ID, FEISHU_APP_SECRET — app credentials
- *   FEISHU_VERIFICATION_TOKEN — event subscription verification
- *   FEISHU_ENCRYPT_KEY — (optional) event encryption key
+ * - Event deduplication
+ * - No external dependencies (uses Node.js built-in http/https)
  */
 export interface FeishuChannelConfig {
     /** Feishu App ID */
@@ -23,7 +20,7 @@ export interface FeishuChannelConfig {
     verificationToken?: string;
     /** Encrypt key (optional, for encrypted events) */
     encryptKey?: string;
-    /** Webhook server port (default: 3002) */
+    /** Webhook server port (default: 8081) */
     port?: number;
     /** API base URL (use 'https://open.larksuite.com' for Lark international) */
     apiBase?: string;
@@ -37,11 +34,29 @@ export declare class FeishuChannel extends BaseChannel {
     constructor(config?: FeishuChannelConfig);
     start(): Promise<void>;
     stop(): Promise<void>;
+    /** Handle Feishu event */
+    private handleEvent;
+    /** Parse Feishu event body (exported for testing) */
+    static parseEventBody(body: any): {
+        type: string;
+        challenge?: string;
+        eventType?: string;
+        content?: string;
+        chatId?: string;
+        senderId?: string;
+        messageId?: string;
+    };
     /** Get tenant access token (cached) */
     private getAccessToken;
     /** Send a text message to a chat */
     sendTextMessage(chatId: string, text: string): Promise<void>;
     /** Send an interactive card message */
     sendCardMessage(chatId: string, card: Record<string, unknown>): Promise<void>;
+    /** Read request body */
+    private readBody;
+    /** HTTPS POST */
+    private httpsPost;
+    /** HTTPS POST with Bearer auth */
+    private httpsPostWithAuth;
 }
 //# sourceMappingURL=feishu.d.ts.map