@rohithvemulapally/mcp-server-salesforce 0.0.6

package/dist/tools/manageField.js

@@ -0,0 +1,349 @@
+export const MANAGE_FIELD = {
+    name: "salesforce_manage_field",
+    description: `Create new custom fields or modify existing fields on any Salesforce object:
+  - Field Types: Text, Number, Date, Lookup, Master-Detail, Picklist etc.
+  - Properties: Required, Unique, External ID, Length, Scale etc.
+  - Relationships: Create lookups and master-detail relationships
+  - Automatically grants Field Level Security to System Administrator (or specified profiles)
+  Examples: Add Rating__c picklist to Account, Create Account lookup on Custom Object
+  Note: Use grantAccessTo parameter to specify profiles, defaults to System Administrator`,
+    inputSchema: {
+        type: "object",
+        properties: {
+            operation: {
+                type: "string",
+                enum: ["create", "update"],
+                description: "Whether to create new field or update existing"
+            },
+            objectName: {
+                type: "string",
+                description: "API name of the object to add/modify the field"
+            },
+            fieldName: {
+                type: "string",
+                description: "API name for the field (without __c suffix)"
+            },
+            label: {
+                type: "string",
+                description: "Label for the field",
+                optional: true
+            },
+            type: {
+                type: "string",
+                enum: ["Checkbox", "Currency", "Date", "DateTime", "Email", "Number", "Percent",
+                    "Phone", "Picklist", "MultiselectPicklist", "Text", "TextArea", "LongTextArea",
+                    "Html", "Url", "Lookup", "MasterDetail"],
+                description: "Field type (required for create)",
+                optional: true
+            },
+            required: {
+                type: "boolean",
+                description: "Whether the field is required",
+                optional: true
+            },
+            unique: {
+                type: "boolean",
+                description: "Whether the field value must be unique",
+                optional: true
+            },
+            externalId: {
+                type: "boolean",
+                description: "Whether the field is an external ID",
+                optional: true
+            },
+            length: {
+                type: "number",
+                description: "Length for text fields",
+                optional: true
+            },
+            precision: {
+                type: "number",
+                description: "Precision for numeric fields",
+                optional: true
+            },
+            scale: {
+                type: "number",
+                description: "Scale for numeric fields",
+                optional: true
+            },
+            referenceTo: {
+                type: "string",
+                description: "API name of the object to reference (for Lookup/MasterDetail)",
+                optional: true
+            },
+            relationshipLabel: {
+                type: "string",
+                description: "Label for the relationship (for Lookup/MasterDetail)",
+                optional: true
+            },
+            relationshipName: {
+                type: "string",
+                description: "API name for the relationship (for Lookup/MasterDetail)",
+                optional: true
+            },
+            deleteConstraint: {
+                type: "string",
+                enum: ["Cascade", "Restrict", "SetNull"],
+                description: "Delete constraint for Lookup fields",
+                optional: true
+            },
+            picklistValues: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        label: { type: "string" },
+                        isDefault: { type: "boolean", optional: true }
+                    }
+                },
+                description: "Values for Picklist/MultiselectPicklist fields",
+                optional: true
+            },
+            description: {
+                type: "string",
+                description: "Description of the field",
+                optional: true
+            },
+            grantAccessTo: {
+                type: "array",
+                items: { type: "string" },
+                description: "Profile names to grant field access to (defaults to ['System Administrator'])",
+                optional: true
+            }
+        },
+        required: ["operation", "objectName", "fieldName"]
+    }
+};
+// Helper function to set field permissions (simplified version of the one in manageFieldPermissions.ts)
+async function grantFieldPermissions(conn, objectName, fieldName, profileNames) {
+    try {
+        const fieldApiName = fieldName.endsWith('__c') || fieldName.includes('.') ? fieldName : `${fieldName}__c`;
+        const fullFieldName = `${objectName}.${fieldApiName}`;
+        // Get profile IDs
+        const profileQuery = await conn.query(`
+      SELECT Id, Name 
+      FROM Profile 
+      WHERE Name IN (${profileNames.map(name => `'${name}'`).join(', ')})
+    `);
+        if (profileQuery.records.length === 0) {
+            return { success: false, message: `No profiles found matching: ${profileNames.join(', ')}` };
+        }
+        const results = [];
+        const errors = [];
+        for (const profile of profileQuery.records) {
+            try {
+                // Check if permission already exists
+                const existingPerm = await conn.query(`
+          SELECT Id, PermissionsRead, PermissionsEdit
+          FROM FieldPermissions
+          WHERE ParentId IN (
+            SELECT Id FROM PermissionSet 
+            WHERE IsOwnedByProfile = true 
+            AND ProfileId = '${profile.Id}'
+          )
+          AND Field = '${fullFieldName}'
+          AND SobjectType = '${objectName}'
+          LIMIT 1
+        `);
+                if (existingPerm.records.length > 0) {
+                    // Update existing permission
+                    await conn.sobject('FieldPermissions').update({
+                        Id: existingPerm.records[0].Id,
+                        PermissionsRead: true,
+                        PermissionsEdit: true
+                    });
+                    results.push(profile.Name);
+                }
+                else {
+                    // Get the PermissionSet ID for this profile
+                    const permSetQuery = await conn.query(`
+            SELECT Id FROM PermissionSet 
+            WHERE IsOwnedByProfile = true 
+            AND ProfileId = '${profile.Id}'
+            LIMIT 1
+          `);
+                    if (permSetQuery.records.length > 0) {
+                        // Create new permission
+                        await conn.sobject('FieldPermissions').create({
+                            ParentId: permSetQuery.records[0].Id,
+                            SobjectType: objectName,
+                            Field: fullFieldName,
+                            PermissionsRead: true,
+                            PermissionsEdit: true
+                        });
+                        results.push(profile.Name);
+                    }
+                    else {
+                        errors.push(profile.Name);
+                    }
+                }
+            }
+            catch (error) {
+                errors.push(profile.Name);
+                console.error(`Error granting permission to ${profile.Name}:`, error);
+            }
+        }
+        if (results.length > 0) {
+            return {
+                success: true,
+                message: `Field Level Security granted to: ${results.join(', ')}${errors.length > 0 ? `. Failed for: ${errors.join(', ')}` : ''}`
+            };
+        }
+        else {
+            return {
+                success: false,
+                message: `Could not grant Field Level Security to any profiles.`
+            };
+        }
+    }
+    catch (error) {
+        console.error('Error granting field permissions:', error);
+        return {
+            success: false,
+            message: `Field Level Security configuration failed.`
+        };
+    }
+}
+export async function handleManageField(conn, args) {
+    const { operation, objectName, fieldName, type, grantAccessTo, ...fieldProps } = args;
+    try {
+        if (operation === 'create') {
+            if (!type) {
+                throw new Error('Field type is required for field creation');
+            }
+            // Prepare base metadata for the new field
+            const metadata = {
+                fullName: `${objectName}.${fieldName}__c`,
+                label: fieldProps.label || fieldName,
+                type,
+                ...(fieldProps.required && { required: fieldProps.required }),
+                ...(fieldProps.unique && { unique: fieldProps.unique }),
+                ...(fieldProps.externalId && { externalId: fieldProps.externalId }),
+                ...(fieldProps.description && { description: fieldProps.description })
+            };
+            // Add type-specific properties
+            switch (type) {
+                case 'MasterDetail':
+                case 'Lookup':
+                    if (fieldProps.referenceTo) {
+                        metadata.referenceTo = fieldProps.referenceTo;
+                        metadata.relationshipName = fieldProps.relationshipName;
+                        metadata.relationshipLabel = fieldProps.relationshipLabel || fieldProps.relationshipName;
+                        if (type === 'Lookup' && fieldProps.deleteConstraint) {
+                            metadata.deleteConstraint = fieldProps.deleteConstraint;
+                        }
+                    }
+                    break;
+                case 'TextArea':
+                    metadata.type = 'LongTextArea';
+                    metadata.length = fieldProps.length || 32768;
+                    metadata.visibleLines = 3;
+                    break;
+                case 'Text':
+                    if (fieldProps.length) {
+                        metadata.length = fieldProps.length;
+                    }
+                    break;
+                case 'Number':
+                    if (fieldProps.precision) {
+                        metadata.precision = fieldProps.precision;
+                        metadata.scale = fieldProps.scale || 0;
+                    }
+                    break;
+                case 'Picklist':
+                case 'MultiselectPicklist':
+                    if (fieldProps.picklistValues) {
+                        metadata.valueSet = {
+                            valueSetDefinition: {
+                                sorted: true,
+                                value: fieldProps.picklistValues.map(val => ({
+                                    fullName: val.label,
+                                    default: val.isDefault || false,
+                                    label: val.label
+                                }))
+                            }
+                        };
+                    }
+                    break;
+            }
+            // Create the field
+            const result = await conn.metadata.create('CustomField', metadata);
+            if (result && (Array.isArray(result) ? result[0].success : result.success)) {
+                let permissionMessage = '';
+                // Grant Field Level Security (default to System Administrator if not specified)
+                const profilesToGrant = grantAccessTo && grantAccessTo.length > 0 ? grantAccessTo : ['System Administrator'];
+                // Wait a moment for field to be fully created
+                await new Promise(resolve => setTimeout(resolve, 2000));
+                const permissionResult = await grantFieldPermissions(conn, objectName, fieldName, profilesToGrant);
+                permissionMessage = `\n${permissionResult.message}`;
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Successfully created custom field ${fieldName}__c on ${objectName}.${permissionMessage}`
+                        }],
+                    isError: false,
+                };
+            }
+        }
+        else {
+            // For update, first get existing metadata
+            const existingMetadata = await conn.metadata.read('CustomField', [`${objectName}.${fieldName}__c`]);
+            const currentMetadata = Array.isArray(existingMetadata) ? existingMetadata[0] : existingMetadata;
+            if (!currentMetadata) {
+                throw new Error(`Field ${fieldName}__c not found on object ${objectName}`);
+            }
+            // Prepare update metadata
+            const metadata = {
+                ...currentMetadata,
+                ...(fieldProps.label && { label: fieldProps.label }),
+                ...(fieldProps.required !== undefined && { required: fieldProps.required }),
+                ...(fieldProps.unique !== undefined && { unique: fieldProps.unique }),
+                ...(fieldProps.externalId !== undefined && { externalId: fieldProps.externalId }),
+                ...(fieldProps.description !== undefined && { description: fieldProps.description }),
+                ...(fieldProps.length && { length: fieldProps.length }),
+                ...(fieldProps.precision && { precision: fieldProps.precision, scale: fieldProps.scale || 0 })
+            };
+            // Special handling for picklist values if provided
+            if (fieldProps.picklistValues &&
+                (currentMetadata.type === 'Picklist' || currentMetadata.type === 'MultiselectPicklist')) {
+                metadata.valueSet = {
+                    valueSetDefinition: {
+                        sorted: true,
+                        value: fieldProps.picklistValues.map(val => ({
+                            fullName: val.label,
+                            default: val.isDefault || false,
+                            label: val.label
+                        }))
+                    }
+                };
+            }
+            // Update the field
+            const result = await conn.metadata.update('CustomField', metadata);
+            if (result && (Array.isArray(result) ? result[0].success : result.success)) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Successfully updated custom field ${fieldName}__c on ${objectName}`
+                        }],
+                    isError: false,
+                };
+            }
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: `Failed to ${operation} custom field ${fieldName}__c`
+                }],
+            isError: true,
+        };
+    }
+    catch (error) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `Error ${operation === 'create' ? 'creating' : 'updating'} custom field: ${error instanceof Error ? error.message : String(error)}`
+                }],
+            isError: true,
+        };
+    }
+}

