@app-connect/core 1.7.24 → 1.7.26

package/mcp/tools/cancelAppointment.js

@@ -0,0 +1,101 @@
+const jwt = require('../../lib/jwt');
+const connectorRegistry = require('../../connector/registry');
+const appointmentCore = require('../../handlers/appointment');
+
+/**
+ * MCP Tool: Cancel Appointment
+ *
+ * Cancels (deletes) an existing appointment/event in the CRM platform.
+ */
+
+const toolDefinition = {
+    name: 'cancelAppointment',
+    description: '⚠️ REQUIRES CRM CONNECTION. | Cancel an existing appointment or event in the CRM platform by its ID. This action is destructive — the appointment will be removed.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            appointmentId: {
+                type: 'string',
+                description: 'The CRM appointment or event ID to cancel.'
+            }
+        },
+        required: ['appointmentId']
+    },
+    annotations: {
+        readOnlyHint: false,
+        openWorldHint: true,
+        destructiveHint: true
+    }
+};
+
+/**
+ * Execute the cancelAppointment tool
+ * @param {Object} args
+ * @param {string} args.jwtToken - Injected server-side JWT token
+ * @param {string} args.appointmentId - CRM appointment ID to cancel
+ * @returns {Object} Result with cancelled appointment data
+ */
+async function execute(args) {
+    try {
+        const { jwtToken, appointmentId } = args;
+
+        if (!jwtToken) {
+            throw new Error('Please go to Settings and authorize CRM platform');
+        }
+
+        if (!appointmentId) {
+            throw new Error('appointmentId is required');
+        }
+
+        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');
+        }
+
+        const platformModule = connectorRegistry.getConnector(platform);
+        if (!platformModule) {
+            throw new Error(`Platform connector not found for: ${platform}`);
+        }
+
+        if (!platformModule.cancelAppointment) {
+            throw new Error(`cancelAppointment is not implemented for platform: ${platform}`);
+        }
+
+        const { successful, appointment, returnMessage } = await appointmentCore.cancelAppointment({
+            platform,
+            userId,
+            appointmentId
+        });
+
+        if (successful) {
+            return {
+                success: true,
+                data: {
+                    appointment,
+                    message: returnMessage?.message || 'Appointment cancelled successfully'
+                }
+            };
+        }
+        else {
+            return {
+                success: false,
+                error: returnMessage?.message || 'Failed to cancel appointment'
+            };
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error.message || 'Unknown error occurred',
+            errorDetails: error.stack
+        };
+    }
+}
+
+exports.definition = toolDefinition;
+exports.execute = execute;

package/mcp/tools/checkAuthStatus.js

