@app-connect/core 1.7.18 → 1.7.20

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

@@ -21,8 +21,8 @@ describe('MCP Tool: logout', () => {
       expect(logout.definition.inputSchema).toBeDefined();
     });
 
-    test('should have jwtToken property', () => {
-      expect(logout.definition.inputSchema.properties).toHaveProperty('jwtToken');
+    test('should have empty properties (jwtToken is server-injected, not in schema)', () => {
+      expect(logout.definition.inputSchema.properties).toEqual({});
     });
   });
 
@@ -94,8 +94,9 @@ describe('MCP Tool: logout', () => {
       });
     });
 
-    test('should handle logout errors gracefully', async () => {
+    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'
@@ -120,10 +121,12 @@ describe('MCP Tool: logout', () => {
         jwtToken: 'mock-jwt-token'
       });
 
-      // Assert
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('Logout API failed');
-      expect(result.errorDetails).toBeDefined();
+      // 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 () => {
@@ -140,8 +143,9 @@ describe('MCP Tool: logout', () => {
       expect(result.error).toBeDefined();
     });
 
-    test('should handle missing platform connector', async () => {
+    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'
@@ -160,9 +164,11 @@ describe('MCP Tool: logout', () => {
         jwtToken: 'mock-jwt-token'
       });
 
-      // Assert
-      expect(result.success).toBe(false);
-      expect(result.error).toBeDefined();
+      // 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();
     });
   });
 });

package/mcp/SupportedPlatforms.md

@@ -1,12 +0,0 @@
-# Supported platforms
-
-- Clio
-- Insightly
-- Redtail
-- NetSuite
-
-# Unsupported platforms
-
-- Bullhorn (unique OAuth)
-- Pipedrive (unique OAuth)
-- Google Sheets (extra sheet config)

package/mcp/tools/collectAuthInfo.js

@@ -1,91 +0,0 @@
-/**
- * MCP Tool: User Authentication
- * 
- * This tool authenticates the user with the CRM platform.
- * It uses the platform-specific connector to authenticate the user.
- */
-
-const { isManifestValid } = require('../lib/validator');
-
-const toolDefinition = {
-    name: 'collectAuthInfo',
-    description: '(This step is skipped if auth type is "apiKey" or environment type is "fixed", this is a MUST if environment type is "dynamic" or "selectable") Auth flow step.3. Get information that is required for authentication. Next step is calling step.4 "doAuth" tool.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            connectorManifest: {
-                type: 'object',
-                description: 'connectorManifest variable from above conversation. Must be the full manifest object, not just serverUrl'
-            },
-            hostname: {
-                type: 'string',
-                description: 'For "dynamic" type environment. User is to login to CRM account then copy and paste the hostname over here.'
-            },
-            selection: {
-                type: 'string',
-                description: 'For "selectable" type environment. User is to select a name (NOT value) of the options from the selectable list'
-            },
-            connectorName: {
-                type: 'string',
-                description: 'connectorName variable from above conversation.'
-            }
-        },
-        required: ['connectorManifest', 'connectorName']
-    },
-    annotations: {
-        readOnlyHint: true,
-        openWorldHint: false,
-        destructiveHint: false
-    }
-};
-
-/**
- * Execute the collectAuthInfo tool
- * @param {Object} args - The tool arguments
- * @param {string} args.connectorManifest - Connector manifest from conversation or memory.
- * @param {string} args.hostname - For "dynamic" type environment. User is to login to CRM account then copy and paste the hostname over here.
- * @param {string} args.selection - For "selectable" type environment. User is to select a name (NOT value) of the options from the selectable list
- * @param {string} args.connectorName - Connector name from conversation or memory.
- * @returns {Object} Result object with hostname or selection
- */
-async function execute(args) {
-    try {
-        const { connectorManifest, hostname, selection, connectorName } = args;
-        const { isValid, errors } = isManifestValid({ connectorManifest, connectorName });
-        if (!isValid) {
-            return {
-                success: false,
-                error: "Invalid connector manifest",
-                errorDetails: errors.join(', '),
-            }
-        }
-        let result = '';
-        switch (connectorManifest.platforms[connectorName].environment.type) {
-            case 'selectable':
-                result = connectorManifest.platforms[connectorName].environment.selections.find(s => s.name === selection).const;
-                break;
-            case 'dynamic':
-                result = hostname;
-                break;
-        }
-        const url = new URL(result);
-        return {
-            success: true,
-            data: {
-                hostname: url.hostname,
-                // Add explicit instruction
-                message: "IMPORTANT: Use hostname in the next few authentication steps.",
-            }
-        }
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: error.message || 'Unknown error occurred',
-            errorDetails: error.stack
-        };
-    }
-}
-
-exports.definition = toolDefinition;
-exports.execute = execute;