package/dist/tools/manageFieldPermissions.d.ts

@@ -0,0 +1,17 @@
+import { Tool } from "@modelcontextprotocol/sdk/types.js";
+export declare const MANAGE_FIELD_PERMISSIONS: Tool;
+export interface ManageFieldPermissionsArgs {
+    operation: 'grant' | 'revoke' | 'view';
+    objectName: string;
+    fieldName: string;
+    profileNames?: string[];
+    readable?: boolean;
+    editable?: boolean;
+}
+export declare function handleManageFieldPermissions(conn: any, args: ManageFieldPermissionsArgs): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError: boolean;
+}>;

package/dist/tools/manageFieldPermissions.js

@@ -0,0 +1,247 @@
+export const MANAGE_FIELD_PERMISSIONS = {
+    name: "salesforce_manage_field_permissions",
+    description: `Manage Field Level Security (Field Permissions) for custom and standard fields.
+  - Grant or revoke read/edit access to fields for specific profiles or permission sets
+  - View current field permissions
+  - Bulk update permissions for multiple profiles
+  
+  Examples:
+  1. Grant System Administrator access to a field
+  2. Give read-only access to a field for specific profiles
+  3. Check which profiles have access to a field`,
+    inputSchema: {
+        type: "object",
+        properties: {
+            operation: {
+                type: "string",
+                enum: ["grant", "revoke", "view"],
+                description: "Operation to perform on field permissions"
+            },
+            objectName: {
+                type: "string",
+                description: "API name of the object (e.g., 'Account', 'Custom_Object__c')"
+            },
+            fieldName: {
+                type: "string",
+                description: "API name of the field (e.g., 'Custom_Field__c')"
+            },
+            profileNames: {
+                type: "array",
+                items: { type: "string" },
+                description: "Names of profiles to grant/revoke access (e.g., ['System Administrator', 'Sales User'])",
+                optional: true
+            },
+            readable: {
+                type: "boolean",
+                description: "Grant/revoke read access (default: true)",
+                optional: true
+            },
+            editable: {
+                type: "boolean",
+                description: "Grant/revoke edit access (default: true)",
+                optional: true
+            }
+        },
+        required: ["operation", "objectName", "fieldName"]
+    }
+};
+export async function handleManageFieldPermissions(conn, args) {
+    const { operation, objectName, fieldName, readable = true, editable = true } = args;
+    let { profileNames } = args;
+    try {
+        // Ensure field name has __c suffix if it's a custom field and doesn't already have it
+        const fieldApiName = fieldName.endsWith('__c') || fieldName.includes('.') ? fieldName : `${fieldName}__c`;
+        const fullFieldName = `${objectName}.${fieldApiName}`;
+        if (operation === 'view') {
+            // Query existing field permissions
+            const permissionsQuery = `
+        SELECT Id, Parent.ProfileId, Parent.Profile.Name, Parent.IsOwnedByProfile,
+               Parent.PermissionSetId, Parent.PermissionSet.Name,
+               Field, PermissionsRead, PermissionsEdit
+        FROM FieldPermissions
+        WHERE SobjectType = '${objectName}'
+        AND Field = '${fullFieldName}'
+        ORDER BY Parent.Profile.Name
+      `;
+            const result = await conn.query(permissionsQuery);
+            if (result.records.length === 0) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `No field permissions found for ${fullFieldName}. This field might not have any specific permissions set, or it might be universally accessible.`
+                        }],
+                    isError: false,
+                };
+            }
+            let responseText = `Field permissions for ${fullFieldName}:\n\n`;
+            result.records.forEach((perm) => {
+                const name = perm.Parent.IsOwnedByProfile
+                    ? perm.Parent.Profile?.Name
+                    : perm.Parent.PermissionSet?.Name;
+                const type = perm.Parent.IsOwnedByProfile ? 'Profile' : 'Permission Set';
+                responseText += `${type}: ${name}\n`;
+                responseText += `  - Read Access: ${perm.PermissionsRead ? 'Yes' : 'No'}\n`;
+                responseText += `  - Edit Access: ${perm.PermissionsEdit ? 'Yes' : 'No'}\n\n`;
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: responseText
+                    }],
+                isError: false,
+            };
+        }
+        // For grant/revoke operations
+        if (!profileNames || profileNames.length === 0) {
+            // If no profiles specified, default to System Administrator
+            profileNames = ['System Administrator'];
+        }
+        // Get profile IDs
+        const profileQuery = await conn.query(`
+      SELECT Id, Name 
+      FROM Profile 
+      WHERE Name IN (${profileNames.map(name => `'${name}'`).join(', ')})
+    `);
+        if (profileQuery.records.length === 0) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `No profiles found matching: ${profileNames.join(', ')}`
+                    }],
+                isError: true,
+            };
+        }
+        const results = [];
+        const errors = [];
+        for (const profile of profileQuery.records) {
+            try {
+                if (operation === 'grant') {
+                    // First, check if permission already exists
+                    const existingPerm = await conn.query(`
+            SELECT Id, PermissionsRead, PermissionsEdit
+            FROM FieldPermissions
+            WHERE ParentId IN (
+              SELECT Id FROM PermissionSet 
+              WHERE IsOwnedByProfile = true 
+              AND ProfileId = '${profile.Id}'
+            )
+            AND Field = '${fullFieldName}'
+            AND SobjectType = '${objectName}'
+            LIMIT 1
+          `);
+                    if (existingPerm.records.length > 0) {
+                        // Update existing permission
+                        const updateResult = await conn.sobject('FieldPermissions').update({
+                            Id: existingPerm.records[0].Id,
+                            PermissionsRead: readable,
+                            PermissionsEdit: editable && readable // Edit requires read
+                        });
+                        results.push({
+                            profile: profile.Name,
+                            action: 'updated',
+                            success: updateResult.success
+                        });
+                    }
+                    else {
+                        // Get the PermissionSet ID for this profile
+                        const permSetQuery = await conn.query(`
+              SELECT Id FROM PermissionSet 
+              WHERE IsOwnedByProfile = true 
+              AND ProfileId = '${profile.Id}'
+              LIMIT 1
+            `);
+                        if (permSetQuery.records.length > 0) {
+                            // Create new permission
+                            const createResult = await conn.sobject('FieldPermissions').create({
+                                ParentId: permSetQuery.records[0].Id,
+                                SobjectType: objectName,
+                                Field: fullFieldName,
+                                PermissionsRead: readable,
+                                PermissionsEdit: editable && readable // Edit requires read
+                            });
+                            results.push({
+                                profile: profile.Name,
+                                action: 'created',
+                                success: createResult.success
+                            });
+                        }
+                        else {
+                            errors.push(`Could not find permission set for profile: ${profile.Name}`);
+                        }
+                    }
+                }
+                else if (operation === 'revoke') {
+                    // Find and delete the permission
+                    const existingPerm = await conn.query(`
+            SELECT Id
+            FROM FieldPermissions
+            WHERE ParentId IN (
+              SELECT Id FROM PermissionSet 
+              WHERE IsOwnedByProfile = true 
+              AND ProfileId = '${profile.Id}'
+            )
+            AND Field = '${fullFieldName}'
+            AND SobjectType = '${objectName}'
+            LIMIT 1
+          `);
+                    if (existingPerm.records.length > 0) {
+                        const deleteResult = await conn.sobject('FieldPermissions').delete(existingPerm.records[0].Id);
+                        results.push({
+                            profile: profile.Name,
+                            action: 'revoked',
+                            success: true
+                        });
+                    }
+                    else {
+                        results.push({
+                            profile: profile.Name,
+                            action: 'no permission found',
+                            success: true
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                errors.push(`${profile.Name}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        // Format response
+        let responseText = `Field permission ${operation} operation completed for ${fullFieldName}:\n\n`;
+        const successful = results.filter(r => r.success);
+        const failed = results.filter(r => !r.success);
+        if (successful.length > 0) {
+            responseText += 'Successful:\n';
+            successful.forEach(r => {
+                responseText += `  - ${r.profile}: ${r.action}\n`;
+            });
+        }
+        if (failed.length > 0 || errors.length > 0) {
+            responseText += '\nFailed:\n';
+            failed.forEach(r => {
+                responseText += `  - ${r.profile}: ${r.action}\n`;
+            });
+            errors.forEach(e => {
+                responseText += `  - ${e}\n`;
+            });
+        }
+        if (operation === 'grant') {
+            responseText += `\nPermissions granted:\n  - Read: ${readable ? 'Yes' : 'No'}\n  - Edit: ${editable ? 'Yes' : 'No'}`;
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: responseText
+                }],
+            isError: false,
+        };
+    }
+    catch (error) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `Error managing field permissions: ${error instanceof Error ? error.message : String(error)}`
+                }],
+            isError: true,
+        };
+    }
+}

package/dist/tools/manageObject.d.ts

@@ -0,0 +1,20 @@
+import { Tool } from "@modelcontextprotocol/sdk/types.js";
+export declare const MANAGE_OBJECT: Tool;
+export interface ManageObjectArgs {
+    operation: 'create' | 'update';
+    objectName: string;
+    label?: string;
+    pluralLabel?: string;
+    description?: string;
+    nameFieldLabel?: string;
+    nameFieldType?: 'Text' | 'AutoNumber';
+    nameFieldFormat?: string;
+    sharingModel?: 'ReadWrite' | 'Read' | 'Private' | 'ControlledByParent';
+}
+export declare function handleManageObject(conn: any, args: ManageObjectArgs): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError: boolean;
+}>;