@@ -1,105 +1,105 @@
-const { getAuthSession } = require('../../lib/authSession');
-const { LlmSessionModel } = require('../../models/llmSessionModel');
-
-/**
- * MCP Tool: Check Auth Status
- *
- * Polls the status of an ongoing OAuth authentication session
- */
-
-const toolDefinition = {
-    name: 'checkAuthStatus',
-    description: 'Check the status of an ongoing OAuth authentication session. Poll this after user clicks the auth link.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            sessionId: {
-                type: 'string',
-                description: 'The session ID returned from doAuth tool'
-            },
-        },
-        required: ['sessionId']
-    },
-    annotations: {
-        readOnlyHint: true,
-        openWorldHint: false,
-        destructiveHint: false
-    }
-};
-
-/**
- * Execute the checkAuthStatus tool
- * @param {Object} args - The tool arguments
- * @param {string} args.sessionId - The session ID to check
- * @param {string} args.rcExtensionId - The RC extension ID
- * @returns {Object} Result object with authentication status
- */
-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
-        // RC identity.
-        const { sessionId, rcExtensionId } = args;
-        if (!rcExtensionId) {
-            throw new Error('rcExtensionId is required');
-        }
-        const session = await getAuthSession(sessionId);
-
-        if (!session) {
-            return {
-                success: false,
-                error: 'CRM auth session not found or expired. Ask the user to start the auth flow again.'
-            };
-        }
-
-        switch (session.status) {
-            case 'completed':
-                await LlmSessionModel.upsert({
-                    id: rcExtensionId,
-                    jwtToken: session.jwtToken,
-                    expiry: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000)
-                });
-                return {
-                    data: {
-                        status: 'completed',
-                        jwtToken: session.jwtToken,
-                        userInfo: session.userInfo,
-                        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 {
-                    data: {
-                        status: 'failed',
-                        errorMessage: session.errorMessage || 'Unknown error'
-                    }
-                };
-
-            case 'pending':
-            default:
-                return {
-                    data: {
-                        status: 'pending'
-                    }
-                };
-        }
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: `CRM auth status check error: ${error.message}`
-        };
-    }
-}
-
-exports.definition = toolDefinition;
-exports.execute = execute;
+const { getAuthSession } = require('../../lib/authSession');
+const { LlmSessionModel } = require('../../models/llmSessionModel');
+
+/**
+ * MCP Tool: Check Auth Status
+ *
+ * Polls the status of an ongoing OAuth authentication session
+ */
+
+const toolDefinition = {
+    name: 'checkAuthStatus',
+    description: 'Check the status of an ongoing OAuth authentication session. Poll this after user clicks the auth link.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            sessionId: {
+                type: 'string',
+                description: 'The session ID returned from doAuth tool'
+            },
+        },
+        required: ['sessionId']
+    },
+    annotations: {
+        readOnlyHint: true,
+        openWorldHint: false,
+        destructiveHint: false
+    }
+};
+
+/**
+ * Execute the checkAuthStatus tool
+ * @param {Object} args - The tool arguments
+ * @param {string} args.sessionId - The session ID to check
+ * @param {string} args.rcExtensionId - The RC extension ID
+ * @returns {Object} Result object with authentication status
+ */
+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
+        // RC identity.
+        const { sessionId, rcExtensionId } = args;
+        if (!rcExtensionId) {
+            throw new Error('rcExtensionId is required');
+        }
+        const session = await getAuthSession(sessionId);
+
+        if (!session) {
+            return {
+                success: false,
+                error: 'CRM auth session not found or expired. Ask the user to start the auth flow again.'
+            };
+        }
+
+        switch (session.status) {
+            case 'completed':
+                await LlmSessionModel.upsert({
+                    id: rcExtensionId,
+                    jwtToken: session.jwtToken,
+                    expiry: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000)
+                });
+                return {
+                    data: {
+                        status: 'completed',
+                        jwtToken: session.jwtToken,
+                        userInfo: session.userInfo,
+                        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 {
+                    data: {
+                        status: 'failed',
+                        errorMessage: session.errorMessage || 'Unknown error'
+                    }
+                };
+
+            case 'pending':
+            default:
+                return {
+                    data: {
+                        status: 'pending'
+                    }
+                };
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `CRM auth status check error: ${error.message}`
+        };
+    }
+}
+
+exports.definition = toolDefinition;
+exports.execute = execute;

package/mcp/tools/confirmAppointment.js

@@ -0,0 +1,101 @@
+const jwt = require('../../lib/jwt');
+const connectorRegistry = require('../../connector/registry');
+const appointmentCore = require('../../handlers/appointment');
+
+/**
+ * MCP Tool: Confirm Appointment
+ *
+ * Marks an existing appointment/event as confirmed in the CRM platform.
+ */
+
+const toolDefinition = {
+    name: 'confirmAppointment',
+    description: '⚠️ REQUIRES CRM CONNECTION. | Confirm an existing appointment or event in the CRM platform by its ID. Returns the updated appointment details.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            appointmentId: {
+                type: 'string',
+                description: 'The CRM appointment or event ID to confirm.'
+            }
+        },
+        required: ['appointmentId']
+    },
+    annotations: {
+        readOnlyHint: false,
+        openWorldHint: true,
+        destructiveHint: false
+    }
+};
+
+/**
+ * Execute the confirmAppointment tool
+ * @param {Object} args
+ * @param {string} args.jwtToken - Injected server-side JWT token
+ * @param {string} args.appointmentId - CRM appointment ID to confirm
+ * @returns {Object} Result with updated appointment data
+ */
+async function execute(args) {
+    try {
+        const { jwtToken, appointmentId } = args;
+
+        if (!jwtToken) {
+            throw new Error('Please go to Settings and authorize CRM platform');
+        }
+
+        if (!appointmentId) {
+            throw new Error('appointmentId is required');
+        }
+
+        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');
+        }
+
+        const platformModule = connectorRegistry.getConnector(platform);
+        if (!platformModule) {
+            throw new Error(`Platform connector not found for: ${platform}`);
+        }
+
+        if (!platformModule.confirmAppointment) {
+            throw new Error(`confirmAppointment is not implemented for platform: ${platform}`);
+        }
+
+        const { successful, appointment, returnMessage } = await appointmentCore.confirmAppointment({
+            platform,
+            userId,
+            appointmentId
+        });
+
+        if (successful) {
+            return {
+                success: true,
+                data: {
+                    appointment,
+                    message: returnMessage?.message || 'Appointment confirmed successfully'
+                }
+            };
+        }
+        else {
+            return {
+                success: false,
+                error: returnMessage?.message || 'Failed to confirm appointment'
+            };
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error.message || 'Unknown error occurred',
+            errorDetails: error.stack
+        };
+    }
+}
+
+exports.definition = toolDefinition;
+exports.execute = execute;

