@app-connect/core 1.7.36 → 1.7.38

package/test/mcp/tools/getSessionInfo.test.js

@@ -1,127 +0,0 @@
-const getSessionInfo = require('../../../mcp/tools/getSessionInfo');
-const jwt = require('../../../lib/jwt');
-const { UserModel } = require('../../../models/userModel');
-const { RingCentral } = require('../../../lib/ringcentral');
-
-jest.mock('../../../lib/jwt');
-jest.mock('../../../models/userModel');
-jest.mock('../../../lib/ringcentral');
-
-describe('MCP Tool: getSessionInfo', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-    RingCentral.mockImplementation(() => ({
-      getExtensionInfo: jest.fn().mockResolvedValue({ name: 'Demo Extension' })
-    }));
-  });
-
-  describe('tool definition', () => {
-    test('should have correct tool definition', () => {
-      expect(getSessionInfo.definition).toBeDefined();
-      expect(getSessionInfo.definition.name).toBe('getSessionInfo');
-      expect(getSessionInfo.definition.description).toContain('session info');
-      expect(getSessionInfo.definition.inputSchema).toBeDefined();
-      expect(getSessionInfo.definition.inputSchema.properties).toEqual({});
-    });
-  });
-
-  describe('execute', () => {
-    test('should return unauthenticated session info when no CRM jwtToken exists', async () => {
-      const result = await getSessionInfo.execute({
-        openaiSessionId: 'session-123',
-        rcExtensionId: 'ext-456',
-        rcAccessToken: 'rc-token'
-      });
-
-      expect(result).toEqual({
-        success: true,
-        data: {
-          openaiSessionId: 'session-123',
-          dataToShow: {
-            isCrmAuthenticated: false,
-            ringcentral: {
-              extensionId: 'ext-456',
-              name: 'Demo Extension',
-            },
-            crm: {
-              userId: null,
-              platform: null,
-              hostname: null
-            }
-          }
-        }
-      });
-      expect(jwt.decodeJwt).not.toHaveBeenCalled();
-      expect(UserModel.findByPk).not.toHaveBeenCalled();
-    });
-
-    test('should return connected CRM session info when jwtToken resolves to a saved user', async () => {
-      jwt.decodeJwt.mockReturnValue({
-        id: 'crm-user-1',
-        platform: 'clio'
-      });
-      UserModel.findByPk.mockResolvedValue({
-        id: 'crm-user-1',
-        platform: 'clio',
-        hostname: 'app.clio.com',
-        accessToken: 'crm-access-token',
-      });
-
-      const result = await getSessionInfo.execute({
-        openaiSessionId: 'session-123',
-        rcExtensionId: 'ext-456',
-        rcAccessToken: 'rc-token',
-        jwtToken: 'jwt-token'
-      });
-
-      expect(jwt.decodeJwt).toHaveBeenCalledWith('jwt-token');
-      expect(UserModel.findByPk).toHaveBeenCalledWith('crm-user-1');
-      expect(result).toEqual({
-        success: true,
-        data: {
-          openaiSessionId: 'session-123',
-          dataToShow: {
-            isCrmAuthenticated: true,
-            ringcentral: {
-              extensionId: 'ext-456',
-              name: 'Demo Extension',
-            },
-            crm: {
-              userId: 'crm-user-1',
-              platform: 'clio',
-              hostname: 'app.clio.com'
-            }
-          }
-        }
-      });
-    });
-
-    test('should report not authenticated when jwtToken is invalid', async () => {
-      jwt.decodeJwt.mockReturnValue(null);
-
-      const result = await getSessionInfo.execute({
-        jwtToken: 'bad-token'
-      });
-
-      expect(result).toEqual({
-        success: true,
-        data: {
-          openaiSessionId: null,
-          dataToShow: {
-            isCrmAuthenticated: false,
-            ringcentral: {
-              extensionId: null,
-              name: null,
-            },
-            crm: {
-              userId: null,
-              platform: null,
-              hostname: null
-            }
-          }
-        }
-      });
-      expect(UserModel.findByPk).not.toHaveBeenCalled();
-    });
-  });
-});

package/test/mcp/tools/logout.test.js

