@mindstone/mcp-server-salesforce 0.1.2

package/dist/client.js

@@ -0,0 +1,118 @@
+import jsforce from 'jsforce';
+import { ConnectorError, } from './types.js';
+import { getAuthMode, getActiveToken, loadAccounts, loadToken, saveToken, deleteToken, saveAccounts, } from './auth.js';
+// Connection cache per account
+const connections = new Map();
+function getLoginUrl(tokenData) {
+    if (tokenData.login_url)
+        return tokenData.login_url;
+    const isSandbox = tokenData.instance_url.includes('test.salesforce.com') ||
+        tokenData.instance_url.includes('.sandbox.') ||
+        tokenData.instance_url.includes('.scratch.');
+    return isSandbox
+        ? 'https://test.salesforce.com'
+        : 'https://login.salesforce.com';
+}
+/**
+ * Ensure the connector is in a mode that can make API calls.
+ */
+export function requireAuth() {
+    const mode = getAuthMode();
+    if (mode === 'unconfigured') {
+        throw new ConnectorError('No Salesforce authentication configured', 'UNCONFIGURED', 'Set up authentication: (1) Set SALESFORCE_CLIENT_ID and SALESFORCE_CLIENT_SECRET for OAuth, or (2) Set SALESFORCE_ACCESS_TOKEN and SALESFORCE_INSTANCE_URL for manual token mode. See README for details.');
+    }
+}
+/**
+ * Get a jsforce connection for the current account.
+ */
+export async function getConnection(accountId) {
+    requireAuth();
+    const { accountId: resolvedId, token: tokenData } = accountId
+        ? { accountId, token: loadToken(accountId) }
+        : getActiveToken();
+    if (!tokenData) {
+        throw new ConnectorError(`Account ${accountId} not found`, 'ACCOUNT_NOT_FOUND', 'Call salesforce_connect_account to connect.');
+    }
+    // Check cache
+    const cached = connections.get(resolvedId);
+    if (cached)
+        return cached;
+    const loginUrl = getLoginUrl(tokenData);
+    const clientId = process.env.SALESFORCE_CLIENT_ID;
+    const clientSecret = process.env.SALESFORCE_CLIENT_SECRET;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const connectionConfig = {
+        instanceUrl: tokenData.instance_url,
+        accessToken: tokenData.access_token,
+        refreshToken: tokenData.refresh_token,
+    };
+    if (clientId && clientSecret && tokenData.refresh_token) {
+        connectionConfig.oauth2 = { clientId, clientSecret, loginUrl };
+    }
+    const conn = new jsforce.Connection(connectionConfig);
+    conn.on('refresh', async (accessToken) => {
+        console.error(`[Salesforce MCP] Token refreshed for account ${resolvedId}`);
+        const updatedToken = {
+            ...tokenData,
+            access_token: accessToken,
+            expires_at: Date.now() + 2 * 60 * 60 * 1000,
+        };
+        saveToken(resolvedId, updatedToken);
+    });
+    connections.set(resolvedId, conn);
+    return conn;
+}
+/**
+ * Execute an operation with a jsforce connection, handling session expiry.
+ */
+export async function withConnection(accountId, operation) {
+    requireAuth();
+    const { accountId: resolvedId } = accountId
+        ? { accountId }
+        : getActiveToken();
+    const conn = await getConnection(resolvedId);
+    try {
+        return await operation(conn);
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            (error.message.includes('INVALID_SESSION_ID') ||
+                error.message.includes('Session expired'))) {
+            // Clear cached connection on session expiry
+            connections.delete(resolvedId);
+            throw new ConnectorError('Session expired', 'SESSION_EXPIRED', 'Call salesforce_connect_account to re-connect.');
+        }
+        throw error;
+    }
+}
+/**
+ * List all connected accounts with their status.
+ */
+export function listConnectedAccounts() {
+    const config = loadAccounts();
+    return config.accounts.map((a) => {
+        const token = loadToken(a.id);
+        return {
+            ...a,
+            is_sandbox: a.instance_url?.includes('test.salesforce.com') ||
+                a.instance_url?.includes('.sandbox.') ||
+                false,
+        };
+    });
+}
+/**
+ * Remove a connected account.
+ */
+export function removeAccount(usernameOrId) {
+    const config = loadAccounts();
+    const account = config.accounts.find((a) => a.username === usernameOrId || a.id === usernameOrId);
+    if (!account) {
+        throw new ConnectorError(`Account not found: ${usernameOrId}`, 'ACCOUNT_NOT_FOUND', 'Use salesforce_list_connected_accounts to see connected accounts.');
+    }
+    connections.delete(account.id);
+    deleteToken(account.id);
+    config.accounts = config.accounts.filter((a) => a.id !== account.id);
+    saveAccounts(config);
+    console.error(`[Salesforce MCP] Removed account: ${account.username}`);
+}
+//# sourceMappingURL=client.js.map

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+/**
+ * Salesforce MCP Server
+ *
+ * Provides Salesforce CRM integration via Model Context Protocol.
+ * Accounts, contacts, opportunities, leads, tasks, users, and custom objects.
+ *
+ * Environment variables:
+ * - SALESFORCE_CLIENT_ID: OAuth client ID (for standalone OAuth mode)
+ * - SALESFORCE_CLIENT_SECRET: OAuth client secret (for standalone OAuth mode)
+ * - SALESFORCE_ACCESS_TOKEN: Static access token (for manual token mode)
+ * - SALESFORCE_INSTANCE_URL: Salesforce instance URL (for manual token mode)
+ * - SALESFORCE_CONFIG_DIR: Custom config directory (default: ~/.mcp/salesforce)
+ * - SALESFORCE_SANDBOX: Set to "true" for sandbox environments
+ * - MCP_HOST_BRIDGE_STATE: Path to host app bridge state file (optional)
+ */
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+/**
+ * Salesforce MCP Server
+ *
+ * Provides Salesforce CRM integration via Model Context Protocol.
+ * Accounts, contacts, opportunities, leads, tasks, users, and custom objects.
+ *
+ * Environment variables:
+ * - SALESFORCE_CLIENT_ID: OAuth client ID (for standalone OAuth mode)
+ * - SALESFORCE_CLIENT_SECRET: OAuth client secret (for standalone OAuth mode)
+ * - SALESFORCE_ACCESS_TOKEN: Static access token (for manual token mode)
+ * - SALESFORCE_INSTANCE_URL: Salesforce instance URL (for manual token mode)
+ * - SALESFORCE_CONFIG_DIR: Custom config directory (default: ~/.mcp/salesforce)
+ * - SALESFORCE_SANDBOX: Set to "true" for sandbox environments
+ * - MCP_HOST_BRIDGE_STATE: Path to host app bridge state file (optional)
+ */
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createServer } from './server.js';
+async function main() {
+    const server = createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('Salesforce MCP server running on stdio');
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/server.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function createServer(): McpServer;
+//# sourceMappingURL=server.d.ts.map

package/dist/server.js

@@ -0,0 +1,21 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { SERVER_NAME, SERVER_VERSION } from './types.js';
+import { resolveAuthMode } from './auth.js';
+import { registerAuthTools, registerAccountTools, registerContactTools, registerOpportunityTools, registerLeadTools, registerTaskTools, registerUserTools, registerQueryTools, } from './tools/index.js';
+export function createServer() {
+    resolveAuthMode();
+    const server = new McpServer({
+        name: SERVER_NAME,
+        version: SERVER_VERSION,
+    });
+    registerAuthTools(server);
+    registerAccountTools(server);
+    registerContactTools(server);
+    registerOpportunityTools(server);
+    registerLeadTools(server);
+    registerTaskTools(server);
+    registerUserTools(server);
+    registerQueryTools(server);
+    return server;
+}
+//# sourceMappingURL=server.js.map

package/dist/tools/accounts.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerAccountTools(server: McpServer): void;
+//# sourceMappingURL=accounts.d.ts.map

package/dist/tools/accounts.js

@@ -0,0 +1,107 @@
+import { z } from 'zod';
+import { withErrorHandling, escapeSOQL, escapeSOQLLike, validateFields, validateAndMergeCustomFields, checkSaveResult } from '../utils.js';
+import { withConnection } from '../client.js';
+export function registerAccountTools(server) {
+    server.registerTool('salesforce_get_accounts', {
+        description: `Get CRM accounts. Filters: name_contains, industry, account_type. Returns: Id, Name, Industry, Type, Phone, Website, Description. Max 200 records (default: 50).`,
+        inputSchema: z.object({
+            limit: z.number().int().min(1).max(200).optional().describe('Max results 1-200 (default: 50)'),
+            name_contains: z.string().optional().describe('Filter by name (case-insensitive)'),
+            industry: z.string().optional().describe('Filter by industry'),
+            account_type: z.string().optional().describe('Filter by type (Customer, Partner, Competitor)'),
+            fields: z.array(z.string()).optional().describe('Custom fields (must be valid API names)'),
+        }),
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, withErrorHandling(async (args) => {
+        return withConnection(undefined, async (conn) => {
+            const defaultFields = ['Id', 'Name', 'Industry', 'Type', 'Phone', 'Website', 'Description'];
+            const fields = validateFields(args.fields || [], defaultFields);
+            let query = `SELECT ${fields.join(', ')} FROM Account`;
+            const conditions = [];
+            if (args.name_contains)
+                conditions.push(`Name LIKE '%${escapeSOQLLike(args.name_contains)}%'`);
+            if (args.industry)
+                conditions.push(`Industry = '${escapeSOQL(args.industry)}'`);
+            if (args.account_type)
+                conditions.push(`Type = '${escapeSOQL(args.account_type)}'`);
+            if (conditions.length > 0)
+                query += ` WHERE ${conditions.join(' AND ')}`;
+            const limit = Math.min(Math.max(1, args.limit ?? 50), 200);
+            query += ` LIMIT ${limit}`;
+            const result = await conn.query(query);
+            return JSON.stringify({ ok: true, records: result.records, totalSize: result.totalSize, done: result.done });
+        });
+    }));
+    server.registerTool('salesforce_create_account', {
+        description: `Create a CRM account. Required: name. Optional: industry, type, phone, website, description, fields.`,
+        inputSchema: z.object({
+            name: z.string().min(1).describe('Account name (required)'),
+            industry: z.string().optional().describe('Industry'),
+            type: z.string().optional().describe('Account type'),
+            phone: z.string().optional().describe('Phone number'),
+            website: z.string().optional().describe('Website URL'),
+            description: z.string().optional().describe('Account description'),
+            fields: z.record(z.unknown()).optional().describe('Additional/custom fields as key-value pairs'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, withErrorHandling(async (args) => {
+        return withConnection(undefined, async (conn) => {
+            const data = { Name: args.name };
+            if (args.industry)
+                data.Industry = args.industry;
+            if (args.type)
+                data.Type = args.type;
+            if (args.phone)
+                data.Phone = args.phone;
+            if (args.website)
+                data.Website = args.website;
+            if (args.description)
+                data.Description = args.description;
+            if (args.fields)
+                validateAndMergeCustomFields(data, args.fields);
+            const result = await conn.sobject('Account').create(data);
+            if (!result.success) {
+                const { ConnectorError } = await import('../types.js');
+                throw new ConnectorError('Failed to create account', 'CREATE_ERROR', JSON.stringify(result.errors));
+            }
+            return JSON.stringify({ ok: true, status: 'success', object: 'Account', id: result.id, name: args.name });
+        });
+    }));
+    server.registerTool('salesforce_update_account', {
+        description: `Update a CRM account. Required: id. Updatable: name, industry, type, phone, website, description, fields.`,
+        inputSchema: z.object({
+            id: z.string().min(1).describe('Salesforce Account ID (required)'),
+            name: z.string().optional().describe('Account name'),
+            industry: z.string().optional().describe('Industry'),
+            type: z.string().optional().describe('Account type'),
+            phone: z.string().optional().describe('Phone number'),
+            website: z.string().optional().describe('Website URL'),
+            description: z.string().optional().describe('Description'),
+            fields: z.record(z.unknown()).optional().describe('Additional/custom fields as key-value pairs'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
+    }, withErrorHandling(async (args) => {
+        return withConnection(undefined, async (conn) => {
+            const updateData = { Id: args.id };
+            if (args.name)
+                updateData.Name = args.name;
+            if (args.industry)
+                updateData.Industry = args.industry;
+            if (args.type)
+                updateData.Type = args.type;
+            if (args.phone)
+                updateData.Phone = args.phone;
+            if (args.website)
+                updateData.Website = args.website;
+            if (args.description)
+                updateData.Description = args.description;
+            if (args.fields)
+                validateAndMergeCustomFields(updateData, args.fields);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const result = await conn.sobject('Account').update(updateData);
+            checkSaveResult(result, 'Failed to update account');
+            return JSON.stringify({ ok: true, status: 'success', object: 'Account', id: args.id });
+        });
+    }));
+}
+//# sourceMappingURL=accounts.js.map

package/dist/tools/auth-tools.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerAuthTools(server: McpServer): void;
+//# sourceMappingURL=auth-tools.d.ts.map

package/dist/tools/auth-tools.js

@@ -0,0 +1,177 @@
+import { z } from 'zod';
+import { withErrorHandling } from '../utils.js';
+import { getAuthMode, loadToken, startStandaloneOAuth } from '../auth.js';
+import { bridgeRequest } from '../bridge.js';
+import { listConnectedAccounts, removeAccount } from '../client.js';
+export function registerAuthTools(server) {
+    server.registerTool('salesforce_connect_account', {
+        description: `Connect a Salesforce account via OAuth. Takes no parameters — call with {}.
+
+Initiates OAuth flow — in standalone mode, opens a browser URL for Salesforce sign-in. In bridge mode, delegates to the host app.
+
+WHEN TO USE:
+- No Salesforce account is connected
+- Authentication errors from other tools
+- User asks to connect Salesforce
+
+After connecting, verify with salesforce_list_connected_accounts.`,
+        inputSchema: z.object({}).strict(),
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+        },
+    }, withErrorHandling(async () => {
+        const mode = getAuthMode();
+        if (mode === 'unconfigured') {
+            return JSON.stringify({
+                ok: false,
+                error: 'No authentication configured',
+                action_required: 'Set SALESFORCE_CLIENT_ID and SALESFORCE_CLIENT_SECRET environment variables for OAuth, or set SALESFORCE_ACCESS_TOKEN and SALESFORCE_INSTANCE_URL for manual token mode. See README for details.',
+            });
+        }
+        if (mode === 'manual_token') {
+            return JSON.stringify({
+                ok: true,
+                message: 'Manual token mode — no connect flow needed. Your SALESFORCE_ACCESS_TOKEN is already configured.',
+                auth_mode: 'manual_token',
+            });
+        }
+        if (mode === 'bridge') {
+            const result = await bridgeRequest(process.env.MCP_BRIDGE_CONFIGURE_ENDPOINT || '/mcp/configure', {});
+            if (result.success) {
+                return JSON.stringify({
+                    ok: true,
+                    status: 'authenticated',
+                    message: `Successfully connected Salesforce account${result.username ? `: ${result.username}` : ''}`,
+                    username: result.username,
+                    next_step: 'You can now use Salesforce tools. Try salesforce_list_connected_accounts to verify.',
+                });
+            }
+            return JSON.stringify({
+                ok: false,
+                error: result.error || 'Failed to authenticate with Salesforce',
+                action_required: 'Please try calling salesforce_connect_account again.',
+            });
+        }
+        // standalone_oauth
+        const result = await startStandaloneOAuth();
+        if (result.success) {
+            return JSON.stringify({
+                ok: true,
+                status: 'authenticated',
+                message: `Successfully connected Salesforce account${result.username ? `: ${result.username}` : ''}`,
+                username: result.username,
+                next_step: 'You can now use Salesforce tools. Try salesforce_list_connected_accounts to verify.',
+            });
+        }
+        return JSON.stringify({
+            ok: false,
+            error: result.error || 'Failed to authenticate',
+            action_required: 'Please try calling salesforce_connect_account again.',
+        });
+    }));
+    server.registerTool('salesforce_list_connected_accounts', {
+        description: `List connected Salesforce accounts. Takes no parameters — call with {}.
+
+Call this FIRST before any Salesforce CRM operations to verify authentication.
+This MCP instance operates on a single Salesforce account. If no account is connected, use salesforce_connect_account.`,
+        inputSchema: z.object({}).strict(),
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, withErrorHandling(async () => {
+        const mode = getAuthMode();
+        if (mode === 'unconfigured') {
+            return JSON.stringify({
+                ok: false,
+                auth_mode: 'unconfigured',
+                accounts: [],
+                count: 0,
+                message: 'No Salesforce authentication configured.',
+                action_required: 'Set SALESFORCE_CLIENT_ID and SALESFORCE_CLIENT_SECRET for OAuth, or SALESFORCE_ACCESS_TOKEN for manual token mode.',
+            });
+        }
+        if (mode === 'manual_token') {
+            const hasToken = !!process.env.SALESFORCE_ACCESS_TOKEN;
+            return JSON.stringify({
+                ok: true,
+                auth_mode: 'manual_token',
+                accounts: hasToken
+                    ? [{ username: 'manual-token', status: 'active', instance_url: process.env.SALESFORCE_INSTANCE_URL || '' }]
+                    : [],
+                count: hasToken ? 1 : 0,
+                message: hasToken
+                    ? 'Manual token mode — using SALESFORCE_ACCESS_TOKEN.'
+                    : 'Manual token mode but SALESFORCE_ACCESS_TOKEN is empty.',
+            });
+        }
+        const accounts = listConnectedAccounts();
+        if (accounts.length === 0) {
+            return JSON.stringify({
+                ok: true,
+                auth_mode: mode,
+                accounts: [],
+                count: 0,
+                message: 'No Salesforce accounts connected.',
+                action_required: 'Call salesforce_connect_account to connect.',
+                next_step: 'salesforce_connect_account',
+            });
+        }
+        const accountList = accounts.map((a) => {
+            const token = loadToken(a.id);
+            const hasValidToken = token && (token.expires_at ?? 0) > Date.now();
+            const hasRefresh = token && !!token.refresh_token;
+            return {
+                username: a.username,
+                instance_url: a.instance_url,
+                is_sandbox: a.is_sandbox,
+                status: hasValidToken || hasRefresh ? 'active' : 'expired',
+                connected_at: a.connected_at,
+            };
+        });
+        return JSON.stringify({
+            ok: true,
+            auth_mode: mode,
+            accounts: accountList,
+            count: accountList.length,
+            note: 'This MCP instance operates on a single Salesforce account.',
+        });
+    }));
+    server.registerTool('salesforce_disconnect_account', {
+        description: `Disconnect a Salesforce account. Example: { "username": "user@company.com" }
+
+Permanently removes stored credentials. Use when switching accounts or troubleshooting.`,
+        inputSchema: z.object({
+            username: z.string().min(1).describe('Username of the account to disconnect'),
+        }),
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, withErrorHandling(async (args) => {
+        const mode = getAuthMode();
+        if (mode === 'unconfigured' || mode === 'manual_token') {
+            return JSON.stringify({
+                ok: false,
+                error: `Cannot disconnect in ${mode} mode.`,
+                resolution: mode === 'manual_token'
+                    ? 'Remove the SALESFORCE_ACCESS_TOKEN environment variable to disconnect.'
+                    : 'No accounts to disconnect — set up authentication first.',
+            });
+        }
+        removeAccount(args.username);
+        return JSON.stringify({
+            ok: true,
+            message: `Disconnected Salesforce account: ${args.username}`,
+            note: 'To reconnect, use salesforce_connect_account.',
+        });
+    }));
+}
+//# sourceMappingURL=auth-tools.js.map

package/dist/tools/contacts.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerContactTools(server: McpServer): void;
+//# sourceMappingURL=contacts.d.ts.map

package/dist/tools/contacts.js

@@ -0,0 +1,105 @@
+import { z } from 'zod';
+import { withErrorHandling, escapeSOQL, escapeSOQLLike, validateFields, validateAndMergeCustomFields, checkSaveResult } from '../utils.js';
+import { withConnection } from '../client.js';
+import { ConnectorError } from '../types.js';
+export function registerContactTools(server) {
+    server.registerTool('salesforce_get_contacts', {
+        description: `Get contacts. Filters: name_contains, email_contains, related_account_id. Returns: Id, FirstName, LastName, Email, Phone, Title, AccountId. Max 200 (default: 50).`,
+        inputSchema: z.object({
+            limit: z.number().int().min(1).max(200).optional().describe('Max results 1-200 (default: 50)'),
+            name_contains: z.string().optional().describe('Filter by first or last name'),
+            email_contains: z.string().optional().describe('Filter by email'),
+            related_account_id: z.string().optional().describe('Filter by Account ID'),
+            fields: z.array(z.string()).optional().describe('Custom fields (valid API names)'),
+        }),
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, withErrorHandling(async (args) => {
+        return withConnection(undefined, async (conn) => {
+            const defaultFields = ['Id', 'FirstName', 'LastName', 'Email', 'Phone', 'Title', 'AccountId'];
+            const fields = validateFields(args.fields || [], defaultFields);
+            let query = `SELECT ${fields.join(', ')} FROM Contact`;
+            const conditions = [];
+            if (args.name_contains) {
+                const escaped = escapeSOQLLike(args.name_contains);
+                conditions.push(`(FirstName LIKE '%${escaped}%' OR LastName LIKE '%${escaped}%')`);
+            }
+            if (args.email_contains)
+                conditions.push(`Email LIKE '%${escapeSOQLLike(args.email_contains)}%'`);
+            if (args.related_account_id)
+                conditions.push(`AccountId = '${escapeSOQL(args.related_account_id)}'`);
+            if (conditions.length > 0)
+                query += ` WHERE ${conditions.join(' AND ')}`;
+            const limit = Math.min(Math.max(1, args.limit ?? 50), 200);
+            query += ` LIMIT ${limit}`;
+            const result = await conn.query(query);
+            return JSON.stringify({ ok: true, records: result.records, totalSize: result.totalSize });
+        });
+    }));
+    server.registerTool('salesforce_create_contact', {
+        description: `Create a contact. Required: last_name. Optional: first_name, email, phone, title, related_account_id, fields.`,
+        inputSchema: z.object({
+            first_name: z.string().optional().describe('First name'),
+            last_name: z.string().min(1).describe('Last name (required)'),
+            email: z.string().optional().describe('Email address'),
+            phone: z.string().optional().describe('Phone number'),
+            title: z.string().optional().describe('Job title'),
+            related_account_id: z.string().optional().describe('Account ID to associate with'),
+            fields: z.record(z.unknown()).optional().describe('Additional/custom fields as key-value pairs'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, withErrorHandling(async (args) => {
+        return withConnection(undefined, async (conn) => {
+            const data = { LastName: args.last_name };
+            if (args.first_name)
+                data.FirstName = args.first_name;
+            if (args.email)
+                data.Email = args.email;
+            if (args.phone)
+                data.Phone = args.phone;
+            if (args.title)
+                data.Title = args.title;
+            if (args.related_account_id)
+                data.AccountId = args.related_account_id;
+            if (args.fields)
+                validateAndMergeCustomFields(data, args.fields);
+            const result = await conn.sobject('Contact').create(data);
+            if (!result.success)
+                throw new ConnectorError('Failed to create contact', 'CREATE_ERROR', JSON.stringify(result.errors));
+            return JSON.stringify({ ok: true, status: 'success', object: 'Contact', id: result.id, name: `${args.first_name || ''} ${args.last_name}`.trim() });
+        });
+    }));
+    server.registerTool('salesforce_update_contact', {
+        description: `Update a contact. Required: id. Updatable: first_name, last_name, email, phone, title, fields.`,
+        inputSchema: z.object({
+            id: z.string().min(1).describe('Salesforce Contact ID (required)'),
+            first_name: z.string().optional().describe('First name'),
+            last_name: z.string().optional().describe('Last name'),
+            email: z.string().optional().describe('Email address'),
+            phone: z.string().optional().describe('Phone number'),
+            title: z.string().optional().describe('Job title'),
+            fields: z.record(z.unknown()).optional().describe('Additional/custom fields as key-value pairs'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
+    }, withErrorHandling(async (args) => {
+        return withConnection(undefined, async (conn) => {
+            const updateData = { Id: args.id };
+            if (args.first_name)
+                updateData.FirstName = args.first_name;
+            if (args.last_name)
+                updateData.LastName = args.last_name;
+            if (args.email)
+                updateData.Email = args.email;
+            if (args.phone)
+                updateData.Phone = args.phone;
+            if (args.title)
+                updateData.Title = args.title;
+            if (args.fields)
+                validateAndMergeCustomFields(updateData, args.fields);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const result = await conn.sobject('Contact').update(updateData);
+            checkSaveResult(result, 'Failed to update contact');
+            return JSON.stringify({ ok: true, status: 'success', object: 'Contact', id: args.id });
+        });
+    }));
+}
+//# sourceMappingURL=contacts.js.map

package/dist/tools/index.d.ts

@@ -0,0 +1,9 @@
+export { registerAuthTools } from './auth-tools.js';
+export { registerAccountTools } from './accounts.js';
+export { registerContactTools } from './contacts.js';
+export { registerOpportunityTools } from './opportunities.js';
+export { registerLeadTools } from './leads.js';
+export { registerTaskTools } from './tasks.js';
+export { registerUserTools } from './users.js';
+export { registerQueryTools } from './query.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/index.js

@@ -0,0 +1,9 @@
+export { registerAuthTools } from './auth-tools.js';
+export { registerAccountTools } from './accounts.js';
+export { registerContactTools } from './contacts.js';
+export { registerOpportunityTools } from './opportunities.js';
+export { registerLeadTools } from './leads.js';
+export { registerTaskTools } from './tasks.js';
+export { registerUserTools } from './users.js';
+export { registerQueryTools } from './query.js';
+//# sourceMappingURL=index.js.map

package/dist/tools/leads.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerLeadTools(server: McpServer): void;
+//# sourceMappingURL=leads.d.ts.map