@app-connect/core 1.7.20 → 1.7.22

package/mcp/tools/updateCallLog.js

@@ -59,7 +59,11 @@ async function execute(args) {
         const { jwtToken, incomingData } = args;
         
         // Decode JWT to get userId and platform
-        const { id: userId, platform } = jwt.decodeJwt(jwtToken);
+        const decodedToken = jwt.decodeJwt(jwtToken);
+        if (!decodedToken) {
+            throw new Error('Invalid JWT token');
+        }
+        const { id: userId, platform } = decodedToken;
         
         if (!userId) {
             throw new Error('Invalid JWT token: userId not found');

package/mcp/ui/App/lib/developerPortal.ts

@@ -90,7 +90,7 @@ export async function fetchManifest(
   dbg.info('fetchManifest: connectorId=', connectorId, 'isPrivate=', isPrivate)
 
   const url = isPrivate && rcAccountId
-    ? `${PORTAL_BASE}/connectors/${connectorId}/manifest?type=internal&accountId=${encodeURIComponent(rcAccountId)}`
+    ? `${PORTAL_BASE}/connectors/${connectorId}/manifest?access=internal&type=connector&accountId=${encodeURIComponent(rcAccountId)}`
     : `${PORTAL_BASE}/connectors/${connectorId}/manifest`
 
   dbg.info('fetchManifest: GET', url)

package/package.json

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

package/releaseNotes.json

@@ -1,4 +1,24 @@
 {
+    "1.7.22": {
+        "global": [
+            {
+                "type": "New",
+                "description": "Managed auth fields for non-OAuth platforms"
+            }
+        ]
+    },
+    "1.7.21": {
+        "global": [
+            {
+                "type": "Fix",
+                "description": "Refresh contact for deleted contact issue"
+            },
+            {
+                "type": "Fix",
+                "description": "Click-to-sms button issue"
+            }
+        ]
+    },
     "1.7.20": {
         "global": [
             {

package/test/handlers/admin.test.js

@@ -123,6 +123,40 @@ describe('Admin Handler', () => {
     });
   });
 
+  describe('validateRcUserToken', () => {
+    test('should return rc account and extension identity from valid token', async () => {
+      axios.get.mockResolvedValue({
+        data: {
+          account: { id: 'rc-account-789' },
+          id: 'extension-789',
+          contact: {
+            firstName: 'Alex',
+            lastName: 'Johnson'
+          }
+        }
+      });
+
+      const result = await adminHandler.validateRcUserToken({
+        rcAccessToken: 'valid-user-token'
+      });
+
+      expect(result).toEqual({
+        rcAccountId: 'rc-account-789',
+        rcExtensionId: 'extension-789',
+        rcUserName: 'Alex Johnson'
+      });
+      expect(axios.get).toHaveBeenCalledWith(
+        'https://platform.ringcentral.com/restapi/v1.0/account/~/extension/~',
+        { headers: { Authorization: 'Bearer valid-user-token' } }
+      );
+    });
+
+    test('should throw when rcAccessToken is missing', async () => {
+      await expect(adminHandler.validateRcUserToken({})).rejects.toThrow('rcAccessToken is required');
+      expect(axios.get).not.toHaveBeenCalled();
+    });
+  });
+
   describe('upsertAdminSettings', () => {
     test('should create new admin config when none exists', async () => {
       // Act

package/test/handlers/auth.test.js

@@ -22,6 +22,8 @@ const oauth = require('../../lib/oauth');
 const { Connector } = require('../../models/dynamo/connectorSchema');
 const { RingCentral } = require('../../lib/ringcentral');
 const adminCore = require('../../handlers/admin');
+const { AccountDataModel } = require('../../models/accountDataModel');
+const { encode } = require('../../lib/encode');
 
 describe('Auth Handler', () => {
   const originalEnv = process.env;
@@ -31,6 +33,7 @@ describe('Auth Handler', () => {
     jest.clearAllMocks();
     global.testUtils.resetConnectorRegistry();
     process.env = { ...originalEnv };
+    process.env.APP_SERVER_SECRET_KEY = 'test-app-server-secret-key-123456';
   });
 
   afterEach(() => {
@@ -38,6 +41,10 @@ describe('Auth Handler', () => {
   });
 
   describe('onApiKeyLogin', () => {
+    afterEach(async () => {
+      await AccountDataModel.destroy({ where: {} });
+    });
+
     test('should handle successful API key login', async () => {
       // Arrange
       const mockUserInfo = {
@@ -60,7 +67,7 @@ describe('Auth Handler', () => {
         getBasicAuth: jest.fn().mockReturnValue('dGVzdC1hcGkta2V5Og=='),
         getUserInfo: jest.fn().mockResolvedValue(mockUserInfo)
       });
-      
+
       connectorRegistry.getConnector.mockReturnValue(mockConnector);
 
       const requestData = {
@@ -82,7 +89,7 @@ describe('Auth Handler', () => {
       expect(mockConnector.getUserInfo).toHaveBeenCalledWith({
         authHeader: 'Basic dGVzdC1hcGkta2V5Og==',
         hostname: 'test.example.com',
-        additionalInfo: {},
+        additionalInfo: { apiKey: 'test-api-key' },
         apiKey: 'test-api-key',
         platform: 'testCRM',
         proxyId: undefined
@@ -105,7 +112,7 @@ describe('Auth Handler', () => {
         getBasicAuth: jest.fn().mockReturnValue('dGVzdC1hcGkta2V5Og=='),
         getUserInfo: jest.fn().mockResolvedValue(mockUserInfo)
       });
-      
+
       connectorRegistry.getConnector.mockReturnValue(mockConnector);
 
       const requestData = {
@@ -123,6 +130,394 @@ describe('Auth Handler', () => {
       expect(result.returnMessage).toEqual(mockUserInfo.returnMessage);
     });
 
+    test('should mark managed auth auto-login failure so the next attempt can fall back to manual auth', async () => {
+      connectorRegistry.getManifest.mockReturnValue({
+        platforms: {
+          testCRM: {
+            auth: {
+              type: 'apiKey',
+              apiKey: {
+                page: {
+                  content: [
+                    { const: 'tenantId', required: true, managed: true, managedScope: 'account' },
+                    { const: 'apiKey', required: true, managed: true, managedScope: 'user' }
+                  ]
+                }
+              }
+            }
+          }
+        }
+      });
+
+      await AccountDataModel.create({
+        rcAccountId: 'rc-account-fail',
+        platformName: 'testCRM',
+        dataKey: 'managed-auth-org',
+        data: {
+          fields: {
+            tenantId: { version: 1, encrypted: true, value: encode(JSON.stringify('tenant-1')) }
+          }
+        }
+      });
+      await AccountDataModel.create({
+        rcAccountId: 'rc-account-fail',
+        platformName: 'testCRM',
+        dataKey: 'managed-auth-user:101',
+        data: {
+          rcExtensionId: '101',
+          rcUserName: 'Agent 101',
+          fields: {
+            apiKey: { version: 1, encrypted: true, value: encode(JSON.stringify('bad-stored-key')) }
+          }
+        }
+      });
+
+      const mockConnector = global.testUtils.createMockConnector({
+        getBasicAuth: jest.fn().mockReturnValue('encoded-bad-key'),
+        getUserInfo: jest.fn().mockResolvedValue({
+          successful: false,
+          platformUserInfo: null,
+          returnMessage: {
+            messageType: 'error',
+            message: 'Invalid API key',
+            ttl: 3000
+          }
+        })
+      });
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      const result = await authHandler.onApiKeyLogin({
+        platform: 'testCRM',
+        hostname: 'test.example.com',
+        rcAccountId: 'rc-account-fail',
+        rcExtensionId: '101',
+        additionalInfo: {}
+      });
+
+      expect(result.userInfo).toBeNull();
+      const failureRecord = await AccountDataModel.findOne({
+        where: {
+          rcAccountId: 'rc-account-fail',
+          platformName: 'testCRM',
+          dataKey: 'managed-auth-login-failure:101'
+        }
+      });
+      expect(failureRecord).not.toBeNull();
+    });
+
+    test('should merge stored org managed auth values into additionalInfo', async () => {
+      connectorRegistry.getManifest.mockReturnValue({
+        platforms: {
+          testCRM: {
+            auth: {
+              type: 'apiKey',
+              apiKey: {
+                page: {
+                  content: [
+                    { const: 'apiKey', required: true, managed: true, managedScope: 'account' },
+                    { const: 'tenantId', required: true, managed: true, managedScope: 'account' },
+                    { const: 'userToken', required: true }
+                  ]
+                }
+              }
+            }
+          }
+        }
+      });
+      await AccountDataModel.create({
+        rcAccountId: 'rc-account-1',
+        platformName: 'testCRM',
+        dataKey: 'managed-auth-org',
+        data: {
+          fields: {
+            apiKey: { version: 1, encrypted: true, value: encode(JSON.stringify('stored-api-key')) },
+            tenantId: { version: 1, encrypted: true, value: encode(JSON.stringify('tenant-1')) }
+          }
+        }
+      });
+
+      const mockUserInfo = {
+        successful: true,
+        platformUserInfo: {
+          id: 'test-user-id',
+          name: 'Test User',
+          platformAdditionalInfo: {}
+        },
+        returnMessage: { messageType: 'success', message: 'ok' }
+      };
+      const mockConnector = global.testUtils.createMockConnector({
+        getBasicAuth: jest.fn().mockReturnValue('encoded-shared'),
+        getUserInfo: jest.fn().mockResolvedValue(mockUserInfo)
+      });
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      await authHandler.onApiKeyLogin({
+        platform: 'testCRM',
+        hostname: 'test.example.com',
+        rcAccountId: 'rc-account-1',
+        additionalInfo: { userToken: 'user-token-1' }
+      });
+
+      expect(mockConnector.getBasicAuth).toHaveBeenCalledWith({ apiKey: 'stored-api-key' });
+      expect(mockConnector.getUserInfo).toHaveBeenCalledWith(expect.objectContaining({
+        additionalInfo: expect.objectContaining({
+          apiKey: 'stored-api-key',
+          tenantId: 'tenant-1',
+          userToken: 'user-token-1'
+        })
+      }));
+    });
+
+    test('should allow submitted shared fields to satisfy missing required managed auth values', async () => {
+      connectorRegistry.getManifest.mockReturnValue({
+        platforms: {
+          testCRM: {
+            auth: {
+              type: 'apiKey',
+              apiKey: {
+                page: {
+                  content: [
+                    { const: 'companyId', required: true, managed: true, managedScope: 'account' },
+                    { const: 'userToken', required: true }
+                  ]
+                }
+              }
+            }
+          }
+        }
+      });
+
+      const mockConnector = global.testUtils.createMockConnector({
+        getBasicAuth: jest.fn(),
+        getUserInfo: jest.fn().mockResolvedValue({
+          successful: true,
+          platformUserInfo: {
+            id: 'test-user-id',
+            name: 'Test User',
+            platformAdditionalInfo: {}
+          },
+          returnMessage: { messageType: 'success', message: 'ok' }
+        })
+      });
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      const result = await authHandler.onApiKeyLogin({
+        platform: 'testCRM',
+        hostname: 'test.example.com',
+        rcAccountId: 'rc-account-2',
+        additionalInfo: {
+          companyId: 'company-123',
+          userToken: 'user-token-1'
+        }
+      });
+
+      expect(result.userInfo).not.toBeNull();
+      expect(mockConnector.getUserInfo).toHaveBeenCalledWith(expect.objectContaining({
+        additionalInfo: expect.objectContaining({
+          companyId: 'company-123',
+          userToken: 'user-token-1'
+        })
+      }));
+    });
+
+    test('should not persist submitted managed auth values from end users', async () => {
+      connectorRegistry.getManifest.mockReturnValue({
+        platforms: {
+          testCRM: {
+            auth: {
+              type: 'apiKey',
+              apiKey: {
+                page: {
+                  content: [
+                    { const: 'companyId', required: false, managed: true, managedScope: 'account' },
+                    { const: 'userToken', required: true }
+                  ]
+                }
+              }
+            }
+          }
+        }
+      });
+
+      const mockUserInfo = {
+        successful: true,
+        platformUserInfo: {
+          id: 'test-user-id',
+          name: 'Test User',
+          platformAdditionalInfo: {}
+        },
+        returnMessage: { messageType: 'success', message: 'ok' }
+      };
+      const mockConnector = global.testUtils.createMockConnector({
+        getBasicAuth: jest.fn().mockReturnValue('encoded'),
+        getUserInfo: jest.fn().mockResolvedValue(mockUserInfo)
+      });
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      await authHandler.onApiKeyLogin({
+        platform: 'testCRM',
+        hostname: 'test.example.com',
+        rcAccountId: 'rc-account-2',
+        additionalInfo: {
+          companyId: 'company-123',
+          userToken: 'user-token-1'
+        }
+      });
+
+      expect(mockConnector.getUserInfo).toHaveBeenCalledWith(expect.objectContaining({
+        additionalInfo: expect.objectContaining({
+          companyId: 'company-123',
+          userToken: 'user-token-1'
+        })
+      }));
+
+      const stored = await AccountDataModel.findOne({
+        where: {
+          rcAccountId: 'rc-account-2',
+          platformName: 'testCRM',
+          dataKey: 'managed-auth-org'
+        }
+      });
+      expect(stored).toBeNull();
+    });
+
+    test('should allow manual fallback values to override stored managed credentials and clear failure state after success', async () => {
+      connectorRegistry.getManifest.mockReturnValue({
+        platforms: {
+          testCRM: {
+            auth: {
+              type: 'apiKey',
+              apiKey: {
+                page: {
+                  content: [
+                    { const: 'apiKey', required: true, managed: true, managedScope: 'user' },
+                    { const: 'tenantId', required: true, managed: true, managedScope: 'account' }
+                  ]
+                }
+              }
+            }
+          }
+        }
+      });
+
+      await AccountDataModel.create({
+        rcAccountId: 'rc-account-recover',
+        platformName: 'testCRM',
+        dataKey: 'managed-auth-org',
+        data: {
+          fields: {
+            tenantId: { version: 1, encrypted: true, value: encode(JSON.stringify('stored-tenant')) }
+          }
+        }
+      });
+      await AccountDataModel.create({
+        rcAccountId: 'rc-account-recover',
+        platformName: 'testCRM',
+        dataKey: 'managed-auth-user:202',
+        data: {
+          rcExtensionId: '202',
+          rcUserName: 'Agent 202',
+          fields: {
+            apiKey: { version: 1, encrypted: true, value: encode(JSON.stringify('stored-bad-key')) }
+          }
+        }
+      });
+      await AccountDataModel.create({
+        rcAccountId: 'rc-account-recover',
+        platformName: 'testCRM',
+        dataKey: 'managed-auth-login-failure:202',
+        data: {
+          failedAt: '2026-04-07T00:00:00.000Z'
+        }
+      });
+
+      const mockConnector = global.testUtils.createMockConnector({
+        getBasicAuth: jest.fn().mockReturnValue('encoded-manual-key'),
+        getUserInfo: jest.fn().mockResolvedValue({
+          successful: true,
+          platformUserInfo: {
+            id: 'test-user-id',
+            name: 'Recovered User',
+            platformAdditionalInfo: {}
+          },
+          returnMessage: { messageType: 'success', message: 'ok' }
+        })
+      });
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      const result = await authHandler.onApiKeyLogin({
+        platform: 'testCRM',
+        hostname: 'test.example.com',
+        rcAccountId: 'rc-account-recover',
+        rcExtensionId: '202',
+        additionalInfo: {
+          apiKey: 'manual-good-key',
+          tenantId: 'manual-tenant'
+        }
+      });
+
+      expect(result.userInfo).not.toBeNull();
+      expect(mockConnector.getBasicAuth).toHaveBeenCalledWith({ apiKey: 'manual-good-key' });
+      expect(mockConnector.getUserInfo).toHaveBeenCalledWith(expect.objectContaining({
+        additionalInfo: {
+          apiKey: 'manual-good-key',
+          tenantId: 'manual-tenant'
+        }
+      }));
+
+      const failureRecord = await AccountDataModel.findOne({
+        where: {
+          rcAccountId: 'rc-account-recover',
+          platformName: 'testCRM',
+          dataKey: 'managed-auth-login-failure:202'
+        }
+      });
+      expect(failureRecord).toBeNull();
+    });
+
+    test('should return warning when required auth fields are missing', async () => {
+      connectorRegistry.getManifest.mockReturnValue({
+        platforms: {
+          testCRM: {
+            auth: {
+              type: 'apiKey',
+              apiKey: {
+                page: {
+                  content: [
+                    { const: 'tenantId', required: true, managed: true, managedScope: 'account' },
+                    { const: 'userToken', required: true }
+                  ]
+                }
+              }
+            }
+          }
+        }
+      });
+
+      const mockConnector = global.testUtils.createMockConnector({
+        getBasicAuth: jest.fn(),
+        getUserInfo: jest.fn()
+      });
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      const result = await authHandler.onApiKeyLogin({
+        platform: 'testCRM',
+        hostname: 'test.example.com',
+        rcAccountId: 'rc-account-4',
+        additionalInfo: {}
+      });
+
+      expect(result.userInfo).toBeNull();
+      expect(result.returnMessage).toEqual({
+        messageType: 'warning',
+        message: 'Missing required authentication fields.',
+        ttl: 3000,
+        missingRequiredFieldConsts: ['tenantId', 'userToken']
+      });
+      expect(mockConnector.getBasicAuth).not.toHaveBeenCalled();
+      expect(mockConnector.getUserInfo).not.toHaveBeenCalled();
+    });
+
     test('should throw error when connector not found', async () => {
       // Arrange
       connectorRegistry.getConnector.mockImplementation(() => {
@@ -160,7 +555,7 @@ describe('Auth Handler', () => {
         getOauthInfo: jest.fn().mockResolvedValue({}),
         authValidation: jest.fn().mockResolvedValue(mockValidationResponse)
       });
-      
+
       connectorRegistry.getConnector.mockReturnValue(mockConnector);
 
       // Mock UserModel.findOne to return a user
@@ -229,7 +624,7 @@ describe('Auth Handler', () => {
         getOauthInfo: jest.fn().mockResolvedValue({}),
         authValidation: jest.fn().mockResolvedValue(mockValidationResponse)
       });
-      
+
       connectorRegistry.getConnector.mockReturnValue(mockConnector);
 
       // Mock UserModel.findOne to return a user
@@ -616,4 +1011,5 @@ describe('Auth Handler', () => {
       expect(RingCentral).not.toHaveBeenCalled();
     });
   });
-}); 
+});
+