@flun/mailer 2.1.23 → 2.1.25

package/lib/smtp-connection/index.js

@@ -7,25 +7,25 @@ import {
     PK, osHostname, isIP, netConnect, regexs, resetRegex, getLogger, resolveHostname, callbackPromise, encodeXText, cleanup
 } from '../shared.js';
 
-// 默认超时(连接,套接字无活动,等待SMTP问候,DNS解析)时间（毫秒）
+// 默认超时(连接,套接字无活动,等待SMTP问候,DNS解析)时间(毫秒)
 const CONNECTION_TIMEOUT = 2 * 60 * 1000, SOCKET_TIMEOUT = 10 * 60 * 1000,
     GREETING_TIMEOUT = 30 * 1000, DNS_TIMEOUT = 30 * 1000;
 
 /**
  * 生成SMTP连接对象;
  * >查看定义:@see {@link SmtpConnection}
- * 可选的选项对象可以包含以下属性：
- *  - **port** - 连接的端口（默认为587或465）
- *  - **host** - 连接的主机名或IP地址（默认为'localhost'）
+ * 可选的选项对象可以包含以下属性:
+ *  - **port** - 连接的端口(默认为587或465)
+ *  - **host** - 连接的主机名或IP地址(默认为'localhost')
  *  - **secure** - 使用SSL
  *  - **ignoreTLS** - 忽略服务器对STARTTLS的支持
  *  - **requireTLS** - 强制客户端使用STARTTLS
  *  - **name** - 客户端服务器名称
  *  - **localAddress** - 绑定的出站地址
- *  - **greetingTimeout** - 等待服务器问候消息的超时时间（毫秒）
- *  - **connectionTimeout** - 等待连接建立的超时时间（毫秒）
- *  - **socketTimeout** - 连接关闭前的无活动超时时间（默认为1小时）
- *  - **dnsTimeout** - 等待DNS请求解析的超时时间（默认为30秒）
+ *  - **greetingTimeout** - 等待服务器问候消息的超时时间(毫秒)
+ *  - **connectionTimeout** - 等待连接建立的超时时间(毫秒)
+ *  - **socketTimeout** - 连接关闭前的无活动超时时间(默认为1小时)
+ *  - **dnsTimeout** - 等待DNS请求解析的超时时间(默认为30秒)
  *  - **lmtp** - 如果为true,使用LMTP而不是SMTP协议
  *  - **logger** - bunyan兼容的日志接口
  *  - **debug** - 如果为true,将SMTP流量传递给日志记录器
@@ -51,7 +51,7 @@ class SmtpConnection extends EventEmitter {
         this.servername = servername ? servername : !isIP(this.host) ? this.host : false;
         this.allowInternalNetworkInterfaces = allowInternalNetworkInterfaces;
 
-        // 如果secure选项未设置但端口是465，则默认为安全连接
+        // 如果secure选项未设置但端口是465,则默认为安全连接
         if (typeof secure === 'undefined' && this.port === 465) this.secureConnection = true;
         this.name = name || this.#getHostname();
         this.logger = getLogger(this.options, { component, sid: this.id }); // 设置日志记录器
@@ -64,7 +64,7 @@ class SmtpConnection extends EventEmitter {
             this.customAuth.set(mapKey, customAuth[key]);
         });
 
-        this.secure = !!this.secureConnection;  // 定义当前连接是否安全。如果不安全，如果服务器支持，可以使用STARTTLS
+        this.secure = !!this.secureConnection;  // 定义当前连接是否安全;如果不安全,如果服务器支持,可以使用STARTTLS
         this.version = PK.version;              // 暴露版本号
         this._remainder = '';                   // 存储来自服务器的不完整消息
         this._maxAllowedSize = 0;               // 定义单个消息允许的最大大小
@@ -73,16 +73,16 @@ class SmtpConnection extends EventEmitter {
         this._recipientQueue = [];              // 这个队列包含要发送的收件人列表
         this._responseQueue = [];               // 来自服务器的未处理响应队列
         this._supportedAuth = [];               // 列出支持的认证机制列表
-        this._socket = false;                   // 连接到服务器的套接字,如果没有套接字，则为false
-        this._closing = false;                  // 如果套接字正在关闭，则设置为true
-        this._envelope = false;                 // 包含当前信封（发件人，收件人）的对象,如果没有信封，则为false
-        this._destroyed = false;                // 如果套接字被认为已关闭，则设置为true
-        this._greetingTimeout = false;          // 等待问候消息的超时变量,如果为true，则表示已超时
-        this._connectionTimeout = false;        // 等待连接开始的超时变量,如果为true，则表示已超时
-        this.destroyed = false;                 // 如果设置为true，此实例不再活跃
-        this.allowsAuth = false;                // 如果EHLO响应包含"AUTH"，则设置为true。如果为false，则不尝试认证
-        this.authenticated = false;             // 如果为true，则表示用户已认证
-        this.lastServerResponse = false;        // 最后的服务器响应,如果没有响应，则为false
+        this._socket = false;                   // 连接到服务器的套接字,如果没有套接字,则为false
+        this._closing = false;                  // 如果套接字正在关闭,则设置为true
+        this._envelope = false;                 // 包含当前信封(发件人,收件人)的对象,如果没有信封,则为false
+        this._destroyed = false;                // 如果套接字被认为已关闭,则设置为true
+        this._greetingTimeout = false;          // 等待问候消息的超时变量,如果为true,则表示已超时
+        this._connectionTimeout = false;        // 等待连接开始的超时变量,如果为true,则表示已超时
+        this.destroyed = false;                 // 如果设置为true,此实例不再活跃
+        this.allowsAuth = false;                // 如果EHLO响应包含"AUTH",则设置为true;如果为false,则不尝试认证
+        this.authenticated = false;             // 如果为true,则表示用户已认证
+        this.lastServerResponse = false;        // 最后的服务器响应,如果没有响应,则为false
 
         /**
          * 套接字监听器的回调函数
@@ -151,13 +151,14 @@ class SmtpConnection extends EventEmitter {
         };
         if (localAddress) opts.localAddress = localAddress;
 
-        // 如果已提供连接对象，则使用它
+        // 如果已提供连接对象,则使用它
         if (connection) {
             this._socket = connection, this.#setupConnectionHandlers();
             if (this.secureConnection && !this.alreadySecured)
                 setImmediate(() =>
                     this.#upgradeConnection(err => {
-                        if (err) return this.#onError(new Error(`启动TLS错误-${(err.message || err)}`), 'ETLS', false, 'CONN');
+                        if (err) return this.#onError(new Error(`启动TLS错误-${(err.message || err)}`), 'ETLS', false,
+                            'CONN');
                         this.#onConnect();
                     })
                 );
@@ -173,13 +174,13 @@ class SmtpConnection extends EventEmitter {
                 this._socket.setKeepAlive(true), this._socket.once('connect', () => this.#onConnect());
             });
         };
-        // 如果套接字已设置，则使用它
+        // 如果套接字已设置,则使用它
         if (socket)
             return createConnection((resolvedOpts) => {
                 socket.connect(this.port, this.host, () => { });
                 return socket;
             });
-        // 如果secureConnection为true，则使用TLS连接
+        // 如果secureConnection为true,则使用TLS连接
         else if (this.secureConnection) {
             if (tls) Object.keys(tls).forEach(key => { opts[key] = tls[key]; })
             if (this.servername && !opts.servername) opts.servername = this.servername; // 确保SNI的服务器名称
@@ -232,12 +233,12 @@ class SmtpConnection extends EventEmitter {
 
         const { method = '', oauth2, credentials, user, pass, options } = this._auth = authData;
         this._authMethod = method.toString().trim().toUpperCase(); // 选择SASL认证方法
-        // 如果没有指定认证方法，则使用XOAUTH2认证，如果没有OAuth2凭据，则使用PLAIN认证
+        // 如果没有指定认证方法,则使用XOAUTH2认证,如果没有OAuth2凭据,则使用PLAIN认证
         if (!this._authMethod && oauth2 && !credentials) this._authMethod = 'XOAUTH2';
         else if (!this._authMethod || (this._authMethod === 'XOAUTH2' && !oauth2))
             this._authMethod = (this._supportedAuth[0] || 'PLAIN').toUpperCase().trim();
 
-        // 如果没有指定凭据，则使用用户名和密码
+        // 如果没有指定凭据,则使用用户名和密码
         if (this._authMethod !== 'XOAUTH2' && (!credentials || !credentials.user || !credentials.pass)) {
             if ((user && pass) || this.customAuth.has(this._authMethod)) this._auth.credentials = { user, pass, options };
             else return callback(this.#formatError(`缺少 "${this._authMethod}" 的凭据`, 'EAUTH', false, 'API'));
@@ -262,7 +263,8 @@ class SmtpConnection extends EventEmitter {
                     extensions: [].concat(this._supportedExtensions), authMethods: [].concat(this._supportedAuth),
                     maxAllowedSize: this._maxAllowedSize || false,
                     sendCommand: (cmd, done) => {
-                        const promise = !done ? new Promise((resolve, reject) => done = callbackPromise(resolve, reject)) : null;
+                        const promise = !done ? new Promise((resolve, reject) => done = callbackPromise(resolve, reject)) :
+                            null;
                         this._responseActions.push(str => {
                             lastResponse = str;
                             const codes = str.match(regexs.RESPONSE_CODE), data = { command: cmd, response: str };
@@ -279,8 +281,9 @@ class SmtpConnection extends EventEmitter {
                     }, resolve, reject
                 });
 
-            // 如果返回了Promise，则等待Promise完成
-            if (handlerResponse && typeof handlerResponse.catch === 'function') handlerResponse.then(resolve).catch(reject);
+            // 如果返回了Promise,则等待Promise完成
+            if (handlerResponse &&
+                typeof handlerResponse.catch === 'function') handlerResponse.then(resolve).catch(reject);
             return;
         }
 
@@ -288,7 +291,8 @@ class SmtpConnection extends EventEmitter {
             case 'XOAUTH2':
                 return this.#actionAUTH_XOAUTH2_TOKEN(false, callback);
             case 'LOGIN':
-                this._responseActions.push(str => this.#actionAUTH_LOGIN_USER(str, callback)), this.#sendCommand('AUTH LOGIN');
+                this._responseActions.push(str => this.#actionAUTH_LOGIN_USER(str, callback)),
+                    this.#sendCommand('AUTH LOGIN');
                 return;
             case 'PLAIN':
                 this._responseActions.push(str => this.#actionAUTH_PLAIN_RESPONSE(str, callback));
@@ -307,7 +311,7 @@ class SmtpConnection extends EventEmitter {
     /**
      * 发送消息
      *
-     * @param {Object} envelope 信封对象，{from: addr, to: [addr]}
+     * @param {Object} envelope 信封对象,{from: addr, to: [addr]}
      * @param {Object} message 字符串、缓冲区或流
      * @param {Function} callback 发送完成后调用的回调函数
      */
