@app-connect/core 1.7.22 → 1.7.24

package/mcp/mcpHandler.js

@@ -7,6 +7,7 @@
  */
 
 const axios = require('axios');
+const { Op } = require('sequelize');
 const tools = require('./tools');
 const { LlmSessionModel } = require('../models/llmSessionModel');
 const { CacheModel } = require('../models/cacheModel');
@@ -23,6 +24,8 @@ const path = require('path');
  */
 const WIDGET_VERSION = 10;
 const WIDGET_URI = `ui://widget/ConnectorList-v${WIDGET_VERSION}.html`;
+const RC_EXTENSION_CACHE_KEY = 'rcExtensionId';
+const RC_EXTENSION_CACHE_STATUS = 'resolved';
 
 const JSON_RPC_INTERNAL_ERROR = -32603;
 const JSON_RPC_METHOD_NOT_FOUND = -32601;
@@ -104,7 +107,7 @@ async function resolveSessionContext(rcAccessToken, openaiSessionId) {
 
     if (openaiSessionId) {
         try {
-            const cached = await CacheModel.findByPk(`${openaiSessionId}-rcExtensionId`);
+            const cached = await CacheModel.findByPk(`${openaiSessionId}-${RC_EXTENSION_CACHE_KEY}`);
             if (cached?.data?.rcExtensionId && (!cached.expiry || cached.expiry > new Date())) {
                 return { rcExtensionId: cached.data.rcExtensionId };
             }
@@ -118,11 +121,11 @@ async function resolveSessionContext(rcAccessToken, openaiSessionId) {
         rcExtensionId = await resolveRcExtensionId(rcAccessToken);
         if (openaiSessionId && rcExtensionId) {
             await CacheModel.upsert({
-                id: `${openaiSessionId}-rcExtensionId`,
+                id: `${openaiSessionId}-${RC_EXTENSION_CACHE_KEY}`,
                 userId: openaiSessionId,
-                cacheKey: 'rcExtensionId',
+                cacheKey: RC_EXTENSION_CACHE_KEY,
                 data: { rcExtensionId },
-                status: 'active',
+                status: RC_EXTENSION_CACHE_STATUS,
                 expiry: new Date(Date.now() + 24 * 60 * 60 * 1000), // 24h TTL
             });
         }
@@ -203,15 +206,34 @@ async function handleMcpRequest(req, res) {
                     toolArgs.rcExtensionId = rcExtensionId;
                     if (!toolArgs.jwtToken) {
                         let llmSession = await LlmSessionModel.findByPk(rcExtensionId);
+                        if (llmSession?.expiry && llmSession.expiry < new Date()) {
+                            await LlmSessionModel.destroy({ where: { id: rcExtensionId } });
+                            llmSession = null;
+                        }
                         if (!llmSession?.jwtToken && openaiSessionId) {
                             const fallback = await LlmSessionModel.findByPk(openaiSessionId);
                             if (fallback?.jwtToken) {
-                                await LlmSessionModel.upsert({ id: rcExtensionId, jwtToken: fallback.jwtToken });
-                                llmSession = fallback;
+                                const { id: fallbackUserId } = jwt.decodeJwt(fallback.jwtToken);
+                                const fallbackUser = fallbackUserId
+                                    ? await UserModel.findByPk(fallbackUserId)
+                                    : null;
+                                if (fallbackUser?.accessToken) {
+                                    await LlmSessionModel.upsert({ id: rcExtensionId, jwtToken: fallback.jwtToken, expiry: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000) });
+                                    llmSession = fallback;
+                                }
                             }
-                            else {
+                            if (!llmSession?.jwtToken) {
                                 const hashedRcExtensionId = getHashValue(rcExtensionId, process.env.HASH_KEY);
-                                const user = await UserModel.findOne({ where: { hashedRcExtensionId } });
+                                const user = await UserModel.findOne({
+                                    where: {
+                                        hashedRcExtensionId,
+                                        [Op.and]: [
+                                            { accessToken: { [Op.not]: null } },
+                                            { accessToken: { [Op.ne]: '' } },
+                                        ],
+                                    },
+                                    order: [['updatedAt', 'DESC']],
+                                });
                                 if (user?.accessToken) {
                                     await LlmSessionModel.upsert({
                                         id: rcExtensionId,
@@ -219,6 +241,7 @@ async function handleMcpRequest(req, res) {
                                             id: user.id.toString(),
                                             platform: user.platform
                                         }),
+                                        expiry: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000)
                                     });
                                     llmSession = await LlmSessionModel.findByPk(rcExtensionId);
                                 }

package/mcp/tools/checkAuthStatus.js

@@ -3,7 +3,7 @@ const { LlmSessionModel } = require('../../models/llmSessionModel');
 
 /**
  * MCP Tool: Check Auth Status
- * 
+ *
  * Polls the status of an ongoing OAuth authentication session
  */
 
@@ -37,7 +37,7 @@ const toolDefinition = {
 async function execute(args) {
     try {
         // rcExtensionId is injected by mcpHandler after verifying the RC access
-        // token.  Using it as the DB key binds the CRM credential to a verified
+        // token. Using it as the DB key binds the CRM credential to a verified
         // RC identity.
         const { sessionId, rcExtensionId } = args;
         if (!rcExtensionId) {
@@ -53,16 +53,12 @@ async function execute(args) {
         }
 
         switch (session.status) {
-            case 'completed': {
-                // Guard against duplicate DB writes if polled concurrently
-                try {
-                    await LlmSessionModel.create({
-                        id: rcExtensionId,
-                        jwtToken: session.jwtToken
-                    });
-                } catch {
-                    // Record already exists from a prior poll — safe to ignore
-                }
+            case 'completed':
+                await LlmSessionModel.upsert({
+                    id: rcExtensionId,
+                    jwtToken: session.jwtToken,
+                    expiry: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000)
+                });
                 return {
                     data: {
                         status: 'completed',
@@ -71,7 +67,14 @@ async function execute(args) {
                         message: 'IMPORTANT: Authentication successful! Keep jwtToken in memory for future use. DO NOT directly show it to user.'
                     }
                 };
-            }
+
+            case 'expired':
+                return {
+                    data: {
+                        status: 'expired',
+                        errorMessage: 'Authentication session expired. Ask the user to start the auth flow again.'
+                    }
+                };
 
             case 'failed':
                 return {
@@ -100,4 +103,3 @@ async function execute(args) {
 
 exports.definition = toolDefinition;
 exports.execute = execute;
-

package/mcp/tools/getPublicConnectors.js

@@ -1,4 +1,5 @@
 const axios = require('axios');
+const { Op } = require('sequelize');
 const { UserModel } = require('../../models/userModel');
 const { getHashValue } = require('../../lib/util');
 
@@ -56,7 +57,16 @@ async function execute({ rcAccessToken, openaiSessionId } = {}) {
 
     // Check if user session already exists from Chrome extension
     const hashedRcExtensionId = getHashValue(rcExtensionId, process.env.HASH_KEY);
-    const user = await UserModel.findOne({ where: { hashedRcExtensionId } });
+    const user = await UserModel.findOne({
+        where: {
+            hashedRcExtensionId,
+            [Op.and]: [
+                { accessToken: { [Op.not]: null } },
+                { accessToken: { [Op.ne]: '' } },
+            ],
+        },
+        order: [['updatedAt', 'DESC']],
+    });
     // Case: user exists, return user info in plain message
     if (user?.accessToken) {
         return {

package/mcp/tools/getSessionInfo.js

@@ -0,0 +1,90 @@
+const jwt = require('../../lib/jwt');
+const { UserModel } = require('../../models/userModel');
+const { RingCentral } = require('../../lib/ringcentral');
+
+/**
+ * MCP Tool: Get Session Info
+ *
+ * Returns non-sensitive information about the current MCP/CRM session.
+ */
+
+const toolDefinition = {
+    name: 'getSessionInfo',
+    description: 'Get the current user session info, including RingCentral identity and CRM connection status.',
+    inputSchema: {
+        type: 'object',
+        properties: {},
+        required: []
+    },
+    annotations: {
+        readOnlyHint: true,
+        openWorldHint: false,
+        destructiveHint: false
+    }
+};
+
+/**
+ * Execute the getSessionInfo tool
+ * @param {Object} args - Tool arguments injected by mcpHandler
+ * @param {string} [args.openaiSessionId] - OpenAI session identifier
+ * @param {string} [args.rcExtensionId] - Verified RingCentral extension identifier
+ * @param {string} [args.jwtToken] - CRM JWT token
+ * @param {string} [args.rcAccessToken] - RingCentral access token
+ * @returns {Object} Result object with session information
+ */
+async function execute(args = {}) {
+    try {
+        const {
+            openaiSessionId = null,
+            rcExtensionId = null,
+            jwtToken,
+            rcAccessToken,
+        } = args;
+
+        const decodedToken = jwtToken ? jwt.decodeJwt(jwtToken) : null;
+        const userId = decodedToken?.id ?? null;
+        const user = userId ? await UserModel.findByPk(userId) : null;
+
+        let rcExtensionInfo = null;
+        if (rcExtensionId && rcAccessToken) {
+            const rcSDK = new RingCentral({
+                server: process.env.RINGCENTRAL_SERVER,
+                clientId: process.env.RINGCENTRAL_CLIENT_ID,
+                clientSecret: process.env.RINGCENTRAL_CLIENT_SECRET,
+                redirectUri: `${process.env.APP_SERVER}/ringcentral/oauth/callback`
+            });
+            rcExtensionInfo = await rcSDK.getExtensionInfo(rcExtensionId, {
+                access_token: rcAccessToken,
+                token_type: 'Bearer'
+            });
+        }
+        return {
+            success: true,
+            data: {
+                openaiSessionId,
+                dataToShow: {
+                    isCrmAuthenticated: Boolean(decodedToken && user?.accessToken),
+                    ringcentral: {
+                        extensionId: rcExtensionId ?? null,
+                        name: rcExtensionInfo?.name ?? null,
+                    },
+                    crm: {
+                        userId,
+                        platform: decodedToken?.platform ?? user?.platform ?? null,
+                        hostname: user?.hostname ?? null
+                    }
+                }
+            }
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error.message || 'Unknown error occurred',
+            errorDetails: error.stack
+        };
+    }
+}
+
+exports.definition = toolDefinition;
+exports.execute = execute;

package/mcp/tools/index.js

@@ -8,6 +8,7 @@
 
 const getHelp = require('./getHelp');
 const getPublicConnectors = require('./getPublicConnectors');
+const getSessionInfo = require('./getSessionInfo');
 const doAuth = require('./doAuth');
 const checkAuthStatus = require('./checkAuthStatus');
 const logout = require('./logout');
@@ -15,13 +16,14 @@ const findContact = require('./findContactByPhone');
 const findContactWithName = require('./findContactByName');
 const createCallLog = require('./createCallLog');
 const rcGetCallLogs = require('./rcGetCallLogs');
-const getGoogleFilePicker = require('./getGoogleFilePicker');
+// const getGoogleFilePicker = require('./getGoogleFilePicker');
 const createContact = require('./createContact');
 
 // AI-visible MCP tools — registered in the MCP server
 module.exports.tools = [
     getHelp,
     getPublicConnectors,
+    getSessionInfo,
     logout,
     findContact,
     findContactWithName,

package/mcp/tools/logout.js

@@ -1,8 +1,11 @@
 const jwt = require('../../lib/jwt');
 const { UserModel } = require('../../models/userModel');
 const { LlmSessionModel } = require('../../models/llmSessionModel');
+const { CacheModel } = require('../../models/cacheModel');
 const connectorRegistry = require('../../connector/registry');
 
+const RC_EXTENSION_CACHE_KEY = 'rcExtensionId';
+
 /**
  * MCP Tool: Logout
  * 
@@ -38,7 +41,7 @@ function isMissingSessionTableError(error) {
  */
 async function execute(args) {
     try {
-        const { jwtToken } = args;
+        const { jwtToken, rcExtensionId, openaiSessionId } = args;
         const session = jwt.decodeJwt(jwtToken);
         if (!session?.platform || !session?.id) {
             throw new Error('Invalid JWT token');
@@ -46,6 +49,12 @@ async function execute(args) {
         const { platform, id } = session;
         try {
             await LlmSessionModel.destroy({ where: { id } });
+            if (rcExtensionId && rcExtensionId !== id) {
+                await LlmSessionModel.destroy({ where: { id: rcExtensionId } });
+            }
+            if (openaiSessionId) {
+                await CacheModel.destroy({ where: { id: `${openaiSessionId}-${RC_EXTENSION_CACHE_KEY}` } });
+            }
         }
         catch (error) {
             if (!isMissingSessionTableError(error)) {

package/models/llmSessionModel.js

@@ -10,5 +10,8 @@ exports.LlmSessionModel = sequelize.define('llmSessions', {
     },
     jwtToken: {
         type: Sequelize.STRING,
+    },
+    expiry: {
+        type: Sequelize.DATE
     }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@app-connect/core",
-  "version": "1.7.22",
+  "version": "1.7.24",
   "description": "RingCentral App Connect Core",
   "main": "index.js",
   "repository": {

package/releaseNotes.json

@@ -1,4 +1,24 @@
 {
+    "1.7.24": {
+        "global": [
+            {
+                "type": "New",
+                "description": "Click-to-dial number matcher selection in User Setting -> General"
+            },  
+            {
+                "type": "Fix",
+                "description": "Error report upload"
+            }
+        ]
+    },
+    "1.7.23": {
+        "global": [
+            {
+                "type": "Rename",
+                "description": "Rename RingSense to ACE"
+            }
+        ]
+    },
     "1.7.22": {
         "global": [
             {

package/test/handlers/admin.test.js

@@ -142,8 +142,7 @@ describe('Admin Handler', () => {
 
       expect(result).toEqual({
         rcAccountId: 'rc-account-789',
-        rcExtensionId: 'extension-789',
-        rcUserName: 'Alex Johnson'
+        rcExtensionId: 'extension-789'
       });
       expect(axios.get).toHaveBeenCalledWith(
         'https://platform.ringcentral.com/restapi/v1.0/account/~/extension/~',

package/test/handlers/log.test.js

@@ -24,6 +24,7 @@ jest.mock('../../models/dynamo/connectorSchema', () => ({
     getProxyConfig: jest.fn()
   }
 }));
+jest.mock('axios');
 
 const logHandler = require('../../handlers/log');
 const { CallLogModel } = require('../../models/callLogModel');
@@ -34,6 +35,7 @@ const connectorRegistry = require('../../connector/registry');
 const oauth = require('../../lib/oauth');
 const { composeCallLog } = require('../../lib/callLogComposer');
 const { NoteCache } = require('../../models/dynamo/noteCacheSchema');
+const axios = require('axios');
 const { sequelize } = require('../../models/sequelize');
 
 describe('Log Handler', () => {
@@ -61,6 +63,7 @@ describe('Log Handler', () => {
       id: 'test-user-id',
       platform: 'testCRM',
       accessToken: 'test-access-token',
+      rcAccountId: '12345',
       platformAdditionalInfo: {}
     };
 
@@ -217,6 +220,63 @@ describe('Log Handler', () => {
       expect(savedLog.thirdPartyLogId).toBe('new-log-123');
     });
 
+    test('should call plugin with Bearer auth and without query jwt token', async () => {
+      await UserModel.create(mockUser);
+      await AccountDataModel.create({
+        rcAccountId: mockUser.rcAccountId,
+        platformName: 'testPlugin',
+        dataKey: 'pluginData',
+        data: {
+          name: 'plugin.sample',
+          supportedLogTypes: ['call'],
+          isAsync: false,
+          endpointUrl: 'https://plugins.example.com/plugin/testPlugin',
+          jwtToken: 'plugin-jwt-token'
+        }
+      });
+
+      const mockConnector = {
+        getAuthType: jest.fn().mockResolvedValue('apiKey'),
+        getBasicAuth: jest.fn().mockReturnValue('base64-encoded'),
+        getLogFormatType: jest.fn().mockReturnValue('text/plain'),
+        createCallLog: jest.fn().mockResolvedValue({
+          logId: 'new-log-123',
+          returnMessage: { message: 'Call logged', messageType: 'success', ttl: 2000 }
+        })
+      };
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+      composeCallLog.mockReturnValue('Composed log details');
+
+      axios.post.mockResolvedValue({
+        data: {
+          ...mockIncomingData,
+          note: 'updated by plugin'
+        },
+        headers: {
+          'x-refreshed-jwt-token': 'refreshed-plugin-jwt'
+        }
+      });
+
+      const result = await logHandler.createCallLog({
+        platform: 'testCRM',
+        userId: 'test-user-id',
+        incomingData: mockIncomingData,
+        hashedAccountId: 'hashed-123',
+        isFromSSCL: false
+      });
+
+      expect(result.successful).toBe(true);
+      expect(axios.post).toHaveBeenCalledWith(
+        'https://plugins.example.com/plugin/testPlugin',
+        { data: mockIncomingData, config: null },
+        {
+          headers: {
+            Authorization: 'Bearer plugin-jwt-token'
+          }
+        }
+      );
+    });
+
     test('should successfully create call log with oauth auth', async () => {
       // Arrange
       const oauthUser = { ...mockUser };

package/test/handlers/plugin.test.js

@@ -9,18 +9,24 @@ jest.mock('../../models/sequelize', () => {
     }),
   };
 });
+jest.mock('axios');
 
 const pluginHandler = require('../../handlers/plugin');
 const { CacheModel } = require('../../models/cacheModel');
+const { AccountDataModel } = require('../../models/accountDataModel');
+const axios = require('axios');
 const { sequelize } = require('../../models/sequelize');
 
 describe('Plugin Handler', () => {
   beforeAll(async () => {
+    process.env.HASH_KEY = 'unit-test-hash-key';
     await CacheModel.sync({ force: true });
+    await AccountDataModel.sync({ force: true });
   });
 
   afterEach(async () => {
     await CacheModel.destroy({ where: {} });
+    await AccountDataModel.destroy({ where: {} });
     jest.clearAllMocks();
   });
 
@@ -283,5 +289,92 @@ describe('Plugin Handler', () => {
       expect(remainingTask).not.toBeNull();
     });
   });
+
+  describe('registerPluginAccount', () => {
+    test('should register plugin account and persist plugin jwt token in account data', async () => {
+      const rcAccountId = '12345';
+      const pluginId = 'sync-all-caps';
+
+      axios.get.mockResolvedValue({
+        data: {
+          platforms: {
+            'plugin.sample': {
+              endpointUrl: `https://plugins.example.com/plugin/${pluginId}`,
+              userRegisterEndpointUrl: `https://plugins.example.com/plugin/${pluginId}/auth/register`
+            }
+          }
+        }
+      });
+      axios.post.mockResolvedValue({
+        data: {
+          jwtToken: 'plugin-jwt-token'
+        }
+      });
+
+      const result = await pluginHandler.registerPluginAccount({
+        pluginId,
+        rcAccessToken: 'rc-access-token',
+        rcAccountId,
+        pluginAccess: 'public',
+        pluginName: 'plugin.sample'
+      });
+
+      expect(result.successful).toBe(true);
+      expect(axios.post).toHaveBeenCalledWith(
+        `https://plugins.example.com/plugin/${pluginId}/auth/register`,
+        {
+          rcAccessToken: 'rc-access-token',
+          rcAccountId
+        }
+      );
+
+      const accountData = await AccountDataModel.findOne({
+        where: {
+          rcAccountId,
+          platformName: pluginId,
+          dataKey: 'pluginData'
+        }
+      });
+      expect(accountData).not.toBeNull();
+      expect(accountData.data.jwtToken).toBe('plugin-jwt-token');
+      expect(accountData.data.endpointUrl).toBe(`https://plugins.example.com/plugin/${pluginId}`);
+    });
+
+    test('should throw when register API does not return jwt token', async () => {
+      const rcAccountId = '12345';
+      const pluginId = 'sync-all-caps';
+
+      axios.get.mockResolvedValue({
+        data: {
+          platforms: {
+            'plugin.sample': {
+              endpointUrl: `https://plugins.example.com/plugin/${pluginId}`,
+              userRegisterEndpointUrl: `https://plugins.example.com/plugin/${pluginId}/auth/register`
+            }
+          }
+        }
+      });
+      axios.post.mockResolvedValue({ data: {} });
+
+      await expect(pluginHandler.registerPluginAccount({
+        pluginId,
+        rcAccessToken: 'rc-access-token',
+        rcAccountId,
+        pluginAccess: 'public',
+        pluginName: 'plugin.sample'
+      })).rejects.toThrow('Plugin register API did not return jwtToken');
+    });
+  });
+
+  describe('token header helper', () => {
+    test('should parse refreshed jwt token from response headers', () => {
+      const token = pluginHandler.getRefreshedJwtTokenFromHeaders({
+        headers: {
+          'x-refreshed-jwt-token': 'new-plugin-token'
+        }
+      });
+      expect(token).toBe('new-plugin-token');
+    });
+  });
 });