@app-connect/core 1.7.22 → 1.7.24

package/handlers/plugin.js

@@ -1,5 +1,55 @@
 const { CacheModel } = require('../models/cacheModel');
 const { Op } = require('sequelize');
+const axios = require('axios');
+const { AccountDataModel } = require('../models/accountDataModel');
+const logger = require('../lib/logger');
+
+const PUBLIC_MANIFEST_BASE = 'https://appconnect.labs.ringcentral.com/public-api/connectors';
+
+async function getPluginsFromRcAccountId({ rcAccountId }) {
+    const accountData = await AccountDataModel.findAll({
+        where: {
+            rcAccountId,
+            dataKey: 'pluginData',
+        },
+    });
+    const workingPlugins = accountData.map(data => ({
+        id: data.platformName,
+        data: data.data,
+    }));
+    return workingPlugins;
+}
+
+function getPluginConfigFromUserSettings({ userSettings, pluginId }) {
+    if (!userSettings) {
+        return null;
+    }
+    const targetPluginSettings = userSettings[`plugin_${pluginId}`];
+    if (!targetPluginSettings?.value?.config) {
+        return null;
+    }
+    return targetPluginSettings.value.config;
+}
+
+async function getPluginLicenseStatus({ rcAccountId, pluginId }) {
+    const accountData = await AccountDataModel.findOne({
+        where: {
+            rcAccountId,
+            platformName: pluginId,
+            dataKey: 'pluginData',
+        },
+    });
+    if (!accountData) {
+        return null;
+    }
+    const licenseStatusUrl = accountData.data.licenseStatusUrl;
+    const licenseStatusResponse = await axios.get(licenseStatusUrl, {
+        headers: {
+            'Authorization': `Bearer ${accountData.data.jwtToken}`
+        }
+    });
+    return licenseStatusResponse.data;
+}
 
 async function getPluginAsyncTasks({ asyncTaskIds }) {
     const caches = await CacheModel.findAll({
@@ -24,4 +74,136 @@ async function getPluginAsyncTasks({ asyncTaskIds }) {
     return result;
 }
 
-exports.getPluginAsyncTasks = getPluginAsyncTasks;
+function getRefreshedJwtTokenFromHeaders({ headers }) {
+    if (!headers) {
+        return null;
+    }
+    return headers['x-refreshed-jwt-token'] || headers['X-Refreshed-Jwt-Token'] || null;
+}
+
+async function resolvePluginManifest({ pluginId, pluginAccess, rcAccountId, pluginName }) {
+    const manifestFetchers = [];
+    if (pluginAccess === 'public') {
+        manifestFetchers.push(`${PUBLIC_MANIFEST_BASE}/${pluginId}/manifest?type=plugin`);
+    } else if (pluginAccess === 'private' || pluginAccess === 'shared') {
+        manifestFetchers.push(`${PUBLIC_MANIFEST_BASE}/${pluginId}/manifest?access=internal&type=plugin&accountId=${rcAccountId}`);
+    } else {
+        manifestFetchers.push(`${PUBLIC_MANIFEST_BASE}/${pluginId}/manifest?type=plugin`);
+        manifestFetchers.push(`${PUBLIC_MANIFEST_BASE}/${pluginId}/manifest?access=internal&type=plugin&accountId=${rcAccountId}`);
+    }
+
+    let pluginData = null;
+    let lastError = null;
+    for (const url of manifestFetchers) {
+        try {
+            const pluginDataResponse = await axios.get(url);
+            pluginData = pluginDataResponse.data;
+            break;
+        } catch (error) {
+            lastError = error;
+        }
+    }
+
+    if (!pluginData) {
+        throw lastError || new Error(`Unable to resolve manifest for plugin ${pluginId}`);
+    }
+
+    const platformKey = pluginName || Object.keys(pluginData.platforms || {})[0];
+    if (!platformKey || !pluginData.platforms?.[platformKey]) {
+        throw new Error(`Unable to resolve platform manifest for plugin ${pluginId}`);
+    }
+
+    return {
+        pluginData,
+        pluginManifest: pluginData.platforms[platformKey],
+        platformKey,
+    };
+}
+
+async function persistPluginData({ rcAccountId, pluginId, jwtToken, pluginData = {} }) {
+    try {
+        const accountData = await AccountDataModel.findOne({
+            where: {
+                rcAccountId,
+                platformName: pluginId
+            },
+        });
+        if (!accountData) {
+            await AccountDataModel.create({
+                rcAccountId,
+                platformName: pluginId,
+                dataKey: 'pluginData',
+                data: {
+                    jwtToken,
+                    ...pluginData,
+                },
+            });
+        } else {
+            await accountData.update({
+                data: {
+                    jwtToken,
+                    ...pluginData,
+                },
+            });
+        }
+    } catch (error) {
+        logger.error('Failed to persist plugin data', {
+            pluginId,
+            rcAccountId,
+            message: error.message,
+        });
+    }
+}
+
+async function registerPluginAccount({ pluginId, rcAccessToken, rcAccountId, pluginAccess, pluginName }) {
+    const { pluginManifest } = await resolvePluginManifest({ pluginId, pluginAccess, rcAccountId, pluginName });
+    if (!pluginManifest?.endpointUrl) {
+        throw new Error(`Plugin endpoint URL not found for ${pluginId}`);
+    }
+
+    const registerUrl = pluginManifest.userRegisterEndpointUrl;
+    const registerResponse = await axios.post(registerUrl, {
+        rcAccessToken,
+        rcAccountId: rcAccountId?.toString(),
+    });
+    const pluginJwtToken = registerResponse.data?.jwtToken;
+    if (!pluginJwtToken) {
+        throw new Error('Plugin register API did not return jwtToken');
+    }
+
+    await persistPluginData({
+        rcAccountId: rcAccountId?.toString(),
+        pluginId,
+        jwtToken: pluginJwtToken,
+        pluginData: pluginManifest,
+    });
+
+    return {
+        successful: true,
+        registerUrl,
+        jwtToken: pluginJwtToken,
+    };
+}
+
+async function unregisterPluginAccount({ pluginId, rcAccountId }) {
+    const accountData = await AccountDataModel.findOne({
+        where: {
+            rcAccountId,
+            platformName: pluginId,
+            dataKey: 'pluginData'
+        },
+    });
+    if (accountData) {
+        await accountData.destroy();
+    }
+}
+
+exports.getPluginsFromRcAccountId = getPluginsFromRcAccountId;
+exports.getPluginConfigFromUserSettings = getPluginConfigFromUserSettings;
+exports.getPluginLicenseStatus = getPluginLicenseStatus;
+exports.getPluginAsyncTasks = getPluginAsyncTasks;
+exports.getRefreshedJwtTokenFromHeaders = getRefreshedJwtTokenFromHeaders;
+exports.resolvePluginManifest = resolvePluginManifest;
+exports.persistPluginData = persistPluginData;
+exports.registerPluginAccount = registerPluginAccount;
+exports.unregisterPluginAccount = unregisterPluginAccount;

package/handlers/user.js

@@ -71,7 +71,7 @@ async function getUserSettings({ user, rcAccessToken, rcAccountId }) {
                                     config[k] = configFromadminSettings[k];
                                 }
                                 else {
-                                    config[k].customizable = configFromadminSettings[k].customizable;
+                                    config[k].customizable = configFromadminSettings[k]?.customizable ?? true;
                                 }
                             }
                             result[key].value.config = config;

package/index.js

@@ -89,6 +89,19 @@ async function initDB() {
             await UserModel.sync();
             logger.info('hashedRcExtensionId column added to users table');
         }
+
+        // if LlmSessionModel doesn't have expiry column, add it
+        const llmSessionTableName = LlmSessionModel.getTableName();
+        const llmSessionTableSchema = await queryInterface.describeTable(llmSessionTableName);
+        if (!llmSessionTableSchema.expiry) {
+            logger.info('adding expiry column to llmSessions table...');
+            await queryInterface.addColumn(llmSessionTableName, 'expiry', {
+                type: Sequelize.DATE,
+                allowNull: true,
+            });
+            await LlmSessionModel.sync();
+            logger.info('expiry column added to llmSessions table');
+        }
     }
 }
 
