emailengine-app 2.63.4 → 2.65.0

package/workers/imap.js

@@ -37,7 +37,7 @@ const { GmailClient } = require('../lib/email-client/gmail-client');
 const { OutlookClient } = require('../lib/email-client/outlook-client');
 const { BaseClient } = require('../lib/email-client/base-client');
 const { Account } = require('../lib/account');
-const { oauth2Apps } = require('../lib/oauth2-apps');
+const { oauth2Apps, isApiBasedApp } = require('../lib/oauth2-apps');
 const { redis, notifyQueue, submitQueue, documentsQueue, getFlowProducer } = require('../lib/db');
 const { MessagePortWritable } = require('../lib/message-port-stream');
 const { getESClient } = require('../lib/document-store');
@@ -78,10 +78,6 @@ class ConnectionHandler {
         this.mids = 0;
 
         this.accounts = new Map();
-
-        // Reconnection metrics tracking
-        this.reconnectMetrics = new Map(); // Track metrics per account
-        this.metricsWindow = 60000; // 1-minute window
     }
 
     async init() {
@@ -213,7 +209,7 @@ class ConnectionHandler {
                 oauth2App = await oauth2Apps.get(accountData.oauth2.provider);
             }
 
-            if (oauth2App && oauth2App.baseScopes === 'api') {
+            if (isApiBasedApp(oauth2App)) {
                 // Use API instead of IMAP
 
                 switch (oauth2App.provider) {
@@ -236,6 +232,7 @@ class ConnectionHandler {
                         accountObject.logger = accountObject.connection.logger;
                         break;
 
+                    case 'outlookService':
                     case 'outlook':
                         accountObject.connection = new OutlookClient(account, {
                             runIndex,
@@ -639,6 +636,34 @@ class ConnectionHandler {
         return await accountData.connection.externalNotify(message);
     }
 
+    async subscriptionLifecycle(message) {
+        if (!this.accounts.has(message.account)) {
+            throw NO_ACTIVE_HANDLER_RESP_ERR;
+        }
+
+        let accountData = this.accounts.get(message.account);
+        if (!accountData.connection) {
+            throw NO_ACTIVE_HANDLER_RESP_ERR;
+        }
+
+        let connection = accountData.connection;
+
+        switch (message.event) {
+            case 'reauthorizationRequired':
+                return await connection.renewSubscription({ force: true });
+
+            case 'subscriptionRemoved':
+                // Clear stored subscription since MS deleted it server-side, under lock
+                logger.info({ msg: 'Handling subscriptionRemoved lifecycle event', account: message.account });
+                await connection.ensureSubscription({ clearExisting: true });
+                return true;
+
+            default:
+                logger.warn({ msg: 'Unknown subscription lifecycle event', event: message.event, account: message.account });
+                return false;
+        }
+    }
+
     async getQuota(message) {
         if (!this.accounts.has(message.account)) {
             throw NO_ACTIVE_HANDLER_RESP_ERR;
@@ -725,49 +750,6 @@ class ConnectionHandler {
         };
     }
 
-    /**
-     * Track reconnection attempts for monitoring (without blocking)
-     * @param {string} account - Account identifier
-     */
-    trackReconnection(account) {
-        const now = Date.now();
-        const metrics = this.reconnectMetrics.get(account) || {
-            attempts: [],
-            warnings: 0
-        };
-
-        // Clean old attempts outside window
-        metrics.attempts = metrics.attempts.filter(t => now - t < this.metricsWindow);
-        metrics.attempts.push(now);
-
-        // Log warning if excessive reconnections
-        if (metrics.attempts.length > 20) {
-            // More than 20 per minute
-            metrics.warnings++;
-            logger.warn({
-                msg: 'Excessive reconnection rate detected',
-                account,
-                rate: `${metrics.attempts.length}/min`,
-                totalWarnings: metrics.warnings
-            });
-
-            // Emit metrics for monitoring/alerting
-            try {
-                parentPort.postMessage({
-                    cmd: 'metrics',
-                    key: 'imap.reconnect.excessive',
-                    method: 'inc',
-                    args: [1],
-                    meta: { account }
-                });
-            } catch (err) {
-                logger.error({ msg: 'Failed to send metrics', err });
-            }
-        }
-
-        this.reconnectMetrics.set(account, metrics);
-    }
-
     async getAttachment(message) {
         if (!this.accounts.has(message.account)) {
             throw NO_ACTIVE_HANDLER_RESP_ERR;
@@ -892,6 +874,7 @@ class ConnectionHandler {
             case 'uploadMessage':
             case 'subconnections':
             case 'externalNotify':
+            case 'subscriptionLifecycle':
             case 'listSignatures':
                 return await this[message.cmd](message);
 
@@ -940,6 +923,7 @@ class ConnectionHandler {
                 err.statusCode = 504;
                 err.code = 'Timeout';
                 err.ttl = ttl;
+                this.callQueue.delete(mid);
                 reject(err);
             }, ttl);
 

package/workers/smtp.js

@@ -77,6 +77,7 @@ async function call(message, transferList) {
             err.statusCode = 504;
             err.code = 'Timeout';
             err.ttl = ttl;
+            callQueue.delete(mid);
             reject(err);
         }, ttl);
 

package/workers/submit.js

@@ -85,6 +85,7 @@ async function call(message, transferList) {
             err.statusCode = 504;
             err.code = 'Timeout';
             err.ttl = ttl;
+            callQueue.delete(mid);
             reject(err);
         }, ttl);
 

package/workers/webhooks.js

@@ -67,6 +67,7 @@ async function call(message, transferList) {
             err.statusCode = 504;
             err.code = 'Timeout';
             err.ttl = ttl;
+            callQueue.delete(mid);
             reject(err);
         }, ttl);
 
@@ -117,6 +118,14 @@ async function onCommand(command) {
         case 'googlePubSub':
             await googlePubSub.update(command.app);
             return true;
+        case 'googlePubSubRemove':
+            googlePubSub.remove(command.app);
+            return true;
+        case 'close':
+            clearTimeout(startRetryTimer);
+            googlePubSub.stopAll();
+            await notifyWorker.close(true);
+            return true;
         default:
             logger.debug({ msg: 'Unhandled command', command });
             return 999;
@@ -132,6 +141,18 @@ setInterval(() => {
     }
 }, 10 * 1000).unref();
 
+// Clean up Pub/Sub instances when parent port closes
+parentPort.on('close', () => {
+    clearTimeout(startRetryTimer);
+    googlePubSub.stopAll();
+    // notifyWorker.close() may throw synchronously if not yet initialized
+    try {
+        notifyWorker.close(true).catch(() => {});
+    } catch {
+        // ignore
+    }
+});
+
 // Send initial ready signal
 parentPort.postMessage({ cmd: 'ready' });
 
@@ -461,28 +482,6 @@ const notifyWorker = new Worker(
                 status: 'success'
             });
         } catch (err) {
-            /*
-            // do not disable by default
-            if (err.status === 410) {
-                // disable webhook
-                logger.error({
-                    msg: 'Webhooks were disabled by server',
-                    action: 'webhook',
-                    queue: job.queue.name,
-                    code: 'disabled_by_server',
-                    job: job.id,
-                    webhooks,
-                    accountWebhooks: !!accountWebhooks,
-                    event: job.name,
-                    status: err.status,
-                    account: job.data.account,
-route: customRoute && customRoute.id,
-                    err
-                });
-                await settings.set('webhooksEnabled', false);
-                return;
-            }
-            */
             logger.error({
                 msg: 'Failed posting webhook',
                 action: 'webhook',
@@ -606,13 +605,26 @@ notifyWorker.on('failed', async job => {
     });
 });
 
-googlePubSub
-    .start()
-    .then(() => {
-        logger.info({ msg: 'Started processing Google pub/sub' });
-    })
-    .catch(err => {
-        logger.fatal({ msg: 'Failed to start processing Google pub/sub', err });
-    });
+let startRetryTimer = null;
+
+(function startGooglePubSub(attempt) {
+    googlePubSub
+        .start()
+        .then(() => {
+            logger.info({ msg: 'Started processing Google pub/sub' });
+        })
+        .catch(err => {
+            let maxNormalAttempts = 20;
+            let delay;
+            if (attempt < maxNormalAttempts) {
+                delay = Math.min(5000 * Math.pow(2, Math.min(attempt, 10)), 60000);
+                logger.error({ msg: 'Failed to start processing Google pub/sub', err, attempt: attempt + 1, retryMs: delay });
+            } else {
+                delay = 5 * 60 * 1000;
+                logger.warn({ msg: 'Failed to start processing Google pub/sub (reduced frequency)', err, attempt: attempt + 1, retryMs: delay });
+            }
+            startRetryTimer = setTimeout(() => startGooglePubSub(attempt + 1), delay);
+        });
+})(0);
 
 logger.info({ msg: 'Started Webhooks worker thread', version: packageData.version });