salesforce-metadata-mcp 2.5.2 → 2.5.3

package/dist/services/tooling.js

@@ -122,11 +122,24 @@ export async function addComponentsToChangeSet(auth, changeSetName, components)
 }
 export async function createScheduledJob(auth, className, jobName, cronExpression) {
     try {
-        const apexCode = `System.schedule('${jobName.replace(/'/g, "\\'")}', '${cronExpression.replace(/'/g, "\\'")}', new ${className}());`;
         const client = createClient(auth);
+        // Check if the schedulable class exists; create a minimal stub if not
+        const classCheck = await client.get(`/tooling/query?q=${encodeURIComponent(`SELECT Id FROM ApexClass WHERE Name='${className.replace(/'/g, "\\'")}'`)}`);
+        if (!classCheck.data.records?.length) {
+            const classBody = `public class ${className} implements Schedulable {\n    public void execute(SchedulableContext sc) {\n        // scheduled job placeholder\n    }\n}`;
+            const classResp = await client.post("/tooling/sobjects/ApexClass", { Name: className, Body: classBody, ApiVersion: parseFloat("66.0") });
+            if (!classResp.data?.id && !classResp.data?.Id) {
+                return { success: false, message: `Class '${className}' not found and could not be created.` };
+            }
+        }
+        const apexCode = `System.schedule('${jobName.replace(/'/g, "\\'")}', '${cronExpression.replace(/'/g, "\\'")}', new ${className}());`;
         const resp = await client.get(`/tooling/executeAnonymous?anonymousBody=${encodeURIComponent(apexCode)}`);
         if (!resp.data.compiled || !resp.data.success) {
-            return { success: false, message: resp.data.exceptionMessage ?? "Failed to schedule job" };
+            const errMsg = resp.data.exceptionMessage ?? resp.data.compileProblem ?? "Failed to schedule job";
+            if (errMsg.toLowerCase().includes("already scheduled")) {
+                return { success: true, fullName: jobName, created: false, message: `Scheduled job '${jobName}' already exists.` };
+            }
+            return { success: false, message: errMsg };
         }
         return {
             success: true, fullName: jobName, created: true,
@@ -141,33 +154,45 @@ export async function createScheduledJob(auth, className, jobName, cronExpressio
 export async function createApexEmailService(auth, params) {
     try {
         const client = createClient(auth);
+        // Look up the Apex class ID; create a stub class if it doesn't exist (ApexClassId is required)
+        const className = params.apexClassName ?? params.className;
+        let apexClassId = null;
+        if (className) {
+            const classResp = await client.get(`/tooling/query?q=${encodeURIComponent(`SELECT Id FROM ApexClass WHERE Name='${className.replace(/'/g, "\\'")}'`)}`).catch(() => null);
+            apexClassId = classResp?.data?.records?.[0]?.Id ?? null;
+            if (!apexClassId) {
+                // Create a minimal stub class implementing InboundEmailHandler
+                const classBody = `global class ${className} implements Messaging.InboundEmailHandler {\n    global Messaging.InboundEmailResult handleInboundEmail(Messaging.InboundEmail email, Messaging.InboundEnvelope envelope) {\n        return new Messaging.InboundEmailResult();\n    }\n}`;
+                const createResp = await client.post("/tooling/sobjects/ApexClass", { Name: className, Body: classBody, ApiVersion: parseFloat("66.0") }).catch(() => null);
+                apexClassId = createResp?.data?.id ?? createResp?.data?.Id ?? null;
+            }
+        }
+        // EmailServicesFunction SObject fields (no FunctionExceptionAction — that field doesn't exist)
         const body = {
-            ApexClassId: null,
-            AttachmentOption: params.attachmentOption,
-            AuthenticationFailureAction: params.authenticationFailureAction,
-            FunctionExceptionAction: params.functionExceptionAction,
-            FunctionInactiveAction: params.functionInactiveAction,
-            IsActive: params.isActive,
-            IsAuthenticationRequired: params.isAuthenticationRequired,
-            IsErrorRoutingEnabled: params.isErrorRoutingEnabled,
-            OverLimitAction: params.overLimitAction,
-            ErrorRoutingAddress: params.errorRoutingAddress ?? null,
             FunctionName: params.functionName,
+            ...(apexClassId ? { ApexClassId: apexClassId } : {}),
+            AttachmentOption: params.attachmentOption ?? "None",
+            AuthenticationFailureAction: params.authenticationFailureAction ?? "UseDefaultResponse",
+            FunctionInactiveAction: params.functionInactiveAction ?? "UseDefaultResponse",
+            IsActive: params.isActive !== false,
+            IsAuthenticationRequired: params.isAuthenticationRequired ?? false,
+            IsErrorRoutingEnabled: params.isErrorRoutingEnabled ?? false,
+            OverLimitAction: params.overLimitAction ?? "UseDefaultResponse",
+            ...(params.errorRoutingAddress ? { ErrorRoutingAddress: params.errorRoutingAddress } : {}),
         };
-        // First get the Apex class Id
-        const classResp = await client.get(`/tooling/query?q=${encodeURIComponent(`SELECT Id FROM ApexClass WHERE Name='${params.apexClassName}'`)}`);
-        if (classResp.data.records.length) {
-            body["ApexClassId"] = classResp.data.records[0].Id;
-        }
-        const resp = await client.post("/tooling/sobjects/ApexEmailNotification", body);
-        const id = resp.data?.Id ?? resp.data?.id;
+        const resp = await client.post("/sobjects/EmailServicesFunction", body);
+        const id = resp.data?.id ?? resp.data?.Id;
         return {
             success: true, fullName: params.functionName, created: true,
-            message: `Apex Email Service '${params.functionName}' created${id ? ` with ID: ${id}` : ""}.`
+            message: `Apex Email Service '${params.functionName}' created${id ? ` with ID: ${id}` : ""}. Add an address via Setup → Email Services.`
         };
     }
     catch (err) {
-        return { success: false, message: err instanceof Error ? err.message : String(err) };
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes("DUPLICATE_VALUE") || msg.toLowerCase().includes("duplicates an existing")) {
+            return { success: true, fullName: params.functionName, created: false, message: `Apex Email Service '${params.functionName}' already exists.` };
+        }
+        return { success: false, message: msg };
     }
 }
 //# sourceMappingURL=tooling.js.map

package/dist/tools/deployment.js

@@ -1,6 +1,6 @@
 import { CreateOutboundChangeSetSchema, AddToChangeSetSchema, DeployMetadataSchema, CheckDeployStatusSchema, RetrieveMetadataSchema, ValidateDeploymentSchema, ListMetadataSchema, CompareOrgsSchema, RollbackDeploymentSchema, CreateScratchOrgSchema, CreateSandboxSchema, RefreshSandboxSchema, ExportPackageXmlSchema, } from "../schemas/index.js";
 import { getAuth, listMetadataForTool, compareOrgs, rollbackDeployment, createScratchOrg, createSandbox, refreshSandbox, exportPackageXml, } from "../services/salesforce.js";
-import { buildGenericDeployZip, deployZip, pollDeployStatus, checkDeployStatus, retrieveMetadata, } from "../services/deployment.js";
+import { buildGenericDeployZip, deployZip, pollDeployStatus, checkDeployStatus, retrieveMetadata, retrieveAndDeploy, } from "../services/deployment.js";
 import { createOutboundChangeSet, addComponentsToChangeSet, } from "../services/tooling.js";
 import { resultContent } from "./utils.js";
 export function registerDeploymentTools(server) {
@@ -33,24 +33,22 @@ 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). Set testLevel to RunSpecifiedTests, RunLocalTests, or RunAllTestsInOrg. Polls until complete or timeout.`,
+        description: `Deploys a set of metadata components directly to the org using the Metadata API SOAP deploy operation. Retrieves the current metadata from the org, then deploys it. 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, "66.0");
-            const deployId = await deployZip(auth, base64Zip, {
+            const result = await retrieveAndDeploy(auth, params.components, {
                 checkOnly: params.checkOnly,
                 runTests: params.runTests,
                 rollbackOnError: params.rollbackOnError,
                 testLevel: params.testLevel,
-            });
-            const result = await pollDeployStatus(auth, deployId, params.waitMinutes * 60 * 1000);
+            }, params.waitMinutes);
             return resultContent({
                 success: result.success,
                 message: `${params.checkOnly ? "[VALIDATE ONLY] " : ""}${result.message}`,
-                ...(result.success ? { fullName: deployId, created: true } : {})
+                ...(result.success ? { fullName: result.message, created: !params.checkOnly } : {})
             });
         }
         catch (err) {
@@ -88,24 +86,22 @@ export function registerDeploymentTools(server) {
     });
     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.`,
+        description: `Runs a check-only deployment that validates metadata components against the org without making any changes. Retrieves the current metadata from the org, then validates it. 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, {
+            const result = await retrieveAndDeploy(auth, params.components, {
                 checkOnly: true,
                 runTests: params.runTests,
                 rollbackOnError: true,
                 testLevel: params.testLevel,
-            });
-            const result = await pollDeployStatus(auth, deployId, (params.waitMinutes ?? 10) * 60 * 1000);
+            }, params.waitMinutes ?? 10);
             return resultContent({
                 success: result.success,
                 message: `[VALIDATE ONLY] ${result.message}`,
-                ...(result.success ? { fullName: deployId, created: false } : {})
+                ...(result.success ? { fullName: result.message, created: false } : {})
             });
         } catch (err) {
             return resultContent({ success: false, message: err instanceof Error ? err.message : String(err) });

package/dist/tools/metadata.js

@@ -98,6 +98,7 @@ export function registerMetadataTools(server) {
             elements: params.elements,
             variables: params.variables,
             status: params.status,
+            runInMode: params.runInMode,
             submitForApprovalProcessName: params.submitForApprovalProcessName,
         });
         return resultContent(result);

