feat: add ignoreConflicts param for deploy/retrieve W-20002028

packages/mcp-provider-dx-core/src/tools/deploy_metadata.ts

@@ -35,12 +35,14 @@ import { textResponse } from '../shared/utils.js';
  * - apexTests: Apex tests classes to run.
  * - usernameOrAlias: Username or alias of the Salesforce org to deploy to.
  * - directory: Directory of the local project.
+ * - ignoreConflicts: Ignore conflicts and deploy local files, even if they overwrite changes in the org.
  *
  * Returns:
  * - textResponse: Deploy result.
  */
 
 export const deployMetadataParams = z.object({
+  ignoreConflicts: z.boolean().describe(' Ignore conflicts and deploy local files, even if they overwrite changes in the org.').optional(),
   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.')
@@ -106,20 +108,22 @@ export class DeployMetadataMcpTool extends McpTool<InputArgsShape, OutputArgsSha
       description: `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.
+If the user doesn't specify what to deploy exactly ("deploy my changes"), leave the "sourceDir", "ignoreConflicts" 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 local files to my org and ignore any conflicts between the local project and org
 Deploy X to my org and run A,B and C apex tests.`,
       inputSchema: deployMetadataParams.shape,
       outputSchema: undefined,
       annotations: {
         destructiveHint: true,
         openWorldHint: false,
       },
+
     };
   }
 
@@ -159,6 +163,7 @@ Deploy X to my org and run A,B and C apex tests.`,
         org,
         project,
         subscribeSDREvents: true,
+        ignoreConflicts: input.ignoreConflicts ?? false,
       });
 
       const componentSet = await buildDeployComponentSet(connection, project, stl, input.sourceDir, input.manifest);

packages/mcp-provider-dx-core/src/tools/retrieve_metadata.ts

@@ -33,12 +33,19 @@ import { textResponse } from '../shared/utils.js';
  * - manifest: Full file path for manifest (XML file) of components to retrieve.
  * - usernameOrAlias: Username or alias of the Salesforce org to retrieve from.
  * - directory: Directory of the local project.
+ * - ignoreConflicts: Ignore conflicts and retrieve and save files to your local filesystem, even if they overwrite your local changes.
  *
  * Returns:
  * - textResponse: Retrieve result.
  */
 
 export const retrieveMetadataParams = z.object({
+  ignoreConflicts: z.boolean()
+  .describe(
+    'Ignore conflicts and retrieve and save files to your local filesystem, even if they overwrite your local changes.',
+  )
+  .optional()
+  .default(false),
   sourceDir: z
     .array(z.string())
     .describe(
@@ -77,14 +84,15 @@ export class RetrieveMetadataMcpTool extends McpTool<InputArgsShape, OutputArgsS
       description: `Retrieve metadata from an org to your local project.
 
 AGENT INSTRUCTIONS:
-If the user doesn't specify what to retrieve exactly ("retrieve my changes"), leave the "sourceDir" and "manifest" params empty so the tool calculates which files to retrieve.
+If the user doesn't specify what to retrieve exactly ("retrieve my changes"), leave the "sourceDir", "ignoreConflicts", and "manifest" params empty so the tool calculates which files to retrieve.
 
 EXAMPLE USAGE:
 Retrieve changes
 Retrieve changes from my org
 Retrieve this file from my org
 Retrieve the metadata in the manifest
