salesforce-metadata-mcp 2.1.4 → 2.2.0

package/dist/tools/agentforce.js

@@ -1,6 +1,6 @@
 import {
     CreateAgentSchema, CreateAgentTopicSchema, CreateAgentActionSchema, CreateAgentPlannerSchema,
-    GetAgentSchema, UpdateAgentTopicSchema, UpdateAgentActionSchema, DeleteAgentSchema,
+    ActivateAgentSchema, DeactivateAgentSchema, GetAgentSchema, UpdateAgentTopicSchema, UpdateAgentActionSchema, DeleteAgentSchema,
     ListAgentsSchema, TestAgentSchema, GetAgentLogsSchema,
 } from "../schemas/index.js";
 import {
@@ -115,7 +115,7 @@ For Knowledge-grounded agents, set dataLibraryName to the API name of a Data Lib
     server.registerTool("sf_activate_agent", {
         title: "Activate Agentforce Agent",
         description: `Activates an Agentforce Agent so it is available to users. After making configuration changes (adding/removing topics or actions), re-activate with this tool.`,
-        inputSchema: { type: "object", properties: { agentApiName: { type: "string", description: "API name of the agent to activate, e.g. 'CRM_Record_Creator'" } }, required: ["agentApiName"] },
+        inputSchema: ActivateAgentSchema,
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
     }, async (params) => {
         const auth = await getAuth();
@@ -126,7 +126,7 @@ For Knowledge-grounded agents, set dataLibraryName to the API name of a Data Lib
     server.registerTool("sf_deactivate_agent", {
         title: "Deactivate Agentforce Agent",
         description: `Deactivates an Agentforce Agent so configuration changes can be made. You must deactivate an agent before modifying its topics, actions, or planner configuration. After making changes, re-activate with sf_activate_agent.`,
-        inputSchema: { type: "object", properties: { agentApiName: { type: "string", description: "API name of the agent to deactivate, e.g. 'CRM_Record_Creator'" } }, required: ["agentApiName"] },
+        inputSchema: DeactivateAgentSchema,
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
     }, async (params) => {
         const auth = await getAuth();

package/dist/tools/apex.js

@@ -1,6 +1,6 @@
-import { CreateApexClassSchema, CreateApexTriggerSchema, CreateApexTestClassSchema, RunApexTestsSchema, ExecuteAnonymousApexSchema, } from "../schemas/index.js";
-import { getAuth } from "../services/salesforce.js";
-import { buildApexClassZip, buildApexTriggerZip, deployZip, pollDeployStatus, } from "../services/deployment.js";
+import { CreateApexClassSchema, CreateApexTriggerSchema, CreateApexTestClassSchema, RunApexTestsSchema, ExecuteAnonymousApexSchema, UpdateApexClassSchema, GetApexClassSchema, GetCodeCoverageSchema, CreateVisualforcePageSchema, CreateAuraComponentSchema, } from "../schemas/index.js";
+import { getAuth, getApexClass, getCodeCoverage, API_VERSION } from "../services/salesforce.js";
+import { buildApexClassZip, buildApexTriggerZip, buildVFPageZip, buildAuraZip, deployZip, pollDeployStatus, } from "../services/deployment.js";
 import { executeAnonymousApex, runApexTests, } from "../services/tooling.js";
 import { resultContent } from "./utils.js";
 export function registerApexTools(server) {
@@ -91,5 +91,73 @@ export function registerApexTools(server) {
         const result = await executeAnonymousApex(auth, params.apexCode);
         return resultContent(result);
     });
+    server.registerTool("sf_update_apex_class", {
+        title: "Update Apex Class",
+        description: `Updates an existing Apex class by redeploying it with new source code. The class body is fully replaced — provide the complete class source. The deploy uses zip-based Metadata API for immediate deployment.`,
+        inputSchema: UpdateApexClassSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        try {
+            const base64Zip = await buildApexClassZip(params.className, params.classBody, API_VERSION);
+            const deployId = await deployZip(auth, base64Zip);
+            const result = await pollDeployStatus(auth, deployId, 120_000);
+            return resultContent(result);
+        } catch (err) {
+            return resultContent({ success: false, message: err instanceof Error ? err.message : String(err) });
+        }
+    });
+    server.registerTool("sf_get_apex_class", {
+        title: "Get Apex Class Source",
+        description: `Retrieves the source code and metadata of an Apex class from the org using the Tooling API. Returns the class body, API version, and status. Useful for reviewing existing code before making changes.`,
+        inputSchema: GetApexClassSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await getApexClass(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_get_code_coverage", {
+        title: "Get Apex Code Coverage",
+        description: `Retrieves Apex code coverage percentages from the last test run using the Tooling API. Returns covered lines, uncovered lines, and coverage percentage per class. Filter by class name or retrieve all classes.`,
+        inputSchema: GetCodeCoverageSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await getCodeCoverage(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_create_visualforce_page", {
+        title: "Create Visualforce Page",
+        description: `Deploys a Visualforce page to the org using zip-based Metadata API. Provide the page name (no spaces) and the full Visualforce markup. Visualforce pages use the apex: and c: tag libraries and can reference Apex controllers.`,
+        inputSchema: CreateVisualforcePageSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        try {
+            const base64Zip = await buildVFPageZip(params.pageName, params.markup, API_VERSION);
+            const deployId = await deployZip(auth, base64Zip);
+            const result = await pollDeployStatus(auth, deployId, 120_000);
+            return resultContent(result);
+        } catch (err) {
+            return resultContent({ success: false, message: err instanceof Error ? err.message : String(err) });
+        }
+    });
+    server.registerTool("sf_create_aura_component", {
+        title: "Create Aura Component Bundle",
+        description: `Deploys an Aura (Lightning) component bundle using zip-based Metadata API. Provide the component name and markup (.cmp file). Optionally include a controller, helper, and CSS style. Aura components are the predecessor to LWC and still supported for complex use cases.`,
+        inputSchema: CreateAuraComponentSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        try {
+            const base64Zip = await buildAuraZip(params.componentName, params.markup, params.controller, params.helper, params.style, API_VERSION);
+            const deployId = await deployZip(auth, base64Zip);
+            const result = await pollDeployStatus(auth, deployId, 120_000);
+            return resultContent(result);
+        } catch (err) {
+            return resultContent({ success: false, message: err instanceof Error ? err.message : String(err) });
+        }
+    });
 }
 //# sourceMappingURL=apex.js.map

package/dist/tools/automation.js

@@ -1,5 +1,5 @@
-import { CreateEmailAlertSchema, CreatePlatformEventSchema, CreateAssignmentRuleSchema, CreateEscalationRuleSchema, CreateAutoResponseRuleSchema, CreateMatchingRuleSchema, CreateDuplicateRuleSchema, CreateApexEmailServiceSchema, CreateScheduledJobSchema, } from "../schemas/index.js";
-import { getAuth, createEmailAlert, createPlatformEvent, createAssignmentRule, createAutoResponseRule, createMatchingRule, createDuplicateRule, } from "../services/salesforce.js";
+import { CreateEmailAlertSchema, CreatePlatformEventSchema, CreateAssignmentRuleSchema, CreateEscalationRuleSchema, CreateAutoResponseRuleSchema, CreateMatchingRuleSchema, CreateDuplicateRuleSchema, CreateApexEmailServiceSchema, CreateScheduledJobSchema, ActivateFlowSchema, CreateQuickActionSchema, } from "../schemas/index.js";
+import { getAuth, createEmailAlert, createPlatformEvent, createAssignmentRule, createAutoResponseRule, createMatchingRule, createDuplicateRule, activateFlow, createQuickAction, } from "../services/salesforce.js";
 import { createApexEmailService, createScheduledJob, } from "../services/tooling.js";
 import { resultContent } from "./utils.js";
 export function registerAutomationTools(server) {
@@ -182,5 +182,28 @@ export function registerAutomationTools(server) {
         const result = await createScheduledJob(auth, params.className, params.jobName, params.cronExpression);
         return resultContent(result);
     });
+    server.registerTool("sf_activate_flow", {
+        title: "Activate a Flow",
+        description: `Activates the latest version of a Flow via the Tooling API. Flow must already exist in the org. The flow's latest version will be set as the active version. Use after creating or updating a flow to make it available.`,
+        inputSchema: ActivateFlowSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await activateFlow(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_create_quick_action", {
+        title: "Create Quick Action",
+        description: `Creates a Quick Action (global or object-specific) for record creation, updates, logging calls, sending emails, or launching flows from record pages and the global action bar.
+
+Action types: Create, Update, LogACall, SendEmail, Flow, Visualforce.
+For object-specific actions, provide objectApiName. For global actions, omit it.`,
+        inputSchema: CreateQuickActionSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createQuickAction(auth, params);
+        return resultContent(result);
+    });
 }
 //# sourceMappingURL=automation.js.map

package/dist/tools/data.js

@@ -0,0 +1,86 @@
+import { CreateUserSchema, UpdateUserSchema, AssignQueueMemberSchema, CreatePublicGroupSchema, QueryRecordsSchema, CreateRecordSchema, UpdateRecordSchema, BulkImportRecordsSchema, } from "../schemas/index.js";
+import { getAuth, createUser, updateUser, assignQueueMember, createPublicGroup, queryRecords, createRecord, updateRecord, bulkImportRecords, } from "../services/salesforce.js";
+import { resultContent } from "./utils.js";
+export function registerDataTools(server) {
+    server.registerTool("sf_create_user", {
+        title: "Create Salesforce User",
+        description: `Creates a new Salesforce user via the REST API. Requires username (must be unique and email-like), lastName, email, and profileName. The profile must already exist. Optionally assign a role by roleApiName (DeveloperName of the UserRole). The user will receive a welcome email unless email confirmations are suppressed in org settings.`,
+        inputSchema: CreateUserSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createUser(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_update_user", {
+        title: "Update Salesforce User",
+        description: `Updates an existing Salesforce user's properties via the REST API. Look up the user by username and update fields like firstName, lastName, email, title, department, phone, or isActive (to deactivate/reactivate). Only fields you provide are updated.`,
+        inputSchema: UpdateUserSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await updateUser(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_assign_queue_member", {
+        title: "Add User to Queue",
+        description: `Adds a user to an existing Queue (GroupMember SObject) by username and queue DeveloperName. The queue must already exist (create via sf_create_queue). Users in queues can be assigned records and receive queue notification emails.`,
+        inputSchema: AssignQueueMemberSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await assignQueueMember(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_create_public_group", {
+        title: "Create Public Group",
+        description: `Creates a Public Group (Group SObject with Type=Regular) for sharing rules, email distribution, or queue membership. Public groups can include users, roles, and other groups. Use as a sharing target in sf_create_sharing_rule.`,
+        inputSchema: CreatePublicGroupSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createPublicGroup(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_query_records", {
+        title: "Query Records (SOQL)",
+        description: `Executes a SOQL query against the org and returns matching records. Provide either a full SOQL string (soql param) or individual parameters (objectApiName, fields, whereClause, orderBy, limit). Use for reading data, checking existing records before creating, or verifying changes.`,
+        inputSchema: QueryRecordsSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await queryRecords(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_create_record", {
+        title: "Create SObject Record",
+        description: `Creates a single SObject record via the Salesforce REST API. Provide the object API name and a fields object with field API names and values. For bulk creation (100+ records), use sf_bulk_import_records instead.`,
+        inputSchema: CreateRecordSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createRecord(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_update_record", {
+        title: "Update SObject Record",
+        description: `Updates an existing SObject record by record ID via the Salesforce REST API. Provide the object API name, the 15 or 18 character record ID, and the fields to update. Only provided fields are changed — omitted fields retain their current values.`,
+        inputSchema: UpdateRecordSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await updateRecord(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_bulk_import_records", {
+        title: "Bulk Import Records (Bulk API 2.0)",
+        description: `Bulk imports records using the Salesforce Bulk API 2.0. Supports insert, upsert, update, and delete operations on large datasets (thousands to millions of records). Provide CSV data with a header row. For upsert, set externalIdField to the field used for matching. Polls until the job completes and returns success/failure counts.`,
+        inputSchema: BulkImportRecordsSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await bulkImportRecords(auth, params);
+        return resultContent(result);
+    });
+}
+//# sourceMappingURL=data.js.map

package/dist/tools/deployment.js

@@ -1,5 +1,5 @@
-import { CreateOutboundChangeSetSchema, AddToChangeSetSchema, DeployMetadataSchema, CheckDeployStatusSchema, RetrieveMetadataSchema, } from "../schemas/index.js";
-import { getAuth } from "../services/salesforce.js";
+import { CreateOutboundChangeSetSchema, AddToChangeSetSchema, DeployMetadataSchema, CheckDeployStatusSchema, RetrieveMetadataSchema, ValidateDeploymentSchema, ListMetadataSchema, } from "../schemas/index.js";
+import { getAuth, listMetadataForTool } from "../services/salesforce.js";
 import { buildGenericDeployZip, deployZip, pollDeployStatus, checkDeployStatus, retrieveMetadata, } from "../services/deployment.js";
 import { createOutboundChangeSet, addComponentsToChangeSet, } from "../services/tooling.js";
 import { resultContent } from "./utils.js";
@@ -33,17 +33,18 @@ export function registerDeploymentTools(server) {
     });
     server.registerTool("sf_deploy_metadata", {
         title: "Deploy Metadata",
-        description: `Deploys a set of metadata components directly to the org using the Metadata API SOAP deploy operation. Builds a package.xml and deployment zip in memory. Supports validate-only (checkOnly:true) for pre-deployment validation without making changes. Specify runTests to execute test classes during deployment (required for production). Polls until complete or timeout.`,
+        description: `Deploys a set of metadata components directly to the org using the Metadata API SOAP deploy operation. Builds a package.xml and deployment zip in memory. Supports validate-only (checkOnly:true) for pre-deployment validation without making changes. Specify runTests to execute test classes during deployment (required for production). Set testLevel to RunSpecifiedTests, RunLocalTests, or RunAllTestsInOrg. Polls until complete or timeout.`,
         inputSchema: DeployMetadataSchema,
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
     }, async (params) => {
         const auth = await getAuth();
         try {
-            const base64Zip = await buildGenericDeployZip(params.components, "62.0");
+            const base64Zip = await buildGenericDeployZip(params.components, "66.0");
             const deployId = await deployZip(auth, base64Zip, {
                 checkOnly: params.checkOnly,
                 runTests: params.runTests,
                 rollbackOnError: params.rollbackOnError,
+                testLevel: params.testLevel,
             });
             const result = await pollDeployStatus(auth, deployId, params.waitMinutes * 60 * 1000);
             return resultContent({
@@ -85,5 +86,40 @@ export function registerDeploymentTools(server) {
         const result = await retrieveMetadata(auth, params.components);
         return resultContent(result);
     });
+    server.registerTool("sf_validate_deployment", {
+        title: "Validate Deployment (Check-Only)",
+        description: `Runs a check-only deployment that validates metadata components against the org without making any changes. Equivalent to sf_deploy_metadata with checkOnly:true. Use before deploying to production to catch errors and test failures without risk. Specify testLevel to control which tests run during validation.`,
+        inputSchema: ValidateDeploymentSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        try {
+            const base64Zip = await buildGenericDeployZip(params.components, "66.0");
+            const deployId = await deployZip(auth, base64Zip, {
+                checkOnly: true,
+                runTests: params.runTests,
+                rollbackOnError: true,
+                testLevel: params.testLevel,
+            });
+            const result = await pollDeployStatus(auth, deployId, (params.waitMinutes ?? 10) * 60 * 1000);
+            return resultContent({
+                success: result.success,
+                message: `[VALIDATE ONLY] ${result.message}`,
+                ...(result.success ? { fullName: deployId, created: false } : {})
+            });
+        } catch (err) {
+            return resultContent({ success: false, message: err instanceof Error ? err.message : String(err) });
+        }
+    });
+    server.registerTool("sf_list_metadata", {
+        title: "List Metadata Components",
+        description: `Lists all metadata components of a given type in the org (e.g., ApexClass, CustomObject, Flow, PermissionSet). Returns full names, file names, and last modified dates. Useful for discovering what metadata exists in the org before retrieving or deploying.`,
+        inputSchema: ListMetadataSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await listMetadataForTool(auth, params.metadataType);
+        return resultContent(result);
+    });
 }
 //# sourceMappingURL=deployment.js.map

package/dist/tools/experience.js

@@ -1,5 +1,5 @@
-import { CreateExperienceSiteSchema, CreateExperiencePageSchema } from "../schemas/index.js";
-import { getAuth, createExperienceSite } from "../services/salesforce.js";
+import { CreateExperienceSiteSchema, CreateExperiencePageSchema, PublishExperienceSiteSchema, UpdateExperienceSiteSchema, CreateNavigationMenuSchema, CreateExperienceSiteMemberSchema, SetExperienceSiteBrandingSchema, } from "../schemas/index.js";
+import { getAuth, createExperienceSite, publishExperienceSite, updateExperienceSite, createNavigationMenu, createExperienceSiteMember, setExperienceSiteBranding, } from "../services/salesforce.js";
 import { resultContent } from "./utils.js";
 export function registerExperienceTools(server) {
     server.registerTool("sf_create_experience_site", {
@@ -49,5 +49,55 @@ export function registerExperienceTools(server) {
             return resultContent({ success: false, message: err instanceof Error ? err.message : String(err) });
         }
     });
+    server.registerTool("sf_publish_experience_site", {
+        title: "Publish Experience Cloud Site",
+        description: `Publishes an Experience Cloud site to make all pending changes (pages, branding, navigation) live. Calls the Salesforce Connect API publish endpoint. The site must be created and in Active or UnderConstruction status. Publishing typically takes 1-5 minutes.`,
+        inputSchema: PublishExperienceSiteSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await publishExperienceSite(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_update_experience_site", {
+        title: "Update Experience Cloud Site Settings",
+        description: `Updates settings on an existing Experience Cloud site (Network metadata) such as description, guest user access, and guest profile. Use after creating a site to configure access control.`,
+        inputSchema: UpdateExperienceSiteSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await updateExperienceSite(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_create_navigation_menu", {
+        title: "Create Experience Site Navigation Menu",
+        description: `Creates a Navigation Menu for an Experience Cloud site. Navigation menus appear in the site header and sidebar. Items can link to internal Salesforce pages, external URLs, or object lists.`,
+        inputSchema: CreateNavigationMenuSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createNavigationMenu(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_add_experience_site_members", {
+        title: "Add Member Profiles to Experience Site",
+        description: `Adds user profiles and/or permission sets as member groups to an Experience Cloud site, allowing users with those profiles to log in and access the community. Updates the Network metadata's networkMemberGroups.`,
+        inputSchema: CreateExperienceSiteMemberSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createExperienceSiteMember(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_set_experience_site_branding", {
+        title: "Set Experience Site Branding",
+        description: `Applies branding properties to an Experience Cloud site using a BrandingSet. Set colors, fonts, logo URLs, and other visual properties. Properties use Salesforce branding token names (e.g., brandingDesignTokenPrimaryColor, brandingDesignTokenFontFamilySans).`,
+        inputSchema: SetExperienceSiteBrandingSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await setExperienceSiteBranding(auth, params);
+        return resultContent(result);
+    });
 }
 //# sourceMappingURL=experience.js.map

package/dist/tools/index.js

@@ -10,6 +10,8 @@ import { registerAgentforceTools } from "./agentforce.js";
 import { registerDeploymentTools } from "./deployment.js";
 import { registerMcpTools } from "./mcp.js";
 import { registerIntegrationTools } from "./integrations.js";
+import { registerReportTools } from "./reports.js";
+import { registerDataTools } from "./data.js";
 export function registerTools(server) {
     registerMetadataTools(server);
     registerObjectTools(server);
@@ -23,5 +25,7 @@ export function registerTools(server) {
     registerDeploymentTools(server);
     registerMcpTools(server);
     registerIntegrationTools(server);
+    registerReportTools(server);
+    registerDataTools(server);
 }
 //# sourceMappingURL=index.js.map

package/dist/tools/integrations.js

@@ -1,5 +1,5 @@
-import { CreateConnectedAppSchema, CreateExternalDataSourceSchema, CreateExternalObjectSchema, CreateRemoteSiteSettingSchema, CreateCspSettingSchema, } from "../schemas/index.js";
-import { getAuth, createConnectedApp, createExternalDataSource, createExternalObject, createRemoteSiteSetting, createCspSetting, } from "../services/salesforce.js";
+import { CreateConnectedAppSchema, CreateExternalDataSourceSchema, CreateExternalObjectSchema, CreateRemoteSiteSettingSchema, CreateCspSettingSchema, CreateOutboundMessageSchema, CreateAuthProviderSchema, } from "../schemas/index.js";
+import { getAuth, createConnectedApp, createExternalDataSource, createExternalObject, createRemoteSiteSetting, createCspSetting, createOutboundMessage, createAuthProvider, } from "../services/salesforce.js";
 import { resultContent } from "./utils.js";
 export function registerIntegrationTools(server) {
     server.registerTool("sf_create_connected_app", {
@@ -92,5 +92,25 @@ export function registerIntegrationTools(server) {
         });
         return resultContent(result);
     });
+    server.registerTool("sf_create_outbound_message", {
+        title: "Create Outbound Message",
+        description: `Creates a Workflow Outbound Message that sends XML data to an external SOAP endpoint when triggered by a Workflow Rule. Use to integrate Salesforce with external systems that listen for HTTP POST notifications.`,
+        inputSchema: CreateOutboundMessageSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createOutboundMessage(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_create_auth_provider", {
+        title: "Create Auth Provider",
+        description: `Creates an Auth Provider (OAuth 2.0 SSO configuration) for third-party identity providers. Supports standard providers (Facebook, Google, Salesforce) and custom OAuth 2.0 flows. Used for Social Sign-On and Named Credential OAuth flows.`,
+        inputSchema: CreateAuthProviderSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createAuthProvider(auth, params);
+        return resultContent(result);
+    });
 }
 //# sourceMappingURL=integrations.js.map

package/dist/tools/objects.js

@@ -1,5 +1,5 @@
-import { CreateCustomMetadataTypeSchema, CreateCustomMetadataRecordSchema, CreateCustomLabelSchema, CreateCustomSettingSchema, CreateGlobalValueSetSchema, CreateRecordTypeSchema, CreateBusinessProcessSchema, CreatePageLayoutSchema, CreateSharingRuleSchema, CreateFieldDependencySchema, } from "../schemas/index.js";
-import { getAuth, createCustomMetadataType, createCustomMetadataRecord, createCustomLabel, createCustomSetting, createGlobalValueSet, createRecordType, createBusinessProcess, createPageLayout, createSharingRule, createFieldDependency, } from "../services/salesforce.js";
+import { CreateCustomMetadataTypeSchema, CreateCustomMetadataRecordSchema, CreateCustomLabelSchema, CreateCustomSettingSchema, CreateGlobalValueSetSchema, CreateRecordTypeSchema, CreateBusinessProcessSchema, CreatePageLayoutSchema, CreateSharingRuleSchema, CreateFieldDependencySchema, UpdateCustomObjectSchema, UpdateCustomFieldSchema, CreateRelationshipFieldSchema, CreateFormulaFieldSchema, } from "../schemas/index.js";
+import { getAuth, createCustomMetadataType, createCustomMetadataRecord, createCustomLabel, createCustomSetting, createGlobalValueSet, createRecordType, createBusinessProcess, createPageLayout, createSharingRule, createFieldDependency, updateCustomObject, updateCustomField, createRelationshipField, createFormulaField, } from "../services/salesforce.js";
 import { resultContent } from "./utils.js";
 export function registerObjectTools(server) {
     server.registerTool("sf_create_custom_metadata_type", {
@@ -168,5 +168,45 @@ export function registerObjectTools(server) {
         });
         return resultContent(result);
     });
+    server.registerTool("sf_update_custom_object", {
+        title: "Update Custom Object",
+        description: `Updates properties of an existing custom object such as label, plural label, description, or feature toggles (history tracking, reports, search, activities). Only provide the fields you want to change.`,
+        inputSchema: UpdateCustomObjectSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await updateCustomObject(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_update_custom_field", {
+        title: "Update Custom Field",
+        description: `Updates properties of an existing custom field such as label, description, help text, required, unique, or default value. Provide objectApiName (e.g. 'Account') and fieldApiName (e.g. 'Annual_Revenue__c').`,
+        inputSchema: UpdateCustomFieldSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await updateCustomField(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_create_relationship_field", {
+        title: "Create Relationship Field (Lookup / Master-Detail)",
+        description: `Creates a Lookup or Master-Detail relationship field on a custom object. Lookup fields are optional references; Master-Detail creates a parent-child relationship where the child cannot exist without the parent.`,
+        inputSchema: CreateRelationshipFieldSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createRelationshipField(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_create_formula_field", {
+        title: "Create Formula Field",
+        description: `Creates a formula field on a custom or standard object. Formula fields are read-only and calculated dynamically based on the formula expression. Supports Text, Number, Currency, Date, DateTime, Checkbox, and Percent return types.`,
+        inputSchema: CreateFormulaFieldSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createFormulaField(auth, params);
+        return resultContent(result);
+    });
 }
 //# sourceMappingURL=objects.js.map

package/dist/tools/reports.js

@@ -0,0 +1,46 @@
+import { CreateReportSchema, UpdateDashboardSchema, CreateReportFolderSchema, ShareReportFolderSchema, } from "../schemas/index.js";
+import { getAuth, createReport, updateDashboard, createReportFolder, shareReportFolder, } from "../services/salesforce.js";
+import { resultContent } from "./utils.js";
+export function registerReportTools(server) {
+    server.registerTool("sf_create_report", {
+        title: "Create Salesforce Report",
+        description: `Creates a Salesforce Report using the Report metadata type. Supports Tabular, Summary, Matrix, and Joined formats. Specify the report type (e.g., Accounts, Opportunities), columns to display, and optional filters. Reports are created in the specified folder or your personal folder by default.`,
+        inputSchema: CreateReportSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createReport(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_update_dashboard", {
+        title: "Update Dashboard",
+        description: `Updates an existing Dashboard's title or description by reading the current configuration from the org and applying changes. The dashboard must already exist. For structural changes (adding/removing components), use sf_create_dashboard to create a new version.`,
+        inputSchema: UpdateDashboardSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await updateDashboard(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_create_report_folder", {
+        title: "Create Report or Dashboard Folder",
+        description: `Creates a folder for organizing Reports or Dashboards. Folder access types: Hidden (only owner), Shared (explicit sharing), Public (all users). After creating, use sf_share_report_folder to grant access to specific users, roles, or groups.`,
+        inputSchema: CreateReportFolderSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createReportFolder(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_share_report_folder", {
+        title: "Share Report or Dashboard Folder",
+        description: `Shares a Report or Dashboard folder with users, roles, groups, or territories. Sets access levels (View, Edit, Manage) per share recipient. Use after creating a folder to grant team members access.`,
+        inputSchema: ShareReportFolderSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await shareReportFolder(auth, params);
+        return resultContent(result);
+    });
+}
+//# sourceMappingURL=reports.js.map

package/dist/tools/security.js

@@ -1,5 +1,5 @@
-import { CreatePermissionSetSchema, CreateRoleSchema, CreateQueueSchema, CreateNamedCredentialSchema, } from "../schemas/index.js";
-import { getAuth, createPermissionSet, createRole, createQueue, createNamedCredential, } from "../services/salesforce.js";
+import { CreatePermissionSetSchema, CreateRoleSchema, CreateQueueSchema, CreateNamedCredentialSchema, AssignPermissionSetSchema, CreatePermissionSetGroupSchema, UpdatePermissionSetSchema, CreateMutingPermissionSetSchema, SetFieldLevelSecuritySchema, SetOrgWideDefaultsSchema, CreateProfileSchema, UpdateProfileSchema, } from "../schemas/index.js";
+import { getAuth, createPermissionSet, createRole, createQueue, createNamedCredential, assignPermissionSet, createPermissionSetGroup, updatePermissionSet, createMutingPermissionSet, setFieldLevelSecurity, setOrgWideDefaults, cloneProfile, updateProfile, } from "../services/salesforce.js";
 import { resultContent } from "./utils.js";
 export function registerSecurityTools(server) {
     server.registerTool("sf_create_permission_set", {
@@ -78,5 +78,85 @@ export function registerSecurityTools(server) {
         });
         return resultContent(result);
     });
+    server.registerTool("sf_assign_permission_set", {
+        title: "Assign Permission Set to User",
+        description: `Assigns an existing Permission Set to a user. Provide the permissionSetName and either the user's username or userId. The assignment takes effect immediately.`,
+        inputSchema: AssignPermissionSetSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await assignPermissionSet(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_create_permission_set_group", {
+        title: "Create Permission Set Group",
+        description: `Creates a Permission Set Group that combines multiple Permission Sets. Users assigned to the group receive all permissions from all included sets. Optionally create a Muting Permission Set to restrict permissions within the group.`,
+        inputSchema: CreatePermissionSetGroupSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createPermissionSetGroup(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_update_permission_set", {
+        title: "Update Permission Set (Object & Field Permissions)",
+        description: `Updates an existing Permission Set by adding or modifying object and field-level permissions. Provide the permission set name and arrays of objectPermissions or fieldPermissions to set. Existing permissions not listed remain unchanged.`,
+        inputSchema: UpdatePermissionSetSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await updatePermissionSet(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_create_muting_permission_set", {
+        title: "Create Muting Permission Set",
+        description: `Creates a Muting Permission Set that removes specific permissions from users within a Permission Set Group. Only valid within a Permission Set Group context.`,
+        inputSchema: CreateMutingPermissionSetSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createMutingPermissionSet(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_set_field_level_security", {
+        title: "Set Field-Level Security",
+        description: `Sets read/edit field-level security for a specific field across one or more Profiles and/or Permission Sets. Use to make a field visible and/or editable without manually editing each profile.`,
+        inputSchema: SetFieldLevelSecuritySchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await setFieldLevelSecurity(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_set_org_wide_defaults", {
+        title: "Set Org-Wide Sharing Defaults",
+        description: `Sets the org-wide default sharing model for a custom or standard object. Internal access options: Private, Read, ReadWrite, ControlledByParent. External sharing can be set separately.`,
+        inputSchema: SetOrgWideDefaultsSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await setOrgWideDefaults(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_clone_profile", {
+        title: "Clone Profile",
+        description: `Creates a new Profile by cloning an existing one. The new profile inherits all permissions, page layout assignments, and field-level security from the source profile. Useful for creating profiles with slight variations.`,
+        inputSchema: CreateProfileSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await cloneProfile(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_update_profile", {
+        title: "Update Profile (Object, Field, Tab, App Permissions)",
+        description: `Updates object permissions, field-level security, tab visibility, and application visibility on an existing Profile. Provide only the permissions you want to change — existing settings not listed remain unchanged.`,
+        inputSchema: UpdateProfileSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await updateProfile(auth, params);
+        return resultContent(result);
+    });
 }
 //# sourceMappingURL=security.js.map