salesforce-metadata-mcp 2.2.0 → 2.4.0

package/dist/services/salesforce.js

@@ -2653,4 +2653,1029 @@ export async function setExperienceSiteBranding(auth, params) {
         return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
     }
 }
+// ─── v2.3.0 OmniStudio Service Functions ─────────────────────────────────────
+function buildFlexCardDefinition(params) {
+    return {
+        name: params.cardName,
+        sObjectType: params.objectApiName ?? "",
+        dataSource: params.dataSourceType !== "None" ? {
+            type: params.dataSourceType,
+            value: params.dataSourceName ?? "",
+        } : null,
+        elements: (params.fields ?? []).map(f => ({
+            type: "text",
+            name: `field_${f.fieldName}`,
+            label: f.label,
+            fieldName: f.fieldName,
+            dataType: f.type ?? "Text",
+        })),
+        actions: (params.actions ?? []).map(a => ({
+            type: a.type,
+            label: a.label,
+            target: a.target,
+        })),
+        states: (params.states ?? [{ name: "Default", conditionType: "ALL", conditions: [] }]).map(s => ({
+            name: s.name,
+            conditionType: s.conditionType,
+            conditions: s.conditions ?? [],
+        })),
+    };
+}
+export async function createFlexCard(auth, params) {
+    try {
+        const definition = buildFlexCardDefinition(params);
+        const xml = `<met:metadata xsi:type="met:OmniUiCard" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.cardName)}</met:fullName>
+    <met:masterLabel>${x(params.label)}</met:masterLabel>
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+    <met:omniUiCardType>Child</met:omniUiCardType>
+    <met:versionNumber>1</met:versionNumber>
+    <met:isActive>false</met:isActive>
+    <met:omniUiCardDefinition>${x(JSON.stringify(definition))}</met:omniUiCardDefinition>
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function updateFlexCard(auth, params) {
+    try {
+        const existing = await readMetadataItem(auth, "OmniUiCard", params.cardName);
+        if (!existing.success) return existing;
+        const defMatch = existing.rawXml.match(/<omniUiCardDefinition[^>]*>([\s\S]*?)<\/omniUiCardDefinition>/i);
+        let definition = {};
+        if (defMatch) {
+            try { definition = JSON.parse(defMatch[1].replace(/&amp;/g,"&").replace(/&lt;/g,"<").replace(/&gt;/g,">").replace(/&quot;/g,'"').replace(/&apos;/g,"'")); }
+            catch { /* use empty definition */ }
+        }
+        const merged = {
+            ...definition,
+            ...(params.dataSourceType ? { dataSource: { type: params.dataSourceType, value: params.dataSourceName ?? "" } } : {}),
+            ...(params.fields ? { elements: params.fields.map(f => ({ type: "text", name: `field_${f.fieldName}`, label: f.label, fieldName: f.fieldName })) } : {}),
+            ...(params.actions ? { actions: params.actions } : {}),
+            ...(params.states ? { states: params.states } : {}),
+        };
+        const labelMatch = existing.rawXml.match(/<masterLabel[^>]*>([\s\S]*?)<\/masterLabel>/i);
+        const currentLabel = labelMatch?.[1] ?? params.cardName;
+        const xml = `<met:metadata xsi:type="met:OmniUiCard" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.cardName)}</met:fullName>
+    <met:masterLabel>${x(params.label ?? currentLabel)}</met:masterLabel>
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+    <met:omniUiCardType>Child</met:omniUiCardType>
+    <met:isActive>false</met:isActive>
+    <met:omniUiCardDefinition>${x(JSON.stringify(merged))}</met:omniUiCardDefinition>
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function activateFlexCard(auth, params) {
+    try {
+        const existing = await readMetadataItem(auth, "OmniUiCard", params.cardName);
+        if (!existing.success) return { success: false, message: `FlexCard '${params.cardName}' not found.` };
+        const labelMatch = existing.rawXml.match(/<masterLabel[^>]*>([\s\S]*?)<\/masterLabel>/i);
+        const defMatch = existing.rawXml.match(/<omniUiCardDefinition[^>]*>([\s\S]*?)<\/omniUiCardDefinition>/i);
+        const typeMatch = existing.rawXml.match(/<omniUiCardType[^>]*>([\s\S]*?)<\/omniUiCardType>/i);
+        const xml = `<met:metadata xsi:type="met:OmniUiCard" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.cardName)}</met:fullName>
+    <met:masterLabel>${labelMatch?.[1] ?? params.cardName}</met:masterLabel>
+    <met:omniUiCardType>${typeMatch?.[1] ?? "Child"}</met:omniUiCardType>
+    <met:isActive>true</met:isActive>
+    ${defMatch ? `<met:omniUiCardDefinition>${defMatch[1]}</met:omniUiCardDefinition>` : ""}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function getFlexCard(auth, params) {
+    try {
+        const result = await readMetadataItem(auth, "OmniUiCard", params.cardName);
+        if (!result.success) return result;
+        const labelMatch = result.rawXml.match(/<masterLabel[^>]*>([\s\S]*?)<\/masterLabel>/i);
+        const isActiveMatch = result.rawXml.match(/<isActive[^>]*>([\s\S]*?)<\/isActive>/i);
+        const defMatch = result.rawXml.match(/<omniUiCardDefinition[^>]*>([\s\S]*?)<\/omniUiCardDefinition>/i);
+        let definition = null;
+        if (defMatch) {
+            try { definition = JSON.parse(defMatch[1].replace(/&amp;/g,"&").replace(/&lt;/g,"<").replace(/&gt;/g,">").replace(/&quot;/g,'"').replace(/&apos;/g,"'")); }
+            catch { definition = defMatch[1]; }
+        }
+        return { success: true, cardName: params.cardName, label: labelMatch?.[1] ?? "", isActive: isActiveMatch?.[1] === "true", definition, message: `FlexCard '${params.cardName}' retrieved.` };
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createOmniScript(auth, params) {
+    try {
+        const fullName = `${params.type}_${params.subType}_${params.language}`;
+        const xml = `<met:metadata xsi:type="met:OmniScript" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(fullName)}</met:fullName>
+    <met:masterLabel>${x(params.label)}</met:masterLabel>
+    <met:type>${x(params.type)}</met:type>
+    <met:subType>${x(params.subType)}</met:subType>
+    <met:language>${x(params.language)}</met:language>
+    <met:omniProcessType>OmniScript</met:omniProcessType>
+    <met:isActive>false</met:isActive>
+    <met:isInternal>false</met:isInternal>
+    <met:isLwcEnabled>${params.isLwcEnabled !== false ? "true" : "false"}</met:isLwcEnabled>
+    <met:isOmniScriptEmbeddable>${params.isOmniScriptEmbeddable ? "true" : "false"}</met:isOmniScriptEmbeddable>
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function updateOmniScript(auth, params) {
+    try {
+        const fullName = `${params.type}_${params.subType}_${params.language}`;
+        const existing = await readMetadataItem(auth, "OmniScript", fullName);
+        if (!existing.success) return { success: false, message: `OmniScript '${fullName}' not found.` };
+        const labelMatch = existing.rawXml.match(/<masterLabel[^>]*>([\s\S]*?)<\/masterLabel>/i);
+        const xml = `<met:metadata xsi:type="met:OmniScript" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(fullName)}</met:fullName>
+    <met:masterLabel>${labelMatch?.[1] ?? fullName}</met:masterLabel>
+    <met:type>${x(params.type)}</met:type>
+    <met:subType>${x(params.subType)}</met:subType>
+    <met:language>${x(params.language)}</met:language>
+    <met:omniProcessType>OmniScript</met:omniProcessType>
+    <met:isActive>false</met:isActive>
+    <met:isInternal>false</met:isInternal>
+    ${params.isLwcEnabled !== undefined ? `<met:isLwcEnabled>${params.isLwcEnabled}</met:isLwcEnabled>` : ""}
+    ${params.isOmniScriptEmbeddable !== undefined ? `<met:isOmniScriptEmbeddable>${params.isOmniScriptEmbeddable}</met:isOmniScriptEmbeddable>` : ""}
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function activateOmniScript(auth, params) {
+    try {
+        const fullName = `${params.type}_${params.subType}_${params.language}`;
+        const existing = await readMetadataItem(auth, "OmniScript", fullName);
+        if (!existing.success) return { success: false, message: `OmniScript '${fullName}' not found.` };
+        const labelMatch = existing.rawXml.match(/<masterLabel[^>]*>([\s\S]*?)<\/masterLabel>/i);
+        const xml = `<met:metadata xsi:type="met:OmniScript" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(fullName)}</met:fullName>
+    <met:masterLabel>${labelMatch?.[1] ?? fullName}</met:masterLabel>
+    <met:type>${x(params.type)}</met:type>
+    <met:subType>${x(params.subType)}</met:subType>
+    <met:language>${x(params.language)}</met:language>
+    <met:omniProcessType>OmniScript</met:omniProcessType>
+    <met:isActive>true</met:isActive>
+    <met:isInternal>false</met:isInternal>
+    <met:isLwcEnabled>true</met:isLwcEnabled>
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function getOmniScript(auth, params) {
+    try {
+        const fullName = `${params.type}_${params.subType}_${params.language}`;
+        const result = await readMetadataItem(auth, "OmniScript", fullName);
+        if (!result.success) return result;
+        const get = (tag) => result.rawXml.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`, "i"))?.[1] ?? "";
+        return {
+            success: true,
+            fullName,
+            type: get("type"),
+            subType: get("subType"),
+            language: get("language"),
+            isActive: get("isActive") === "true",
+            isLwcEnabled: get("isLwcEnabled") === "true",
+            message: `OmniScript '${fullName}' retrieved.`,
+        };
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createDataRaptor(auth, params) {
+    try {
+        const mapItemsXml = (params.fields ?? []).map((f, i) => {
+            const isJSON = f.sourceField.startsWith("$.");
+            return `
+    <met:mapItems>
+        <met:index>${i}</met:index>
+        <met:objectName>${x(params.objectApiName ?? "")}</met:objectName>
+        <met:field>${x(isJSON ? "" : f.sourceField)}</met:field>
+        <met:JSONPath>${x(isJSON ? f.sourceField : "")}</met:JSONPath>
+        <met:targetField>${x(f.targetField)}</met:targetField>
+        <met:dataType>${x(f.dataType ?? "String")}</met:dataType>
+        ${f.formula ? `<met:formula>${x(f.formula)}</met:formula>` : ""}
+        <met:operationType>First</met:operationType>
+        <met:sourceObjectName>${x(params.objectApiName ?? "")}</met:sourceObjectName>
+    </met:mapItems>`;
+        }).join("");
+        const xml = `<met:metadata xsi:type="met:DataRaptorInterface" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.dataRaptorName)}</met:fullName>
+    <met:masterLabel>${x(params.label)}</met:masterLabel>
+    <met:interfaceType>${x(params.interfaceType)}</met:interfaceType>
+    ${params.objectApiName ? `<met:objectName>${x(params.objectApiName)}</met:objectName>` : ""}
+    ${params.filterCriteria ? `<met:filterCriteria>${x(params.filterCriteria)}</met:filterCriteria>` : ""}
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+    ${mapItemsXml}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function getDataRaptor(auth, params) {
+    try {
+        const result = await readMetadataItem(auth, "DataRaptorInterface", params.dataRaptorName);
+        if (!result.success) return result;
+        const get = (tag) => result.rawXml.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`, "i"))?.[1]?.trim() ?? "";
+        const items = [...result.rawXml.matchAll(/<mapItems>([\s\S]*?)<\/mapItems>/gi)].map(m => {
+            const inner = m[1];
+            const gi = (t) => inner.match(new RegExp(`<${t}[^>]*>([\\s\\S]*?)<\\/${t}>`, "i"))?.[1]?.trim() ?? "";
+            return { field: gi("field"), jsonPath: gi("JSONPath"), targetField: gi("targetField"), dataType: gi("dataType") };
+        });
+        return { success: true, dataRaptorName: params.dataRaptorName, label: get("masterLabel"), interfaceType: get("interfaceType"), objectName: get("objectName"), filterCriteria: get("filterCriteria"), fieldMappings: items, message: `DataRaptor '${params.dataRaptorName}' retrieved.` };
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createIntegrationProcedure(auth, params) {
+    try {
+        const fullName = `${params.procedureName}_${params.subType}`;
+        const xml = `<met:metadata xsi:type="met:OmniScript" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(fullName)}</met:fullName>
+    <met:masterLabel>${x(params.label)}</met:masterLabel>
+    <met:type>${x(params.procedureName)}</met:type>
+    <met:subType>${x(params.subType)}</met:subType>
+    <met:language>English</met:language>
+    <met:omniProcessType>IntegrationProcedure</met:omniProcessType>
+    <met:isActive>${params.isActive ? "true" : "false"}</met:isActive>
+    <met:isInternal>false</met:isInternal>
+    <met:isLwcEnabled>false</met:isLwcEnabled>
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function updateIntegrationProcedure(auth, params) {
+    try {
+        const fullName = `${params.procedureName}_${params.subType}`;
+        const existing = await readMetadataItem(auth, "OmniScript", fullName);
+        if (!existing.success) return { success: false, message: `Integration Procedure '${fullName}' not found.` };
+        const labelMatch = existing.rawXml.match(/<masterLabel[^>]*>([\s\S]*?)<\/masterLabel>/i);
+        const xml = `<met:metadata xsi:type="met:OmniScript" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(fullName)}</met:fullName>
+    <met:masterLabel>${labelMatch?.[1] ?? fullName}</met:masterLabel>
+    <met:type>${x(params.procedureName)}</met:type>
+    <met:subType>${x(params.subType)}</met:subType>
+    <met:language>English</met:language>
+    <met:omniProcessType>IntegrationProcedure</met:omniProcessType>
+    ${params.isActive !== undefined ? `<met:isActive>${params.isActive}</met:isActive>` : "<met:isActive>false</met:isActive>"}
+    <met:isInternal>false</met:isInternal>
+    <met:isLwcEnabled>false</met:isLwcEnabled>
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function activateIntegrationProcedure(auth, params) {
+    try {
+        const fullName = `${params.procedureName}_${params.subType}`;
+        const existing = await readMetadataItem(auth, "OmniScript", fullName);
+        if (!existing.success) return { success: false, message: `Integration Procedure '${fullName}' not found.` };
+        const labelMatch = existing.rawXml.match(/<masterLabel[^>]*>([\s\S]*?)<\/masterLabel>/i);
+        const xml = `<met:metadata xsi:type="met:OmniScript" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(fullName)}</met:fullName>
+    <met:masterLabel>${labelMatch?.[1] ?? fullName}</met:masterLabel>
+    <met:type>${x(params.procedureName)}</met:type>
+    <met:subType>${x(params.subType)}</met:subType>
+    <met:language>English</met:language>
+    <met:omniProcessType>IntegrationProcedure</met:omniProcessType>
+    <met:isActive>true</met:isActive>
+    <met:isInternal>false</met:isInternal>
+    <met:isLwcEnabled>false</met:isLwcEnabled>
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function getIntegrationProcedure(auth, params) {
+    try {
+        const fullName = `${params.procedureName}_${params.subType}`;
+        const result = await readMetadataItem(auth, "OmniScript", fullName);
+        if (!result.success) return result;
+        const get = (tag) => result.rawXml.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`, "i"))?.[1]?.trim() ?? "";
+        return { success: true, fullName, type: get("type"), subType: get("subType"), isActive: get("isActive") === "true", description: get("description"), message: `Integration Procedure '${fullName}' retrieved.` };
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createCalculationMatrix(auth, params) {
+    try {
+        const inputVarsXml = params.inputVariables.map(v => `
+    <met:inputVariables>
+        <met:dataType>${x(v.dataType ?? "String")}</met:dataType>
+        <met:name>${x(v.name)}</met:name>
+    </met:inputVariables>`).join("");
+        const outputVarsXml = params.outputVariables.map(v => `
+    <met:outputVariables>
+        <met:dataType>${x(v.dataType ?? "String")}</met:dataType>
+        <met:name>${x(v.name)}</met:name>
+    </met:outputVariables>`).join("");
+        const rowsXml = (params.rows ?? []).map((row, ri) => {
+            const cellsXml = Object.entries(row).map(([k, v]) => `
+        <met:cells>
+            <met:variableName>${x(k)}</met:variableName>
+            <met:value>${x(v)}</met:value>
+        </met:cells>`).join("");
+            return `
+    <met:matrixRows>
+        <met:rowNumber>${ri + 1}</met:rowNumber>
+        ${cellsXml}
+    </met:matrixRows>`;
+        }).join("");
+        const xml = `<met:metadata xsi:type="met:CalculationMatrix" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.matrixName)}</met:fullName>
+    <met:masterLabel>${x(params.label)}</met:masterLabel>
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+    ${inputVarsXml}
+    ${outputVarsXml}
+    ${rowsXml}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createCalculationProcedure(auth, params) {
+    try {
+        const stepsXml = (params.steps ?? []).map((s, i) => `
+    <met:calculationProcedureSteps>
+        <met:stepNumber>${i + 1}</met:stepNumber>
+        <met:developerName>${x(s.name)}</met:developerName>
+        <met:stepType>${x(s.type ?? "Expression")}</met:stepType>
+        ${s.matrixName ? `<met:calculationMatrix>${x(s.matrixName)}</met:calculationMatrix>` : ""}
+        ${s.expression ? `<met:expression>${x(s.expression)}</met:expression>` : ""}
+        ${s.inputMap ? Object.entries(s.inputMap).map(([k,v]) => `<met:inputParameters><met:name>${x(k)}</met:name><met:value>${x(v)}</met:value></met:inputParameters>`).join("") : ""}
+        ${s.outputMap ? Object.entries(s.outputMap).map(([k,v]) => `<met:outputParameters><met:name>${x(k)}</met:name><met:value>${x(v)}</met:value></met:outputParameters>`).join("") : ""}
+    </met:calculationProcedureSteps>`).join("");
+        const xml = `<met:metadata xsi:type="met:CalculationProcedure" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.procedureName)}</met:fullName>
+    <met:masterLabel>${x(params.label)}</met:masterLabel>
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+    ${stepsXml}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+// ─── v2.3.0 OmniChannel Service Functions ────────────────────────────────────
+export async function createServiceChannel(auth, params) {
+    try {
+        const xml = `<met:metadata xsi:type="met:ServiceChannel" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.channelName)}</met:fullName>
+    <met:label>${x(params.label)}</met:label>
+    <met:relatedEntity>${x(params.relatedObjectApiName ?? (params.channelType === "Case" ? "Case" : params.channelType === "Chat" ? "LiveChatTranscript" : params.channelType === "Email" ? "EmailMessage" : "Case"))}</met:relatedEntity>
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createRoutingConfiguration(auth, params) {
+    try {
+        const xml = `<met:metadata xsi:type="met:RoutingConfiguration" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.configName)}</met:fullName>
+    <met:label>${x(params.label)}</met:label>
+    <met:routingModel>${x(params.routingModel)}</met:routingModel>
+    <met:routingPriority>${params.priority ?? 1}</met:routingPriority>
+    ${params.unitType === "Items" ? `<met:capacityWeight>${params.capacity ?? 1}</met:capacityWeight>` : `<met:capacityPercentage>${params.capacity ?? 100}</met:capacityPercentage>`}
+    <met:unitType>${x(params.unitType ?? "Percentage")}</met:unitType>
+    ${params.pushTimeout !== undefined ? `<met:pushTimeout>${params.pushTimeout}</met:pushTimeout>` : ""}
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createQueueRoutingConfig(auth, params) {
+    try {
+        // Link a routing config to a queue by updating the Queue metadata
+        const readResult = await readMetadataItem(auth, "Queue", params.queueDeveloperName);
+        if (!readResult.success) return { success: false, message: `Queue '${params.queueDeveloperName}' not found.` };
+        const labelMatch = readResult.rawXml.match(/<label[^>]*>([\s\S]*?)<\/label>/i);
+        const emailMatch = readResult.rawXml.match(/<email[^>]*>([\s\S]*?)<\/email>/i);
+        const xml = `<met:metadata xsi:type="met:Queue" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.queueDeveloperName)}</met:fullName>
+    <met:label>${labelMatch?.[1] ?? params.queueDeveloperName}</met:label>
+    ${emailMatch?.[1] ? `<met:email>${emailMatch[1]}</met:email>` : ""}
+    <met:routingConfiguration>${x(params.routingConfigName)}</met:routingConfiguration>
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createPresenceConfiguration(auth, params) {
+    try {
+        const channelsXml = (params.serviceChannels ?? []).map(ch => `
+    <met:presenceConfigAssignments>
+        <met:serviceChannel>${x(ch.channelName)}</met:serviceChannel>
+        ${ch.capacity ? `<met:capacity>${ch.capacity}</met:capacity>` : ""}
+    </met:presenceConfigAssignments>`).join("");
+        const xml = `<met:metadata xsi:type="met:PresenceUserConfig" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.configName)}</met:fullName>
+    <met:label>${x(params.label)}</met:label>
+    <met:capacity>${params.capacity ?? 10}</met:capacity>
+    <met:allowAgentsToChangeSatus>${params.allowAgentsToChangeStatus !== false ? "true" : "false"}</met:allowAgentsToChangeSatus>
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+    ${channelsXml}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createPresenceStatus(auth, params) {
+    try {
+        const channelsXml = (params.serviceChannels ?? []).map(ch => `
+    <met:serviceChannels>
+        <met:channel>${x(ch)}</met:channel>
+    </met:serviceChannels>`).join("");
+        const xml = `<met:metadata xsi:type="met:ServicePresenceStatus" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.statusName)}</met:fullName>
+    <met:label>${x(params.label)}</met:label>
+    <met:statusType>${x(params.statusType ?? "Online")}</met:statusType>
+    ${channelsXml}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function assignPresenceStatus(auth, params) {
+    try {
+        const results = [];
+        for (const profileName of (params.profiles ?? [])) {
+            const xml = `<met:metadata xsi:type="met:Profile" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(profileName)}</met:fullName>
+    <met:servicePresenceStatusAccesses>
+        <met:servicePresenceStatus>${x(params.statusName)}</met:servicePresenceStatus>
+        <met:visible>true</met:visible>
+    </met:servicePresenceStatusAccesses>
+</met:metadata>`;
+            results.push(await upsertMetadata(auth, xml));
+        }
+        for (const psName of (params.permissionSets ?? [])) {
+            const xml = `<met:metadata xsi:type="met:PermissionSet" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(psName)}</met:fullName>
+    <met:servicePresenceStatusAccesses>
+        <met:servicePresenceStatus>${x(params.statusName)}</met:servicePresenceStatus>
+        <met:visible>true</met:visible>
+    </met:servicePresenceStatusAccesses>
+</met:metadata>`;
+            results.push(await upsertMetadata(auth, xml));
+        }
+        if (!results.length) return { success: false, message: "Provide at least one profile or permissionSet." };
+        const allOk = results.every(r => r.success);
+        return { success: allOk, message: allOk ? `Presence status '${params.statusName}' assigned to ${results.length} profile(s)/permission set(s).` : results.filter(r => !r.success).map(r => r.message).join("; ") };
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createSkill(auth, params) {
+    try {
+        // Skill is a REST SObject in Service Cloud
+        const client = createClient(auth);
+        const resp = await client.post("/sobjects/Skill", { MasterLabel: params.label, DeveloperName: params.skillName, Description: params.description ?? "" });
+        return { success: true, fullName: resp.data.id, created: true, message: `Skill '${params.skillName}' created with ID ${resp.data.id}.` };
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function assignSkillToAgent(auth, params) {
+    try {
+        const client = createClient(auth);
+        // Get skill ID
+        const skillResp = await client.get(`/query?q=${encodeURIComponent(`SELECT Id FROM Skill WHERE DeveloperName = '${params.skillName.replace(/'/g,"\\'")}' LIMIT 1`)}`);
+        const skillId = skillResp.data.records?.[0]?.Id;
+        if (!skillId) return { success: false, message: `Skill '${params.skillName}' not found.` };
+        // Get user ID
+        const userResp = await client.get(`/query?q=${encodeURIComponent(`SELECT Id FROM User WHERE Username = '${params.username.replace(/'/g,"\\'")}' LIMIT 1`)}`);
+        const userId = userResp.data.records?.[0]?.Id;
+        if (!userId) return { success: false, message: `User '${params.username}' not found.` };
+        // Get or create ServiceResource
+        const srResp = await client.get(`/query?q=${encodeURIComponent(`SELECT Id FROM ServiceResource WHERE RelatedRecordId = '${userId}' LIMIT 1`)}`);
+        let srId = srResp.data.records?.[0]?.Id;
+        if (!srId) {
+            const newSr = await client.post("/sobjects/ServiceResource", { RelatedRecordId: userId, Name: params.username, ResourceType: "T", IsActive: true });
+            srId = newSr.data.id;
+        }
+        // Create ServiceResourceSkill
+        const resp = await client.post("/sobjects/ServiceResourceSkill", { ServiceResourceId: srId, SkillId: skillId, SkillLevel: params.skillLevel ?? 5, EffectiveStartDate: new Date().toISOString().slice(0, 10) });
+        return { success: true, fullName: resp.data.id, created: true, message: `Skill '${params.skillName}' assigned to '${params.username}' with level ${params.skillLevel ?? 5}.` };
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createServiceTerritory(auth, params) {
+    try {
+        const client = createClient(auth);
+        const payload = { Name: params.label, IsActive: params.isActive !== false };
+        if (params.street) payload["Street"] = params.street;
+        if (params.city) payload["City"] = params.city;
+        if (params.state) payload["State"] = params.state;
+        if (params.country) payload["Country"] = params.country;
+        if (params.postalCode) payload["PostalCode"] = params.postalCode;
+        if (params.operatingHoursName) {
+            const ohResp = await client.get(`/query?q=${encodeURIComponent(`SELECT Id FROM OperatingHours WHERE Name = '${params.operatingHoursName.replace(/'/g,"\\'")}' LIMIT 1`)}`);
+            const ohId = ohResp.data.records?.[0]?.Id;
+            if (ohId) payload["OperatingHoursId"] = ohId;
+        }
+        const resp = await client.post("/sobjects/ServiceTerritory", payload);
+        return { success: true, fullName: resp.data.id, created: true, message: `Service Territory '${params.label}' created with ID ${resp.data.id}.` };
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createWorkType(auth, params) {
+    try {
+        const client = createClient(auth);
+        const durationInMinutes = params.durationType === "Hours" ? (params.estimatedDuration * 60) : params.estimatedDuration;
+        const payload = {
+            Name: params.label,
+            EstimatedDuration: durationInMinutes,
+            DurationType: "Minutes",
+            BlockTimeBeforeWork: params.blockTimeBeforeWork ?? 0,
+            BlockTimeAfterWork: params.blockTimeAfterWork ?? 0,
+            Description: params.description ?? "",
+        };
+        const resp = await client.post("/sobjects/WorkType", payload);
+        const workTypeId = resp.data.id;
+        // Add skill requirements if provided
+        for (const skillName of (params.skillRequirements ?? [])) {
+            const skillResp = await client.get(`/query?q=${encodeURIComponent(`SELECT Id FROM Skill WHERE DeveloperName = '${skillName.replace(/'/g,"\\'")}' LIMIT 1`)}`);
+            const skillId = skillResp.data.records?.[0]?.Id;
+            if (skillId) await client.post("/sobjects/WorkTypeSkill", { WorkTypeId: workTypeId, SkillId: skillId, SkillType: "Required" }).catch(() => null);
+        }
+        return { success: true, fullName: workTypeId, created: true, message: `Work Type '${params.label}' created with ID ${workTypeId}.` };
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createMessagingChannel(auth, params) {
+    try {
+        const xml = `<met:metadata xsi:type="met:MessagingChannel" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.channelName)}</met:fullName>
+    <met:masterLabel>${x(params.label)}</met:masterLabel>
+    <met:channelType>${x(params.channelType)}</met:channelType>
+    <met:isActive>true</met:isActive>
+    ${params.phoneNumber ? `<met:messagingPlatformKey>${x(params.phoneNumber)}</met:messagingPlatformKey>` : ""}
+    ${params.pageId ? `<met:pageId>${x(params.pageId)}</met:pageId>` : ""}
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createChatButton(auth, params) {
+    try {
+        const xml = `<met:metadata xsi:type="met:LiveChatButton" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.buttonName)}</met:fullName>
+    <met:label>${x(params.label)}</met:label>
+    <met:type>Standard</met:type>
+    <met:routingType>${params.routingType === "Bot" ? "Choice" : "Choice"}</met:routingType>
+    <met:optionsHasTimeoutAlert>${params.optionsHasTimeoutAlert ? "true" : "false"}</met:optionsHasTimeoutAlert>
+    <met:windowLanguage>${x(params.windowLanguage ?? "en")}</met:windowLanguage>
+    ${params.queueName ? `<met:overallQueueLength>0</met:overallQueueLength>` : ""}
+    ${params.customAgentName ? `<met:customAgentCrxName>${x(params.customAgentName)}</met:customAgentCrxName>` : ""}
+    ${params.inviteRenderer ? `<met:inviteRenderer>${x(params.inviteRenderer)}</met:inviteRenderer>` : ""}
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createEmbeddedService(auth, params) {
+    try {
+        const isLiveAgent = params.channelType === "LiveAgent";
+        const xml = `<met:metadata xsi:type="met:EmbeddedServiceConfig" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.deploymentName)}</met:fullName>
+    <met:masterLabel>${x(params.label)}</met:masterLabel>
+    <met:embeddedServiceType>${isLiveAgent ? "Chat" : "Messaging"}</met:embeddedServiceType>
+    <met:isEnabled>true</met:isEnabled>
+    <met:site>${x(params.site)}</met:site>
+    ${isLiveAgent && params.chatButtonName ? `
+    <met:embeddedServiceLiveAgent>
+        <met:liveChatButton>${x(params.chatButtonName)}</met:liveChatButton>
+        <met:embeddedServiceConfigName>${x(params.deploymentName)}</met:embeddedServiceConfigName>
+        <met:offlineSupportEnabled>false</met:offlineSupportEnabled>
+    </met:embeddedServiceLiveAgent>` : ""}
+    ${!isLiveAgent && params.messagingChannelName ? `<met:embeddedServiceMessaging><met:messagingChannel>${x(params.messagingChannelName)}</met:messagingChannel></met:embeddedServiceMessaging>` : ""}
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createBotRouting(auth, params) {
+    try {
+        // Read the existing BotVersion to find the bot's ID
+        const botVersions = await listMetadataType(auth, "BotVersion");
+        if (!botVersions.success) return { success: false, message: "Could not list BotVersions." };
+        const botFullName = botVersions.items.find(i => i.fullName.startsWith(params.botName + "."))?.fullName;
+        if (!botFullName) return { success: false, message: `No BotVersion found for bot '${params.botName}'.` };
+        const escalationsXml = (params.escalationConditions ?? [{ trigger: "agentRequested", action: "TransferToQueue" }]).map((ec, i) => `
+    <met:botDialogs>
+        <met:botSteps>
+            <met:conversationStepType>Transfer</met:conversationStepType>
+            <met:botMessage>${x(params.transferMessage ?? "Connecting you to an agent...")}</met:botMessage>
+            <met:conversationTransfer>
+                <met:transferToType>Queue</met:transferToType>
+                <met:transferToName>${x(params.transferToQueueName)}</met:transferToName>
+            </met:conversationTransfer>
+            <met:stepIdentifier>step_${i + 1}</met:stepIdentifier>
+        </met:botSteps>
+        <met:developerName>Transfer_To_Agent_${i + 1}</met:developerName>
+        <met:isGoalStep>false</met:isGoalStep>
+        <met:label>Transfer To Agent ${i + 1}</met:label>
+        <met:showInFooterMenu>false</met:showInFooterMenu>
+    </met:botDialogs>`).join("");
+        const xml = `<met:metadata xsi:type="met:BotVersion" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(botFullName)}</met:fullName>
+    ${escalationsXml}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+// ─── v2.4.0 — NEW SERVICE FUNCTIONS ──────────────────────────────────────────
+export async function createLightningAppPage(auth, params) {
+    return createFlexiPage(auth, { ...params, pageType: "AppPage" });
+}
+export async function deleteRecord(auth, params) {
+    try {
+        const client = createClient(auth);
+        await client.del(`/sobjects/${params.objectApiName}/${params.recordId}`);
+        return { success: true, fullName: params.recordId, created: false, message: `${params.objectApiName} record ${params.recordId} deleted successfully.` };
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function getSetupAuditTrail(auth, params) {
+    try {
+        const client = createClient(auth);
+        const conditions = [];
+        conditions.push(`CreatedDate >= ${params.startDate}T00:00:00Z`);
+        conditions.push(`CreatedDate <= ${params.endDate}T23:59:59Z`);
+        if (params.createdByUsername) conditions.push(`CreatedBy.Username = '${params.createdByUsername.replace(/'/g, "\\'")}'`);
+        if (params.section) conditions.push(`Section = '${params.section.replace(/'/g, "\\'")}'`);
+        const soql = `SELECT Id, CreatedDate, CreatedBy.Username, Section, Action, Display FROM SetupAuditTrail WHERE ${conditions.join(" AND ")} ORDER BY CreatedDate DESC LIMIT ${params.limit ?? 100}`;
+        const resp = await client.get(`/query?q=${encodeURIComponent(soql)}`);
+        const records = (resp.data.records ?? []).map((r) => ({
+            date: r.CreatedDate,
+            username: r.CreatedBy?.Username ?? "",
+            section: r.Section,
+            action: r.Action,
+            display: r.Display,
+        }));
+        return { success: true, totalSize: resp.data.totalSize, records, message: `${records.length} setup audit trail record(s) returned.` };
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function getLoginHistory(auth, params) {
+    try {
+        const client = createClient(auth);
+        const conditions = [];
+        conditions.push(`LoginTime >= ${params.startDate}T00:00:00Z`);
+        conditions.push(`LoginTime <= ${params.endDate}T23:59:59Z`);
+        if (params.username) conditions.push(`Username = '${params.username.replace(/'/g, "\\'")}'`);
+        if (params.status) conditions.push(`Status = '${params.status.replace(/'/g, "\\'")}'`);
+        const soql = `SELECT Id, LoginTime, Username, SourceIp, Browser, Platform, Status, LoginType FROM LoginHistory WHERE ${conditions.join(" AND ")} ORDER BY LoginTime DESC LIMIT ${params.limit ?? 100}`;
+        const resp = await client.get(`/query?q=${encodeURIComponent(soql)}`);
+        const records = (resp.data.records ?? []).map((r) => ({
+            loginTime: r.LoginTime,
+            username: r.Username,
+            sourceIp: r.SourceIp,
+            browser: r.Browser,
+            platform: r.Platform,
+            status: r.Status,
+            loginType: r.LoginType,
+        }));
+        return { success: true, totalSize: resp.data.totalSize, records, message: `${records.length} login history record(s) returned.` };
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function getEventLogs(auth, params) {
+    try {
+        const client = createClient(auth);
+        const soql = `SELECT Id, EventType, LogFile, LogDate, LogFileLength FROM EventLogFile WHERE EventType = '${params.eventType.replace(/'/g, "\\'")}' AND LogDate >= ${params.startDate}T00:00:00Z AND LogDate <= ${params.endDate}T23:59:59Z ORDER BY LogDate DESC LIMIT ${params.limit ?? 10}`;
+        const resp = await client.get(`/query?q=${encodeURIComponent(soql)}`);
+        const logFiles = resp.data.records ?? [];
+        if (logFiles.length === 0) {
+            return { success: true, totalSize: 0, logs: [], message: `No event log files found for type '${params.eventType}' in the specified date range.` };
+        }
+        const logs = [];
+        for (const logFile of logFiles.slice(0, 3)) {
+            if (!logFile.LogFile) continue;
+            try {
+                const csvResp = await fetchWithTimeout(`${auth.instanceUrl}${logFile.LogFile}`, {
+                    method: "GET",
+                    headers: { Authorization: `Bearer ${auth.accessToken}` },
+                }, 30_000);
+                if (csvResp.ok) {
+                    const csvText = await csvResp.text();
+                    const lines = csvText.split("\n").filter(l => l.trim());
+                    const headers = lines[0]?.split(",").map(h => h.replace(/"/g, "").trim()) ?? [];
+                    const rows = lines.slice(1, 21).map(line => {
+                        const values = line.split(",").map(v => v.replace(/"/g, "").trim());
+                        return Object.fromEntries(headers.map((h, i) => [h, values[i] ?? ""]));
+                    });
+                    logs.push({ logDate: logFile.LogDate, eventType: logFile.EventType, logFileLength: logFile.LogFileLength, entries: rows });
+                }
+            } catch {
+                logs.push({ logDate: logFile.LogDate, eventType: logFile.EventType, logFileLength: logFile.LogFileLength, entries: [], note: "Could not fetch log content." });
+            }
+        }
+        return { success: true, totalSize: resp.data.totalSize, logs, message: `${logs.length} event log file(s) returned.` };
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function getFieldHistory(auth, params) {
+    try {
+        const client = createClient(auth);
+        const historyObject = `${params.objectApiName}History`;
+        const fieldFilter = params.fields && params.fields.length > 0
+            ? ` AND Field IN (${params.fields.map(f => `'${f.replace(/'/g, "\\'")}'`).join(",")})`
+            : "";
+        const soql = `SELECT Id, Field, OldValue, NewValue, CreatedDate, CreatedBy.Username FROM ${historyObject} WHERE ParentId = '${params.recordId}'${fieldFilter} ORDER BY CreatedDate DESC LIMIT ${params.limit ?? 100}`;
+        const resp = await client.get(`/query?q=${encodeURIComponent(soql)}`);
+        const records = (resp.data.records ?? []).map((r) => ({
+            date: r.CreatedDate,
+            field: r.Field,
+            oldValue: r.OldValue,
+            newValue: r.NewValue,
+            changedBy: r.CreatedBy?.Username ?? "",
+        }));
+        return { success: true, totalSize: resp.data.totalSize, records, message: `${records.length} field history record(s) returned.` };
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function compareOrgs(params) {
+    const { execSync: exec } = await import("child_process");
+    function getAuthForAlias(alias) {
+        if (!/^[A-Za-z0-9_-]+$/.test(alias)) throw new Error(`Invalid org alias: ${alias}`);
+        let raw;
+        try {
+            raw = exec(`sf org display --target-org ${alias} --json`, { encoding: "utf-8", timeout: 30_000, env: { PATH: process.env["PATH"] ?? "" } });
+        } catch (e) {
+            throw new Error(`SF CLI failed for alias '${alias}': ${e instanceof Error ? sanitizeError(e.message) : "unknown error"}`);
+        }
+        const parsed = JSON.parse(raw);
+        const accessToken = parsed?.result?.accessToken;
+        const instanceUrl = parsed?.result?.instanceUrl;
+        if (!accessToken || !instanceUrl) throw new Error(`No credentials returned for alias '${alias}'.`);
+        return { instanceUrl: instanceUrl.replace(/\/$/, ""), accessToken };
+    }
+    try {
+        const sourceAuth = getAuthForAlias(params.sourceAlias);
+        const targetAuth = getAuthForAlias(params.targetAlias);
+        const metadataTypes = params.metadataTypes ?? ["ApexClass","Flow","CustomObject","PermissionSet","LightningComponentBundle"];
+        const results = { onlyInSource: [], onlyInTarget: [], differentInBoth: [], same: [] };
+        for (const mdType of metadataTypes) {
+            const [sourceList, targetList] = await Promise.all([
+                listMetadataType(sourceAuth, mdType),
+                listMetadataType(targetAuth, mdType),
+            ]);
+            if (!sourceList.success || !targetList.success) continue;
+            const sourceMap = new Map(sourceList.items.map(i => [i.fullName, i.lastModifiedDate]));
+            const targetMap = new Map(targetList.items.map(i => [i.fullName, i.lastModifiedDate]));
+            for (const [name, sourceDate] of sourceMap) {
+                if (!targetMap.has(name)) {
+                    results.onlyInSource.push({ type: mdType, fullName: name, lastModified: sourceDate });
+                } else {
+                    const targetDate = targetMap.get(name);
+                    if (sourceDate !== targetDate) {
+                        results.differentInBoth.push({ type: mdType, fullName: name, sourceLastModified: sourceDate, targetLastModified: targetDate });
+                    } else {
+                        results.same.push({ type: mdType, fullName: name });
+                    }
+                }
+            }
+            for (const [name, targetDate] of targetMap) {
+                if (!sourceMap.has(name)) {
+                    results.onlyInTarget.push({ type: mdType, fullName: name, lastModified: targetDate });
+                }
+            }
+        }
+        return { success: true, sourceAlias: params.sourceAlias, targetAlias: params.targetAlias,
+            summary: { onlyInSource: results.onlyInSource.length, onlyInTarget: results.onlyInTarget.length, different: results.differentInBoth.length, same: results.same.length },
+            onlyInSource: results.onlyInSource, onlyInTarget: results.onlyInTarget, differentInBoth: results.differentInBoth,
+            message: `Comparison complete. Source-only: ${results.onlyInSource.length}, Target-only: ${results.onlyInTarget.length}, Different: ${results.differentInBoth.length}, Same: ${results.same.length}` };
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createCertificate(auth, params) {
+    try {
+        const xml = `<met:metadata xsi:type="met:Certificate" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.certName)}</met:fullName>
+    <met:masterLabel>${x(params.label)}</met:masterLabel>
+    <met:keySize>${x(params.keySize ?? "2048")}</met:keySize>
+    <met:privateKeyExportable>${params.privateKeyExportable ? "true" : "false"}</met:privateKeyExportable>
+    ${params.expirationDate ? `<met:expirationDate>${x(params.expirationDate)}</met:expirationDate>` : ""}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createEventRelay(auth, params) {
+    try {
+        const xml = `<met:metadata xsi:type="met:EventRelayConfig" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.relayName)}</met:fullName>
+    <met:label>${x(params.label)}</met:label>
+    <met:eventChannel>${x(params.eventChannel)}</met:eventChannel>
+    <met:destinationType>${x(params.destinationType)}</met:destinationType>
+    <met:destinationResourceName>${x(params.destinationResourceName)}</met:destinationResourceName>
+    <met:state>${x(params.state ?? "RUN")}</met:state>
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createLetterhead(auth, params) {
+    try {
+        const xml = `<met:metadata xsi:type="met:Letterhead" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.letterheadName)}</met:fullName>
+    <met:available>true</met:available>
+    <met:backgroundColor>${x(params.bodyColor ?? "#FFFFFF")}</met:backgroundColor>
+    <met:bodyColor>${x(params.bodyColor ?? "#FFFFFF")}</met:bodyColor>
+    <met:description>${x(params.footerText ?? "")}</met:description>
+    <met:footer>
+        <met:backgroundColor>${x(params.footerColor ?? "#404040")}</met:backgroundColor>
+        <met:color>${x(params.footerFontColor ?? "#FFFFFF")}</met:color>
+        <met:fontFace>${x(params.fontName ?? "Arial")}</met:fontFace>
+        <met:fontSize>${params.fontSize ?? 12}</met:fontSize>
+        <met:height>60</met:height>
+        <met:horizontalAlignment>Center</met:horizontalAlignment>
+        <met:verticalAlignment>Bottom</met:verticalAlignment>
+    </met:footer>
+    <met:header>
+        <met:backgroundColor>${x(params.headerColor ?? "#0070D2")}</met:backgroundColor>
+        <met:color>${x(params.headerFontColor ?? "#FFFFFF")}</met:color>
+        <met:fontFace>${x(params.fontName ?? "Arial")}</met:fontFace>
+        <met:fontSize>${params.fontSize ?? 12}</met:fontSize>
+        <met:height>60</met:height>
+        <met:horizontalAlignment>Center</met:horizontalAlignment>
+        <met:verticalAlignment>Middle</met:verticalAlignment>
+    </met:header>
+    <met:name>${x(params.label)}</met:name>
+    <met:topLine>
+        <met:color>${x(params.topLineColor ?? "#0070D2")}</met:color>
+        <met:height>3</met:height>
+        <met:style>Solid</met:style>
+    </met:topLine>
+    <met:bottomLine>
+        <met:color>${x(params.bottomLineColor ?? "#0070D2")}</met:color>
+        <met:height>3</met:height>
+        <met:style>Solid</met:style>
+    </met:bottomLine>
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function sendEmail(auth, params) {
+    try {
+        const client = createClient(auth);
+        const emailBody = params.htmlBody || params.body || "";
+        const payload = {
+            inputs: [{
+                emailAddresses: params.toAddresses.join(","),
+                emailSubject: params.subject,
+                emailBody,
+                saveAsActivity: params.saveAsActivity ?? true,
+                senderAddress: "",
+                ...(params.whoId && { targetObjectId: params.whoId }),
+                ...(params.whatId && { whatId: params.whatId }),
+                ...(params.ccAddresses?.length && { ccAddresses: params.ccAddresses.join(",") }),
+            }],
+        };
+        const resp = await client.post("/actions/standard/emailSimple", payload);
+        const output = Array.isArray(resp.data) ? resp.data[0] : resp.data;
+        if (output?.isSuccess === false) {
+            const errMsg = output?.errors?.map((e) => e.message).join("; ") ?? "Email action failed.";
+            return { success: false, message: errMsg };
+        }
+        return { success: true, fullName: "sendEmail", created: false, message: `Email sent to ${params.toAddresses.join(", ")}.` };
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createEinsteinPrediction(auth, params) {
+    try {
+        const xml = `<met:metadata xsi:type="met:MLPredictionDefinition" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.predictionName)}</met:fullName>
+    <met:label>${x(params.label)}</met:label>
+    <met:active>false</met:active>
+    <met:negativeLabel>${x(params.negativeLabel ?? "No")}</met:negativeLabel>
+    <met:positiveLabel>${x(params.positiveLabel ?? "Yes")}</met:positiveLabel>
+    <met:predictionType>${x(params.predictionType)}</met:predictionType>
+    <met:status>Draft</met:status>
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+    ${params.pushbackField ? `<met:pushbackField>
+        <met:fieldName>${x(params.pushbackField)}</met:fieldName>
+        <met:objectName>${x(params.objectApiName)}</met:objectName>
+    </met:pushbackField>` : ""}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createNextBestAction(auth, params) {
+    try {
+        const recsXml = (params.recommendations ?? []).map(rec => `
+    <met:recommendationDefinitions>
+        <met:developerName>${x(rec.name)}</met:developerName>
+        <met:label>${x(rec.label)}</met:label>
+        <met:acceptanceLabel>${x(rec.acceptanceLabel ?? "Accept")}</met:acceptanceLabel>
+        <met:rejectionLabel>${x(rec.rejectionLabel ?? "Decline")}</met:rejectionLabel>
+        ${rec.actionReference ? `<met:actionReference>${x(rec.actionReference)}</met:actionReference>` : ""}
+    </met:recommendationDefinitions>`).join("");
+        const xml = `<met:metadata xsi:type="met:RecommendationStrategy" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.strategyName)}</met:fullName>
+    <met:label>${x(params.label)}</met:label>
+    <met:contextObjectName>${x(params.contextObjectApiName)}</met:contextObjectName>
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+    ${recsXml}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createEinsteinBot(auth, params) {
+    try {
+        const mlIntentsXml = (params.dialogs ?? []).map(d => `
+    <met:mlIntents>
+        <met:developerName>${x(d.name)}</met:developerName>
+        <met:label>${x(d.label)}</met:label>
+        ${(d.utterances ?? []).map(u => `<met:mlIntentUtterances><met:utterance>${x(u)}</met:utterance></met:mlIntentUtterances>`).join("")}
+    </met:mlIntents>`).join("");
+        const dialogsXml = (params.dialogs ?? [{ name: "Welcome", label: "Welcome", type: "Main", isGoalStep: false, messages: ["Hello! How can I help you today?"] }]).map(d => `
+    <met:botDialogs>
+        ${(d.messages ?? ["Hello!"]).map((msg, i) => `
+        <met:botSteps>
+            <met:conversationStepType>Message</met:conversationStepType>
+            <met:botMessage>${x(msg)}</met:botMessage>
+            <met:stepIdentifier>${x(d.name)}_step${i + 1}</met:stepIdentifier>
+        </met:botSteps>`).join("")}
+        <met:developerName>${x(d.name)}</met:developerName>
+        <met:isGoalStep>${d.isGoalStep ? "true" : "false"}</met:isGoalStep>
+        <met:label>${x(d.label)}</met:label>
+        <met:showInFooterMenu>false</met:showInFooterMenu>
+    </met:botDialogs>`).join("");
+        const botXml = `<met:metadata xsi:type="met:Bot" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.botName)}</met:fullName>
+    <met:label>${x(params.label)}</met:label>
+    <met:defaultLocale>${x(params.defaultLocale ?? "en_US")}</met:defaultLocale>
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+    <met:mlDomain>
+        <met:developerName>${x(params.botName)}_MLDomain</met:developerName>
+        <met:label>${x(params.label)} ML Domain</met:label>
+        ${mlIntentsXml}
+    </met:mlDomain>
+</met:metadata>`;
+        const botResult = await upsertMetadata(auth, botXml);
+        if (!botResult.success) return botResult;
+        const versionXml = `<met:metadata xsi:type="met:BotVersion" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.botName)}.v1</met:fullName>
+    ${dialogsXml}
+</met:metadata>`;
+        const versionResult = await upsertMetadata(auth, versionXml);
+        return { success: versionResult.success, fullName: params.botName, created: true, message: versionResult.success ? `Einstein Bot '${params.botName}' created with ${(params.dialogs ?? []).length || 1} dialog(s).` : versionResult.message };
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
 //# sourceMappingURL=salesforce.js.map