-Retrieve X metadata from my org`,
+Retrieve X metadata from my org
+Retrieve X metadata from my org and ignore any conflicts between the local project and org`,
       inputSchema: retrieveMetadataParams.shape,
       outputSchema: undefined,
       annotations: {
@@ -125,6 +133,7 @@ Retrieve X metadata from my org`,
         org,
         project,
         subscribeSDREvents: true,
+        ignoreConflicts: input.ignoreConflicts ?? false,
       });
 
       const componentSet = await buildRetrieveComponentSet(connection, project, stl, input.sourceDir, input.manifest);

packages/mcp-provider-dx-core/test/e2e/deploy_metadata.test.ts

@@ -15,10 +15,12 @@
  */
 
 import path from 'node:path';
+import { promises as fs } from 'node:fs';
 import { expect, assert } from 'chai';
 import { McpTestClient, DxMcpTransport } from '@salesforce/mcp-test-client';
 import { TestSession } from '@salesforce/cli-plugins-testkit';
 import { z } from 'zod';
+import { AuthInfo, Connection } from '@salesforce/core';
 import { ensureString } from '@salesforce/ts-types';
 import { deployMetadataParams } from '../../src/tools/deploy_metadata.js';
 
@@ -227,4 +229,150 @@ describe('deploy_metadata', () => {
     expect(deployResult.numberTestsCompleted).to.equal(11);
     expect(deployResult.runTestsEnabled).to.be.true;
   });
+
+  it('should deploy local edit when ignoreConflicts is set to true', async () => {
+    const apexClassPath = path.join(
+      testSession.project.dir,
+      'force-app',
+      'main',
+      'default',
+      'classes',
+      'GeocodingService.cls',
+    );
+
+    // Deploy baseline
+    const baseline = await client.callTool(deployMetadataSchema, {
+      name: 'deploy_metadata',
+      params: {
+        sourceDir: [apexClassPath],
+        usernameOrAlias: orgUsername,
+        directory: testSession.project.dir,
+      },
+    });
+
+    expect(baseline.isError).to.be.false;
+    expect(baseline.content.length).to.equal(1);
+
+    // Make a local edit
+    const baselineContent = await fs.readFile(apexClassPath, 'utf8');
+    const localEdited = baselineContent.replace(
+      /(public\s+(?:with\s+sharing\s+)?class\s+GeocodingService[^{]*\{)/,
+      '$1\n    // Local edit',
+    );
+    await fs.writeFile(apexClassPath, localEdited, 'utf8');
+
+    // Deploy the local change with ignoreConflicts true
+    const deployResult = await client.callTool(deployMetadataSchema, {
+      name: 'deploy_metadata',
+      params: {
+        sourceDir: [apexClassPath],
+        ignoreConflicts: true,
+        usernameOrAlias: orgUsername,
+        directory: testSession.project.dir,
+      },
+    });
+
+    expect(deployResult.isError).to.equal(false);
+    expect(deployResult.content.length).to.equal(1);
+    if (deployResult.content[0].type !== 'text') assert.fail();
+
+    const deployText = deployResult.content[0].text;
+    expect(deployText).to.contain('Deploy result:');
+
+    const deployMatch = deployText.match(/Deploy result: ({.*})/);
+    expect(deployMatch).to.not.be.null;
+
+    const result = JSON.parse(deployMatch![1]) as {
+      success: boolean;
+      done: boolean;
+      numberComponentsDeployed: number;
+    };
+
+    expect(result.success).to.be.true;
+    expect(result.done).to.be.true;
+    expect(result.numberComponentsDeployed).to.equal(1);
+  });
+
+  it('should deploy remote edit when ignoreConflicts is set to true', async () => {
+    const customAppPath = path.join(
+      testSession.project.dir,
+      'force-app',
+      'main',
+      'default',
+      'applications',
+      'Dreamhouse.app-meta.xml',
+    );
+
+    // deploy the whole project to ensure the file exists
+    const fullProjectDeploy = await client.callTool(deployMetadataSchema, {
+      name: 'deploy_metadata',
+      params: {
+        usernameOrAlias: orgUsername,
+        directory: testSession.project.dir,
+      },
+    });
+
+    expect(fullProjectDeploy.isError).to.be.false;
+    expect(fullProjectDeploy.content.length).to.equal(1);
+
+    // Make a remote edit using Tooling API
+    const conn = await Connection.create({
+      authInfo: await AuthInfo.create({ username: orgUsername }),
+    });
+
+    const customApp = await conn.singleRecordQuery<{ 
+      Id: string; 
+      Metadata: {
+        description: string | null;
+      };
+    }>(
+      "SELECT Id, Metadata FROM CustomApplication WHERE DeveloperName = 'Dreamhouse'",
+      {
+        tooling: true,
+      }
+    );
+
+    const updatedMetadata = {
+      ...customApp.Metadata,
+      description: customApp.Metadata.description 
+        ? `${customApp.Metadata.description} - Remote edit via Tooling API`
+        : 'Remote edit via Tooling API',
+    };
+
+    await conn.tooling.sobject('CustomApplication').update({
+      Id: customApp.Id,
+      Metadata: updatedMetadata,
+    });
+
+    // Deploy with ignoreConflicts=true - should override remote edit
+    const deployResult = await client.callTool(deployMetadataSchema, {
+      name: 'deploy_metadata',
+      params: {
+        sourceDir: [customAppPath],
+        ignoreConflicts: true,
+        usernameOrAlias: orgUsername,
+        directory: testSession.project.dir,
+      },
+    });
+
+    expect(deployResult.isError).to.equal(false);
+    expect(deployResult.content.length).to.equal(1);
+    if (deployResult.content[0].type !== 'text') assert.fail();
+
+    const deployText = deployResult.content[0].text;
+    expect(deployText).to.contain('Deploy result:');
+
+    const deployMatch = deployText.match(/Deploy result: ({.*})/);
+    expect(deployMatch).to.not.be.null;
+
+    const result = JSON.parse(deployMatch![1]) as {
+      success: boolean;
+      done: boolean;
+      numberComponentsDeployed: number;
+    };
+
+    expect(result.success).to.be.true;
+    expect(result.done).to.be.true;
+    expect(result.numberComponentsDeployed).to.equal(1);
+  });
 });

packages/mcp-provider-dx-core/test/e2e/retrieve_metadata.test.ts

@@ -182,4 +182,56 @@ describe('retrieve_metadata', () => {
     expect(apexClasses.length).to.equal(9);
     expect(packageXml.length).to.equal(1);
   });
+
+  it('should retrieve and overwrite local edits when ignoreConflicts is true', async () => {
+    const apexClassPath = path.join('force-app', 'main', 'default', 'classes', 'GeocodingService.cls');
+    const localFilePath = path.join(testSession.project.dir, apexClassPath);
+    const originalContent = fs.readFileSync(localFilePath, 'utf8');
+    const localEditContent = originalContent + '\n// Local edit';
+
+    // Make a local edit to the file
+    fs.writeFileSync(localFilePath, localEditContent, 'utf8');
+
+    // Retrieve with ignoreConflicts=true - should overwrite local edit
+    const result = await client.callTool(retrieveMetadataSchema, {
+      name: 'retrieve_metadata',
+      params: {
+        sourceDir: [apexClassPath],
+        ignoreConflicts: true,
+        usernameOrAlias: orgUsername,
+        directory: testSession.project.dir,
+      },
+    });
+
+    expect(result.isError).to.equal(false);
+    expect(result.content.length).to.equal(1);
+    if (result.content[0].type !== 'text') assert.fail();
+
+    const responseText = result.content[0].text;
+    expect(responseText).to.contain('Retrieve result:');
+
+    // Parse the retrieve result JSON
+    const retrieveMatch = responseText.match(/Retrieve result: ({.*})/);
+    expect(retrieveMatch).to.not.be.null;
+
+    const retrieveResult = JSON.parse(retrieveMatch![1]) as {
+      success: boolean;
+      done: boolean;
+      fileProperties: Array<{
+        type: string;
+        fullName: string;
+        fileName: string;
+      }>;
+    };
+    expect(retrieveResult.success).to.be.true;
+    expect(retrieveResult.done).to.be.true;
+    expect(retrieveResult.fileProperties.length).to.equal(2);
+
+    const apexClass = retrieveResult.fileProperties.find(
+      (fp: { type: string; fullName: string }) => fp.type === 'ApexClass',
+    );
+    if (!apexClass) assert.fail();
+    expect(apexClass.fullName).to.equal('GeocodingService');
+    expect(apexClass.fileName).to.equal('unpackaged/classes/GeocodingService.cls');
+  });
 });