@salesforce/mcp 0.17.1 → 0.17.2-dev.1

package/lib/modules/platform-cli/sf-test-apex.js

@@ -1,132 +0,0 @@
-/*
- * 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 { TestService } from '@salesforce/apex-node';
-import { Duration, ensureArray } from '@salesforce/kit';
-import { directoryParam, usernameOrAliasParam } from '../../shared/params.js';
-import { textResponse } from '../../shared/utils.js';
-import { getConnection } from '../../shared/auth.js';
-const runApexTestsParam = z.object({
-    testLevel: z.enum(["RunLocalTests" /* TestLevel.RunLocalTests */, "RunAllTestsInOrg" /* TestLevel.RunAllTestsInOrg */, "RunSpecifiedTests" /* TestLevel.RunSpecifiedTests */]).describe(`Apex test level
-
-AGENT INSTRUCTIONS
-Choose the correct value based on what tests are meant to be executed in some of these ways:
-
-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"
-RunSpecifiedTests="Run the Apex tests I specify, these will be specified in the classNames parameter"
-`),
-    classNames: z
-        .array(z.string())
-        .describe(`Apex tests classes to run.
-            if Running all tests, all tests should be listed
-            Run the tests, find apex classes matching the pattern **/classes/*.cls, that include the @isTest decorator in the file and then join their test names together with ','
-`)
-        .optional(),
-    methodNames: z
-        .array(z.string())
-        .describe('Specific test method names, functions inside of an apex test class, must be joined with the Apex tests name')
-        .optional(),
-    async: z
-        .boolean()
-        .default(false)
-        .describe('Weather to wait for the test to finish (false) or enque the Apex tests and return the test run id (true)'),
-    suiteName: z.string().describe('a suite of apex test classes to run').optional(),
-    testRunId: z.string().default('an id of an in-progress, or completed apex test run').optional(),
-    verbose: z
-        .boolean()
-        .default(false)
-        .describe('If a user wants more test information in the context, or information about passing tests'),
-    codeCoverage: z
-        .boolean()
-        .default(false)
-        .describe('set to true if a user wants codecoverage calculated by the server'),
-    usernameOrAlias: usernameOrAliasParam,
-    directory: directoryParam,
-});
-/*
- * Run Apex tests in a Salesforce org.
- *
- * Parameters:
- * - testLevel: 'RunSpecifiedTests', 'RunLocalTests', 'RunAllTestsInOrg', used to specify the specific test-level.
- * - classNames: if testLevel='RunSpecifiedTests', this will be the specified tests to run
- * - usernameOrAlias: Username or alias of the Salesforce org to run tests in.
- * - directory: Directory of the local project.
- *
- * Returns:
- * - textResponse: Test result.
- */
-export const testApex = (server) => {
-    server.tool('sf-test-apex', `Run Apex tests in an org.
-
-AGENT INSTRUCTIONS:
-If the user doesn't specify what to test, take context from the currently open file
-This will ONLY run APEX tests, NOT agent tests, lightning tests, flow tests, or any other type of test.
-
-this should be chosen when a file in the 'classes' directory is mentioned
-
-EXAMPLE USAGE:
-Run tests A, B, C.
-Run the myTestMethod in this file
-Run this test and include success and failures
-Run all tests in the org.
-Test the "mySuite" suite asynchronously. I’ll check results later.
-Run tests for this file and include coverage
-What are the results for 707XXXXXXXXXXXX
-`, runApexTestsParam.shape, {
-        title: 'Apex Tests',
-        openWorldHint: false,
-    }, async ({ testLevel, usernameOrAlias, classNames, directory, methodNames, suiteName, async, testRunId, verbose, codeCoverage, }) => {
-        if ((ensureArray(suiteName).length > 1 ||
-            ensureArray(methodNames).length > 1 ||
-            ensureArray(classNames).length > 1) &&
-            testLevel !== "RunSpecifiedTests" /* TestLevel.RunSpecifiedTests */) {
-            return textResponse("You can't specify which tests to run without setting testLevel='RunSpecifiedTests'", true);
-        }
-        if (!usernameOrAlias)
-            return textResponse('The usernameOrAlias parameter is required, if the user did not specify one use the #sf-get-username tool', true);
-        // needed for org allowlist to work
-        process.chdir(directory);
-        const connection = await getConnection(usernameOrAlias);
-        try {
-            const testService = new TestService(connection);
-            let result;
-            if (testRunId) {
-                // we just need to get the test results
-                result = await testService.reportAsyncResults(testRunId, codeCoverage);
-            }
-            else {
-                // we need to run tests
-                const payload = await testService.buildAsyncPayload(testLevel, methodNames?.join(','), classNames?.join(','), suiteName);
-                result = await testService.runTestAsynchronous(payload, codeCoverage, async, undefined, undefined, Duration.minutes(10));
-                if (async) {
-                    return textResponse(`Test Run Id: ${JSON.stringify(result)}`);
-                }
-                // the user waited for the full results, we know they're TestResult
-                result = result;
-            }
-            if (!verbose) {
-                // aka concise, filter out passing tests
-                result.tests = result.tests.filter((test) => test.outcome === "Fail" /* ApexTestResultOutcome.Fail */);
-            }
-            return textResponse(`Test result: ${JSON.stringify(result)}`);
-        }
-        catch (e) {
-            return textResponse(`Failed to run Apex Tests: ${e instanceof Error ? e.message : 'Unknown error'}`, true);
-        }
-    });
-};
-//# sourceMappingURL=sf-test-apex.js.map

