@salesforce/mcp 0.20.1 → 0.21.0

package/lib/index.d.ts

@@ -5,6 +5,7 @@ export default class McpServerCommand extends Command {
     static flags: {
         orgs: import("@oclif/core/interfaces").OptionFlag<string[], import("@oclif/core/interfaces").CustomOptions>;
         toolsets: import("@oclif/core/interfaces").OptionFlag<(import("@salesforce/mcp-provider-api/src/enums.js").Toolset | "all")[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        tools: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
         version: import("@oclif/core/interfaces").BooleanFlag<void>;
         'no-telemetry': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         debug: import("@oclif/core/interfaces").BooleanFlag<boolean>;

package/lib/index.js

@@ -73,12 +73,21 @@ You can also use special values to control access to orgs:
         }),
         toolsets: Flags.option({
             options: ['all', ...TOOLSETS],
-            char: 't',
-            summary: 'Toolset to enable',
+            summary: 'Toolset(s) to enable. Set to "all" to enable every toolset',
             multiple: true,
             delimiter: ',',
-            exclusive: ['dynamic-toolsets'],
+            exclusive: ['dynamic-tools'],
         })(),
+        // It would be nice if we could get these as an Flags.option
+        // Since the tools need `services` passed in I am not sure we
+        // can get the list of tools this early. We could build a json
+        // manifest (pre-commit) that could be read from for tool names
+        tools: Flags.string({
+            summary: 'Tool(s) to enable',
+            multiple: true,
+            delimiter: ',',
+            exclusive: ['dynamic-tools'],
+        }),
         version: Flags.version(),
         'no-telemetry': Flags.boolean({
             summary: 'Disable telemetry',
@@ -98,19 +107,23 @@ You can also use special values to control access to orgs:
     static examples = [
         {
             description: 'Start the server with all toolsets enabled and access only to the default org in the project',
-            command: '<%= config.bin %> --orgs DEFAULT_TARGET_ORG',
+            command: '<%= config.bin %> --toolsets all --orgs DEFAULT_TARGET_ORG',
         },
         {
-            description: 'Allow access to the default org and "my-alias" one with only "data" tools',
+            description: 'Allow access to the default target org and "my-alias" with only the "data" toolset',
             command: '<%= config.bin %> --orgs DEFAULT_TARGET_DEV_HUB,my-alias --toolsets data',
         },
         {
             description: 'Allow access to 3 specific orgs and enable all toolsets',
-            command: '<%= config.bin %> --orgs test-org@example.com,my-dev-hub,my-alias',
+            command: '<%= config.bin %> --toolsets all --orgs test-org@example.com,my-dev-hub,my-alias',
+        },
+        {
+            description: 'Start the server with the "data" toolset and also the "create_scratch_org" tool',
+            command: '<%= config.bin %> --orgs DEFAULT_TARGET_ORG --toolsets data --tools create_scratch_org',
         },
         {
-            description: 'Allow tools that are not generally available (GA) to be registered with the server',
-            command: '<%= config.bin %> --orgs DEFAULT_TARGET_ORG --allow-non-ga-tools',
+            description: 'Allow tools that are not generally available (NON-GA) to be registered with the server',
+            command: '<%= config.bin %> --toolsets all --orgs DEFAULT_TARGET_ORG --allow-non-ga-tools',
         },
     ];
     telemetry;
@@ -149,7 +162,7 @@ You can also use special values to control access to orgs:
                 debug: flags.debug,
             },
         });
-        await registerToolsets(flags.toolsets ?? ['all'], flags['dynamic-tools'] ?? false, flags['allow-non-ga-tools'] ?? false, server, services);
+        await registerToolsets(flags.toolsets ?? [], flags.tools ?? [], flags['dynamic-tools'] ?? false, flags['allow-non-ga-tools'] ?? false, server, services);
         const transport = new StdioServerTransport();
         await server.connect(transport);
         console.error(`✅ Salesforce MCP Server v${this.config.version} running on stdio`);

package/lib/main-server-provider.js

@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { EnableToolsMcpTool } from './tools/sf-enable-tools.js';
-import { ListToolsMcpTool } from './tools/sf-list-tools.js';
+import { EnableToolsMcpTool } from './tools/enable_tools.js';
+import { ListToolsMcpTool } from './tools/list_tools.js';
 export function createDynamicServerTools(server) {
     return [new EnableToolsMcpTool(server), new ListToolsMcpTool()];
 }

package/lib/registry.js

