@salesforce/mcp 0.0.1 → 0.2.5

package/lib/shared/utils.js

@@ -0,0 +1,155 @@
+/*
+ * Copyright 2025, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/* eslint-disable no-console */
+import { sep } from 'node:path';
+import { EOL } from 'node:os';
+import { parseArgs } from 'node:util';
+const usageMessage = `Usage: sf-mcp-server [OPTIONS]
+
+FLAGS:
+  -o, --orgs             - Org username(s) to allow access to.
+  -t, --toolsets         - List of toolsets to enable.
+
+FLAG DESCRIPTIONS:
+  -o, --orgs=<string>  Org usernames to allow access to.
+
+    Use this flag to specify the org usernames to allow the MCP server to access to.
+    If you need to pass more than one username/alias, pass all of them as a comma-separated string.
+
+    Special values:
+    DEFAULT_TARGET_ORG     - Allow access to default orgs (global and local)
+    DEFAULT_TARGET_DEV_HUB - Allow access to default dev hubs (global and local)
+    ALLOW_ALL_ORGS         - Allow access to all authenticated orgs (use with caution)
+
+  -t, --toolsets=<string>  List of toolsets to enable.
+
+  Specify the toolsets to enable, possible values:
+  * all (default)
+  * orgs
+  * data
+  * users
+  * metadata
+
+EXAMPLES:
+  // Start the server with all toolsets enabled and access only to the default org in the project:
+  sf-mcp-server --orgs DEFAULT_TARGET_ORG
+
+  // Allow access to the default org and "my-alias" one with only "data" tools;
+  sf-mcp-server --orgs DEFAULT_TARGET_DEV_HUB,my-alias --toolsets data
+
+  // Allow acccess to 3 specific orgs and enable all toolsets:
+  sf-mcp-server --orgs test-org@example.com,my-dev-hub,my-alias
+
+Documentation:
+  See: https://github.com/salesforcecli/mcp`;
+export function parseStartupArguments() {
+    const options = {
+        toolsets: { type: 'string', short: 't', default: 'all' },
+        orgs: { type: 'string', short: 'o' },
+    };
+    // TODO: strict false is to ignore flags pass at testing startup. Revisit this
+    const { values } = parseArgs({
+        args: process.argv,
+        options,
+        allowPositionals: true,
+        strict: false,
+    });
+    return { values };
+}
+export function buildOrgAllowList(orgs) {
+    // Fail if `--orgs` wasn't specified
+    if (!orgs) {
+        console.error(`Missing --orgs flag${EOL}${EOL}${usageMessage}`);
+        process.exit(1);
+    }
+    // Fail if `--orgs` was specified without a value
+    if (orgs === 'boolean') {
+        console.error(usageMessage);
+        process.exit(1);
+    }
+    const allOrgs = orgs.split(',').map((toolset) => toolset.trim());
+    const allowedOrgs = new Set();
+    if (allOrgs.includes('ALLOW_ALL_ORGS')) {
+        console.warn('WARNING: ALLOW_ALL_ORGS is set. This allows access to all authenticated orgs. Use with caution.');
+        // TODO Add telemetry
+        return new Set(['ALLOW_ALL_ORGS']);
+    }
+    // Process other arguments
+    for (const arg of allOrgs) {
+        if (arg === 'DEFAULT_TARGET_ORG' || arg === 'DEFAULT_TARGET_DEV_HUB' || arg.includes('@') || !arg.startsWith('-')) {
+            allowedOrgs.add(arg);
+        }
+        else {
+            console.error(`Invalid flag value: ${arg + EOL + EOL + usageMessage}`);
+            process.exit(1); // Stop the server
+        }
+    }
+    return allowedOrgs;
+}
+// TODO: break into two helpers? One for errors and one for success?
+export function textResponse(text, isError = false) {
+    if (text === '')
+        throw new Error('textResponse error: "text" cannot be empty');
+    return {
+        isError,
+        content: [
+            {
+                type: 'text',
+                text,
+            },
+        ],
+    };
+}
+/**
+ * Gets the enabled toolsets based on user input and validates against available toolsets
+ *
+ * @param availableToolsets - The list of available toolsets
+ * @param toolsetsInput - The comma-separated list of toolsets
+ * @returns A Set of enabled toolsets
+ */
+export function getEnabledToolsets(availableToolsets, toolsetsInput) {
+    const availableToolsetsSet = new Set(availableToolsets);
+    const passedToolsets = toolsetsInput.split(',').map((toolset) => toolset.trim());
+    // Check if any passed toolset is not in the available list
+    for (const toolset of passedToolsets) {
+        if (!availableToolsetsSet.has(toolset)) {
+            console.error(`Passed toolset "${toolset}" is not in the allowed toolset list. Available toolsets are "all (default), ${Array.from(availableToolsetsSet)
+                .filter((t) => t !== 'all')
+                .join(', ')}"`);
+            process.exit(1);
+        }
+    }
+    const enabledToolsets = new Set(passedToolsets.filter((toolset) => availableToolsetsSet.has(toolset)));
+    console.error('Enabling toolsets:', Array.from(enabledToolsets).join(', '));
+    return enabledToolsets;
+}
+export function sanitizePath(path) {
+    // Decode URL-encoded sequences
+    const decodedPath = decodeURIComponent(path);
+    // Normalize Unicode characters
+    const normalizedPath = decodedPath.normalize();
+    // Check for various traversal patterns
+    const hasTraversal = normalizedPath.includes('..') ||
+        normalizedPath.includes('\\..') ||
+        normalizedPath.includes('../') ||
+        normalizedPath.includes('..\\') ||
+        normalizedPath.includes('\u2025') || // Unicode horizontal ellipsis
+        normalizedPath.includes('\u2026'); // Unicode vertical ellipsis
+    // Ensure path is absolute
+    const isAbsolute = path.startsWith(sep);
+    return !hasTraversal && isAbsolute;
+}
+//# sourceMappingURL=utils.js.map

