salesforce-metadata-mcp 2.3.0 → 2.4.0

package/CHANGELOG.md

@@ -1,5 +1,47 @@
 # Changelog
 
+## [2.4.0] - 2026-05-28
+
+### New Tools — 14 Additions Across 6 Categories
+
+#### Lightning Pages & App Builder (2 new)
+- `sf_create_lightning_app_page` — Create a Lightning App Page (FlexiPage of type AppPage) for use in Lightning Apps
+- `sf_create_letterhead` — Create email letterheads (Letterhead metadata) for Classic email templates
+
+#### Users & Data Management (2 new)
+- `sf_delete_record` — Delete a single SObject record by ID via REST API
+- `sf_send_email` — Send email from Salesforce via the emailSimple invocable action
+
+#### Audit Trail & Monitoring (4 new)
+- `sf_get_setup_audit_trail` — Query SetupAuditTrail for org configuration change history (last 6 months)
+- `sf_get_login_history` — Query LoginHistory for user login activity (source IP, browser, status)
+- `sf_get_event_logs` — Fetch and parse EventLogFile entries (Login, API, Report, Flow, Apex, LightningPageView, etc.)
+- `sf_get_field_history` — Query {Object}History for field-level change history on a specific record
+
+#### Deployment & Org Management (1 new)
+- `sf_compare_orgs` — Compare metadata between two orgs using SF CLI aliases; returns components only in source, only in target, or different in both
+
+#### Integration & Connectivity (2 new)
+- `sf_create_certificate` — Create a self-signed Certificate (Certificate metadata) for callout signing and SSO
+- `sf_create_event_relay` — Create an EventRelayConfig to relay Platform Events or CDC to Amazon EventBridge or another event bus
+
+#### Einstein & AI Features (3 new)
+- `sf_create_einstein_prediction` — Create an Einstein Prediction Builder definition (MLPredictionDefinition metadata) for binary classification or regression
+- `sf_create_next_best_action` — Create a Next Best Action recommendation strategy (RecommendationStrategy metadata)
+- `sf_create_einstein_bot` — Create a classic Einstein Bot with ML domain and conversation dialogs (Bot + BotVersion metadata)
+
+### Notes on Existing Tools
+The following tools requested in v2.4.0 were already present from earlier releases and are unchanged:
+- Security & Permissions: `sf_create_permission_set_group`, `sf_create_muting_permission_set`, `sf_set_field_level_security`, `sf_set_org_wide_defaults`, `sf_clone_profile`, `sf_update_profile`
+- Lightning Pages: `sf_create_lightning_record_page`, `sf_create_lightning_home_page`, `sf_update_lightning_page`, `sf_assign_lightning_page`, `sf_assign_compact_layout`
+- Reports & Dashboards: `sf_create_report`, `sf_update_dashboard`, `sf_create_report_folder`, `sf_share_report_folder`
+- Users & Data: `sf_create_user`, `sf_update_user`, `sf_assign_queue_member`, `sf_create_public_group`, `sf_query_records`, `sf_create_record`, `sf_update_record`, `sf_bulk_import_records`
+- Deployment: `sf_validate_deployment`, `sf_list_metadata`
+- Integrations: `sf_create_outbound_message`, `sf_create_auth_provider`
+- GitHub Actions workflows: present since v2.3.0 (ci.yml, publish.yml, sf-release-monitor.yml, api-version-bump.yml)
+
+---
+
 ## [2.3.0] - 2026-05-28
 
 ### New Tools — 30 Additions Across 8 Categories

package/README.md

@@ -1,10 +1,10 @@
 # salesforce-metadata-mcp
 