@@ -18,6 +18,7 @@ import { CodeAnalyzerMcpProvider } from '@salesforce/mcp-provider-code-analyzer'
 import { LwcExpertsMcpProvider } from '@salesforce/mcp-provider-lwc-experts';
 import { AuraExpertsMcpProvider } from '@salesforce/mcp-provider-aura-experts';
 import { MobileWebMcpProvider } from '@salesforce/mcp-provider-mobile-web';
+import { DevOpsMcpProvider } from '@salesforce/mcp-provider-devops';
 /** -------- ADD McpProvider INSTANCES HERE ------------------------------------------------------------------------- */
 export const MCP_PROVIDER_REGISTRY = [
     new DxCoreMcpProvider(),
@@ -25,6 +26,7 @@ export const MCP_PROVIDER_REGISTRY = [
     new LwcExpertsMcpProvider(),
     new AuraExpertsMcpProvider(),
     new MobileWebMcpProvider(),
+    new DevOpsMcpProvider(),
     // Add new instances here
 ];
 //# sourceMappingURL=registry.js.map

package/lib/tools/{sf-enable-tools.js → enable_tools.js}

@@ -32,7 +32,7 @@ export class EnableToolsMcpTool extends McpTool {
         return [Toolset.CORE];
     }
     getName() {
-        return 'sf-enable-tools';
+        return 'enable_tools';
     }
     getConfig() {
         return {
@@ -40,7 +40,7 @@ export class EnableToolsMcpTool extends McpTool {
             description: `Enable one or more of the tools the Salesforce MCP server provides.
 
 AGENT INSTRUCTIONS:
-Use sf-list-all-tools first to learn what tools are available for enabling.
+Use list_tools first to learn what tools are available for enabling.
 Once you have enabled the tool, you MUST invoke that tool to accomplish the user's original request - DO NOT USE A DIFFERENT TOOL OR THE COMMAND LINE.`,
             inputSchema: enableToolsParamsSchema.shape,
             outputSchema: undefined,
@@ -77,4 +77,4 @@ Once you have enabled the tool, you MUST invoke that tool to accomplish the user
         };
     }
 }
-//# sourceMappingURL=sf-enable-tools.js.map
+//# sourceMappingURL=enable_tools.js.map

package/lib/tools/{sf-list-tools.js → list_tools.js}

@@ -23,7 +23,7 @@ export class ListToolsMcpTool extends McpTool {
         return ReleaseState.GA;
     }
     getName() {
-        return 'sf-list-tools';
+        return 'list_tools';
     }
     getConfig() {
         return {
@@ -37,9 +37,9 @@ ONLY use this tool if:
 2. You genuinely don't know what tools are available for a specific task
 3. You need to discover new tools for an unfamiliar use case
 
-If you find one or more tools you want to enable, call sf-enable-tools with all the tool names.
+If you find one or more tools you want to enable, call enable_tools with all the tool names.
 Once you have enabled a tool, you MUST invoke the tool to accomplish the user's original request - DO NOT USE A DIFFERENT TOOL OR THE COMMAND LINE.
-Once a tool has been enabled, you do not need to call sf-list-tools again - instead, invoke the desired tool directly.`,
+Once a tool has been enabled, you do not need to call list_tools again - instead, invoke the desired tool directly.`,
             inputSchema: undefined,
             outputSchema: undefined,
             annotations: {
@@ -60,4 +60,4 @@ Once a tool has been enabled, you do not need to call sf-list-tools again - inst
         };
     }
 }
-//# sourceMappingURL=sf-list-tools.js.map
+//# sourceMappingURL=list_tools.js.map

package/lib/utils/auth.js

@@ -100,34 +100,22 @@ export async function filterAllowedOrgs(orgs, allowList) {
         return false;
     });
 }