package/lib/tools/core/index.d.ts

@@ -0,0 +1 @@
+export * from './sf-get-username.js';

package/lib/tools/core/index.js

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2025, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from './sf-get-username.js';
+//# sourceMappingURL=index.js.map

package/lib/tools/core/sf-get-username.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare const getUsernameParamsSchema: z.ZodObject<{
+    defaultTargetOrg: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    defaultDevHub: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    directory: z.ZodEffects<z.ZodString, string, string>;
+}, "strip", z.ZodTypeAny, {
+    defaultTargetOrg: boolean;
+    defaultDevHub: boolean;
+    directory: string;
+}, {
+    directory: string;
+    defaultTargetOrg?: boolean | undefined;
+    defaultDevHub?: boolean | undefined;
+}>;
+export type GetUsernameParamsSchema = z.infer<typeof getUsernameParamsSchema>;
+export declare const registerToolGetUsername: (server: McpServer) => void;

package/lib/tools/core/sf-get-username.js

@@ -0,0 +1,105 @@
+/*
+ * Copyright 2025, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { z } from 'zod';
+import { textResponse } from '../../shared/utils.js';
+import { getDefaultTargetOrg, getDefaultTargetDevHub, suggestUsername } from '../../shared/auth.js';
+import { directoryParam } from '../../shared/params.js';
+/*
+ * Get username for Salesforce org
+ *
+ * Intelligently determines the appropriate username or alias for Salesforce operations.
+ *
+ * Parameters:
+ * - defaultTargetOrg: Force lookup of default target org (optional)
+ * - defaultDevHub: Force lookup of default dev hub (optional)
+ * - directory: The directory to run this tool from
+ *
+ * Returns:
+ * - textResponse: Username/alias and org configuration
+ */
+export const getUsernameParamsSchema = z.object({
+    defaultTargetOrg: z.boolean().optional().default(false).describe(`Try to find default org
+AGENT INSTRUCTIONS:
+ONLY SET TO TRUE when the user explicitly asks for the default org or default target org.
+Leave it as false when the user is vague and says something like "for my org" or "for my-alias".
+
+USAGE EXAMPLE:
+Get username for my default org
+...for my default target org`),
+    defaultDevHub: z.boolean().optional().default(false).describe(`Try to find default dev hub
+AGENT INSTRUCTIONS:
+ONLY SET TO TRUE when the user explicitly asks for the default dev hub or default target devhub.
+Leave it as false when the user is vague and says something like "for my org" or "for my-alias".
+
+USAGE EXAMPLE:
+Get username for my default dev hub
+...for my default target dev hub
+...for my default devhub`),
+    directory: directoryParam,
+});
+export const registerToolGetUsername = (server) => {
+    server.tool('sf-get-username', `Intelligently determines the appropriate username or alias for Salesforce operations.
+
+AGENT/LLM INSTRUCTIONS:
+Use this tool when uncertain which username/org a user wants for Salesforce operations.
+This tool handles three distinct scenarios:
+
+1. When defaultTargetOrg=true: Fetches the default target org configuration
+   - Use when user says "for my default org" or "for my default target org"
+
+2. When defaultDevHub=true: Fetches the default dev hub configuration
+   - Use when user says "for my default dev hub" or "for my default target dev hub"
+
+3. When both are false (default): Uses suggestUsername to intelligently determine the appropriate org
+   - Use when user is vague and says something like "for my org" or doesn't specify
+
+EXAMPLE USAGE:
+- When user says "Do X for my org" → defaultTargetOrg=false, defaultDevHub=false
+- When user says "For my default org" → defaultTargetOrg=true
+- When user says "For my default dev hub" → defaultDevHub=true`, getUsernameParamsSchema.shape, async ({ defaultTargetOrg, defaultDevHub, directory }) => {
+        try {
+            process.chdir(directory);
+            const generateResponse = (defaultFromConfig) => textResponse(`ALWAYS notify the user the following 3 (maybe 4) pieces of information:
+1. If it is default target-org or target-dev-hub ('.key' on the config)
+2. The value of '.location' on the config
+3. The value of '.value' on the config
+4. IF '.cached' IS TRUE, tell then we are using a cached value and if they have changed it, restart the MCP Server
+
+- Full config: ${JSON.stringify(defaultFromConfig, null, 2)}
+
+UNLESS THE USER SPECIFIES OTHERWISE, use this username for the "usernameOrAlias" parameter in future Tool calls.`);
+            // Case 1: User explicitly asked for default target org
+            if (defaultTargetOrg)
+                return generateResponse(await getDefaultTargetOrg());
+            // Case 2: User explicitly asked for default dev hub
+            if (defaultDevHub)
+                return generateResponse(await getDefaultTargetDevHub());
+            // Case 3: User was vague, so suggest a username
+            const { aliasForReference, suggestedUsername, reasoning } = await suggestUsername();
+            if (!suggestedUsername) {
+                return textResponse("No suggested username found. Please specify a username or alias explicitly. Also check the MCP server's startup args for allowlisting orgs.", true);
+            }
+            return textResponse(`
+YOU MUST inform the user that we are going to use "${suggestedUsername}" ${aliasForReference ? `(Alias: ${aliasForReference}) ` : ''}for the "usernameOrAlias" parameter.
+YOU MUST explain the reasoning for selecting this org, which is: "${reasoning}"
+UNLESS THE USER SPECIFIES OTHERWISE, use this username for the "usernameOrAlias" parameter in future Tool calls.`);
+        }
+        catch (error) {
+            return textResponse(`Failed to determine appropriate username: ${error instanceof Error ? error.message : 'Unknown error'}`, true);
+        }
+    });
+};
+//# sourceMappingURL=sf-get-username.js.map