-[![Version](https://img.shields.io/badge/version-2.3.0-blue.svg)](https://npmjs.com/package/salesforce-metadata-mcp)
+[![Version](https://img.shields.io/badge/version-2.4.0-blue.svg)](https://npmjs.com/package/salesforce-metadata-mcp)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 [![MCP Compatible](https://img.shields.io/badge/MCP-Compatible-green.svg)](https://modelcontextprotocol.io)
 
-**The most comprehensive Salesforce MCP server.** 140+ tools for building, configuring, and automating Salesforce orgs directly from Claude or any MCP client — covering metadata, Apex, LWC, Agentforce agents, OmniStudio, OmniChannel, Experience Cloud, Field Service, Messaging, bulk data, users, reports, security, and more.
+**The most comprehensive Salesforce MCP server.** 155+ tools for building, configuring, and automating Salesforce orgs directly from Claude or any MCP client — covering metadata, Apex, LWC, Agentforce agents, OmniStudio, OmniChannel, Experience Cloud, Field Service, Messaging, Einstein AI, audit trail, bulk data, users, reports, security, and more.
 
 ---
 
@@ -46,6 +46,24 @@ See [SETUP.md](SETUP.md) for all authentication methods and detailed setup instr
 
 ---
 
+## What's New in v2.4.0
+
+14 new tools across 6 categories:
+
+- **Lightning App Page** — `sf_create_lightning_app_page` for Lightning App tab pages
+- **Letterhead** — `sf_create_letterhead` for Classic email template branding
+- **Record Delete** — `sf_delete_record` via REST API
+- **Email** — `sf_send_email` via the emailSimple invocable action
+- **Audit Trail** — `sf_get_setup_audit_trail`, `sf_get_login_history`, `sf_get_event_logs`, `sf_get_field_history`
+- **Org Comparison** — `sf_compare_orgs` using SF CLI aliases
+- **Certificates** — `sf_create_certificate` (self-signed, for callout signing/SSO)
+- **Event Relay** — `sf_create_event_relay` to Amazon EventBridge or event bus
+- **Einstein AI** — `sf_create_einstein_prediction`, `sf_create_next_best_action`, `sf_create_einstein_bot`
+
+See [CHANGELOG.md](CHANGELOG.md) for full release notes.
+
+---
+
 ## What's New in v2.3.0
 
 30 new tools across 8 categories:
@@ -82,7 +100,7 @@ See [CHANGELOG.md](CHANGELOG.md) for the full release notes.
 
 ---
 
-## Tools (140+)
+## Tools (155+)
 
 ### Objects & Fields
 | Tool | Description |
@@ -159,6 +177,8 @@ See [CHANGELOG.md](CHANGELOG.md) for the full release notes.
 | `sf_create_lightning_home_page` | Create a Lightning Home Page (FlexiPage) |
 | `sf_update_lightning_page` | Update an existing Lightning Page |
 | `sf_assign_lightning_page` | Assign a Lightning Page to an Experience site |
+| `sf_create_lightning_app_page` | Create a Lightning App Page (FlexiPage for App tabs) |
+| `sf_create_letterhead` | Create an email letterhead for Classic email templates |
 
 ### Apex, Visualforce & Aura
 | Tool | Description |
@@ -199,6 +219,8 @@ See [CHANGELOG.md](CHANGELOG.md) for the full release notes.
 | `sf_create_record` | Create a single SObject record |
 | `sf_update_record` | Update an existing SObject record by ID |
 | `sf_bulk_import_records` | Bulk insert/upsert/update/delete via Bulk API 2.0 |
+| `sf_delete_record` | Delete a single SObject record by ID |
+| `sf_send_email` | Send email from Salesforce via the emailSimple action |
 
 ### Experience Cloud
 | Tool | Description |
@@ -238,6 +260,8 @@ See [CHANGELOG.md](CHANGELOG.md) for the full release notes.
 | `sf_create_csp_setting` | Create CSP trusted sites for LWC |
 | `sf_create_outbound_message` | Create Workflow Outbound Messages |
 | `sf_create_auth_provider` | Create OAuth Auth Providers |
+| `sf_create_certificate` | Create a self-signed Certificate for callout signing/SSO |
+| `sf_create_event_relay` | Create an Event Relay to Amazon EventBridge or event bus |
 
 ### Change Sets & Deployment
 | Tool | Description |
@@ -249,6 +273,7 @@ See [CHANGELOG.md](CHANGELOG.md) for the full release notes.
 | `sf_check_deploy_status` | Check deployment job status |
 | `sf_retrieve_metadata` | Retrieve metadata from the org |
 | `sf_list_metadata` | List all components of a metadata type |
+| `sf_compare_orgs` | Compare metadata between two orgs using SF CLI aliases |
 
 ### OmniStudio
 | Tool | Description |
@@ -270,6 +295,21 @@ See [CHANGELOG.md](CHANGELOG.md) for the full release notes.
 | `sf_create_calculation_matrix` | Create a Calculation Matrix for rule-based lookups |
 | `sf_create_calculation_procedure` | Create a Calculation Procedure with multi-step logic |
 
+### Audit Trail & Monitoring
+| Tool | Description |
+|------|-------------|
+| `sf_get_setup_audit_trail` | Query SetupAuditTrail for org configuration change history |
+| `sf_get_login_history` | Query LoginHistory for user login activity |
+| `sf_get_event_logs` | Fetch and parse EventLogFile entries (Login, API, Flow, Apex, etc.) |
+| `sf_get_field_history` | Get field-level change history for a specific record |
+
+### Einstein & AI
+| Tool | Description |
+|------|-------------|
+| `sf_create_einstein_prediction` | Create an Einstein Prediction Builder definition |
+| `sf_create_next_best_action` | Create a Next Best Action recommendation strategy |
+| `sf_create_einstein_bot` | Create a classic Einstein Bot with dialogs |
+
 ### OmniChannel & Field Service
 | Tool | Description |
 |------|-------------|

package/dist/index.js

@@ -6,14 +6,14 @@ import { createServer } from "http";
 import { registerTools } from "./tools/index.js";
 const server = new McpServer({
     name: "salesforce-metadata-mcp",
-    version: "2.3.0",
+    version: "2.4.0",
 });
 registerTools(server);
 // ─── Transport: stdio ─────────────────────────────────────────────────────────
 async function runStdio() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error("Salesforce Metadata MCP server v2.3.0 running on stdio");
+    console.error("Salesforce Metadata MCP server v2.4.0 running on stdio");
 }
 // ─── Transport: HTTP ──────────────────────────────────────────────────────────
 function readBody(req) {
@@ -38,7 +38,7 @@ async function runHTTP() {
         const url = req.url ?? "/";
         if (url === "/health" && req.method === "GET") {
             res.writeHead(200, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ status: "ok", server: "salesforce-metadata-mcp", version: "2.3.0"}));
+            res.end(JSON.stringify({ status: "ok", server: "salesforce-metadata-mcp", version: "2.4.0"}));
             return;
         }
         if (url === "/mcp" && req.method === "POST") {
@@ -64,7 +64,7 @@ async function runHTTP() {
         res.end(JSON.stringify({ error: "Not found" }));
     });
     httpServer.listen(port, () => {
-        console.error(`Salesforce Metadata MCP server v2.3.0 running on http://localhost:${port}/mcp`);
+        console.error(`Salesforce Metadata MCP server v2.4.0 running on http://localhost:${port}/mcp`);
     });
 }
 // ─── Entry point ──────────────────────────────────────────────────────────────

package/dist/schemas/index.js

@@ -1667,4 +1667,127 @@ export const CreateBotRoutingSchema = z.object({
         action: z.enum(["TransferToQueue","EndChat","SetVariable"]).default("TransferToQueue"),
     })).optional().describe("Conditions that trigger transfer to human agent"),
 }).strict();