@@ -1,233 +0,0 @@
-const logout = require('../../../mcp/tools/logout');
-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');
-
-// Mock dependencies
-jest.mock('../../../lib/jwt');
-jest.mock('../../../models/userModel');
-jest.mock('../../../models/llmSessionModel');
-jest.mock('../../../models/cacheModel');
-jest.mock('../../../connector/registry');
-
-describe('MCP Tool: logout', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-    LlmSessionModel.destroy.mockResolvedValue(1);
-    CacheModel.destroy.mockResolvedValue(1);
-  });
-
-  describe('tool definition', () => {
-    test('should have correct tool definition', () => {
-      expect(logout.definition).toBeDefined();
-      expect(logout.definition.name).toBe('logout');
-      expect(logout.definition.description).toContain('Logout');
-      expect(logout.definition.inputSchema).toBeDefined();
-    });
-
-    test('should have empty properties (jwtToken is server-injected, not in schema)', () => {
-      expect(logout.definition.inputSchema.properties).toEqual({});
-    });
-  });
-
-  describe('execute', () => {
-    test('should logout user successfully', async () => {
-      // Arrange
-      const mockUser = {
-        id: 'test-user-id',
-        platform: 'testCRM',
-        accessToken: 'test-access-token'
-      };
-
-      const mockConnector = {
-        unAuthorize: jest.fn().mockResolvedValue({
-          returnMessage: {
-            messageType: 'success',
-            message: 'Logged out successfully'
-          }
-        })
-      };
-
-      jwt.decodeJwt.mockReturnValue({
-        id: 'test-user-id',
-        platform: 'testCRM'
-      });
-
-      UserModel.findByPk.mockResolvedValue(mockUser);
-      connectorRegistry.getConnector.mockReturnValue(mockConnector);
-
-      // Act
-      const result = await logout.execute({
-        jwtToken: 'mock-jwt-token'
-      });
-
-      // Assert
-      expect(result).toEqual({
-        success: true,
-        data: {
-          message: expect.stringContaining('IMPORTANT')
-        }
-      });
-      expect(jwt.decodeJwt).toHaveBeenCalledWith('mock-jwt-token');
-      expect(LlmSessionModel.destroy).toHaveBeenCalledWith({ where: { id: 'test-user-id' } });
-      expect(UserModel.findByPk).toHaveBeenCalledWith('test-user-id');
-      expect(connectorRegistry.getConnector).toHaveBeenCalledWith('testCRM');
-      expect(mockConnector.unAuthorize).toHaveBeenCalledWith({
-        user: mockUser
-      });
-    });
-
-    test('should return error when user not found', async () => {
-      // Arrange
-      jwt.decodeJwt.mockReturnValue({
-        id: 'non-existent-user',
-        platform: 'testCRM'
-      });
-
-      UserModel.findByPk.mockResolvedValue(null);
-
-      // Act
-      const result = await logout.execute({
-        jwtToken: 'mock-jwt-token'
-      });
-
-      // Assert
-      expect(result).toEqual({
-        success: false,
-        error: 'User not found',
-        errorDetails: 'User not found'
-      });
-    });
-
-    test('should treat CRM unAuthorize failure as non-fatal and still succeed', async () => {
-      // Arrange
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
-      const mockUser = {
-        id: 'test-user-id',
-        platform: 'testCRM'
-      };
-
-      const mockConnector = {
-        unAuthorize: jest.fn().mockRejectedValue(
-          new Error('Logout API failed')
-        )
-      };
-
-      jwt.decodeJwt.mockReturnValue({
-        id: 'test-user-id',
-        platform: 'testCRM'
-      });
-
-      UserModel.findByPk.mockResolvedValue(mockUser);
-      connectorRegistry.getConnector.mockReturnValue(mockConnector);
-
-      // Act
-      const result = await logout.execute({
-        jwtToken: 'mock-jwt-token'
-      });
-
-      // Assert — local session is cleared; CRM revoke errors are logged only
-      expect(result.success).toBe(true);
-      expect(result.data.message).toContain('IMPORTANT');
-      expect(mockConnector.unAuthorize).toHaveBeenCalled();
-      expect(consoleSpy).toHaveBeenCalled();
-      consoleSpy.mockRestore();
-    });
-
-    test('should handle invalid JWT token', async () => {
-      // Arrange
-      jwt.decodeJwt.mockReturnValue(null);
-
-      // Act
-      const result = await logout.execute({
-        jwtToken: 'invalid-token'
-      });
-
-      // Assert
-      expect(result.success).toBe(false);
-      expect(result.error).toBeDefined();
-    });
-
-    test('should succeed when platform connector is missing (unAuthorize skipped)', async () => {
-      // Arrange
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
-      const mockUser = {
-        id: 'test-user-id',
-        platform: 'unknownCRM'
-      };
-
-      jwt.decodeJwt.mockReturnValue({
-        id: 'test-user-id',
-        platform: 'unknownCRM'
-      });
-
-      UserModel.findByPk.mockResolvedValue(mockUser);
-      connectorRegistry.getConnector.mockReturnValue(null);
-
-      // Act
-      const result = await logout.execute({
-        jwtToken: 'mock-jwt-token'
-      });
-
-      // Assert — null connector throws on unAuthorize; error is caught, logout still succeeds locally
-      expect(result.success).toBe(true);
-      expect(result.data.message).toContain('IMPORTANT');
-      expect(consoleSpy).toHaveBeenCalled();
-      consoleSpy.mockRestore();
-    });
-
-    test('should clear both CRM user and RC extension session rows when rcExtensionId is provided', async () => {
-      const mockUser = {
-        id: 'test-user-id',
-        platform: 'testCRM'
-      };
-
-      jwt.decodeJwt.mockReturnValue({
-        id: 'test-user-id',
-        platform: 'testCRM'
-      });
-      UserModel.findByPk.mockResolvedValue(mockUser);
-      connectorRegistry.getConnector.mockReturnValue({
-        unAuthorize: jest.fn().mockResolvedValue({})
-      });
-
-      const result = await logout.execute({
-        jwtToken: 'mock-jwt-token',
-        rcExtensionId: 'rc-ext-123'
-      });
-
-      expect(result.success).toBe(true);
-      expect(LlmSessionModel.destroy).toHaveBeenNthCalledWith(1, { where: { id: 'test-user-id' } });
-      expect(LlmSessionModel.destroy).toHaveBeenNthCalledWith(2, { where: { id: 'rc-ext-123' } });
-    });
-
-    test('should clear the resolved rcExtension cache for the current OpenAI session on logout', async () => {
-      const mockUser = {
-        id: 'test-user-id',
-        platform: 'testCRM'
-      };
-
-      jwt.decodeJwt.mockReturnValue({
-        id: 'test-user-id',
-        platform: 'testCRM'
-      });
-      UserModel.findByPk.mockResolvedValue(mockUser);
-      connectorRegistry.getConnector.mockReturnValue({
-        unAuthorize: jest.fn().mockResolvedValue({})
-      });
-
-      const result = await logout.execute({
-        jwtToken: 'mock-jwt-token',
-        openaiSessionId: 'oa-session-123'
-      });
-
-      expect(result.success).toBe(true);
-      expect(CacheModel.destroy).toHaveBeenCalledWith({
-        where: { id: 'oa-session-123-rcExtensionId' }
-      });
-    });
-  });
-});
-