package/lib/tools/data/index.d.ts

@@ -0,0 +1 @@
+export * from './sf-query-org.js';

package/lib/tools/data/index.js

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2025, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from './sf-query-org.js';
+//# sourceMappingURL=index.js.map

package/lib/tools/data/sf-query-org.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare const queryOrgParamsSchema: z.ZodObject<{
+    query: z.ZodString;
+    usernameOrAlias: z.ZodString;
+    directory: z.ZodEffects<z.ZodString, string, string>;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+    directory: string;
+    usernameOrAlias: string;
+}, {
+    query: string;
+    directory: string;
+    usernameOrAlias: string;
+}>;
+export type QueryOrgOptions = z.infer<typeof queryOrgParamsSchema>;
+export declare const registerToolQueryOrg: (server: McpServer) => void;

package/lib/tools/data/sf-query-org.js

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2025, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/*
+ * Query Salesforce org
+ *
+ * Run a SOQL query against a Salesforce org.
+ *
+ * Parameters:
+ * - query: SOQL query to run (required)
+ * - usernameOrAlias: username or alias for the Salesforce org to run the query against
+ *
+ * Returns:
+ * - textResponse: SOQL query results
+ */
+import { z } from 'zod';
+import { getConnection } from '../../shared/auth.js';
+import { textResponse } from '../../shared/utils.js';
+import { directoryParam, usernameOrAliasParam } from '../../shared/params.js';
+export const queryOrgParamsSchema = z.object({
+    query: z.string().describe('SOQL query to run'),
+    usernameOrAlias: usernameOrAliasParam,
+    directory: directoryParam,
+});
+export const registerToolQueryOrg = (server) => {
+    server.tool('sf-query-org', 'Run a SOQL query against a Salesforce org.', queryOrgParamsSchema.shape, async ({ query, usernameOrAlias, directory }) => {
+        try {
+            process.chdir(directory);
+            const connection = await getConnection(usernameOrAlias);
+            const result = await connection.query(query);
+            return textResponse(`SOQL query results:\n\n${JSON.stringify(result, null, 2)}`);
+        }
+        catch (error) {
+            return textResponse(`Failed to query org: ${error instanceof Error ? error.message : 'Unknown error'}`, true);
+        }
+    });
+};
+//# sourceMappingURL=sf-query-org.js.map