@@ -1165,13 +1178,13 @@ function createCoreRouter() {
                 res.status(400).send(tracer ? tracer.wrapResponse('Missing platform name') : 'Missing platform name');
                 return;
             }
-            let rcAccountId = null;
-            let rcExtensionId = null;
-            if (rcAccessToken) {
-                const rcUserTokenResult = await adminCore.validateRcUserToken({ rcAccessToken });
-                rcAccountId = rcUserTokenResult.rcAccountId;
-                rcExtensionId = rcUserTokenResult.rcExtensionId;
+            if (!rcAccessToken) {
+                res.status(400).send(tracer ? tracer.wrapResponse('Missing RingCentral access token') : 'Missing RingCentral access token');
+                return;
             }
+            const rcUserTokenResult = await adminCore.validateRcUserToken({ rcAccessToken });
+            const rcAccountId = rcUserTokenResult.rcAccountId;
+            const rcExtensionId = rcUserTokenResult.rcExtensionId;
             const { userInfo, returnMessage } = await authCore.onApiKeyLogin({
                 platform,
                 hostname,
@@ -2197,7 +2210,7 @@ function createCoreRouter() {
         let platformName = null;
         let success = false;
         const { hashedExtensionId, hashedAccountId, userAgent, ip, author, eventAddedVia } = getAnalyticsVariablesInReqHeaders({ headers: req.headers })
-        const { jwtToken } = req.query;
+        const jwtToken = req.jwtToken || req.query.jwtToken;
         try {
             if (!jwtToken) {
                 tracer?.trace('pluginAsyncTask:noToken', {});
@@ -2239,6 +2252,151 @@ function createCoreRouter() {
         });
     });
 
+    router.post('/plugin/register', async function (req, res) {
+        const requestStartTime = new Date().getTime();
+        const tracer = req.headers['is-debug'] === 'true' ? DebugTracer.fromRequest(req) : null;
+        tracer?.trace('pluginRegister:start', { body: req.body });
+        let success = false;
+        const { hashedExtensionId, hashedAccountId, userAgent, ip, author, eventAddedVia } = getAnalyticsVariablesInReqHeaders({ headers: req.headers })
+        try {
+            const { pluginId, rcAccountId, pluginAccess, pluginName } = req.body || {};
+            const rcAccessToken = req.query?.rcAccessToken;
+            if (!pluginId || !rcAccountId) {
+                res.status(400).send(tracer ? tracer.wrapResponse({ successful: false, returnMessage: 'pluginId and rcAccountId are required' }) : { successful: false, returnMessage: 'pluginId and rcAccountId are required' });
+                return;
+            }
+            if (!rcAccessToken) {
+                res.status(400).send(tracer ? tracer.wrapResponse({ successful: false, returnMessage: 'Missing RingCentral access token' }) : { successful: false, returnMessage: 'Missing RingCentral access token' });
+                return;
+            }
+            const { isValidated, rcAccountId: validatedRcAccountId } = await adminCore.validateAdminRole({ rcAccessToken });
+            if (!isValidated) {
+                res.status(403).send(tracer ? tracer.wrapResponse({ successful: false, returnMessage: 'Admin validation failed' }) : { successful: false, returnMessage: 'Admin validation failed' });
+                return;
+            }
+            if (validatedRcAccountId?.toString() !== rcAccountId?.toString()) {
+                res.status(403).send(tracer ? tracer.wrapResponse({ successful: false, returnMessage: 'rcAccountId mismatch' }) : { successful: false, returnMessage: 'rcAccountId mismatch' });
+                return;
+            }
+
+            await pluginCore.registerPluginAccount({
+                pluginId,
+                rcAccessToken,
+                rcAccountId: rcAccountId?.toString(),
+                pluginAccess,
+                pluginName,
+            });
+            res.status(200).send(tracer ? tracer.wrapResponse({ successful: true }) : { successful: true });
+            success = true;
+        } catch (e) {
+            logger.error('Plugin register failed', { stack: e.stack });
+            res.status(400).send(tracer ? tracer.wrapResponse({ successful: false, returnMessage: e.message || e }) : { successful: false, returnMessage: e.message || e });
+            tracer?.traceError('pluginRegister:error', e);
+            success = false;
+        }
+
+        const requestEndTime = new Date().getTime();
+        analytics.track({
+            eventName: 'Plugin Register',
+            interfaceName: 'pluginRegister',
+            accountId: hashedAccountId,
+            extensionId: hashedExtensionId,
+            success,
+            requestDuration: (requestEndTime - requestStartTime) / 1000,
+            userAgent,
+            ip,
+            author,
+            eventAddedVia
+        });
+    });
+
+    router.delete('/plugin/unregister', async function (req, res) {
+        const requestStartTime = new Date().getTime();
+        const tracer = req.headers['is-debug'] === 'true' ? DebugTracer.fromRequest(req) : null;
+        tracer?.trace('pluginUnregister:start', { query: req.query });
+        let success = false;
+        const { hashedExtensionId, hashedAccountId, userAgent, ip, author, eventAddedVia } = getAnalyticsVariablesInReqHeaders({ headers: req.headers })
+        try {
+            const { pluginId, rcAccountId, pluginName } = req.query || {};
+            const rcAccessToken = req.query?.rcAccessToken;
+            if (!pluginId || !rcAccountId) {
+                res.status(400).send(tracer ? tracer.wrapResponse({ successful: false, returnMessage: 'pluginId and rcAccountId are required' }) : { successful: false, returnMessage: 'pluginId and rcAccountId are required' });
+                return;
+            }
+            if (!rcAccessToken) {
+                res.status(400).send(tracer ? tracer.wrapResponse({ successful: false, returnMessage: 'Missing RingCentral access token' }) : { successful: false, returnMessage: 'Missing RingCentral access token' });
+                return;
+            }
+            const { isValidated, rcAccountId: validatedRcAccountId } = await adminCore.validateAdminRole({ rcAccessToken });
+            if (!isValidated) {
+                res.status(403).send(tracer ? tracer.wrapResponse({ successful: false, returnMessage: 'Admin validation failed' }) : { successful: false, returnMessage: 'Admin validation failed' });
+                return;
+            }
+            if (validatedRcAccountId?.toString() !== rcAccountId?.toString()) {
+                res.status(403).send(tracer ? tracer.wrapResponse({ successful: false, returnMessage: 'rcAccountId mismatch' }) : { successful: false, returnMessage: 'rcAccountId mismatch' });
+                return;
+            }
+
+            await pluginCore.unregisterPluginAccount({
+                pluginId,
+                rcAccountId: rcAccountId?.toString(),
+                pluginName,
+            });
+            res.status(200).send(tracer ? tracer.wrapResponse({ successful: true }) : { successful: true });
+            success = true;
+        } catch (e) {
+            logger.error('Plugin unregister failed', { stack: e.stack });
+            res.status(400).send(tracer ? tracer.wrapResponse({ successful: false, returnMessage: e.message || e }) : { successful: false, returnMessage: e.message || e });
+            tracer?.traceError('pluginUnregister:error', e);
+            success = false;
+        }
+        const requestEndTime = new Date().getTime();
+        analytics.track({
+            eventName: 'Plugin Unregister',
+            interfaceName: 'pluginUnregister',
+            accountId: hashedAccountId,
+            extensionId: hashedExtensionId,
+            success,
+            requestDuration: (requestEndTime - requestStartTime) / 1000,
+            userAgent,
+            ip,
+            author,
+            eventAddedVia
+        });
+    });
+
+    router.get('/plugin/licenseStatus', async function (req, res) {
+        const tracer = req.headers['is-debug'] === 'true' ? DebugTracer.fromRequest(req) : null;
+        tracer?.trace('getPluginLicenseStatus:start', { query: req.query });
+        try {
+            const jwtToken = req.jwtToken || req.query.jwtToken;
+            if (!jwtToken) {
+                tracer?.trace('getPluginLicenseStatus:noToken', {});
+                res.status(400).send(tracer ? tracer.wrapResponse('Please go to Settings and authorize CRM platform') : 'Please go to Settings and authorize CRM platform');
+                return;
+            }
+            const unAuthData = jwt.decodeJwt(jwtToken);
+            const user = await UserModel.findByPk(unAuthData?.id);
+            if (!user) {
+                tracer?.trace('getPluginLicenseStatus:userNotFound', {});
+                res.status(400).send(tracer ? tracer.wrapResponse('User not found') : 'User not found');
+                return;
+            }
+            const { rcAccountId, pluginId } = req.query;
+            if (!rcAccountId || !pluginId) {
+                res.status(400).send(tracer ? tracer.wrapResponse('rcAccountId and pluginId are required') : 'rcAccountId and pluginId are required');
+                return;
+            }
+            const licenseStatus = await pluginCore.getPluginLicenseStatus({ rcAccountId, pluginId });
+            res.status(200).send(tracer ? tracer.wrapResponse(licenseStatus) : licenseStatus);
+        }
+        catch (e) {
+            logger.error('Get plugin license status failed', { stack: e.stack });
+            res.status(200).send(tracer ? tracer.wrapResponse({ licenseStatus: false, licenseStatusDescription: e.message || e }) : { licenseStatus: false, licenseStatusDescription: e.message || e });
+            tracer?.traceError('getPluginLicenseStatus:error', e);
+        }
+    });
+
     if (process.env.IS_PROD === 'false') {
         router.post('/registerMockUser', async function (req, res) {
             const secretKey = req.query.secretKey;

package/lib/authSession.js

@@ -7,7 +7,20 @@
 const { CacheModel } = require('../models/cacheModel');
 
 const AUTH_SESSION_PREFIX = 'auth-session';
-const SESSION_EXPIRY_MINUTES = 5;
+const PENDING_SESSION_EXPIRY_MINUTES = 5;
+const SETTLED_SESSION_EXPIRY_MINUTES = 15;
+
+function getSessionRecordId(sessionId) {
+    return `${AUTH_SESSION_PREFIX}-${sessionId}`;
+}
+
+function getExpiry(minutes) {
+    return new Date(Date.now() + minutes * 60 * 1000);
+}
+
+function isExpired(record) {
+    return Boolean(record?.expiry && record.expiry <= new Date());
+}
 
 /**
  * Create (or reset) an auth session.
@@ -16,9 +29,13 @@ const SESSION_EXPIRY_MINUTES = 5;
  * correctly for the new attempt.
  */
 async function createAuthSession(sessionId, data) {
-    const id = `${AUTH_SESSION_PREFIX}-${sessionId}`;
-    const expiry = new Date(Date.now() + SESSION_EXPIRY_MINUTES * 60 * 1000);
-    const sessionData = { ...data, createdAt: new Date().toISOString() };
+    const id = getSessionRecordId(sessionId);
+    const expiry = getExpiry(PENDING_SESSION_EXPIRY_MINUTES);
+    const sessionData = {
+        platform: data.platform,
+        hostname: data.hostname || '',
+        createdAt: new Date().toISOString(),
+    };
 
     const existing = await CacheModel.findByPk(id);
     if (existing) {
@@ -39,10 +56,21 @@ async function createAuthSession(sessionId, data) {
  * Get an auth session by ID
  */
 async function getAuthSession(sessionId) {
-    const record = await CacheModel.findByPk(`${AUTH_SESSION_PREFIX}-${sessionId}`);
-    
+    const record = await CacheModel.findByPk(getSessionRecordId(sessionId));
+
     if (!record) return null;
-    
+
+    if (isExpired(record)) {
+        if (record.status !== 'expired') {
+            await record.update({ status: 'expired' });
+        }
+        return {
+            sessionId: record.userId,
+            status: 'expired',
+            ...record.data
+        };
+    }
+
     return {
         sessionId: record.userId,
         status: record.status,
@@ -54,18 +82,22 @@ async function getAuthSession(sessionId) {
  * Update an auth session
  */
 async function updateAuthSession(sessionId, data) {
-    const record = await CacheModel.findByPk(`${AUTH_SESSION_PREFIX}-${sessionId}`);
-    
+    const record = await CacheModel.findByPk(getSessionRecordId(sessionId));
+
     if (!record) return;
-    
+
     const existingData = record.data || {};
+    const nextStatus = data.status || record.status;
     await record.update({
-        status: data.status || record.status,
+        status: nextStatus,
         data: {
             ...existingData,
             ...data,
             updatedAt: new Date().toISOString()
-        }
+        },
+        expiry: nextStatus === 'pending'
+            ? getExpiry(PENDING_SESSION_EXPIRY_MINUTES)
+            : getExpiry(SETTLED_SESSION_EXPIRY_MINUTES)
     });
 }
 

package/lib/callLogComposer.js

@@ -702,27 +702,27 @@ function upsertRingSenseTranscript({ body, transcript, logFormat }) {
     switch (logFormat) {
         case LOG_DETAILS_FORMAT_TYPE.HTML:
             const formattedTranscript = clearedTranscript.replace(/(?:\r\n|\r|\n)/g, '<br>');
-            transcriptRegex = /<div><b>RingSense transcript<\/b><br>(.+?)<\/div>/;
+            transcriptRegex = /<div><b>ACE transcript<\/b><br>(.+?)<\/div>/;
             if (transcriptRegex.test(result)) {
-                result = result.replace(transcriptRegex, `<div><b>RingSense transcript</b><br>${formattedTranscript}</div>`);
+                result = result.replace(transcriptRegex, `<div><b>ACE transcript</b><br>${formattedTranscript}</div>`);
             } else {
-                result += `<div><b>RingSense transcript</b><br>${formattedTranscript}</div>`;
+                result += `<div><b>ACE transcript</b><br>${formattedTranscript}</div>`;
             }
             break;
         case LOG_DETAILS_FORMAT_TYPE.MARKDOWN:
-            transcriptRegex = /### RingSense transcript\n([\s\S]*?)(?=\n### |\n$|$)/;
+            transcriptRegex = /### ACE transcript\n([\s\S]*?)(?=\n### |\n$|$)/;
             if (transcriptRegex.test(result)) {
-                result = result.replace(transcriptRegex, `### RingSense transcript\n${clearedTranscript}\n`);
+                result = result.replace(transcriptRegex, `### ACE transcript\n${clearedTranscript}\n`);
             } else {
-                result += `### RingSense transcript\n${clearedTranscript}\n`;
+                result += `### ACE transcript\n${clearedTranscript}\n`;
             }
             break;
         case LOG_DETAILS_FORMAT_TYPE.PLAIN_TEXT:
-            transcriptRegex = /- RingSense transcript:([\s\S]*?)--- END/;
+            transcriptRegex = /- ACE transcript:([\s\S]*?)--- END/;
             if (transcriptRegex.test(result)) {
-                result = result.replace(transcriptRegex, `- RingSense transcript:\n${clearedTranscript}\n--- END`);
+                result = result.replace(transcriptRegex, `- ACE transcript:\n${clearedTranscript}\n--- END`);
             } else {
-                result += `\n- RingSense transcript:\n${clearedTranscript}\n--- END\n`;
+                result += `\n- ACE transcript:\n${clearedTranscript}\n--- END\n`;
             }
             break;
     }
@@ -739,28 +739,28 @@ function upsertRingSenseSummary({ body, summary, logFormat }) {
 
     switch (logFormat) {
         case LOG_DETAILS_FORMAT_TYPE.HTML:
-            summaryRegex = /<div><b>RingSense summary<\/b><br>(.+?)<\/div>/;
+            summaryRegex = /<div><b>ACE summary<\/b><br>(.+?)<\/div>/;
             const formattedSummary = clearedSummary.replace(/(?:\r\n|\r|\n)/g, '<br>');
             if (summaryRegex.test(result)) {
-                result = result.replace(summaryRegex, `<div><b>RingSense summary</b><br>${formattedSummary}</div>`);
+                result = result.replace(summaryRegex, `<div><b>ACE summary</b><br>${formattedSummary}</div>`);
             } else {
-                result += `<div><b>RingSense summary</b><br>${formattedSummary}</div>`;
+                result += `<div><b>ACE summary</b><br>${formattedSummary}</div>`;
             }
             break;
         case LOG_DETAILS_FORMAT_TYPE.MARKDOWN:
-            summaryRegex = /### RingSense summary\n([\s\S]*?)(?=\n### |\n$|$)/;
+            summaryRegex = /### ACE summary\n([\s\S]*?)(?=\n### |\n$|$)/;
             if (summaryRegex.test(result)) {
-                result = result.replace(summaryRegex, `### RingSense summary\n${summary}\n`);
+                result = result.replace(summaryRegex, `### ACE summary\n${summary}\n`);
             } else {
-                result += `### RingSense summary\n${summary}\n`;
+                result += `### ACE summary\n${summary}\n`;
             }
             break;
         case LOG_DETAILS_FORMAT_TYPE.PLAIN_TEXT:
-            summaryRegex = /- RingSense summary:([\s\S]*?)--- END/;
+            summaryRegex = /- ACE summary:([\s\S]*?)--- END/;
             if (summaryRegex.test(result)) {
-                result = result.replace(summaryRegex, `- RingSense summary:\n${summary}\n--- END`);
+                result = result.replace(summaryRegex, `- ACE summary:\n${summary}\n--- END`);
             } else {
-                result += `\n- RingSense summary:\n${summary}\n--- END\n`;
+                result += `\n- ACE summary:\n${summary}\n--- END\n`;
             }
             break;
     }
@@ -811,28 +811,28 @@ function upsertRingSenseBulletedSummary({ body, summary, logFormat }) {
 
     switch (logFormat) {
         case LOG_DETAILS_FORMAT_TYPE.HTML:
-            summaryRegex = /<div><b>RingSense bulleted summary<\/b><br>(.+?)<\/div>/;
+            summaryRegex = /<div><b>ACE bulleted summary<\/b><br>(.+?)<\/div>/;
             const formattedSummary = clearedSummary.replace(/(?:\r\n|\r|\n)/g, '<br>');
             if (summaryRegex.test(result)) {
-                result = result.replace(summaryRegex, `<div><b>RingSense bulleted summary</b><br>${formattedSummary}</div>`);
+                result = result.replace(summaryRegex, `<div><b>ACE bulleted summary</b><br>${formattedSummary}</div>`);
             } else {
-                result += `<div><b>RingSense bulleted summary</b><br>${formattedSummary}</div>`;
+                result += `<div><b>ACE bulleted summary</b><br>${formattedSummary}</div>`;
             }
             break;
         case LOG_DETAILS_FORMAT_TYPE.MARKDOWN:
-            summaryRegex = /### RingSense bulleted summary\n([\s\S]*?)(?=\n### |\n$|$)/;
+            summaryRegex = /### ACE bulleted summary\n([\s\S]*?)(?=\n### |\n$|$)/;
             if (summaryRegex.test(result)) {
-                result = result.replace(summaryRegex, `### RingSense bulleted summary\n${summary}\n`);
+                result = result.replace(summaryRegex, `### ACE bulleted summary\n${summary}\n`);
             } else {
-                result += `### RingSense bulleted summary\n${summary}\n`;
+                result += `### ACE bulleted summary\n${summary}\n`;
             }
             break;
         case LOG_DETAILS_FORMAT_TYPE.PLAIN_TEXT:
-            summaryRegex = /- RingSense bulleted summary:\s*([^<\n]+)(?=\n|$)/i;
+            summaryRegex = /- ACE bulleted summary:\s*([^<\n]+)(?=\n|$)/i;
             if (summaryRegex.test(result)) {
-                result = result.replace(summaryRegex, `- RingSense bulleted summary:\n${summary}\n--- END`);
+                result = result.replace(summaryRegex, `- ACE bulleted summary:\n${summary}\n--- END`);
             } else {
-                result += `\n- RingSense bulleted summary:\n${summary}\n--- END\n`;
+                result += `\n- ACE bulleted summary:\n${summary}\n--- END\n`;
             }
             break;
     }
@@ -847,27 +847,27 @@ function upsertRingSenseLink({ body, link, logFormat }) {
 
     switch (logFormat) {
         case LOG_DETAILS_FORMAT_TYPE.HTML:
-            linkRegex = /(?:<li>)?<b>RingSense recording link<\/b>:\s*(?:<a[^>]*>[^<]*<\/a>|[^<]+)(?:<\/li>|(?=<|$))/i;
+            linkRegex = /(?:<li>)?<b>ACE recording link<\/b>:\s*(?:<a[^>]*>[^<]*<\/a>|[^<]+)(?:<\/li>|(?=<|$))/i;
             if (linkRegex.test(result)) {
-                result = result.replace(linkRegex, `<li><b>RingSense recording link</b>: <a target="_blank" href="${link}">open</a></li>`);
+                result = result.replace(linkRegex, `<li><b>ACE recording link</b>: <a target="_blank" href="${link}">open</a></li>`);
             } else {
-                result += `<li><b>RingSense recording link</b>: <a target="_blank" href="${link}">open</a></li>`;
+                result += `<li><b>ACE recording link</b>: <a target="_blank" href="${link}">open</a></li>`;
             }
             break;
         case LOG_DETAILS_FORMAT_TYPE.MARKDOWN:
-            linkRegex = /\*\*RingSense recording link\*\*:\s*([^<\n]+)(?=\n|$)/i;
+            linkRegex = /\*\*ACE recording link\*\*:\s*([^<\n]+)(?=\n|$)/i;
             if (linkRegex.test(result)) {
-                result = result.replace(linkRegex, `**RingSense recording link**: ${link}\n`);
+                result = result.replace(linkRegex, `**ACE recording link**: ${link}\n`);
             } else {
-                result += `**RingSense recording link**: ${link}\n`;
+                result += `**ACE recording link**: ${link}\n`;
             }
             break;
         case LOG_DETAILS_FORMAT_TYPE.PLAIN_TEXT:
-            linkRegex = /- RingSense recording link:\s*([^<\n]+)(?=\n|$)/i;
+            linkRegex = /- ACE recording link:\s*([^<\n]+)(?=\n|$)/i;
             if (linkRegex.test(result)) {
-                result = result.replace(linkRegex, `- RingSense recording link: ${link}`);
+                result = result.replace(linkRegex, `- ACE recording link: ${link}`);
             } else {
-                result += `- RingSense recording link: ${link}\n`;
+                result += `- ACE recording link: ${link}\n`;
             }
             break;
     }

package/lib/util.js

@@ -60,26 +60,8 @@ function getMediaReaderLinkByPlatformMediaLink(platformMediaLink) {
     return `https://ringcentral.github.io/ringcentral-media-reader/?media=${encodedPlatformMediaLink}`;
 }
 
-function getPluginsFromUserSettings({ userSettings, logType }) {
-    const result = [];
-    if (!userSettings) {
-        return result;
-    }
-    for (const userSettingKey in userSettings) {
-        if (!userSettingKey.startsWith('plugin_')) {
-            continue;
-        }
-        const pluginUserSetting = userSettings[userSettingKey];
-        if (pluginUserSetting.value.logTypes.includes(logType)) {
-            result.push({ id: userSettingKey.replace('plugin_', ''), value: pluginUserSetting.value });
-        }
-    }
-    return result;
-}
-
 exports.getTimeZone = getTimeZone;
 exports.getHashValue = getHashValue;
 exports.secondsToHoursMinutesSeconds = secondsToHoursMinutesSeconds;
 exports.getMostRecentDate = getMostRecentDate;
 exports.getMediaReaderLinkByPlatformMediaLink = getMediaReaderLinkByPlatformMediaLink;
-exports.getPluginsFromUserSettings = getPluginsFromUserSettings;