package/mcp/tools/createAppointment.js

@@ -0,0 +1,157 @@
+const jwt = require('../../lib/jwt');
+const connectorRegistry = require('../../connector/registry');
+const appointmentCore = require('../../handlers/appointment');
+
+/**
+ * MCP Tool: Create Appointment
+ *
+ * Creates a new appointment/event in the CRM platform.
+ */
+
+const toolDefinition = {
+    name: 'createAppointment',
+    description: '⚠️ REQUIRES CRM CONNECTION. | Create a new appointment or event in the CRM platform. Returns the created appointment ID and details.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            title: {
+                type: 'string',
+                description: 'Title or subject of the appointment (e.g. "Client Meeting").'
+            },
+            summary: {
+                type: 'string',
+                description: 'Description or notes for the appointment.'
+            },
+            startTimeUtc: {
+                type: 'string',
+                description: 'Start date and time in ISO 8601 UTC format (e.g. "2026-05-10T14:00:00Z").'
+            },
+            durationMinutes: {
+                type: 'number',
+                description: 'Duration of the appointment in minutes (e.g. 60 for one hour).'
+            },
+            contacts: {
+                type: 'array',
+                description: 'List of CRM contact IDs to invite as attendees. Each item should be a contact ID string or an object with an "id" field.',
+                items: {
+                    oneOf: [
+                        {
+                            type: 'string',
+                            description: 'CRM contact ID'
+                        },
+                        {
+                            type: 'object',
+                            description: 'Contact object with id field',
+                            properties: {
+                                id: {
+                                    type: 'string',
+                                    description: 'CRM contact ID'
+                                }
+                            },
+                            required: ['id']
+                        }
+                    ]
+                }
+            }
+        },
+        required: ['title', 'startTimeUtc', 'durationMinutes']
+    },
+    annotations: {
+        readOnlyHint: false,
+        openWorldHint: true,
+        destructiveHint: false
+    }
+};
+
+/**
+ * Execute the createAppointment tool
+ * @param {Object} args
+ * @param {string} args.jwtToken - Injected server-side JWT token
+ * @param {string} args.title - Appointment title
+ * @param {string} [args.summary] - Appointment description
+ * @param {string} args.startTimeUtc - ISO 8601 UTC start time
+ * @param {number} args.durationMinutes - Duration in minutes
+ * @param {Array} [args.contacts] - List of contact IDs or contact objects to invite
+ * @returns {Object} Result with created appointment ID and data
+ */
+async function execute(args) {
+    try {
+        const { jwtToken, title, summary, startTimeUtc, durationMinutes, contacts } = args;
+
+        if (!jwtToken) {
+            throw new Error('Please go to Settings and authorize CRM platform');
+        }
+
+        if (!title) {
+            throw new Error('title is required');
+        }
+
+        if (!startTimeUtc) {
+            throw new Error('startTimeUtc is required (ISO 8601 UTC format, e.g. "2026-05-10T14:00:00Z")');
+        }
+
+        if (durationMinutes == null) {
+            throw new Error('durationMinutes is required');
+        }
+
+        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');
+        }
+
+        const platformModule = connectorRegistry.getConnector(platform);
+        if (!platformModule) {
+            throw new Error(`Platform connector not found for: ${platform}`);
+        }
+
+        if (!platformModule.createAppointment) {
+            throw new Error(`createAppointment is not implemented for platform: ${platform}`);
+        }
+
+        const payload = {
+            title,
+            summary: summary ?? '',
+            startTimeUtc,
+            durationMinutes: Number(durationMinutes),
+            contacts: contacts ?? []
+        };
+
+        const { successful, appointmentId, appointment, returnMessage } = await appointmentCore.createAppointment({
+            platform,
+            userId,
+            payload
+        });
+
+        if (successful) {
+            return {
+                success: true,
+                data: {
+                    appointmentId,
+                    appointment,
+                    message: returnMessage?.message || 'Appointment created successfully'
+                }
+            };
+        }
+        else {
+            return {
+                success: false,
+                error: returnMessage?.message || 'Failed to create appointment'
+            };
+        }
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error.message || 'Unknown error occurred',
+            errorDetails: error.stack
+        };
+    }
+}
+
+exports.definition = toolDefinition;
+exports.execute = execute;