+// ─── v2.4.0 — NEW TOOLS ──────────────────────────────────────────────────────
+export const CreateLightningAppPageSchema = z.object({
+    pageName: z.string().min(1).max(80).regex(/^[A-Za-z][A-Za-z0-9_]*$/).describe("FlexiPage API name"),
+    label: z.string().min(1).describe("Page display label"),
+    template: z.string().default("AppDefaultTemplate").describe("Page template, e.g. AppDefaultTemplate, OneRegion, TwoColumn_LeftSidebar"),
+    components: z.array(FlexiComponentSchema).optional().describe("Components to add to the page"),
+    description: z.string().optional().describe("Page description"),
+}).strict();
+export const DeleteRecordSchema = z.object({
+    objectApiName: z.string().min(1).describe("SObject API name, e.g. 'Account'"),
+    recordId: z.string().min(15).max(18).describe("15 or 18 character Salesforce record ID"),
+}).strict();
+export const GetSetupAuditTrailSchema = z.object({
+    startDate: z.string().describe("Start date in ISO format, e.g. '2025-01-01'"),
+    endDate: z.string().describe("End date in ISO format, e.g. '2025-12-31'"),
+    createdByUsername: z.string().optional().describe("Filter by the username who made the change"),
+    section: z.string().optional().describe("Filter by section, e.g. 'Custom Fields', 'Profiles', 'Flows', 'Apex Classes'"),
+    limit: z.number().int().min(1).max(2000).default(100).describe("Maximum records to return"),
+}).strict();
+export const GetLoginHistorySchema = z.object({
+    startDate: z.string().describe("Start date in ISO format, e.g. '2025-01-01'"),
+    endDate: z.string().describe("End date in ISO format, e.g. '2025-12-31'"),
+    username: z.string().optional().describe("Filter by Salesforce username"),
+    status: z.string().optional().describe("Filter by login status, e.g. 'Success', 'Failed'"),
+    limit: z.number().int().min(1).max(2000).default(100).describe("Maximum records to return"),
+}).strict();
+export const GetEventLogsSchema = z.object({
+    eventType: z.string().describe("Event type, e.g. 'Login', 'API', 'Report', 'Flow', 'ApexExecution', 'LightningPageView', 'RestApi'"),
+    startDate: z.string().describe("Start date in ISO format, e.g. '2025-01-01'"),
+    endDate: z.string().describe("End date in ISO format, e.g. '2025-12-31'"),
+    limit: z.number().int().min(1).max(50).default(10).describe("Maximum log files to fetch"),
+}).strict();
+export const GetFieldHistorySchema = z.object({
+    objectApiName: z.string().min(1).describe("Object API name, e.g. 'Account', 'Case', 'Opportunity'"),
+    recordId: z.string().min(15).max(18).describe("Record ID to fetch history for"),
+    fields: z.array(z.string()).optional().describe("Optional field names to filter — returns all tracked fields if omitted"),
+    limit: z.number().int().min(1).max(500).default(100).describe("Maximum history records to return"),
+}).strict();
+export const CompareOrgsSchema = z.object({
+    sourceAlias: z.string().min(1).regex(/^[A-Za-z0-9_-]+$/).describe("SF CLI alias for the source org (run: sf org list to see aliases)"),
+    targetAlias: z.string().min(1).regex(/^[A-Za-z0-9_-]+$/).describe("SF CLI alias for the target org"),
+    metadataTypes: z.array(z.string()).default(["ApexClass","Flow","CustomObject","PermissionSet","LightningComponentBundle"]).describe("Metadata types to compare"),
+}).strict();
+export const CreateCertificateSchema = z.object({
+    certName: z.string().min(1).max(80).regex(/^[A-Za-z][A-Za-z0-9_]*$/).describe("Certificate API name"),
+    label: z.string().min(1).describe("Certificate display label"),
+    keySize: z.enum(["2048","4096"]).default("2048").describe("Key size in bits"),
+    expirationDate: z.string().optional().describe("Expiration date in ISO format, e.g. '2030-01-01'"),
+    privateKeyExportable: z.boolean().default(false).describe("Whether the private key can be exported"),
+}).strict();
+export const CreateEventRelaySchema = z.object({
+    relayName: z.string().min(1).max(80).regex(/^[A-Za-z][A-Za-z0-9_]*$/).describe("Event relay API name"),
+    label: z.string().min(1).describe("Display label"),
+    eventChannel: z.string().min(1).describe("Platform event or CDC channel API name, e.g. 'My_Event__e' or 'AccountChangeEvent'"),
+    destinationType: z.enum(["AmazonEventBridge","EventBus"]).describe("Destination type for the relay"),
+    destinationResourceName: z.string().min(1).describe("ARN or event bus name for the destination"),
+    state: z.enum(["RUN","STOP","PAUSE"]).default("RUN").describe("Initial relay state"),
+    description: z.string().optional().describe("Relay description"),
+}).strict();
+export const CreateLetterheadSchema = z.object({
+    letterheadName: z.string().min(1).max(80).regex(/^[A-Za-z][A-Za-z0-9_]*$/).describe("Letterhead API name"),
+    label: z.string().min(1).describe("Letterhead display name"),
+    headerColor: z.string().default("#0070D2").describe("Header background color (hex)"),
+    headerFontColor: z.string().default("#FFFFFF").describe("Header text color"),
+    bodyColor: z.string().default("#FFFFFF").describe("Body background color"),
+    footerColor: z.string().default("#404040").describe("Footer background color"),
+    footerFontColor: z.string().default("#FFFFFF").describe("Footer text color"),
+    fontName: z.string().default("Arial").describe("Font name, e.g. 'Arial', 'Helvetica', 'Times New Roman'"),
+    fontSize: z.number().int().default(12).describe("Font size in points"),
+    footerText: z.string().optional().describe("Footer text content"),
+    topLineColor: z.string().default("#0070D2").describe("Top separator line color"),
+    bottomLineColor: z.string().default("#0070D2").describe("Bottom separator line color"),
+}).strict();
+export const SendEmailSchema = z.object({
+    toAddresses: z.array(z.string()).min(1).describe("Recipient email addresses"),
+    subject: z.string().min(1).describe("Email subject line"),
+    body: z.string().optional().describe("Plain text email body"),
+    htmlBody: z.string().optional().describe("HTML email body (takes precedence over body)"),
+    templateName: z.string().optional().describe("Email template API name (uses template instead of body)"),
+    whatId: z.string().optional().describe("Related record ID (e.g. Opportunity or Case ID)"),
+    whoId: z.string().optional().describe("Contact or Lead ID"),
+    saveAsActivity: z.boolean().default(true).describe("Save email as an Activity record"),
+    useSignature: z.boolean().default(false).describe("Append running user's email signature"),
+    ccAddresses: z.array(z.string()).optional().describe("CC email addresses"),
+}).strict();
+export const CreateEinsteinPredictionSchema = z.object({
+    predictionName: z.string().min(1).max(80).regex(/^[A-Za-z][A-Za-z0-9_]*$/).describe("Prediction API name"),
+    label: z.string().min(1).describe("Prediction display label"),
+    objectApiName: z.string().min(1).describe("Salesforce object to run predictions on, e.g. 'Opportunity'"),
+    predictionType: z.enum(["BinaryClassification","Regression"]).describe("BinaryClassification for yes/no, Regression for numeric"),
+    targetField: z.string().min(1).describe("Field API name to predict"),
+    positiveLabel: z.string().default("Yes").describe("Label for positive outcome (BinaryClassification only)"),
+    negativeLabel: z.string().default("No").describe("Label for negative outcome (BinaryClassification only)"),
+    pushbackField: z.string().optional().describe("Field to write the prediction score to, e.g. 'Win_Score__c'"),
+    description: z.string().optional().describe("Prediction description"),
+}).strict();
+export const CreateNextBestActionSchema = z.object({
+    strategyName: z.string().min(1).max(80).regex(/^[A-Za-z][A-Za-z0-9_]*$/).describe("Strategy API name"),
+    label: z.string().min(1).describe("Strategy display label"),
+    contextObjectApiName: z.string().min(1).describe("Object that provides context, e.g. 'Account', 'Case'"),
+    recommendations: z.array(z.object({
+        name: z.string().min(1).describe("Recommendation developer name"),
+        label: z.string().min(1).describe("Label shown to users"),
+        acceptanceLabel: z.string().default("Accept").describe("Accept button label"),
+        rejectionLabel: z.string().default("Decline").describe("Reject button label"),
+        actionReference: z.string().optional().describe("Flow API name to execute on acceptance"),
+    })).optional().describe("Recommendation definitions"),
+    description: z.string().optional().describe("Strategy description"),
+}).strict();
+export const CreateEinsteinBotSchema = z.object({
+    botName: z.string().min(1).max(40).regex(/^[A-Za-z][A-Za-z0-9_]*$/).describe("Bot API name"),
+    label: z.string().min(1).describe("Bot display label"),
+    defaultLocale: z.string().default("en_US").describe("Default language/locale, e.g. 'en_US', 'fr', 'de'"),
+    description: z.string().optional().describe("Bot description"),
+    dialogs: z.array(z.object({
+        name: z.string().min(1).describe("Dialog developer name"),
+        label: z.string().min(1).describe("Dialog display label"),
+        type: z.enum(["Main","System","Rule"]).default("Main").describe("Dialog type"),
+        isGoalStep: z.boolean().default(false).describe("Whether this dialog represents goal completion"),
+        utterances: z.array(z.string()).optional().describe("Training utterances that trigger this dialog"),
+        messages: z.array(z.string()).optional().describe("Bot messages to show"),
+    })).optional().describe("Bot dialogs"),
+}).strict();
 //# sourceMappingURL=index.js.map

