@app-connect/core 1.7.18 → 1.7.20

package/mcp/ui/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@app-connect/mcp-ui",
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@openai/apps-sdk-ui": "^0.2.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1"
+  },
+  "devDependencies": {
+    "@tailwindcss/vite": "^4.0.0",
+    "@types/react": "^18.3.12",
+    "@types/react-dom": "^18.3.1",
+    "@vitejs/plugin-react": "^4.3.4",
+    "tailwindcss": "^4.0.0",
+    "typescript": "^5.6.3",
+    "vite": "^6.0.1",
+    "vite-plugin-singlefile": "^2.3.0"
+  }
+}

package/mcp/ui/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "types": []
+  },
+  "include": ["App"]
+}
+

package/mcp/ui/vite.config.ts

@@ -0,0 +1,16 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+import tailwindcss from '@tailwindcss/vite'
+import { viteSingleFile } from 'vite-plugin-singlefile'
+
+export default defineConfig({
+  plugins: [
+    react(),
+    tailwindcss(),
+    viteSingleFile(),
+  ],
+  build: {
+    outDir: 'dist',
+  }
+})
+

package/models/llmSessionModel.js

@@ -0,0 +1,14 @@
+const Sequelize = require('sequelize');
+const { sequelize } = require('./sequelize');
+
+// Model for Admin data
+exports.LlmSessionModel = sequelize.define('llmSessions', {
+    // LLM session ID
+    id: {
+        type: Sequelize.STRING,
+        primaryKey: true,
+    },
+    jwtToken: {
+        type: Sequelize.STRING,
+    }
+});

package/models/userModel.js

