salesforce-metadata-mcp 2.1.3 → 2.2.0

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

package/dist/tools/ui.js

@@ -1,5 +1,5 @@
-import { CreateLightningAppSchema, CreateTabSchema, CreateCompactLayoutSchema, CreateListViewSchema, CreateEmailTemplateSchema, CreateStaticResourceSchema, CreateCustomNotificationTypeSchema, CreateReportTypeSchema, CreateDashboardSchema, } from "../schemas/index.js";
-import { getAuth, createLightningApp, createTab, createCompactLayout, createListView, createEmailTemplate, createCustomNotificationType, createReportType, } from "../services/salesforce.js";
+import { CreateLightningAppSchema, CreateTabSchema, CreateCompactLayoutSchema, CreateListViewSchema, CreateEmailTemplateSchema, CreateStaticResourceSchema, CreateCustomNotificationTypeSchema, CreateReportTypeSchema, CreateDashboardSchema, UpdatePageLayoutSchema, AssignPageLayoutSchema, CreateLightningRecordPageSchema, CreateLightningHomePageSchema, UpdateLightningPageSchema, AssignLightningPageSchema, AssignCompactLayoutSchema, } from "../schemas/index.js";
+import { getAuth, createLightningApp, createTab, createCompactLayout, createListView, createEmailTemplate, createCustomNotificationType, createReportType, updatePageLayout, assignPageLayout, createFlexiPage, updateFlexiPage, assignFlexiPage, assignCompactLayout, } from "../services/salesforce.js";
 import { buildStaticResourceZip, deployZip, pollDeployStatus, } from "../services/deployment.js";
 import { API_VERSION } from "../services/salesforce.js";
 import { resultContent } from "./utils.js";
@@ -191,5 +191,75 @@ export function registerUiTools(server) {
         const result = await upsertMetadata(auth, xml);
         return resultContent(result);
     });
+    server.registerTool("sf_update_page_layout", {
+        title: "Update Page Layout",
+        description: `Updates an existing Page Layout by reading the current layout from the org and applying changes. Currently supports renaming the layout. For full section/field changes, use sf_create_page_layout to create a new layout.`,
+        inputSchema: UpdatePageLayoutSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await updatePageLayout(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_assign_page_layout", {
+        title: "Assign Page Layout to Profile(s)",
+        description: `Assigns a Page Layout to one or more Profiles for a given object. All listed profiles will be updated to use the specified layout for that object's detail and edit pages.`,
+        inputSchema: AssignPageLayoutSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await assignPageLayout(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_create_lightning_record_page", {
+        title: "Create Lightning Record Page (FlexiPage)",
+        description: `Creates a Lightning Record Page (FlexiPage of type RecordPage) with regions and components. Use to build custom Lightning record pages for an object with specific layouts, related lists, and custom components.`,
+        inputSchema: CreateLightningRecordPageSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createFlexiPage(auth, { ...params, pageType: "RecordPage" });
+        return resultContent(result);
+    });
+    server.registerTool("sf_create_lightning_home_page", {
+        title: "Create Lightning Home Page (FlexiPage)",
+        description: `Creates a Lightning Home Page (FlexiPage of type HomePage) with regions and components. Home Pages appear in the Lightning App's home tab and can display dashboards, reports, or custom components.`,
+        inputSchema: CreateLightningHomePageSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createFlexiPage(auth, { ...params, pageType: "HomePage" });
+        return resultContent(result);
+    });
+    server.registerTool("sf_update_lightning_page", {
+        title: "Update Lightning Page (FlexiPage)",
+        description: `Updates an existing Lightning Page (FlexiPage) by reading its current configuration and applying label changes. Use to rename or modify existing Lightning record or home pages.`,
+        inputSchema: UpdateLightningPageSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await updateFlexiPage(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_assign_lightning_page", {
+        title: "Assign Lightning Page to Experience Site",
+        description: `Assigns a Lightning Page (FlexiPage) to an Experience Cloud site via the Connect API. Use after creating a Lightning page to make it active within a specific community.`,
+        inputSchema: AssignLightningPageSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await assignFlexiPage(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_assign_compact_layout", {
+        title: "Set Default Compact Layout for Object",
+        description: `Sets the default compact layout for a custom or standard object. The compact layout controls the fields shown in record highlights, mobile cards, and hover panels. The compact layout must already exist on the object.`,
+        inputSchema: AssignCompactLayoutSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await assignCompactLayout(auth, params);
+        return resultContent(result);
+    });
 }
 //# sourceMappingURL=ui.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "salesforce-metadata-mcp",
-  "version": "2.1.3",
-  "description": "The most comprehensive Salesforce metadata and development MCP server: 60+ tools for custom objects, flows, Apex, LWC, Agentforce, deployments, and more",
+  "version": "2.2.0",
+  "description": "The most comprehensive Salesforce MCP server: 110+ tools for metadata, Apex, LWC, Agentforce agents, Experience Cloud, bulk data, users, reports, security, and more",
   "license": "MIT",
   "private": false,
   "type": "module",
@@ -47,7 +47,18 @@
     "salesforce-dx",
     "crm",
     "automation",
-    "lightning"
+    "lightning",
+    "permission-set",
+    "page-layout",
+    "reports",
+    "dashboard",
+    "experience-cloud",
+    "community",
+    "users",
+    "bulk-api",
+    "visualforce",
+    "aura",
+    "formula-fields"
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.29.0",