package/dist/services/salesforce.js

@@ -3320,4 +3320,362 @@ export async function createBotRouting(auth, params) {
         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

package/dist/tools/audit.js

@@ -0,0 +1,96 @@
+import {
+    GetSetupAuditTrailSchema, GetLoginHistorySchema, GetEventLogsSchema, GetFieldHistorySchema,
+} from "../schemas/index.js";
+import { getAuth, getSetupAuditTrail, getLoginHistory, getEventLogs, getFieldHistory } from "../services/salesforce.js";
+import { resultContent } from "./utils.js";
+
+export function registerAuditTools(server) {
+    server.registerTool("sf_get_setup_audit_trail", {
+        title: "Get Setup Audit Trail",
+        description: `Queries the SetupAuditTrail object to see who made what configuration changes to the org, and when. Covers the last 6 months of setup activity.
+
+Returns records with: date, username, section, action, display (human-readable description)
+
+section filter examples: 'Custom Fields', 'Profiles', 'Flows', 'Apex Classes', 'Permission Sets', 'Connected Apps', 'Users'
+
+Useful for:
+- Security audits (who changed profiles or permissions)
+- Debugging unexpected configuration changes
+- Compliance reporting on org configuration changes`,
+        inputSchema: GetSetupAuditTrailSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await getSetupAuditTrail(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_get_login_history", {
+        title: "Get Login History",
+        description: `Queries LoginHistory to see user login activity — who logged in, from where, and whether they succeeded.
+
+Returns records with: loginTime, username, sourceIp, browser, platform, status, loginType
+
+status values: 'Success', 'Failed', 'No Password', 'Blocked', 'No Cookie'
+loginType values: 'Application', 'API', 'SAML', 'OAuth', 'LightningLogin', 'Chatter'
+
+Useful for:
+- Security monitoring (failed logins, unusual IP addresses)
+- Compliance auditing (who accessed the org and when)
+- Investigating suspicious account activity
+
+Note: LoginHistory covers the past 6 months.`,
+        inputSchema: GetLoginHistorySchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await getLoginHistory(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_get_event_logs", {
+        title: "Get Event Log Files",
+        description: `Queries EventLogFile for detailed activity logs. Event logs capture granular org activity for security monitoring and performance analysis.
+
+Common eventType values:
+- Login — login attempts and results
+- API — SOAP/REST API calls
+- Report — report executions
+- Flow — Flow runs and executions
+- ApexExecution — Apex code executions
+- LightningPageView — Lightning page views
+- RestApi — REST API requests
+- VisualforceRequest — Visualforce page requests
+- URI — general HTTP requests
+- LightningError — Lightning component errors
+
+Returns parsed CSV log entries (up to 20 rows per log file, up to 3 files per call).
+
+Requires Event Monitoring add-on OR Agentforce debug logs to be enabled.`,
+        inputSchema: GetEventLogsSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await getEventLogs(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_get_field_history", {
+        title: "Get Field History for a Record",
+        description: `Queries the {Object}History object to retrieve a field-level change history for a specific record. Shows what changed, when, the old and new values, and who made the change.
+
+Returns records with: date, field, oldValue, newValue, changedBy
+
+objectApiName: the SObject with history tracking enabled, e.g. 'Account', 'Opportunity', 'Case'
+recordId: the specific record to retrieve history for
+
+Note: Field history tracking must be enabled for the object and for each field you want to track (Setup → Object Manager → {Object} → Fields & Relationships → Field History Tracking). History is retained for up to 18 months.`,
+        inputSchema: GetFieldHistorySchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await getFieldHistory(auth, params);
+        return resultContent(result);
+    });
+}
+//# sourceMappingURL=audit.js.map

package/dist/tools/data.js

@@ -1,5 +1,5 @@
-import { CreateUserSchema, UpdateUserSchema, AssignQueueMemberSchema, CreatePublicGroupSchema, QueryRecordsSchema, CreateRecordSchema, UpdateRecordSchema, BulkImportRecordsSchema, } from "../schemas/index.js";
-import { getAuth, createUser, updateUser, assignQueueMember, createPublicGroup, queryRecords, createRecord, updateRecord, bulkImportRecords, } from "../services/salesforce.js";
+import { CreateUserSchema, UpdateUserSchema, AssignQueueMemberSchema, CreatePublicGroupSchema, QueryRecordsSchema, CreateRecordSchema, UpdateRecordSchema, BulkImportRecordsSchema, DeleteRecordSchema, SendEmailSchema, } from "../schemas/index.js";
+import { getAuth, createUser, updateUser, assignQueueMember, createPublicGroup, queryRecords, createRecord, updateRecord, bulkImportRecords, deleteRecord, sendEmail, } from "../services/salesforce.js";
 import { resultContent } from "./utils.js";
 export function registerDataTools(server) {
     server.registerTool("sf_create_user", {
@@ -82,5 +82,36 @@ export function registerDataTools(server) {
         const result = await bulkImportRecords(auth, params);
         return resultContent(result);
     });
+    server.registerTool("sf_delete_record", {
+        title: "Delete SObject Record",
+        description: `Deletes a single SObject record by record ID via the Salesforce REST API. The deletion is permanent and cannot be undone (the record goes to the Recycle Bin for objects that support it, from where it can be undeleted within 15 days).
+
+Provide the object API name and the 15 or 18 character record ID. For bulk deletions (100+ records), use sf_bulk_import_records with operation='delete'.`,
+        inputSchema: DeleteRecordSchema,
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await deleteRecord(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_send_email", {
+        title: "Send Email via Salesforce",
+        description: `Sends an email from Salesforce using the emailSimple invocable action. The email is sent from the running user's email address through Salesforce's email infrastructure (respects org email deliverability settings).
+
+toAddresses: one or more recipient email addresses
+body / htmlBody: email body content (htmlBody takes precedence)
+templateName: use an existing email template instead of providing body text
+whatId: related record ID (e.g. Opportunity, Case) — links the email as an activity
+whoId: Contact or Lead ID — links the email to the person record
+saveAsActivity: saves the email as an EmailMessage activity (default: true)
+
+Note: Salesforce email limits apply (daily email limits based on org edition). Mass emails should use list email features instead.`,
+        inputSchema: SendEmailSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await sendEmail(auth, params);
+        return resultContent(result);
+    });
 }
 //# sourceMappingURL=data.js.map

package/dist/tools/deployment.js

@@ -1,5 +1,5 @@
-import { CreateOutboundChangeSetSchema, AddToChangeSetSchema, DeployMetadataSchema, CheckDeployStatusSchema, RetrieveMetadataSchema, ValidateDeploymentSchema, ListMetadataSchema, } from "../schemas/index.js";
-import { getAuth, listMetadataForTool } from "../services/salesforce.js";
+import { CreateOutboundChangeSetSchema, AddToChangeSetSchema, DeployMetadataSchema, CheckDeployStatusSchema, RetrieveMetadataSchema, ValidateDeploymentSchema, ListMetadataSchema, CompareOrgsSchema, } from "../schemas/index.js";
+import { getAuth, listMetadataForTool, compareOrgs } from "../services/salesforce.js";
 import { buildGenericDeployZip, deployZip, pollDeployStatus, checkDeployStatus, retrieveMetadata, } from "../services/deployment.js";
 import { createOutboundChangeSet, addComponentsToChangeSet, } from "../services/tooling.js";
 import { resultContent } from "./utils.js";
@@ -121,5 +121,25 @@ export function registerDeploymentTools(server) {
         const result = await listMetadataForTool(auth, params.metadataType);
         return resultContent(result);
     });
+    server.registerTool("sf_compare_orgs", {
+        title: "Compare Metadata Between Two Orgs",
+        description: `Compares metadata components of specified types between two Salesforce orgs using their SF CLI aliases. Returns components that exist only in the source, only in the target, or differ between both.
+
+Requires the Salesforce CLI to be installed and both org aliases to be authenticated (run: sf org list to see available aliases).
+
+sourceAlias / targetAlias: SF CLI org aliases (letters, numbers, hyphens, underscores only)
+metadataTypes: list of metadata types to compare — defaults to common types (ApexClass, Flow, CustomObject, PermissionSet, LightningComponentBundle)
+
+Returns:
+- onlyInSource: components in source that don't exist in target
+- onlyInTarget: components in target that don't exist in source
+- differentInBoth: components that exist in both but have different lastModifiedDate
+- summary: counts for each category`,
+        inputSchema: CompareOrgsSchema,
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const result = await compareOrgs(params);
+        return resultContent(result);
+    });
 }
 //# sourceMappingURL=deployment.js.map

package/dist/tools/einstein.js

@@ -0,0 +1,79 @@
+import {
+    CreateEinsteinPredictionSchema, CreateNextBestActionSchema, CreateEinsteinBotSchema,
+} from "../schemas/index.js";
+import { getAuth, createEinsteinPrediction, createNextBestAction, createEinsteinBot } from "../services/salesforce.js";
+import { resultContent } from "./utils.js";
+
+export function registerEinsteinTools(server) {
+    server.registerTool("sf_create_einstein_prediction", {
+        title: "Create Einstein Prediction (ML Prediction Definition)",
+        description: `Creates an Einstein Prediction Builder prediction definition (MLPredictionDefinition metadata type). Predictions analyze historical Salesforce data to score or classify records automatically.
+
+predictionType:
+- BinaryClassification: predict a yes/no outcome (e.g. Will this opportunity close? Is this lead likely to convert?)
+- Regression: predict a numeric value (e.g. Expected revenue, likelihood score)
+
+targetField: the field the prediction is based on (e.g. 'IsWon' for BinaryClassification on Opportunity)
+pushbackField: an existing custom field to write the prediction score to automatically
+
+IMPORTANT: Einstein Prediction Builder requires an Einstein Analytics license or the Einstein Platform add-on. If the org lacks this license, the metadata deployment will succeed but the prediction cannot be trained or activated. This tool creates the definition — training happens in Setup → Einstein → Prediction Builder.
+
+The prediction is created in Draft status. Activate it from Setup after training is complete.`,
+        inputSchema: CreateEinsteinPredictionSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createEinsteinPrediction(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_create_next_best_action", {
+        title: "Create Next Best Action Strategy",
+        description: `Creates a Next Best Action (NBA) recommendation strategy (RecommendationStrategy metadata type). NBA strategies surface contextual recommendations to agents and customers on record pages, communities, and chatbots.
+
+A strategy defines:
+- contextObjectApiName: the record type that provides context (e.g. 'Account', 'Case', 'Opportunity')
+- recommendations: a list of actions the agent can offer, each with Accept/Decline buttons and an optional Flow to execute on acceptance
+
+NBA strategies can be displayed via:
+- Einstein Next Best Action component on a Lightning Record Page
+- OmniScripts and FlexCards
+- Service Console
+
+After creating, add the "Einstein Next Best Action" Lightning component to a record page and configure it to use this strategy.`,
+        inputSchema: CreateNextBestActionSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createNextBestAction(auth, params);
+        return resultContent(result);
+    });
+
+    server.registerTool("sf_create_einstein_bot", {
+        title: "Create Einstein Bot (Classic)",
+        description: `Creates a classic Einstein Bot (Bot + BotVersion metadata types) with one or more conversation dialogs. Classic Einstein Bots handle chat and messaging channels via rule-based and ML-powered conversation flows.
+
+Note: For AI-first agents using large language models, use sf_create_agent (Agentforce/Einstein Service Agent) instead. Classic Einstein Bots are best suited for:
+- Structured FAQ automation
+- Simple data collection workflows
+- Channels that don't support Agentforce (SMS, WhatsApp via classic routing)
+
+Each dialog defines:
+- name/label: the dialog identifier
+- utterances: training phrases that trigger this dialog
+- messages: bot responses shown to the user
+- type: Main (user-facing), System (internal), Rule (condition-based)
+
+The bot is created with an ML domain for intent classification. After creation:
+1. Train the bot in Setup → Einstein Bots → {BotName} → Train
+2. Activate the bot
+3. Connect it to a messaging channel or chat button`,
+        inputSchema: CreateEinsteinBotSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createEinsteinBot(auth, params);
+        return resultContent(result);
+    });
+}
+//# sourceMappingURL=einstein.js.map

package/dist/tools/index.js

@@ -14,6 +14,8 @@ import { registerReportTools } from "./reports.js";
 import { registerDataTools } from "./data.js";
 import { registerOmniStudioTools } from "./omnistudio.js";
 import { registerOmniChannelTools } from "./omnichannel.js";
+import { registerAuditTools } from "./audit.js";
+import { registerEinsteinTools } from "./einstein.js";
 export function registerTools(server) {
     registerMetadataTools(server);
     registerObjectTools(server);
@@ -31,5 +33,7 @@ export function registerTools(server) {
     registerDataTools(server);
     registerOmniStudioTools(server);
     registerOmniChannelTools(server);
+    registerAuditTools(server);
+    registerEinsteinTools(server);
 }
 //# sourceMappingURL=index.js.map

package/dist/tools/integrations.js

@@ -1,5 +1,5 @@
-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 { CreateConnectedAppSchema, CreateExternalDataSourceSchema, CreateExternalObjectSchema, CreateRemoteSiteSettingSchema, CreateCspSettingSchema, CreateOutboundMessageSchema, CreateAuthProviderSchema, CreateCertificateSchema, CreateEventRelaySchema, } from "../schemas/index.js";
+import { getAuth, createConnectedApp, createExternalDataSource, createExternalObject, createRemoteSiteSetting, createCspSetting, createOutboundMessage, createAuthProvider, createCertificate, createEventRelay, } from "../services/salesforce.js";
 import { resultContent } from "./utils.js";
 export function registerIntegrationTools(server) {
     server.registerTool("sf_create_connected_app", {
@@ -112,5 +112,42 @@ export function registerIntegrationTools(server) {
         const result = await createAuthProvider(auth, params);
         return resultContent(result);
     });
+    server.registerTool("sf_create_certificate", {
+        title: "Create Self-Signed Certificate",
+        description: `Creates a self-signed certificate in Salesforce (Certificate metadata type). Certificates are used for:
+- Signing outbound callouts (mutual TLS / client certificate authentication)
+- Signing SAML assertions for SSO
+- Encrypting/decrypting data in Named Credentials
+
+keySize: 2048 (standard) or 4096 (high security)
+expirationDate: optional ISO date for the certificate expiry (e.g. '2030-01-01')
+privateKeyExportable: set true only if you need to export the private key (not recommended for production)
+
+After creation, the certificate can be referenced in Named Credentials and Connected Apps.`,
+        inputSchema: CreateCertificateSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createCertificate(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_create_event_relay", {
+        title: "Create Event Relay Configuration",
+        description: `Creates an EventRelayConfig that relays Salesforce Platform Events or Change Data Capture events to an external event bus (Amazon EventBridge or another Salesforce event bus).
+
+eventChannel: the Platform Event or CDC channel to relay, e.g. 'MyEvent__e', 'AccountChangeEvent', or 'data/ChangeEvents' for all CDC
+destinationType: AmazonEventBridge or EventBus
+destinationResourceName: ARN for Amazon EventBridge (e.g. 'arn:aws:events:us-east-1:123456789:event-bus/my-bus') or target event bus name
+
+state: RUN (immediately start relaying), STOP (create but don't relay), PAUSE (temporarily paused)
+
+Requires Event Relay entitlement in the org. For Amazon EventBridge, the AWS partner event source must be set up first.`,
+        inputSchema: CreateEventRelaySchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createEventRelay(auth, params);
+        return resultContent(result);
+    });
 }
 //# sourceMappingURL=integrations.js.map

package/dist/tools/ui.js

@@ -1,5 +1,5 @@
-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 { CreateLightningAppSchema, CreateTabSchema, CreateCompactLayoutSchema, CreateListViewSchema, CreateEmailTemplateSchema, CreateStaticResourceSchema, CreateCustomNotificationTypeSchema, CreateReportTypeSchema, CreateDashboardSchema, UpdatePageLayoutSchema, AssignPageLayoutSchema, CreateLightningRecordPageSchema, CreateLightningHomePageSchema, UpdateLightningPageSchema, AssignLightningPageSchema, AssignCompactLayoutSchema, CreateLightningAppPageSchema, CreateLetterheadSchema, } from "../schemas/index.js";
+import { getAuth, createLightningApp, createTab, createCompactLayout, createListView, createEmailTemplate, createCustomNotificationType, createReportType, updatePageLayout, assignPageLayout, createFlexiPage, updateFlexiPage, assignFlexiPage, assignCompactLayout, createLightningAppPage, createLetterhead, } from "../services/salesforce.js";
 import { buildStaticResourceZip, deployZip, pollDeployStatus, } from "../services/deployment.js";
 import { API_VERSION } from "../services/salesforce.js";
 import { resultContent } from "./utils.js";
@@ -261,5 +261,35 @@ export function registerUiTools(server) {
         const result = await assignCompactLayout(auth, params);
         return resultContent(result);
     });
+    server.registerTool("sf_create_lightning_app_page", {
+        title: "Create Lightning App Page (FlexiPage)",
+        description: `Creates a Lightning App Page (FlexiPage of type AppPage) for use in Lightning Apps. App Pages appear as tabs in a Lightning App and can display dashboards, lists, and custom components.
+
+template options: AppDefaultTemplate (single region), OneRegion, TwoColumn_LeftSidebar, TwoColumn_RightSidebar, ThreeColumn
+
+After creating, assign the page to a Lightning App via App Manager in Setup, or use the Lightning App Builder to activate it.`,
+        inputSchema: CreateLightningAppPageSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createLightningAppPage(auth, params);
+        return resultContent(result);
+    });
+    server.registerTool("sf_create_letterhead", {
+        title: "Create Email Letterhead",
+        description: `Creates an email letterhead (Letterhead metadata type) for use with Classic email templates. Letterheads define the visual branding of email templates — header/footer colors, fonts, separator lines, and logo placement.
+
+After creating a letterhead, reference it by API name when creating email templates (sf_create_email_template with htmlValue that includes the letterhead).
+
+headerColor/footerColor/bodyColor: hex color values (e.g. '#0070D2')
+fontName: font face, e.g. 'Arial', 'Helvetica', 'Times New Roman'
+footerText: optional static text shown in the footer`,
+        inputSchema: CreateLetterheadSchema,
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, async (params) => {
+        const auth = await getAuth();
+        const result = await createLetterhead(auth, params);
+        return resultContent(result);
+    });
 }
 //# sourceMappingURL=ui.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "salesforce-metadata-mcp",
-  "version": "2.3.0",
-  "description": "The most comprehensive Salesforce MCP server: 140+ tools for metadata, Apex, LWC, Agentforce, OmniStudio, OmniChannel, Experience Cloud, Field Service, Messaging, bulk data, users, reports, security, and more",
+  "version": "2.4.0",
+  "description": "The most comprehensive Salesforce MCP server: 155+ tools covering custom objects, flows, Apex, LWC, page layouts, permissions, profiles, users, reports, dashboards, Experience Cloud, OmniStudio, OmniChannel, Agentforce, Einstein AI, audit trail, and more — everything a Salesforce admin, advanced admin and developer needs.",
   "license": "MIT",
   "private": false,
   "type": "module",
@@ -70,7 +70,18 @@
     "messaging",
     "live-chat",
     "skill-routing",
-    "presence"
+    "presence",
+    "einstein",
+    "next-best-action",
+    "audit-trail",
+    "login-history",
+    "lightning-page",
+    "flexipage",
+    "app-builder",
+    "letterhead",
+    "soql",
+    "github-actions",
+    "ci-cd"
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.29.0",