package/mcp/tools/setConnector.js

@@ -1,69 +0,0 @@
-const developerPortal = require('../../connector/developerPortal');
-
-/**
- * MCP Tool: Set Connector
- * 
- * This tool helps the user set the connector.
- */
-
-const toolDefinition = {
-    name: 'setConnector',
-    description: 'Auth flow step.2. Save connectorManifest to memory if successful.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            connectorDisplayName: {
-                type: 'string',
-                description: 'Connector displayname to set'
-            }
-        },
-        required: ['connectorDisplayName']
-    },
-    annotations: {
-        readOnlyHint: true,
-        openWorldHint: false,
-        destructiveHint: false
-    }
-};
-
-/**
- * Execute the setConnector tool
- * @param {Object} args - The tool arguments
- * @param {string} args.connectorDisplayName - Connector display name to set
- * @returns {Object} Result object with connector information
- */
-async function execute(args) {
-    try {
-        const { connectorDisplayName } = args;
-        const { connectors: publicConnectorList } = await developerPortal.getPublicConnectorList();
-        const { privateConnectors } = await developerPortal.getPrivateConnectorList();
-        const connectorList = [...publicConnectorList, ...privateConnectors];
-        const connector = connectorList.find(c => c.displayName === connectorDisplayName);
-        const connectorName = connector.name;
-        const connectorManifest = await developerPortal.getConnectorManifest({ connectorId: connector.id, isPrivate: connector.status === 'private' });
-        if (!connectorManifest) {
-            throw new Error(`Connector manifest not found: ${connectorDisplayName}`);
-        }
-        return {
-            success: true,
-            data: {
-                connectorManifest,
-                connectorDisplayName,
-                connectorName,
-                // Add explicit instruction
-                message: "IMPORTANT: Use connectorManifest, connectorDisplayName, and connectorName in the next few authentication steps. Call 'collectAuthInfo' tool if the connector is oauth, unless connectorManifest.platform[0].environment.type == 'fixed'.",
-                
-            }
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: error.message || 'Unknown error occurred',
-            errorDetails: error.stack
-        };
-    }
-}
-
-exports.definition = toolDefinition;
-exports.execute = execute;

package/test/mcp/tools/collectAuthInfo.test.js