package/test/mcp/tools/rcGetCallLogs.test.js

@@ -1,56 +0,0 @@
-const rcGetCallLogs = require('../../../mcp/tools/rcGetCallLogs');
-const jwt = require('../../../lib/jwt');
-const { RingCentral } = require('../../../lib/ringcentral');
-
-jest.mock('../../../lib/jwt');
-jest.mock('../../../lib/ringcentral', () => ({
-  RingCentral: jest.fn()
-}));
-
-describe('MCP Tool: rcGetCallLogs', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-    process.env.RINGCENTRAL_SERVER = 'https://platform.ringcentral.com';
-    process.env.RINGCENTRAL_CLIENT_ID = 'client-id';
-    process.env.RINGCENTRAL_CLIENT_SECRET = 'client-secret';
-    process.env.APP_SERVER = 'https://app.example.com';
-  });
-
-  test('should have correct tool definition', () => {
-    expect(rcGetCallLogs.definition).toBeDefined();
-    expect(rcGetCallLogs.definition.name).toBe('rcGetCallLogs');
-  });
-
-  test('should return call logs successfully', async () => {
-    jwt.decodeJwt.mockReturnValue({ id: 'user-123' });
-    const getCallLogData = jest.fn().mockResolvedValue({ records: [{ id: '1' }] });
-    RingCentral.mockImplementation(() => ({ getCallLogData }));
-
-    const result = await rcGetCallLogs.execute({
-      jwtToken: 'mock-jwt',
-      rcAccessToken: 'rc-token',
-      timeFrom: '2026-04-01T00:00:00.000Z',
-      timeTo: '2026-04-02T00:00:00.000Z'
-    });
-
-    expect(result).toEqual({ records: [{ id: '1' }] });
-    expect(getCallLogData).toHaveBeenCalledWith({
-      token: { access_token: 'rc-token', token_type: 'Bearer' },
-      timeFrom: '2026-04-01T00:00:00.000Z',
-      timeTo: '2026-04-02T00:00:00.000Z'
-    });
-  });
-
-  test('should return error when decodeJwt returns null', async () => {
-    jwt.decodeJwt.mockReturnValue(null);
-
-    const result = await rcGetCallLogs.execute({
-      jwtToken: 'bad-jwt',
-      rcAccessToken: 'rc-token'
-    });
-
-    expect(result.success).toBe(false);
-    expect(result.error).toContain('Invalid JWT token');
-  });
-});
-