@salesforce/mcp 0.9.0 → 0.10.0

package/lib/index.js

@@ -167,8 +167,8 @@ You can also use special values to control access to orgs:
         // ************************
         if (all || enabledToolsets.has('testing')) {
             this.logToStderr('Registering testing tools');
-            testing.registerToolRunApexTest(server);
-            testing.registerToolRunAgentTest(server);
+            testing.registerToolTestApex(server);
+            testing.registerToolTestAgent(server);
         }
         // ************************
         // METADATA TOOLS

package/lib/shared/auth.js

@@ -102,11 +102,6 @@ export async function getAllAllowedOrgs() {
     const sanitizedOrgs = sanitizeOrgs(allOrgs);
     // Filter out orgs that are not in ORG_ALLOWLIST
     const allowedOrgs = await filterAllowedOrgs(sanitizedOrgs, orgAllowList);
-    // If no orgs are found, stop the server
-    if (allowedOrgs.length === 0) {
-        console.error('No orgs found that match the allowed orgs configuration. Check MCP Server startup config.');
-        process.exit(1);
-    }
     return allowedOrgs;
 }
 // Function to filter orgs based on ORG_ALLOWLIST configuration

package/lib/tools/testing/sf-test-agents.d.ts

@@ -4,7 +4,9 @@ declare const runAgentTestsParam: z.ZodObject<{
     agentApiName: z.ZodString;
     usernameOrAlias: z.ZodString;
     directory: z.ZodEffects<z.ZodString, string, string>;
+    async: z.ZodDefault<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
+    async: boolean;
     directory: string;
     usernameOrAlias: string;
     agentApiName: string;
@@ -12,7 +14,8 @@ declare const runAgentTestsParam: z.ZodObject<{
     directory: string;
     usernameOrAlias: string;
     agentApiName: string;
+    async?: boolean | undefined;
 }>;
 export type AgentRunTests = z.infer<typeof runAgentTestsParam>;
-export declare const registerToolRunAgentTest: (server: SfMcpServer) => void;
+export declare const registerToolTestAgent: (server: SfMcpServer) => void;
 export {};

package/lib/tools/testing/sf-test-agents.js

@@ -21,11 +21,15 @@ import { textResponse } from '../../shared/utils.js';
 import { getConnection } from '../../shared/auth.js';
 const runAgentTestsParam = z.object({
     agentApiName: z.string().describe(`Agent test to run
-            if unsure, list all files matching the pattern *.aiEvaluationDefinition-meta.xml
+            if unsure, list all files matching the pattern **/aiEvaluationDefinitions/*.aiEvaluationDefinition-meta.xml
             only one test can be executed at a time
 `),
     usernameOrAlias: usernameOrAliasParam,
     directory: directoryParam,
+    async: z
+        .boolean()
+        .default(false)
+        .describe('Whether to wait for the tests to finish (false) or quickly return only the test id (true)'),
 });
 /*
  * Run Agent tests in a Salesforce org.
@@ -38,7 +42,7 @@ const runAgentTestsParam = z.object({
  * Returns:
  * - textResponse: Test result.
  */
-export const registerToolRunAgentTest = (server) => {
+export const registerToolTestAgent = (server) => {
     server.tool('sf-test-agents', `Run Agent tests in an org.
 
 AGENT INSTRUCTIONS:
@@ -50,10 +54,11 @@ this should be chosen when a file in the 'aiEvaluationDefinitions' directory is
 EXAMPLE USAGE:
 Run tests for the X agent
 Run this test
+start myAgentTest and don't wait for results
 `, runAgentTestsParam.shape, {
         title: 'Run Agent Tests',
         openWorldHint: false,
-    }, async ({ usernameOrAlias, agentApiName, directory }) => {
+    }, async ({ usernameOrAlias, agentApiName, directory, async }) => {
         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
@@ -61,9 +66,15 @@ Run this test
         const connection = await getConnection(usernameOrAlias);
         try {
             const agentTester = new AgentTester(connection);
-            const test = await agentTester.start(agentApiName);
-            const result = await agentTester.poll(test.runId, { timeout: Duration.minutes(10) });
-            return textResponse(`Test result: ${JSON.stringify(result)}`);
+            if (async) {
+                const startResult = await agentTester.start(agentApiName);
+                return textResponse(`Test Run: ${JSON.stringify(startResult)}`);
+            }
+            else {
+                const test = await agentTester.start(agentApiName);
+                const result = await agentTester.poll(test.runId, { timeout: Duration.minutes(10) });
+                return textResponse(`Test result: ${JSON.stringify(result)}`);
+            }
         }
         catch (e) {
             return textResponse(`Failed to run Agent Tests: ${e instanceof Error ? e.message : 'Unknown error'}`, true);

package/lib/tools/testing/sf-test-apex.d.ts

@@ -3,20 +3,38 @@ import { TestLevel } from '@salesforce/apex-node';
 import { SfMcpServer } from '../../sf-mcp-server.js';
 declare const runApexTestsParam: z.ZodObject<{
     testLevel: z.ZodEnum<[TestLevel.RunLocalTests, TestLevel.RunAllTestsInOrg, TestLevel.RunSpecifiedTests]>;
-    classNames: z.ZodArray<z.ZodString, "many">;
+    classNames: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    methodNames: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    async: z.ZodDefault<z.ZodBoolean>;
+    suiteName: z.ZodOptional<z.ZodString>;
+    testRunId: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+    verbose: z.ZodDefault<z.ZodBoolean>;
+    codeCoverage: z.ZodDefault<z.ZodBoolean>;
     usernameOrAlias: z.ZodString;
     directory: z.ZodEffects<z.ZodString, string, string>;
 }, "strip", z.ZodTypeAny, {
+    async: boolean;
+    codeCoverage: boolean;
     testLevel: TestLevel;
     directory: string;
     usernameOrAlias: string;
-    classNames: string[];
+    verbose: boolean;
+    classNames?: string[] | undefined;
+    methodNames?: string[] | undefined;
+    suiteName?: string | undefined;
+    testRunId?: string | undefined;
 }, {
     testLevel: TestLevel;
     directory: string;
     usernameOrAlias: string;
-    classNames: string[];
+    async?: boolean | undefined;
+    codeCoverage?: boolean | undefined;
+    classNames?: string[] | undefined;
+    methodNames?: string[] | undefined;
+    suiteName?: string | undefined;
+    testRunId?: string | undefined;
+    verbose?: boolean | undefined;
 }>;
 export type ApexRunTests = z.infer<typeof runApexTestsParam>;
-export declare const registerToolRunApexTest: (server: SfMcpServer) => void;
+export declare const registerToolTestApex: (server: SfMcpServer) => void;
 export {};

package/lib/tools/testing/sf-test-apex.js

@@ -15,6 +15,7 @@
  */
 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';
@@ -28,10 +29,31 @@ RunLocalTests="Run all tests in the org, except the ones that originate from ins
 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.
+    classNames: z
+        .array(z.string())
+        .describe(`Apex tests classes to run.
             if Running all tests, all tests should be listed
-            if unsure, find apex classes matching the pattern **/classes/*.cls, that include the @isTest decorator in the file and then join their test names together with ','
-`),
+            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,
 });
@@ -47,7 +69,7 @@ RunSpecifiedTests="Run the Apex tests I specify, these will be specified in the
  * Returns:
  * - textResponse: Test result.
  */
-export const registerToolRunApexTest = (server) => {
+export const registerToolTestApex = (server) => {
     server.tool('sf-test-apex', `Run Apex tests in an org.
 
 AGENT INSTRUCTIONS:
@@ -58,13 +80,20 @@ this should be chosen when a file in the 'classes' directory is mentioned
 
 EXAMPLE USAGE:
 Run tests A, B, C.
-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 ','
+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 }) => {
-        if (testLevel !== "RunSpecifiedTests" /* TestLevel.RunSpecifiedTests */ && classNames?.length && classNames?.length >= 1) {
+    }, 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)
@@ -74,8 +103,25 @@ Run all tests in the org.
         const connection = await getConnection(usernameOrAlias);
         try {
             const testService = new TestService(connection);
-            const payload = await testService.buildAsyncPayload(testLevel, classNames.join(','));
-            const result = (await testService.runTestAsynchronous(payload, false));
+            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) {