@@ -36,6 +36,9 @@ exports.UserModel = sequelize.define('users', {
   platformAdditionalInfo: {
     type: Sequelize.JSON
   },
+  hashedRcExtensionId: {
+    type: Sequelize.STRING,
+  },
   userSettings: {
     type: Sequelize.JSON
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@app-connect/core",
-  "version": "1.7.18",
+  "version": "1.7.20",
   "description": "RingCentral App Connect Core",
   "main": "index.js",
   "repository": {
@@ -25,7 +25,7 @@
     "@aws-sdk/client-dynamodb": "^3.751.0",
     "@aws-sdk/client-s3": "^3.947.0",
     "@aws-sdk/s3-request-presigner": "^3.947.0",
-    "@modelcontextprotocol/sdk": "^1.21.1",
+    "@modelcontextprotocol/sdk": "^1.26.0",
     "awesome-phonenumber": "^5.6.0",
     "body-parser": "^1.20.4",
     "body-parser-xml": "^2.0.5",

package/releaseNotes.json

@@ -1,4 +1,28 @@
 {
+    "1.7.20": {
+        "global": [
+            {
+                "type": "Fix",
+                "description": "Click-to-dial not detecting numbers in input fields"
+            },
+            {
+                "type": "Fix",
+                "description": "Warm transfer call logging issue"
+            }
+        ]
+    },
+    "1.7.19": {
+        "global": [
+            {
+                "type": "Beta",
+                "description": "Plugin system infrastructure. No plugin available yet, but add soon. Take a quick look at its [overview](https://appconnect.labs.ringcentral.com/users/plugins)"
+            },
+            {
+                "type": "Better",
+                "description": "Click-to-dial with wider number match"
+            }
+        ]
+    },
     "1.7.18": {
         "global": [
             {

package/test/handlers/auth.test.js

@@ -501,6 +501,7 @@ describe('Auth Handler', () => {
   describe('getLicenseStatus', () => {
     test('should return license status from platform module', async () => {
       // Arrange
+      const mockUser = global.testUtils.createMockUser({ id: 'user-123' });
       const mockLicenseStatus = {
         isValid: true,
         expiresAt: '2025-12-31',
@@ -513,6 +514,9 @@ describe('Auth Handler', () => {
 
       connectorRegistry.getConnector.mockReturnValue(mockConnector);
 
+      const { UserModel } = require('../../models/userModel');
+      jest.spyOn(UserModel, 'findByPk').mockResolvedValue(mockUser);
+
       // Act
       const result = await authHandler.getLicenseStatus({
         userId: 'user-123',
@@ -523,8 +527,35 @@ describe('Auth Handler', () => {
       expect(result).toEqual(mockLicenseStatus);
       expect(mockConnector.getLicenseStatus).toHaveBeenCalledWith({
         userId: 'user-123',
+        platform: 'testCRM',
+        user: mockUser
+      });
+    });
+
+    test('should return invalid license status when user not found', async () => {
+      // Arrange
+      const mockConnector = global.testUtils.createMockConnector({
+        getLicenseStatus: jest.fn()
+      });
+      connectorRegistry.getConnector.mockReturnValue(mockConnector);
+
+      const { UserModel } = require('../../models/userModel');
+      jest.spyOn(UserModel, 'findByPk').mockResolvedValue(null);
+
+      // Act
+      const result = await authHandler.getLicenseStatus({
+        userId: 'missing-user',
         platform: 'testCRM'
       });
+
+      // Assert
+      expect(result).toEqual({
+        isLicenseValid: false,
+        licenseStatus: 'Invalid (User not found)',
+        licenseStatusDescription: ''
+      });
+      expect(connectorRegistry.getConnector).not.toHaveBeenCalled();
+      expect(mockConnector.getLicenseStatus).not.toHaveBeenCalled();
     });
   });
 

package/test/handlers/plugin.test.js

@@ -0,0 +1,287 @@
+// Use in-memory SQLite for isolated model tests
+jest.mock('../../models/sequelize', () => {
+  const { Sequelize } = require('sequelize');
+  return {
+    sequelize: new Sequelize({
+      dialect: 'sqlite',
+      storage: ':memory:',
+      logging: false,
+    }),
+  };
+});
+
+const pluginHandler = require('../../handlers/plugin');
+const { CacheModel } = require('../../models/cacheModel');
+const { sequelize } = require('../../models/sequelize');
+
+describe('Plugin Handler', () => {
+  beforeAll(async () => {
+    await CacheModel.sync({ force: true });
+  });
+
+  afterEach(async () => {
+    await CacheModel.destroy({ where: {} });
+    jest.clearAllMocks();
+  });
+
+  afterAll(async () => {
+    await sequelize.close();
+  });
+
+  describe('getPluginAsyncTasks', () => {
+    test('should retrieve async task status by IDs from CacheModel', async () => {
+      // Arrange
+      await CacheModel.create({
+        id: 'user-123-task-1',
+        status: 'processing',
+        userId: 'user-123',
+        cacheKey: 'pluginTask-googleDrive'
+      });
+      await CacheModel.create({
+        id: 'user-123-task-2',
+        status: 'completed',
+        userId: 'user-123',
+        cacheKey: 'pluginTask-piiRedaction'
+      });
+
+      // Act
+      const result = await pluginHandler.getPluginAsyncTasks({
+        asyncTaskIds: ['user-123-task-1', 'user-123-task-2']
+      });
+
+      // Assert
+      expect(result).toHaveLength(2);
+      expect(result).toContainEqual({ cacheKey: 'pluginTask-googleDrive', status: 'processing' });
+      expect(result).toContainEqual({ cacheKey: 'pluginTask-piiRedaction', status: 'completed' });
+    });
+
+    test('should return empty array when no matching tasks found', async () => {
+      // Arrange - no tasks created
+
+      // Act
+      const result = await pluginHandler.getPluginAsyncTasks({
+        asyncTaskIds: ['non-existent-task-1', 'non-existent-task-2']
+      });
+
+      // Assert
+      expect(result).toEqual([]);
+    });
+
+    test('should filter and return only tasks with matching IDs', async () => {
+      // Arrange
+      await CacheModel.create({
+        id: 'user-123-task-1',
+        status: 'processing',
+        userId: 'user-123',
+        cacheKey: 'pluginTask-googleDrive'
+      });
+      await CacheModel.create({
+        id: 'user-456-task-2',
+        status: 'completed',
+        userId: 'user-456',
+        cacheKey: 'pluginTask-piiRedaction'
+      });
+      await CacheModel.create({
+        id: 'user-789-task-3',
+        status: 'failed',
+        userId: 'user-789',
+        cacheKey: 'pluginTask-other'
+      });
+
+      // Act - only request tasks for user-123 and user-789
+      const result = await pluginHandler.getPluginAsyncTasks({
+        asyncTaskIds: ['user-123-task-1', 'user-789-task-3']
+      });
+
+      // Assert
+      expect(result).toHaveLength(2);
+      expect(result).toContainEqual({ cacheKey: 'pluginTask-googleDrive', status: 'processing' });
+      expect(result).toContainEqual({ cacheKey: 'pluginTask-other', status: 'failed' });
+      expect(result).not.toContainEqual(expect.objectContaining({ cacheKey: 'pluginTask-piiRedaction' }));
+    });
+
+    test('should automatically remove completed tasks from cache after retrieval', async () => {
+      // Arrange
+      await CacheModel.create({
+        id: 'user-123-completed-task',
+        status: 'completed',
+        userId: 'user-123',
+        cacheKey: 'pluginTask-googleDrive'
+      });
+
+      // Act
+      const result = await pluginHandler.getPluginAsyncTasks({
+        asyncTaskIds: ['user-123-completed-task']
+      });
+
+      // Assert - result should contain the task
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({ cacheKey: 'pluginTask-googleDrive', status: 'completed' });
+
+      // Verify task was removed from cache
+      const remainingTask = await CacheModel.findByPk('user-123-completed-task');
+      expect(remainingTask).toBeNull();
+    });
+
+    test('should automatically remove failed tasks from cache after retrieval', async () => {
+      // Arrange
+      await CacheModel.create({
+        id: 'user-123-failed-task',
+        status: 'failed',
+        userId: 'user-123',
+        cacheKey: 'pluginTask-piiRedaction'
+      });
+
+      // Act
+      const result = await pluginHandler.getPluginAsyncTasks({
+        asyncTaskIds: ['user-123-failed-task']
+      });
+
+      // Assert - result should contain the task
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({ cacheKey: 'pluginTask-piiRedaction', status: 'failed' });
+
+      // Verify task was removed from cache
+      const remainingTask = await CacheModel.findByPk('user-123-failed-task');
+      expect(remainingTask).toBeNull();
+    });
+
+    test('should preserve pending tasks in cache after retrieval', async () => {
+      // Arrange
+      await CacheModel.create({
+        id: 'user-123-pending-task',
+        status: 'pending',
+        userId: 'user-123',
+        cacheKey: 'pluginTask-googleDrive'
+      });
+
+      // Act
+      const result = await pluginHandler.getPluginAsyncTasks({
+        asyncTaskIds: ['user-123-pending-task']
+      });
+
+      // Assert - result should contain the task
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({ cacheKey: 'pluginTask-googleDrive', status: 'pending' });
+
+      // Verify task was NOT removed from cache
+      const remainingTask = await CacheModel.findByPk('user-123-pending-task');
+      expect(remainingTask).not.toBeNull();
+      expect(remainingTask.status).toBe('pending');
+    });
+
+    test('should preserve processing tasks in cache after retrieval', async () => {
+      // Arrange
+      await CacheModel.create({
+        id: 'user-123-processing-task',
+        status: 'processing',
+        userId: 'user-123',
+        cacheKey: 'pluginTask-piiRedaction'
+      });
+
+      // Act
+      const result = await pluginHandler.getPluginAsyncTasks({
+        asyncTaskIds: ['user-123-processing-task']
+      });
+
+      // Assert - result should contain the task
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({ cacheKey: 'pluginTask-piiRedaction', status: 'processing' });
+
+      // Verify task was NOT removed from cache
+      const remainingTask = await CacheModel.findByPk('user-123-processing-task');
+      expect(remainingTask).not.toBeNull();
+      expect(remainingTask.status).toBe('processing');
+    });
+
+    test('should handle mixed task statuses - remove completed/failed but preserve pending/processing', async () => {
+      // Arrange
+      await CacheModel.create({
+        id: 'task-completed',
+        status: 'completed',
+        userId: 'user-123',
+        cacheKey: 'pluginTask-1'
+      });
+      await CacheModel.create({
+        id: 'task-failed',
+        status: 'failed',
+        userId: 'user-123',
+        cacheKey: 'pluginTask-2'
+      });
+      await CacheModel.create({
+        id: 'task-pending',
+        status: 'pending',
+        userId: 'user-123',
+        cacheKey: 'pluginTask-3'
+      });
+      await CacheModel.create({
+        id: 'task-processing',
+        status: 'processing',
+        userId: 'user-123',
+        cacheKey: 'pluginTask-4'
+      });
+
+      // Act
+      const result = await pluginHandler.getPluginAsyncTasks({
+        asyncTaskIds: ['task-completed', 'task-failed', 'task-pending', 'task-processing']
+      });
+
+      // Assert - all tasks should be in result
+      expect(result).toHaveLength(4);
+
+      // Verify completed and failed tasks were removed
+      expect(await CacheModel.findByPk('task-completed')).toBeNull();
+      expect(await CacheModel.findByPk('task-failed')).toBeNull();
+
+      // Verify pending and processing tasks were preserved
+      expect(await CacheModel.findByPk('task-pending')).not.toBeNull();
+      expect(await CacheModel.findByPk('task-processing')).not.toBeNull();
+    });
+
+    test('should handle empty asyncTaskIds array', async () => {
+      // Arrange
+      await CacheModel.create({
+        id: 'some-task',
+        status: 'completed',
+        userId: 'user-123',
+        cacheKey: 'pluginTask-test'
+      });
+
+      // Act
+      const result = await pluginHandler.getPluginAsyncTasks({
+        asyncTaskIds: []
+      });
+
+      // Assert
+      expect(result).toEqual([]);
+
+      // Verify existing task was not touched
+      const existingTask = await CacheModel.findByPk('some-task');
+      expect(existingTask).not.toBeNull();
+    });
+
+    test('should preserve initialized status tasks in cache', async () => {
+      // Arrange
+      await CacheModel.create({
+        id: 'user-123-initialized-task',
+        status: 'initialized',
+        userId: 'user-123',
+        cacheKey: 'pluginTask-googleDrive'
+      });
+
+      // Act
+      const result = await pluginHandler.getPluginAsyncTasks({
+        asyncTaskIds: ['user-123-initialized-task']
+      });
+
+      // Assert
+      expect(result).toHaveLength(1);
+      expect(result[0]).toEqual({ cacheKey: 'pluginTask-googleDrive', status: 'initialized' });
+
+      // Verify task was NOT removed from cache
+      const remainingTask = await CacheModel.findByPk('user-123-initialized-task');
+      expect(remainingTask).not.toBeNull();
+    });
+  });
+});
+