package/lib/shared/params.d.ts

@@ -1,5 +0,0 @@
-import { z } from 'zod';
-export declare const usernameOrAliasParam: z.ZodString;
-export declare const useToolingApiParam: z.ZodOptional<z.ZodBoolean>;
-export declare const baseAbsolutePathParam: z.ZodEffects<z.ZodString, string, string>;
-export declare const directoryParam: z.ZodEffects<z.ZodString, string, string>;

package/lib/shared/params.js

@@ -1,46 +0,0 @@
-/*
- * 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 { sanitizePath } from './utils.js';
-/*
- * A collection of reusable Tool parameters
- */
-export const usernameOrAliasParam = z.string()
-    .describe(`The username or alias for the Salesforce org to run this tool against.
-
-AGENT INSTRUCTIONS:
-If it is not clear what username or alias is, run the #sf-get-username tool.
-NEVER guess or make-up a username or alias, use #sf-get-username if you are not sure.
-DO NOT use #sf-get-username if the user mentions an alias or username, like "for my an-alias org" or "for my test-prgelc2petd9@example.com org".
-
-USAGE:
-...for the my-alias org
-...for my 'my-alias' user
-...for alias myAlias
-...for my 'test@example.com' user
-...for the 'test@example.com' org`);
-export const useToolingApiParam = z.boolean().optional().describe('Use Tooling API for the operation');
-export const baseAbsolutePathParam = z
-    .string()
-    .refine(sanitizePath, 'Invalid path: Must be an absolute path and cannot contain path traversal sequences');
-export const directoryParam = baseAbsolutePathParam.describe(`The directory to run this tool from.
-AGENT INSTRUCTIONS:
-We need to know where the user wants to run this tool from.
-Look at your current Workspace Context to determine this filepath.
-ALWAYS USE A FULL PATH TO THE DIRECTORY.
-Unless the user explicitly asks for a different directory, or a new directory is created from the action of a tool, use this same directory for future tool calls.
-`);
-//# sourceMappingURL=params.js.map

package/lib/shared/types.d.ts

@@ -1,33 +0,0 @@
-import { ConfigInfo } from '@salesforce/core';
-import { type Nullable } from '@salesforce/ts-types';
-import { RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
-export type ConfigInfoWithCache = {
-    key: string;
-    location?: ConfigInfo['location'];
-    value: string;
-    cached?: boolean;
-    path: string;
-};
-export type SanitizedOrgAuthorization = {
-    aliases?: Nullable<string[]>;
-    configs?: Nullable<string[]>;
-    username?: string;
-    instanceUrl?: string;
-    isScratchOrg?: boolean;
-    isDevHub?: boolean;
-    isSandbox?: boolean;
-    orgId?: string;
-    oauthMethod?: string;
-    isExpired?: boolean | 'unknown';
-};
-export type ToolTextResponse = {
-    isError: boolean;
-    content: Array<{
-        type: 'text';
-        text: string;
-    }>;
-};
-export type ToolInfo = {
-    tool: RegisteredTool;
-    name: string;
-};

package/lib/shared/utils.d.ts

@@ -1,11 +0,0 @@
-import { type ToolTextResponse } from './types.js';
-export declare function textResponse(text: string, isError?: boolean): ToolTextResponse;
-/**
- * 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 declare function getEnabledToolsets(availableToolsets: string[], toolsetsInput: string): Set<string>;
-export declare function sanitizePath(projectPath: string): boolean;

package/lib/shared/utils.js

@@ -1,71 +0,0 @@
-/*
- * 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 path from 'node:path';
-// 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(projectPath) {
-    // Decode URL-encoded sequences
-    const decodedProjectPath = decodeURIComponent(projectPath);
-    // Normalize Unicode characters
-    const normalizedProjectPath = decodedProjectPath.normalize();
-    // Check for various traversal patterns
-    const hasTraversal = normalizedProjectPath.includes('..') ||
-        normalizedProjectPath.includes('\u2025') || // Unicode horizontal ellipsis
-        normalizedProjectPath.includes('\u2026'); // Unicode vertical ellipsis
-    // `path.isAbsolute` doesn't cover Windows's drive-relative path:
-    // https://github.com/nodejs/node/issues/56766
-    //
-    // we can assume it's a drive-relative path if it's starts with `\`.
-    const isAbsolute = path.isAbsolute(projectPath) && (process.platform === 'win32' ? !projectPath.startsWith('\\') : true);
-    return !hasTraversal && isAbsolute;
-}
-//# sourceMappingURL=utils.js.map