@ulthon/ul-opencode-event 0.1.4 → 0.1.5

package/dist/email.d.ts

@@ -1,6 +1,7 @@
 import type { Channel } from './types.js';
 export interface EmailSender {
     send: (subject: string, body: string) => Promise<void>;
+    close: () => Promise<void>;
 }
 /**
  * Creates an email sender for the given SMTP channel

package/dist/email.js

@@ -40,6 +40,30 @@ async function resolveHostViaLookup(host) {
     catch { }
     return null;
 }
+/**
+ * Creates nodemailer transport options
+ */
+function buildTransportOptions(config, hostOverride) {
+    const host = hostOverride || config.host;
+    const transportOptions = {
+        host,
+        port: config.port,
+        secure: config.secure,
+        auth: {
+            user: config.auth.user,
+            pass: config.auth.pass,
+        },
+    };
+    if (config.localAddress) {
+        transportOptions.localAddress = config.localAddress;
+    }
+    if (hostOverride && hostOverride !== config.host) {
+        transportOptions.tls = {
+            servername: config.host,
+        };
+    }
+    return transportOptions;
+}
 /**
  * Creates an email sender for the given SMTP channel
  * @param channel - The channel configuration (must be SMTP type)
@@ -60,30 +84,10 @@ export function createEmailSender(channel) {
     }
     const config = channel.config;
     const fromName = channel.name || 'Notification';
-    const createTransport = (hostOverride) => {
-        const host = hostOverride || config.host;
-        const transportOptions = {
-            host,
-            port: config.port,
-            secure: config.secure,
-            auth: {
-                user: config.auth.user,
-                pass: config.auth.pass,
-            },
-        };
-        if (config.localAddress) {
-            transportOptions.localAddress = config.localAddress;
-        }
-        if (hostOverride && hostOverride !== config.host) {
-            transportOptions.tls = {
-                servername: config.host,
-            };
-        }
-        const transport = nodemailer.createTransport(transportOptions);
-        transport.set('disableFileAccess', true);
-        transport.set('disableUrlAccess', true);
-        return transport;
-    };
+    // Create and cache the primary transporter (connection reuse)
+    const primaryTransport = nodemailer.createTransport(buildTransportOptions(config));
+    primaryTransport.set('disableFileAccess', true);
+    primaryTransport.set('disableUrlAccess', true);
     return {
         async send(subject, body) {
             const mailOptions = {
@@ -93,30 +97,45 @@ export function createEmailSender(channel) {
                 html: body,
                 text: body,
             };
+            // Try pre-resolved host first if DNS resolution succeeded
             const preResolvedHost = await resolveHostViaLookup(config.host);
             if (preResolvedHost && preResolvedHost !== config.host) {
+                let preResolvedTransport = null;
                 try {
-                    const preResolvedTransport = createTransport(preResolvedHost);
+                    // Create temporary transport for resolved IP (can't reuse for different host)
+                    preResolvedTransport = nodemailer.createTransport(buildTransportOptions(config, preResolvedHost));
+                    preResolvedTransport.set('disableFileAccess', true);
+                    preResolvedTransport.set('disableUrlAccess', true);
                     await preResolvedTransport.sendMail(mailOptions);
                     return;
                 }
                 catch { }
+                finally {
+                    preResolvedTransport?.close();
+                }
             }
             try {
-                const transport = createTransport();
-                await transport.sendMail(mailOptions);
+                // Use cached primary transporter (connection reuse)
+                await primaryTransport.sendMail(mailOptions);
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
                 if (shouldRetryWithLookup(message)) {
                     const resolvedHost = await resolveHostViaLookup(config.host);
                     if (resolvedHost) {
+                        let fallbackTransport = null;
                         try {
-                            const fallbackTransport = createTransport(resolvedHost);
+                            // Create temporary transport for fallback (different host)
+                            fallbackTransport = nodemailer.createTransport(buildTransportOptions(config, resolvedHost));
+                            fallbackTransport.set('disableFileAccess', true);
+                            fallbackTransport.set('disableUrlAccess', true);
                             await fallbackTransport.sendMail(mailOptions);
                             return;
                         }
                         catch { }
+                        finally {
+                            fallbackTransport?.close();
+                        }
                     }
                 }
                 // Silent failure: log error but don't throw
@@ -124,5 +143,8 @@ export function createEmailSender(channel) {
                 console.error(`[${timestamp}] [${fromName}] Failed to send email:`, error);
             }
         },
+        async close() {
+            primaryTransport.close();
+        },
     };
 }

package/dist/handler.d.ts

@@ -4,8 +4,10 @@
 import type { NotificationConfig, EventPayload, EventType } from './types.js';
 export interface EventHandler {
     handle: (eventType: EventType, payload: EventPayload) => Promise<void>;
+    close: () => Promise<void>;
 }
 /**
  * Creates an event handler that dispatches notifications to all enabled channels
+ * Senders are cached at initialization for connection reuse)
  */
 export declare function createEventHandler(config: NotificationConfig): EventHandler;