@@ -1,234 +0,0 @@
-const collectAuthInfo = require('../../../mcp/tools/collectAuthInfo');
-
-describe('MCP Tool: collectAuthInfo', () => {
-  describe('tool definition', () => {
-    test('should have correct tool definition', () => {
-      expect(collectAuthInfo.definition).toBeDefined();
-      expect(collectAuthInfo.definition.name).toBe('collectAuthInfo');
-      expect(collectAuthInfo.definition.description).toContain('Auth flow step.3');
-      expect(collectAuthInfo.definition.inputSchema).toBeDefined();
-    });
-
-    test('should require connectorManifest and connectorName parameters', () => {
-      expect(collectAuthInfo.definition.inputSchema.required).toContain('connectorManifest');
-      expect(collectAuthInfo.definition.inputSchema.required).toContain('connectorName');
-    });
-  });
-
-  describe('execute', () => {
-    test('should handle selectable environment type', async () => {
-      // Arrange
-      const mockManifest = {
-        platforms: {
-          salesforce: {
-            name: 'salesforce',
-            auth: {
-              type: 'oauth',
-              oauth: {
-                authUrl: 'https://login.salesforce.com/services/oauth2/authorize',
-                clientId: 'test-client-id'
-              }
-            },
-            environment: {
-              type: 'selectable',
-              selections: [
-                { name: 'Production', const: 'https://login.salesforce.com' },
-                { name: 'Sandbox', const: 'https://test.salesforce.com' }
-              ]
-            }
-          }
-        }
-      };
-
-      // Act
-      const result = await collectAuthInfo.execute({
-        connectorManifest: mockManifest,
-        connectorName: 'salesforce',
-        selection: 'Production'
-      });
-
-      // Assert
-      expect(result).toEqual({
-        success: true,
-        data: {
-          hostname: 'login.salesforce.com',
-          message: expect.stringContaining('IMPORTANT')
-        }
-      });
-    });
-
-    test('should handle dynamic environment type', async () => {
-      // Arrange
-      const mockManifest = {
-        platforms: {
-          netsuite: {
-            name: 'netsuite',
-            auth: {
-              type: 'oauth',
-              oauth: {
-                authUrl: 'https://system.netsuite.com/app/login/oauth2/authorize.nl',
-                clientId: 'test-client-id'
-              }
-            },
-            environment: {
-              type: 'dynamic'
-            }
-          }
-        }
-      };
-
-      // Act
-      const result = await collectAuthInfo.execute({
-        connectorManifest: mockManifest,
-        connectorName: 'netsuite',
-        hostname: 'https://1234567.app.netsuite.com'
-      });
-
-      // Assert
-      expect(result).toEqual({
-        success: true,
-        data: {
-          hostname: '1234567.app.netsuite.com',
-          message: expect.stringContaining('IMPORTANT')
-        }
-      });
-    });
-
-    test('should handle sandbox selection', async () => {
-      // Arrange
-      const mockManifest = {
-        platforms: {
-          salesforce: {
-            name: 'salesforce',
-            auth: {
-              type: 'oauth',
-              oauth: {
-                authUrl: 'https://login.salesforce.com/services/oauth2/authorize',
-                clientId: 'test-client-id'
-              }
-            },
-            environment: {
-              type: 'selectable',
-              selections: [
-                { name: 'Production', const: 'https://login.salesforce.com' },
-                { name: 'Sandbox', const: 'https://test.salesforce.com' }
-              ]
-            }
-          }
-        }
-      };
-
-      // Act
-      const result = await collectAuthInfo.execute({
-        connectorManifest: mockManifest,
-        connectorName: 'salesforce',
-        selection: 'Sandbox'
-      });
-
-      // Assert
-      expect(result.success).toBe(true);
-      expect(result.data.hostname).toBe('test.salesforce.com');
-    });
-
-    test('should handle invalid hostname URL', async () => {
-      // Arrange
-      const mockManifest = {
-        platforms: {
-          netsuite: {
-            name: 'netsuite',
-            auth: {
-              type: 'oauth',
-              oauth: {
-                authUrl: 'https://system.netsuite.com/app/login/oauth2/authorize.nl',
-                clientId: 'test-client-id'
-              }
-            },
-            environment: {
-              type: 'dynamic'
-            }
-          }
-        }
-      };
-
-      // Act
-      const result = await collectAuthInfo.execute({
-        connectorManifest: mockManifest,
-        connectorName: 'netsuite',
-        hostname: 'invalid-url'
-      });
-
-      // Assert
-      expect(result.success).toBe(false);
-      expect(result.error).toBeDefined();
-      expect(result.errorDetails).toBeDefined();
-    });
-
-    test('should handle missing selection for selectable type', async () => {
-      // Arrange
-      const mockManifest = {
-        platforms: {
-          salesforce: {
-            name: 'salesforce',
-            auth: {
-              type: 'oauth',
-              oauth: {
-                authUrl: 'https://login.salesforce.com/services/oauth2/authorize',
-                clientId: 'test-client-id'
-              }
-            },
-            environment: {
-              type: 'selectable',
-              selections: [
-                { name: 'Production', const: 'https://login.salesforce.com' }
-              ]
-            }
-          }
-        }
-      };
-
-      // Act
-      const result = await collectAuthInfo.execute({
-        connectorManifest: mockManifest,
-        connectorName: 'salesforce',
-        selection: 'NonExistent'
-      });
-
-      // Assert
-      expect(result.success).toBe(false);
-      expect(result.error).toBeDefined();
-    });
-
-    test('should handle missing hostname for dynamic type', async () => {
-      // Arrange
-      const mockManifest = {
-        platforms: {
-          netsuite: {
-            name: 'netsuite',
-            auth: {
-              type: 'oauth',
-              oauth: {
-                authUrl: 'https://system.netsuite.com/app/login/oauth2/authorize.nl',
-                clientId: 'test-client-id'
-              }
-            },
-            environment: {
-              type: 'dynamic'
-            }
-          }
-        }
-      };
-
-      // Act
-      const result = await collectAuthInfo.execute({
-        connectorManifest: mockManifest,
-        connectorName: 'netsuite'
-        // hostname is missing
-      });
-
-      // Assert
-      expect(result.success).toBe(false);
-      expect(result.error).toBeDefined();
-    });
-  });
-});
-

package/test/mcp/tools/setConnector.test.js