package/lib/tools/metadata/index.d.ts

@@ -0,0 +1,2 @@
+export * from './sf-deploy-metadata.js';
+export * from './sf-retrieve-metadata.js';

package/lib/tools/metadata/index.js

@@ -0,0 +1,18 @@
+/*
+ * Copyright 2025, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from './sf-deploy-metadata.js';
+export * from './sf-retrieve-metadata.js';
+//# sourceMappingURL=index.js.map

package/lib/tools/metadata/sf-deploy-metadata.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+declare const deployMetadataParams: z.ZodObject<{
+    sourceDir: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    manifest: z.ZodOptional<z.ZodString>;
+    apexTestLevel: z.ZodOptional<z.ZodEnum<["NoTestRun", "RunLocalTests", "RunAllTestsInOrg"]>>;
+    apexTests: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    usernameOrAlias: z.ZodString;
+    directory: z.ZodEffects<z.ZodString, string, string>;
+}, "strip", z.ZodTypeAny, {
+    directory: string;
+    usernameOrAlias: string;
+    manifest?: string | undefined;
+    sourceDir?: string[] | undefined;
+    apexTestLevel?: "RunLocalTests" | "RunAllTestsInOrg" | "NoTestRun" | undefined;
+    apexTests?: string[] | undefined;
+}, {
+    directory: string;
+    usernameOrAlias: string;
+    manifest?: string | undefined;
+    sourceDir?: string[] | undefined;
+    apexTestLevel?: "RunLocalTests" | "RunAllTestsInOrg" | "NoTestRun" | undefined;
+    apexTests?: string[] | undefined;
+}>;
+export type DeployMetadata = z.infer<typeof deployMetadataParams>;
+export declare const registerToolDeployMetadata: (server: McpServer) => void;
+export {};

package/lib/tools/metadata/sf-deploy-metadata.js

@@ -0,0 +1,150 @@
+/*
+ * Copyright 2025, Salesforce, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { z } from 'zod';
+import { Org, SfProject } from '@salesforce/core';
+import { SourceTracking } from '@salesforce/source-tracking';
+import { ComponentSet, ComponentSetBuilder } from '@salesforce/source-deploy-retrieve';
+import { ensureString } from '@salesforce/ts-types';
+import { Duration } from '@salesforce/kit';
+import { directoryParam, usernameOrAliasParam } from '../../shared/params.js';
+import { textResponse } from '../../shared/utils.js';
+import { getConnection } from '../../shared/auth.js';
+const deployMetadataParams = z.object({
+    sourceDir: z
+        .array(z.string())
+        .describe('Path to the local source files to deploy. Leave this unset if the user is vague about what to deploy.')
+        .optional(),
+    manifest: z.string().describe('Full file path for manifest (XML file) of components to deploy.').optional(),
+    // `RunSpecifiedTests` is excluded on purpose because the tool sets this level when Apex tests to run are passed in.
+    //
+    // Can be left unset to let the org decide which test level to use:
+    // https://developer.salesforce.com/docs/atlas.en-us.api_meta.meta/api_meta/meta_deploy_running_tests.htm
+    apexTestLevel: z
+        .enum(['NoTestRun', 'RunLocalTests', 'RunAllTestsInOrg'])
+        .optional()
+        .describe(`Apex test level to use during deployment.
+
+AGENT INSTRUCTIONS
+Set this only if the user specifically ask to run apex tests in some of these ways:
+
+NoTestRun="No tests are run"
+RunLocalTests="Run all tests in the org, except the ones that originate from installed managed and unlocked packages."
+RunAllTestsInOrg="Run all tests in the org, including tests of managed packages"
+
+Don't set this param is "apexTests" is also set.
+`),
+    apexTests: z
+        .array(z.string())
+        .describe(`Apex tests classes to run.
+
+Set this param if the user ask an Apex test to be run during deployment.
+`)
+        .optional(),
+    usernameOrAlias: usernameOrAliasParam,
+    directory: directoryParam,
+});
+/*
+ * Deploy metadata to a Salesforce org.
+ *
+ * Parameters:
+ * - sourceDir: Path to the local source files to deploy.
+ * - manifest: Full file path for manifest (XML file) of components to deploy.
+ * - apexTestLevel: Apex test level to use during deployment.
+ * - apexTests: Apex tests classes to run.
+ * - usernameOrAlias: Username or alias of the Salesforce org to deploy to.
+ * - directory: Directory of the local project.
+ *
+ * Returns:
+ * - textResponse: Deploy result.
+ */
+export const registerToolDeployMetadata = (server) => {
+    server.tool('sf-deploy-metadata', `Deploy metadata to an org from your local project.
+
+AGENT INSTRUCTIONS:
+If the user doesn't specify what to deploy exactly ("deploy my changes"), leave the "sourceDir" and "manifest" params empty so the tool calculates which files to deploy.
+
+EXAMPLE USAGE:
+Deploy changes to my org
+Deploy this file to my org
+Deploy the manifest
+Deploy X metadata to my org
+Deploy X to my org and run A,B and C apex tests.
+`, deployMetadataParams.shape, async ({ sourceDir, usernameOrAlias, apexTests, apexTestLevel, directory, manifest }) => {
+        if (apexTests && apexTestLevel) {
+            return textResponse("You can't specify both `apexTests` and `apexTestLevel` parameters.", true);
+        }
+        if (sourceDir && manifest) {
+            return textResponse("You can't specify both `sourceDir` and `manifest` parameters.", true);
+        }
+        // needed for org allowlist to work
+        process.chdir(directory);
+        const connection = await getConnection(usernameOrAlias);
+        const project = await SfProject.resolve(directory);
+        const org = await Org.create({ connection });
+        if (!sourceDir && !manifest && !(await org.tracksSource())) {
+            return textResponse('This org does not have source-tracking enabled or does not support source-tracking. You should specify the files or a manifest to deploy.', true);
+        }
+        try {
+            const stl = await SourceTracking.create({
+                org,
+                project,
+                subscribeSDREvents: true,
+            });
+            const componentSet = await buildDeployComponentSet(connection, project, stl, sourceDir, manifest);
+            if (componentSet.size === 0) {
+                // STL found no changes
+                return textResponse('No local changes to deploy were found.');
+            }
+            const deploy = await componentSet.deploy({
+                usernameOrConnection: connection,
+                apiOptions: {
+                    ...(apexTests ? { runTests: apexTests, testLevel: 'RunSpecifiedTests' } : {}),
+                    ...(apexTestLevel ? { testLevel: apexTestLevel } : {}),
+                },
+            });
+            // polling freq. is set dynamically by SDR based no the component set size.
+            const result = await deploy.pollStatus({
+                timeout: Duration.minutes(10),
+            });
+            return textResponse(`Deploy result: ${JSON.stringify(result.response)}`, !result.response.success);
+        }
+        catch (error) {
+            return textResponse(`Failed to deploy metadata: ${error instanceof Error ? error.message : 'Unknown error'}`, true);
+        }
+    });
+};
+async function buildDeployComponentSet(connection, project, stl, sourceDir, manifestPath) {
+    if (sourceDir || manifestPath) {
+        return ComponentSetBuilder.build({
+            apiversion: connection.getApiVersion(),
+            sourceapiversion: ensureString((await project.resolveProjectConfig()).sourceApiVersion),
+            sourcepath: sourceDir,
+            ...(manifestPath
+                ? {
+                    manifest: {
+                        manifestPath,
+                        directoryPaths: project.getUniquePackageDirectories().map((pDir) => pDir.fullPath),
+                    },
+                }
+                : {}),
+            projectDir: stl?.projectPath,
+        });
+    }
+    // No specific metadata requested to deploy, build component set from STL.
+    const cs = (await stl.localChangesAsComponentSet(false))[0] ?? new ComponentSet(undefined, stl.registry);
+    return cs;
+}
+//# sourceMappingURL=sf-deploy-metadata.js.map

package/lib/tools/metadata/sf-retrieve-metadata.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare const registerToolRetrieveMetadata: (server: McpServer) => void;