-const defaultOrgMaps = {
-    [OrgConfigProperties.TARGET_ORG]: new Map(),
-    [OrgConfigProperties.TARGET_DEV_HUB]: new Map(),
-};
 // Helper function to get default config for a property
 // Values are cached based on ConfigInfo path after first retrieval
 // This is to prevent manipulation of the config file after server start
 async function getDefaultConfig(property) {
-    // If the directory changes, the singleton instance of ConfigAggregator is not updated.
-    // It continues to use the old local or global config.
+    // If the directory changes, the ConfigAggregator singleton does not update.
+    // It continues to use the old local or global config instead.
+    // We call clearInstance on the singleton to read the new config.
     await ConfigAggregator.clearInstance();
     const aggregator = await ConfigAggregator.create();
     const config = aggregator.getInfo(property);
     const { value, path, key, location } = config;
     if (!value || typeof value !== 'string' || !path)
         return undefined;
-    // Create a typed config object with the necessary properties
+    // Return an typed object with only the necessary properties
     // This reduces assertions and lowers context returned to the LLM
-    const typedConfig = { key, location, value, path };
-    if (defaultOrgMaps[property].has(path)) {
-        // If the cache has the config's path set, use the cached config
-        const cachedConfig = defaultOrgMaps[property].get(path);
-        return cachedConfig;
-    }
-    else {
-        defaultOrgMaps[property].set(path, typedConfig);
-        return typedConfig;
-    }
+    return { key, location, value, path };
 }
 export async function getDefaultTargetOrg() {
     return getDefaultConfig(OrgConfigProperties.TARGET_ORG);

package/lib/utils/registry-utils.d.ts

@@ -1,4 +1,4 @@
 import { Toolset } from '@salesforce/mcp-provider-api';
 import { SfMcpServer } from '../sf-mcp-server.js';
 import { Services } from '../services.js';
-export declare function registerToolsets(toolsets: Array<Toolset | 'all'>, useDynamicTools: boolean, allowNonGaTools: boolean, server: SfMcpServer, services: Services): Promise<void>;
+export declare function registerToolsets(toolsets: Array<Toolset | 'all'>, tools: string[], useDynamicTools: boolean, allowNonGaTools: boolean, server: SfMcpServer, services: Services): Promise<void>;

package/lib/utils/registry-utils.js

@@ -13,14 +13,26 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { EOL } from 'node:os';
 import { ux } from '@oclif/core';
 import { MCP_PROVIDER_API_VERSION, ReleaseState, Toolset, TOOLSETS, } from '@salesforce/mcp-provider-api';
 import { MCP_PROVIDER_REGISTRY } from '../registry.js';
 import { addTool, isToolRegistered } from '../utils/tools.js';
 import { createDynamicServerTools } from '../main-server-provider.js';
-export async function registerToolsets(toolsets, useDynamicTools, allowNonGaTools, server, services) {
+export async function registerToolsets(toolsets, tools, useDynamicTools, allowNonGaTools, server, services) {
+    // If no toolsets, tools, or dynamic tools flag was passed, throw an error
+    // NOTE: In the future we will also want to check for Personas here
+    if (!toolsets.length && !tools.length && !useDynamicTools) {
+        throw new Error('Tool registration error. Start server with one of the following flags: --toolsets, --tools, --dynamic-tools');
+    }
     if (useDynamicTools) {
+        // If --dynamic-tools flag was passed, register the tools needed to handle dynamic tool registration
         const dynamicTools = createDynamicServerTools(server);
+        // This should always be true because using `--dynamic-tools` and `--toolsets` is blocked.
+        // If that doesn't change after GA, this can be just `toolsets.push('all')`
+        const isAllToolsetEnabled = toolsets.includes('all');
+        if (!isAllToolsetEnabled)
+            toolsets.push('all');
         ux.stderr('Registering dynamic tools.');
         // eslint-disable-next-line no-await-in-loop
         await registerTools(dynamicTools, server, useDynamicTools, allowNonGaTools);
@@ -30,16 +42,37 @@ export async function registerToolsets(toolsets, useDynamicTools, allowNonGaTool
     }
     const toolsetsToEnable = toolsets.includes('all')
         ? new Set(TOOLSETS)
+        // CORE toolset is always enabled
         : new Set([Toolset.CORE, ...toolsets]);
-    const newToolRegistry = await createToolRegistryFromProviders(MCP_PROVIDER_REGISTRY, services);
+    const toolsetRegistry = await createToolRegistryFromProviders(MCP_PROVIDER_REGISTRY, services);
+    ux.stderr('REGISTERING TOOLSETS (--toolsets)');
     for (const toolset of TOOLSETS) {
         if (toolsetsToEnable.has(toolset)) {
-            ux.stderr(`Registering tools from the '${toolset}' toolset.`);
+            ux.stderr(`Registering toolset: '${toolset}'`);
             // eslint-disable-next-line no-await-in-loop
-            await registerTools(newToolRegistry[toolset], server, useDynamicTools, allowNonGaTools);
+            await registerTools(toolsetRegistry[toolset], server, useDynamicTools, allowNonGaTools);
         }
         else {
-            ux.stderr(`Skipping registration of the tools from the '${toolset}' toolset.`);
+            ux.stderr(`!! Skipping toolset: '${toolset}'`);
+        }
+    }
+    if (tools.length > 0) {
+        ux.stderr('REGISTERING TOOLS (--tools)');
+        // Build an array of available McpTools
+        const toolRegistry = Object.values(toolsetRegistry).flat();
+        // NOTE: This validation could be removed it we implemented Flags.option
+        const existingToolNames = new Set(toolRegistry.map(tool => tool.getName()));
+        // Validate that all requested tools exist
+        const invalidTools = tools.filter(toolName => !existingToolNames.has(toolName));
+        if (invalidTools.length > 0)
+            throw new Error(`Invalid tool names provided to --tools: "${invalidTools.join('", "')}"
+Valid tools include:
+- ${Array.from(existingToolNames).join(`${EOL}- `)}`);
+        for (const tool of toolRegistry) {
+            if (tools.includes(tool.getName())) {
+                // eslint-disable-next-line no-await-in-loop
+                await registerTools([tool], server, useDynamicTools, allowNonGaTools);
+            }
         }
     }
 }
@@ -61,7 +94,7 @@ async function registerTools(tools, server, useDynamicTools, allowNonGaTools) {
             registeredTool.disable();
         }
         else {
-            ux.stderr(`* Registering tool '${tool.getName()}'.`);
+            ux.stderr(`-> Registering tool: '${tool.getName()}'`);
         }
         // eslint-disable-next-line no-await-in-loop
         await addTool(registeredTool, tool.getName());
@@ -91,10 +124,8 @@ async function createToolRegistryFromProviders(providers, services) {
  */
 function validateMcpProviderVersion(provider) {
     if (provider.getVersion().major !== MCP_PROVIDER_API_VERSION.major) {
-        throw new Error(`The version '${provider
-            .getVersion()
-            .toString()}' for '${provider.getName()}' is incompatible with this MCP Server.\n` +
-            `Expected the major version to be '${MCP_PROVIDER_API_VERSION.major}'.`);
+        throw new Error(`The version '${provider.getVersion().toString()}' for '${provider.getName()}' is incompatible with this MCP Server.
+Expected the major version to be '${MCP_PROVIDER_API_VERSION.major}'.`);
     }
 }
 //# sourceMappingURL=registry-utils.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salesforce/mcp",
-  "version": "0.20.1",
+  "version": "0.21.0",
   "description": "MCP Server for interacting with Salesforce instances",
   "bin": {
     "sf-mcp-server": "bin/run.js"
@@ -22,8 +22,6 @@
     "lint-fix": "yarn sf-lint --fix",
     "package": "yarn pack",
     "postpack": "sf-clean --ignore-signing-artifacts",
-    "prepack": "sf-prepack",
-    "prepare": "sf-install",
     "start": "yarn build && npm link && mcp-inspector sf-mcp-server",
     "test": "wireit",
     "test:only": "wireit"
@@ -42,18 +40,19 @@
     "package.json"
   ],
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.16.0",
+    "@modelcontextprotocol/sdk": "^1.18.0",
     "@oclif/core": "^4.5.1",
     "@salesforce/agents": "^0.15.4",
     "@salesforce/apex-node": "^8.2.1",
-    "@salesforce/core": "^8.18.0",
+    "@salesforce/core": "^8.23.1",
     "@salesforce/kit": "^3.1.6",
-    "@salesforce/mcp-provider-api": "0.2.2",
-    "@salesforce/mcp-provider-dx-core": "0.2.4",
-    "@salesforce/mcp-provider-code-analyzer": "0.0.2",
-    "@salesforce/mcp-provider-lwc-experts": "0.1.1",
-    "@salesforce/mcp-provider-aura-experts": "0.1.1",
-    "@salesforce/mcp-provider-mobile-web": "0.0.3",
+    "@salesforce/mcp-provider-api": "0.4.0",
+    "@salesforce/mcp-provider-dx-core": "0.3.3",
+    "@salesforce/mcp-provider-code-analyzer": "0.1.0",
+    "@salesforce/mcp-provider-lwc-experts": "0.5.0",
+    "@salesforce/mcp-provider-aura-experts": "0.3.0",
+    "@salesforce/mcp-provider-mobile-web": "0.1.1",
+    "@salesforce/mcp-provider-devops": "0.1.1",
     "@salesforce/source-deploy-retrieve": "^12.22.0",
     "@salesforce/source-tracking": "^7.4.8",
     "@salesforce/telemetry": "^6.1.0",