package/dist/handler.js

@@ -17,16 +17,27 @@ const defaultTemplates = {
 };
 /**
  * Creates an event handler that dispatches notifications to all enabled channels
+ * Senders are cached at initialization for connection reuse)
  */
 export function createEventHandler(config) {
+    // Create and cache all senders at initialization (connection reuse)
+    const senders = new Map();
+    // map channel index to sender key for same order
+    const channelIndexMap = new Map();
+    for (let i = 0; i < config.channels.length; i++) {
+        const channel = config.channels[i];
+        const sender = createChannelSender(channel);
+        if (sender) {
+            const key = channel.name || `channel-${i}`;
+            senders.set(key, sender);
+            channelIndexMap.set(i, key);
+        }
+    }
     return {
         handle: async (eventType, payload) => {
-            // Process each channel
-            for (const channel of config.channels) {
-                // Skip disabled channels
-                if (channel.enabled === false) {
-                    continue;
-                }
+            // Process each channel using cached senders
+            for (let i = 0; i < config.channels.length; i++) {
+                const channel = config.channels[i];
                 // Check if this event type is enabled for the channel
                 const eventEnabled = channel.events[eventType];
                 if (eventEnabled === false) {
@@ -34,7 +45,7 @@ export function createEventHandler(config) {
                 }
                 // Get template (channel-specific or default)
                 const template = channel.templates?.[eventType] ?? defaultTemplates[eventType];
-                // Prepare template variables from payload
+                // prepare template variables from payload
                 const variables = {
                     eventType: payload.eventType,
                     timestamp: payload.timestamp,
@@ -44,35 +55,42 @@ export function createEventHandler(config) {
                     error: payload.error,
                     duration: payload.duration,
                 };
-                // Render templates
+                // render templates
                 const subject = template.subject ? renderTemplate(template.subject, variables) : '';
                 const body = template.body ? renderTemplate(template.body, variables) : '';
-                // Dispatch based on channel type
-                await dispatchToChannel(channel, subject, body);
+                // dispatch using cached sender
+                const key = channel.name || `channel-${i}`;
+                const sender = senders.get(key);
+                if (sender) {
+                    await sender.send(subject, body);
+                }
             }
         },
+        close: async () => {
+            // close all cached senders (cleanup SMTP connections)
+            const closePromises = Array.from(senders.values()).map(sender => sender.close());
+            await Promise.all(closePromises);
+            senders.clear();
+            channelIndexMap.clear();
+        },
     };
 }
 /**
- * Dispatch notification to the appropriate channel sender
+ * create a sender for the given channel type
  */
-async function dispatchToChannel(channel, subject, body) {
+function createChannelSender(channel) {
     switch (channel.type) {
-        case 'smtp': {
-            const sender = createEmailSender(channel);
-            if (sender) {
-                await sender.send(subject, body);
-            }
-            break;
-        }
+        case 'smtp':
+            return createEmailSender(channel);
         case 'feishu':
         case 'dingtalk':
-            // Skip unsupported channel types silently
-            break;
+            // skip unsupported channel types silently
+            return null;
         default: {
-            // Log warning for unknown channel types
+            // log warning for unknown channel types
             const _exhaustiveCheck = channel.type;
-            console.warn(`[EventHandler] Unsupported channel type: ${_exhaustiveCheck}`);
+            console.warn(`[EventHandler] unsupported channel type: ${_exhaustiveCheck}`);
+            return null;
         }
     }
 }

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 /**
- * Notification Plugin Entry Point
- * Sends email notifications when session events occur
+ * * Notification Plugin Entry Point
+ * * Sends email notifications when session events occur
  */
 import type { Plugin } from '@opencode-ai/plugin';
 /**

package/dist/index.js

@@ -88,6 +88,21 @@ export const NotificationPlugin = async (ctx) => {
     if (DEBUG_ENABLED) {
         console.info(`${LOG_PREFIX} Plugin initialized for ${ctx.directory} with ${config.channels.length} channels`);
     }
+    // Register cleanup handlers for graceful shutdown
+    const cleanup = async () => {
+        await eventHandler.close();
+        if (DEBUG_ENABLED) {
+            console.info(`${LOG_PREFIX} Closed all SMTP connections`);
+        }
+    };
+    // Handle process exit (sync handler, cannot be async)
+    process.on('exit', () => {
+        // Note: async cleanup won't work in 'exit' handler, but we try anyway
+        eventHandler.close().catch(() => { });
+    });
+    // Handle termination signals (async cleanup possible)
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
     return {
         event: async ({ event }) => {
             if (event.type === 'session.created') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ulthon/ul-opencode-event",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "OpenCode notification plugin - sends email when session events occur",
   "author": "augushong",
   "license": "MIT",