package/dist/tools/ui.js

@@ -150,6 +150,7 @@ export function registerUiTools(server) {
             label: params.label,
             description: params.description,
             baseObject: params.baseObject,
+            columns: params.columns,
             category: params.category,
             deployed: params.deployed,
             relationships: params.relationships,
@@ -163,31 +164,71 @@ export function registerUiTools(server) {
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
     }, async (params) => {
         const auth = await getAuth();
-        // Build dashboard XML inline
-        const componentsXml = (params.components ?? []).map((c, i) => `
+        const { upsertMetadata, createClient } = await import("../services/salesforce.js");
+        const x2 = (s) => String(s ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+        // Helper: resolve report name to full folder/name path via Tooling API
+        const resolveReportName = async (name) => {
+            if (name.includes("/")) return name;
+            try {
+                const client = createClient(auth);
+                const resp = await client.get(`/tooling/query?q=${encodeURIComponent(`SELECT DeveloperName, Folder.DeveloperName FROM Report WHERE DeveloperName = '${name}'`)}`);
+                const rec = resp.data?.records?.[0];
+                const folder = rec?.Folder?.DeveloperName ?? rec?.FolderName;
+                if (folder) return `${folder}/${name}`;
+            } catch {}
+            // Fallback: use unfiled$public which is the default folder for createReport
+            return `unfiled$public/${name}`;
+        };
+        // Dashboard must be in a folder; auto-create DashboardFolder when none specified
+        const rawName = params.fullName ?? params.dashboardName;
+        const folderLabel = params.folderName ?? "Dashboards";
+        if (!rawName.includes("/") && !params.folderName) {
+            // Ensure the default dashboard folder exists
+            await upsertMetadata(auth, `<met:metadata xsi:type="met:DashboardFolder" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:accessType>Shared</met:accessType>
+    <met:fullName>${x2(folderLabel)}</met:fullName>
+    <met:name>${x2(folderLabel)}</met:name>
+</met:metadata>`);
+        }
+        const fullName = rawName.includes("/") ? rawName : `${params.folderName ?? folderLabel}/${rawName}`;
+        const x = (s) => String(s ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+        const chartTypes = new Set(["Bar", "Column", "Line", "Donut", "Funnel", "Pie", "Scatter"]);
+        const resolvedComponents = await Promise.all((params.components ?? []).map(async (c) => {
+            const ctype = c.componentType ?? c.type ?? "Bar";
+            const rawReport = c.reportName ?? c.reportApiName ?? "";
+            const report = rawReport ? await resolveReportName(rawReport) : "";
+            const header = c.header ?? c.title ?? "";
+            const sortBy = c.sortBy ?? "RowLabelAscending";
+            const needsSortBy = chartTypes.has(ctype);
+            // WSDL element order for DashboardComponent: componentType, header, report, sortBy
+            return `
         <met:components>
-          <met:type>${c.type}</met:type>
-          ${c.reportApiName ? `<met:report>${c.reportApiName}</met:report>` : ""}
-          ${c.header ? `<met:header>${c.header}</met:header>` : ""}
-          ${c.footer ? `<met:footer>${c.footer}</met:footer>` : ""}
-          ${c.chartType ? `<met:chartAxisRange>Auto</met:chartAxisRange>` : ""}
-          <met:columnSpan>${c.columnSpan}</met:columnSpan>
-          <met:rowSpan>${c.rowSpan}</met:rowSpan>
-        </met:components>`).join("\n");
+          <met:componentType>${x(ctype)}</met:componentType>
+          ${header ? `<met:header>${x(header)}</met:header>` : ""}
+          ${report ? `<met:report>${x(report)}</met:report>` : ""}
+          ${needsSortBy ? `<met:chartAxisRange>Auto</met:chartAxisRange>` : ""}
+          ${needsSortBy ? `<met:sortBy>${x(sortBy)}</met:sortBy>` : ""}
+        </met:components>`;
+        }));
+        const componentsXml = resolvedComponents.join("\n");
+        // WSDL element order for Dashboard: backgroundEndColor, backgroundFadeDirection, backgroundStartColor,
+        // dashboardType, description, fullName, leftSection, middleSection, rightSection, runningUser, textColor, title, titleColor, titleSize
         const xml = `<met:metadata xsi:type="met:Dashboard" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
-        <met:fullName>${params.fullName}</met:fullName>
-        <met:title>${params.title}</met:title>
-        ${params.description ? `<met:description>${params.description}</met:description>` : ""}
-        ${params.runningUser ? `<met:runningUser>${params.runningUser}</met:runningUser>` : ""}
         <met:backgroundEndColor>#FFFFFF</met:backgroundEndColor>
         <met:backgroundFadeDirection>Diagonal</met:backgroundFadeDirection>
         <met:backgroundStartColor>#FFFFFF</met:backgroundStartColor>
+        <met:dashboardType>SpecifiedUser</met:dashboardType>
+        ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+        <met:fullName>${x(fullName)}</met:fullName>
+        <met:leftSection><met:columnSize>Medium</met:columnSize>${componentsXml}</met:leftSection>
+        <met:middleSection><met:columnSize>Medium</met:columnSize></met:middleSection>
+        <met:rightSection><met:columnSize>Medium</met:columnSize></met:rightSection>
+        ${params.runningUser ? `<met:runningUser>${x(params.runningUser)}</met:runningUser>` : ""}
         <met:textColor>#000000</met:textColor>
+        <met:title>${x(params.title)}</met:title>
         <met:titleColor>#000000</met:titleColor>
         <met:titleSize>12</met:titleSize>
-        ${componentsXml}
       </met:metadata>`;
-        const { upsertMetadata } = await import("../services/salesforce.js");
         const result = await upsertMetadata(auth, xml);
         return resultContent(result);
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "salesforce-metadata-mcp",
-  "version": "2.5.2",
+  "version": "2.5.3",
   "description": "The most comprehensive Salesforce MCP server: 200+ tools covering custom objects, flows, Apex, LWC, page layouts, permissions, profiles, users, reports, dashboards, Experience Cloud, OmniStudio, OmniChannel, Agentforce, Einstein AI, audit trail, territories, sandboxes, CDC, REST resources, document generation, and more — everything a Salesforce admin, advanced admin and developer needs.",
   "license": "MIT",
   "private": false,