@@ -1,177 +0,0 @@
-const setConnector = require('../../../mcp/tools/setConnector');
-const developerPortal = require('../../../connector/developerPortal');
-
-// Mock the developerPortal module
-jest.mock('../../../connector/developerPortal');
-
-describe('MCP Tool: setConnector', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe('tool definition', () => {
-    test('should have correct tool definition', () => {
-      expect(setConnector.definition).toBeDefined();
-      expect(setConnector.definition.name).toBe('setConnector');
-      expect(setConnector.definition.description).toContain('Auth flow step.2');
-      expect(setConnector.definition.inputSchema).toBeDefined();
-    });
-
-    test('should require connectorDisplayName parameter', () => {
-      expect(setConnector.definition.inputSchema.required).toContain('connectorDisplayName');
-    });
-  });
-
-  describe('execute', () => {
-    test('should set connector successfully', async () => {
-      // Arrange
-      const mockPublicConnectors = [
-        { id: '1', name: 'salesforce', displayName: 'Salesforce', status: 'public' }
-      ];
-      const mockPrivateConnectors = [];
-      const mockManifest = {
-        platforms: {
-          salesforce: {
-            name: 'salesforce',
-            auth: { type: 'oauth' },
-            environment: { type: 'fixed' }
-          }
-        }
-      };
-
-      developerPortal.getPublicConnectorList.mockResolvedValue({
-        connectors: mockPublicConnectors
-      });
-      developerPortal.getPrivateConnectorList.mockResolvedValue({
-        privateConnectors: mockPrivateConnectors
-      });
-      developerPortal.getConnectorManifest.mockResolvedValue(mockManifest);
-
-      // Act
-      const result = await setConnector.execute({ 
-        connectorDisplayName: 'Salesforce' 
-      });
-
-      // Assert
-      expect(result).toEqual({
-        success: true,
-        data: {
-          connectorManifest: mockManifest,
-          connectorDisplayName: 'Salesforce',
-          connectorName: 'salesforce',
-          message: expect.stringContaining('IMPORTANT')
-        }
-      });
-      expect(developerPortal.getConnectorManifest).toHaveBeenCalledWith({
-        connectorId: '1',
-        isPrivate: false
-      });
-    });
-
-    test('should handle private connector', async () => {
-      // Arrange
-      const mockPublicConnectors = [];
-      const mockPrivateConnectors = [
-        { id: '2', name: 'custom-crm', displayName: 'Custom CRM', status: 'private' }
-      ];
-      const mockManifest = {
-        platforms: {
-          'custom-crm': {
-            name: 'custom-crm',
-            auth: { type: 'apiKey' }
-          }
-        }
-      };
-
-      developerPortal.getPublicConnectorList.mockResolvedValue({
-        connectors: mockPublicConnectors
-      });
-      developerPortal.getPrivateConnectorList.mockResolvedValue({
-        privateConnectors: mockPrivateConnectors
-      });
-      developerPortal.getConnectorManifest.mockResolvedValue(mockManifest);
-
-      // Act
-      const result = await setConnector.execute({ 
-        connectorDisplayName: 'Custom CRM' 
-      });
-
-      // Assert
-      expect(result.success).toBe(true);
-      expect(result.data.connectorName).toBe('custom-crm');
-      expect(developerPortal.getConnectorManifest).toHaveBeenCalledWith({
-        connectorId: '2',
-        isPrivate: true
-      });
-    });
-
-    test('should return error when connector manifest not found', async () => {
-      // Arrange
-      const mockPublicConnectors = [
-        { id: '1', name: 'salesforce', displayName: 'Salesforce', status: 'public' }
-      ];
-      const mockPrivateConnectors = [];
-
-      developerPortal.getPublicConnectorList.mockResolvedValue({
-        connectors: mockPublicConnectors
-      });
-      developerPortal.getPrivateConnectorList.mockResolvedValue({
-        privateConnectors: mockPrivateConnectors
-      });
-      developerPortal.getConnectorManifest.mockResolvedValue(null);
-
-      // Act
-      const result = await setConnector.execute({ 
-        connectorDisplayName: 'Salesforce' 
-      });
-
-      // Assert
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Connector manifest not found');
-    });
-
-    test('should return error when connector not found in list', async () => {
-      // Arrange
-      const mockPublicConnectors = [
-        { id: '1', name: 'salesforce', displayName: 'Salesforce', status: 'public' }
-      ];
-      const mockPrivateConnectors = [];
-
-      developerPortal.getPublicConnectorList.mockResolvedValue({
-        connectors: mockPublicConnectors
-      });
-      developerPortal.getPrivateConnectorList.mockResolvedValue({
-        privateConnectors: mockPrivateConnectors
-      });
-
-      // Act
-      const result = await setConnector.execute({ 
-        connectorDisplayName: 'NonExistentCRM' 
-      });
-
-      // Assert
-      expect(result.success).toBe(false);
-      expect(result.error).toBeDefined();
-      expect(result.errorDetails).toBeDefined();
-    });
-
-    test('should handle API errors gracefully', async () => {
-      // Arrange
-      const errorMessage = 'API connection failed';
-      developerPortal.getPublicConnectorList.mockRejectedValue(
-        new Error(errorMessage)
-      );
-
-      // Act
-      const result = await setConnector.execute({ 
-        connectorDisplayName: 'Salesforce' 
-      });
-
-      // Assert
-      expect(result.success).toBe(false);
-      expect(result.error).toBe(errorMessage);
-      expect(result.errorDetails).toBeDefined();
-    });
-  });
-});
-