@@ -324,7 +328,8 @@ class SmtpConnection extends EventEmitter {
             });
 
         const state = { returned: false }, callback = (...args) => { cleanup(state), done(...args) };
-        if (typeof message.on === 'function') message.on('error', err => callback(this.#formatError(err, 'ESTREAM', false, 'API')));
+        if (typeof message.on === 'function') message.on('error', err => callback(this.#formatError(err, 'ESTREAM', false,
+            'API')));
 
         // 将消息写入流
         const writeMessageToStream = stream => {
@@ -355,7 +360,8 @@ class SmtpConnection extends EventEmitter {
     reset(callback) {
         this.#sendCommand('RSET');
         this._responseActions.push(str => {
-            if (!str.startsWith('2')) return callback(this.#formatError(`无法重置会话状态;响应=${str}`, 'EPROTOCOL', str, 'RSET'));
+            if (!str.startsWith('2')) return callback(this.#formatError(`无法重置会话状态;响应=${str}`, 'EPROTOCOL', str,
+                'RSET'));
             this._envelope = false;
             return callback(null, true);
         });
@@ -372,7 +378,7 @@ class SmtpConnection extends EventEmitter {
         this.logger.info({ tnx: 'network', localAddress, localPort, remoteAddress, remotePort },
             '%s 已建立到 %s:%s', this.secure ? '安全连接' : '连接', remoteAddress, remotePort
         );
-        if (this._destroyed) return this.close(); // 如果连接已销毁，则关闭连接
+        if (this._destroyed) return this.close(); // 如果连接已销毁,则关闭连接
 
         this.stage = 'connected';
         // 清除套接字的现有监听器
@@ -383,7 +389,7 @@ class SmtpConnection extends EventEmitter {
             .setTimeout(this.options.socketTimeout || SOCKET_TIMEOUT).on('timeout', this.onSocketTimeout);
 
         this._greetingTimeout = setTimeout(() => {
-            // 如果仍在等待问候消息，则放弃
+            // 如果仍在等待问候消息,则放弃
             if (this._socket && !this._destroyed && this._responseActions[0] === this.#actionGreeting)
                 this.#onError('从未收到问候消息', 'ETIMEDOUT', false, 'CONN');
 
@@ -406,13 +412,14 @@ class SmtpConnection extends EventEmitter {
         let lastline = rQueue.at(-1) ?? null;
         for (let i = 0; i < lines.length; i++) {
             const line = lines[i];
-            // 检查是否需要延续（确保 lastline 存在）
+            // 检查是否需要延续(确保 lastline 存在)
             if (lastline && regexs.CONTINUATION_RESPONSE.test(lastline.split('\n').pop()))
                 lastline += `\n${line}`, rQueue[rQueue.length - 1] = lastline;
-            else rQueue.push(line), lastline = line; // 新响应：推入队列并更新 lastline
+            else rQueue.push(line), lastline = line; // 新响应:推入队列并更新 lastline
         }
 
-        if (lastline && regexs.CONTINUATION_RESPONSE.test(lastline.split('\n').pop())) return; // 如果响应未完成，等待后续数据
+        if (lastline &&
+            regexs.CONTINUATION_RESPONSE.test(lastline.split('\n').pop())) return; // 如果响应未完成，等待后续数据
         this.#processResponse(); // 处理完整响应
     }
 
@@ -425,7 +432,7 @@ class SmtpConnection extends EventEmitter {
      */
     #onError(err, type, data, command) {
         clearTimeout(this._connectionTimeout), clearTimeout(this._greetingTimeout);
-        if (this._destroyed) return;  // 如果连接已被销毁，则忽略错误
+        if (this._destroyed) return;  // 如果连接已被销毁,则忽略错误
 
         err = this.#formatError(err, type, data, command);
         this.logger.error(data, err.message), this.emit('error', err), this.close();
@@ -452,12 +459,14 @@ class SmtpConnection extends EventEmitter {
         let serverResponse = false;
         const _remainder = this._remainder, { debug, transactionLog } = this.options;
         if (_remainder?.trim()) {
-            if (debug || transactionLog) this.logger.debug({ tnx: 'server' }, _remainder.replace(regexs.OPTIONAL_CRLF, ''));
+            if (debug || transactionLog) this.logger.debug({ tnx: 'server' }, _remainder.replace(regexs.OPTIONAL_CRLF,
+                ''));
             this.lastServerResponse = serverResponse = _remainder.trim();
         }
 
         this.logger.info({ tnx: 'network' }, '连接已关闭');
-        if (this.upgrading && !this._destroyed) return this.#onError(new Error('连接意外关闭'), 'ETLS', serverResponse, 'CONN');
+        if (this.upgrading && !this._destroyed) return this.#onError(new Error('连接意外关闭'), 'ETLS', serverResponse,
+            'CONN');
         else if ((![this.#actionGreeting, this.close].includes(this._responseActions[0]) && !this._destroyed) ||
             regexs.RESPONSE_4XX_5XX.test(serverResponse))
             return this.#onError(new Error('连接意外关闭'), 'ECONNECTION', serverResponse, 'CONN');
@@ -484,7 +493,7 @@ class SmtpConnection extends EventEmitter {
     }
 
     /**
-     * 销毁客户端，发出'end'事件
+     * 销毁客户端,发出'end'事件
      */
     #destroy() {
         if (this._destroyed) return;
@@ -521,13 +530,13 @@ class SmtpConnection extends EventEmitter {
             this.upgrading = false;
             return callback(err);
         }
-        socketPlain.resume();  // 如果套接字暂停，则恢复
+        socketPlain.resume();  // 如果套接字暂停,则恢复
     }
 
     /**
      * 处理来自服务器的排队响应
      *
-     * @param {Boolean} force 如果为true，忽略_processing标志
+     * @param {Boolean} force 如果为true,忽略_processing标志
      */
     #processResponse() {
         if (!this._responseQueue.length) return false;
@@ -545,13 +554,13 @@ class SmtpConnection extends EventEmitter {
     }
 
     /**
-     * 向服务器发送命令，附加\r\n
+     * 向服务器发送命令,附加\r\n
      *
      * @param {String} str 要发送到服务器的字符串
-     * @param {String} logStr 用于记录的可选字符串，而不是实际字符串
+     * @param {String} logStr 用于记录的可选字符串,而不是实际字符串
      */
     #sendCommand(str = '', logStr) {
-        if (this._destroyed) return; // 连接已关闭，无法发送更多数据
+        if (this._destroyed) return; // 连接已关闭,无法发送更多数据
         if (this._socket.destroyed) return this.close();
         if (this.options.debug || this.options.transactionLog)
             this.logger.debug({ tnx: 'client' }, (logStr || str).toString().replace(regexs.OPTIONAL_CRLF, ''));
@@ -560,9 +569,9 @@ class SmtpConnection extends EventEmitter {
     }
 
     /**
-     * 通过提交信封数据来初始化新消息，以MAIL FROM:命令开始
+     * 通过提交信封数据来初始化新消息,以MAIL FROM:命令开始
      *
-     * @param {Object} envelope 信封对象，形式为 {from:'...', to:['...']} 或
+     * @param {Object} envelope 信封对象,形式为 {from:'...', to:['...']} 或
      *  {from:{address:'...',name:'...'}, to:[address:'...',name:'...']}
      */
     #setEnvelope(envelope = {}, callback) {
@@ -579,7 +588,8 @@ class SmtpConnection extends EventEmitter {
         // 验证单个地址并检测非ASCII字符
         const _validateAddress = (address, type) => {
             if (regexs.INVALID_ADDRESS_CHARS.test(address)) errors.push(`无效的${type}: ${JSON.stringify(address)}`);
-            else if (regexs.NON_ASCII.test(address)) useSmtpUtf8 = true;  // 检查地址是否使用ASCII字符，否则需使用SMTPUTF8扩展
+// 检查地址是否使用ASCII字符，否则需使用SMTPUTF8扩展
+            else if (regexs.NON_ASCII.test(address)) useSmtpUtf8 = true;
         };
         _validateAddress(from, '发件人');
         to.forEach(addr => _validateAddress(addr, '收件人'));
@@ -599,11 +609,13 @@ class SmtpConnection extends EventEmitter {
 
         this._responseActions.push(str => this.#actionMAIL(str, callback));
 
-        // 如果服务器支持SMTPUTF8并且信封包含国际化电子邮件地址，则将SMTPUTF8关键字附加到MAIL FROM命令
-        if (useSmtpUtf8 && this._supportedExtensions.includes('SMTPUTF8')) args.push('SMTPUTF8'), this._usingSmtpUtf8 = true;
+        // 如果服务器支持SMTPUTF8并且信封包含国际化电子邮件地址,则将SMTPUTF8关键字附加到MAIL FROM命令
+        if (useSmtpUtf8 && this._supportedExtensions.includes('SMTPUTF8')) args.push('SMTPUTF8'),
+            this._usingSmtpUtf8 = true;
 
         // 如果服务器支持8BITMIME并且消息可能包含非ASCII字节,则将8BITMIME关键字附加到MAIL FROM命令
-        if (use8BitMime && this._supportedExtensions.includes('8BITMIME')) args.push('BODY=8BITMIME'), this._using8BitMime = true;
+        if (use8BitMime && this._supportedExtensions.includes('8BITMIME')) args.push('BODY=8BITMIME'),
+            this._using8BitMime = true;
 
         if (size && this._supportedExtensions.includes('SIZE')) args.push(`SIZE=${size}`);
 
@@ -701,8 +713,8 @@ class SmtpConnection extends EventEmitter {
     }
 
     /**
-     * 在连接创建后且服务器发送问候消息后运行。
-     * 如果传入消息以220开头，则通过发送EHLO命令启动SMTP会话
+     * 在连接创建后且服务器发送问候消息后运行;
+     * 如果传入消息以220开头,则通过发送EHLO命令启动SMTP会话
      *
      * @param {String} str 来自服务器的消息
      */
@@ -713,8 +725,8 @@ class SmtpConnection extends EventEmitter {
     }
 
     /**
-     * 处理LHLO命令的服务器响应。如果产生错误，
-     * 发出'error'，否则将其视为EHLO响应
+     * 处理LHLO命令的服务器响应;如果产生错误,
+     * 发出'error',否则将其视为EHLO响应
      *
      * @param {String} str 来自服务器的消息
      */
@@ -724,14 +736,15 @@ class SmtpConnection extends EventEmitter {
     }
 
     /**
-     * 处理EHLO命令的服务器响应。如果产生错误，
-     * 尝试改用HELO，否则如果服务器支持STARTTLS
-     * 则启动TLS协商，或进入认证阶段。
+     * 处理EHLO命令的服务器响应;如果产生错误,
+     * 尝试改用HELO,否则如果服务器支持STARTTLS
+     * 则启动TLS协商,或进入认证阶段;
      *
      * @param {String} str 来自服务器的消息
      */
     #actionEHLO(str) {
-        if (str.startsWith('421')) return this.#onError(new Error(`服务器终止连接;响应=${str}`), 'ECONNECTION', str, 'EHLO');
+        if (str.startsWith('421')) return this.#onError(new Error(`服务器终止连接;响应=${str}`), 'ECONNECTION', str,
+            'EHLO');
 
         // 通用命令队列函数
         const queueCommand = (action, command) => {
@@ -739,7 +752,8 @@ class SmtpConnection extends EventEmitter {
         }, { requireTLS, ignoreTLS } = this.options;
         if (!str.startsWith('2')) {
             if (requireTLS)
-                return this.#onError(new Error(`EHLO失败但HELO不支持必需的STARTTLS;响应=${str}`), 'ECONNECTION', str, 'EHLO');
+                return this.#onError(new Error(`EHLO失败但HELO不支持必需的STARTTLS;响应=${str}`), 'ECONNECTION', str,
+                    'EHLO');
             return queueCommand(this.#actionHELO, `HELO ${this.name}`);  // 使用通用函数发送 HELO
         }
 
@@ -762,14 +776,14 @@ class SmtpConnection extends EventEmitter {
         if (new RegExp(`${authMechanismSource}CRAM-MD5`, 'i').test(str)) this._supportedAuth.push('CRAM-MD5');
         if (new RegExp(`${authMechanismSource}XOAUTH2`, 'i').test(str)) this._supportedAuth.push('XOAUTH2');
 
-        // 检测服务器是否支持SIZE扩展（以及最大允许大小）
+        // 检测服务器是否支持SIZE扩展(以及最大允许大小)
         if (match) this._supportedExtensions.push('SIZE'), this._maxAllowedSize = Number(match[1]) || 0;
         this.emit('connect');
     }
 
     /**
-     * 处理HELO命令的服务器响应。如果产生错误，
-     * 发出'error'，否则进入认证阶段。
+     * 处理HELO命令的服务器响应;如果产生错误,
+     * 发出'error',否则进入认证阶段;
      *
      * @param {String} str 来自服务器的消息
      */
@@ -779,15 +793,15 @@ class SmtpConnection extends EventEmitter {
     }
 
     /**
-     * 处理STARTTLS命令的服务器响应。如果有错误
-     * 尝试改用HELO，否则启动TLS升级。如果升级成功，重新启动EHLO
+     * 处理STARTTLS命令的服务器响应;如果有错误
+     * 尝试改用HELO,否则启动TLS升级;如果升级成功,重新启动EHLO
      *
      * @param {String} str 来自服务器的消息
      */
     #actionSTARTTLS(str) {
         if (!str.startsWith('2')) {
             if (this.options.opportunisticTLS) {
-                this.logger.info({ tnx: 'smtp' }, 'STARTTLS升级失败，继续未加密');
+                this.logger.info({ tnx: 'smtp' }, 'STARTTLS升级失败,继续未加密');
                 return this.emit('connect');
             }
             return this.#onError(new Error('使用STARTTLS升级连接时出错'), 'ETLS', str, 'STARTTLS');
@@ -797,14 +811,14 @@ class SmtpConnection extends EventEmitter {
             if (err) return this.#onError(new Error(`启动TLS错误-${err.message || err}`), 'ETLS', false, 'STARTTLS');
 
             this.logger.info({ tnx: 'smtp' }, '连接已使用STARTTLS升级');
-            secured ? this.#sendHeloCommand() : this.emit('connect');// 如果升级成功，重新启动会话,否则继续未加密
+            secured ? this.#sendHeloCommand() : this.emit('connect');// 如果升级成功,重新启动会话,否则继续未加密
         });
     }
 
     /**
      * 处理AUTH LOGIN用户名认证阶段
-     * 预期收到服务器334响应（Base64编码的"Username:"提示）
-     * 发送Base64编码的用户名，并准备处理密码认证
+     * 预期收到服务器334响应(Base64编码的"Username:"提示)
+     * 发送Base64编码的用户名,并准备处理密码认证
      *
      * @param {String} str 服务器响应消息
      * @param {Function} callback 认证结果回调
@@ -820,16 +834,17 @@ class SmtpConnection extends EventEmitter {
     /**
      * 处理AUTH CRAM-MD5命令:
      * 1. 服务器发送一个随机字符串
-     * 2. 客户端用密码作为密钥，对其进行HMAC-MD5加密
+     * 2. 客户端用密码作为密钥,对其进行HMAC-MD5加密
      * 3. 将"用户名 加密结果"进行base64编码后返回给服务器
      *
-     * @param {String} str 服务器发送的消息，格式：334 <base64编码的随机字符串>
+     * @param {String} str 服务器发送的消息,格式:334 <base64编码的随机字符串>
      * @param {Function} callback 认证结果回调函数
      */
     #actionAUTH_CRAM_MD5(str, callback) {
         const challengeMatch = str.match(regexs.CRAM_MD5_CHALLENGE);
         let challengeString = '';
-        if (!challengeMatch) return callback(this.#formatError('在等待服务器响应时登录序列无效', 'EAUTH', str, 'AUTH CRAM-MD5'));
+        if (!challengeMatch) return callback(this.#formatError('在等待服务器响应时登录序列无效', 'EAUTH', str,
+            'AUTH CRAM-MD5'));
         else challengeString = challengeMatch[1];
 
         // 从base64解码
@@ -840,12 +855,13 @@ class SmtpConnection extends EventEmitter {
         const prepended = `${user} ${hmacMD5.digest('hex')}`;
 
         this._responseActions.push(str => this.#actionAUTH_CRAM_MD5_PASS(str, callback));
-        this.#sendCommand(Buffer.from(prepended).toString('base64'), Buffer.from(`${user} /* secret */`).toString('base64'));
+        this.#sendCommand(Buffer.from(prepended).toString('base64'),
+            Buffer.from(`${user} /* secret */`).toString('base64'));
     }
 
     /**
-     * 处理CRAM-MD5认证的响应，如果没有错误，
-     * 用户可以视为已登录。开始等待要发送的消息
+     * 处理CRAM-MD5认证的响应,如果没有错误,
+     * 用户可以视为已登录;开始等待要发送的消息
      *
      * @param {String} str 来自服务器的消息
      */
@@ -862,7 +878,7 @@ class SmtpConnection extends EventEmitter {
 
     /**
      * 处理AUTH LOGIN命令的响应
-     * 以'334 UGFzc3dvcmQ6'（'Password:'的base64编码）作为响应发送的数据
+     * 以'334 UGFzc3dvcmQ6'('Password:'的base64编码)作为响应发送的数据
      *
      * @param {String} str 来自服务器的消息
      */
@@ -878,8 +894,8 @@ class SmtpConnection extends EventEmitter {
     }
 
     /**
-     * 处理认证的响应，如果没有错误，
-     * 用户可以视为已登录。开始等待要发送的消息
+     * 处理认证的响应,如果没有错误,
+     * 用户可以视为已登录;开始等待要发送的消息
      *
      * @param {String} str 来自服务器的消息
      */
@@ -902,7 +918,8 @@ class SmtpConnection extends EventEmitter {
             return callback(this.#formatError('无效的登录', 'EAUTH', str, `AUTH ${method}`));
         }
 
-        this.logger.info({ tnx: 'smtp', username: user, action: 'authenticated', method }, '用户 %s 已认证', JSON.stringify(user));
+        this.logger.info({ tnx: 'smtp', username: user, action: 'authenticated', method }, '用户 %s 已认证',
+            JSON.stringify(user));
         this.authenticated = true, callback(null, true);
     }
 
@@ -927,9 +944,9 @@ class SmtpConnection extends EventEmitter {
             this.#sendCommand(`RCPT TO:<${recipient}>${this.#getDsnRcptToArgs()}`);
         };
 
-        // 流水线模式：一次性发送所有收件人
+        // 流水线模式:一次性发送所有收件人
         if (this._supportedExtensions.includes('PIPELINING')) while (rcptQueue.length) processRecipient(rcptQueue.shift());
-        else processRecipient(rcptQueue.shift()); // 非流水线模式：逐个发送收件
+        else processRecipient(rcptQueue.shift()); // 非流水线模式:逐个发送收件
     }
 
     /**
@@ -971,7 +988,7 @@ class SmtpConnection extends EventEmitter {
      * @param {String} str 来自服务器的消息
      */
     #actionDATA(str, callback) {
-        // 如果不是23，则数据命令失败
+        // 如果不是23,则数据命令失败
         if (!regexs.DATA_RESPONSE.test(str)) return callback(this.#formatError('数据命令失败', 'EENVELOPE', str, 'DATA'));
         const { accepted, rejected, rejectedErrors } = this._envelope, response = { accepted, rejected };
 
@@ -986,7 +1003,8 @@ class SmtpConnection extends EventEmitter {
      * @param {String} str 来自服务器的消息
      */
     #actionSMTPStream(str, callback) {
-        return str.startsWith('2') ? callback(null, str) : callback(this.#formatError('消息失败', 'EMESSAGE', str, 'DATA'));
+        return str.startsWith('2') ? callback(null, str) : callback(this.#formatError('消息失败', 'EMESSAGE', str,
+            'DATA'));
     }
 
     /**
@@ -1007,7 +1025,7 @@ class SmtpConnection extends EventEmitter {
             return callback(err);
         }
 
-        return callback(null, final ? str : null); // 成功情况：总是调用回调
+        return callback(null, final ? str : null); // 成功情况:总是调用回调
     }
 
     // 处理_XOAUTH2认证