Merge branch 'main' into feature-W-20893800-add-stateful-auth-support

amit-kumar8-sf · web-flow · commit 1fb22a60a665 · 2026-02-20T12:31:43.000+05:30
diff --git a/packages/b2c-dx-mcp/README.md b/packages/b2c-dx-mcp/README.md
@@ -165,7 +165,7 @@ Get registration status of custom API endpoints deployed on the instance (remote
 **Good prompts:**
 - ✅ "Use the MCP tool to build and push my Storefront Next bundle to staging."
 - ✅ "Use the MCP tool to push the bundle from ./build directory to Managed Runtime."
-- ✅ "Use the MCP tool to deploy my PWA Kit bundle to production with a deployment message."
+- ✅ "Use the MCP tool to deploy my PWA Kit or Storefront Next bundle to production with a deployment message."
 
 #### Tips for Better Results
 
diff --git a/packages/b2c-dx-mcp/src/tools/cartridges/index.ts b/packages/b2c-dx-mcp/src/tools/cartridges/index.ts
@@ -12,12 +12,13 @@
  * @module tools/cartridges
  */
 
+import path from 'node:path';
 import {z} from 'zod';
 import type {McpTool} from '../../utils/index.js';
 import type {Services} from '../../services.js';
 import {createToolAdapter, jsonResult} from '../adapter.js';
-import {findAndDeployCartridges} from '@salesforce/b2c-tooling-sdk/operations/code';
-import type {DeployResult, DeployOptions} from '@salesforce/b2c-tooling-sdk/operations/code';
+import {findAndDeployCartridges, getActiveCodeVersion} from '@salesforce/b2c-tooling-sdk/operations/code';
+import type {DeployResult, DeployOptions, CodeVersion} from '@salesforce/b2c-tooling-sdk/operations/code';
 import type {B2CInstance} from '@salesforce/b2c-tooling-sdk';
 import {getLogger} from '@salesforce/b2c-tooling-sdk/logging';
 
@@ -41,6 +42,8 @@ interface CartridgeDeployInput {
 interface CartridgeToolInjections {
   /** Mock findAndDeployCartridges function for testing */
   findAndDeployCartridges?: (instance: B2CInstance, directory: string, options: DeployOptions) => Promise<DeployResult>;
+  /** Mock getActiveCodeVersion function for testing */
+  getActiveCodeVersion?: (instance: B2CInstance) => Promise<CodeVersion | undefined>;
 }
 
 /**
@@ -58,6 +61,7 @@ interface CartridgeToolInjections {
  */
 function createCartridgeDeployTool(loadServices: () => Services, injections?: CartridgeToolInjections): McpTool {
   const findAndDeployCartridgesFn = injections?.findAndDeployCartridges || findAndDeployCartridges;
+  const getActiveCodeVersionFn = injections?.getActiveCodeVersion || getActiveCodeVersion;
   return createToolAdapter<CartridgeDeployInput, DeployResult>(
     {
       name: 'cartridge_deploy',
@@ -104,33 +108,65 @@ function createCartridgeDeployTool(loadServices: () => Services, injections?: Ca
       async execute(args, context) {
         // Get instance from context (guaranteed by adapter when requiresInstance is true)
         const instance = context.b2cInstance!;
+        const logger = getLogger();
 
-        // Default directory to current directory
-        const directory = args.directory || context.services.getWorkingDirectory();
+        try {
+          // If no code version specified, get the active one
+          let codeVersion = instance.config.codeVersion;
+          if (!codeVersion) {
+            logger.debug('No code version specified, getting active version...');
+            const active = await getActiveCodeVersionFn(instance);
+            if (!active?.id) {
+              throw new Error(
+                'No code version specified and no active code version found. ' +
+                  'Specify a code version using one of: ' +
+                  '--code-version flag, SFCC_CODE_VERSION environment variable, ' +
+                  'or code-version field in dw.json configuration file.',
+              );
+            }
+            codeVersion = active.id;
+            instance.config.codeVersion = codeVersion;
+          }
 
-        // Parse options
-        const options: DeployOptions = {
-          include: args.cartridges,
-          exclude: args.exclude,
-          reload: args.reload,
-        };
+          // Resolve directory path: relative paths are resolved relative to working directory, absolute paths are used as-is
+          const directory = args.directory
+            ? path.isAbsolute(args.directory)
+              ? args.directory
+              : path.resolve(context.services.getWorkingDirectory(), args.directory)
+            : context.services.getWorkingDirectory();
 
-        // Log all computed variables before deploying
-        const logger = getLogger();
-        logger.debug(
-          {
-            directory,
-            include: options.include,
-            exclude: options.exclude,
-            reload: options.reload,
-          },
-          '[Cartridges] Deploying cartridges with computed options',
-        );
+          // Parse options
+          const options: DeployOptions = {
+            include: args.cartridges,
+            exclude: args.exclude,
+            reload: args.reload,
+          };
+
+          // Log all computed variables before deploying
+          logger.debug(
+            {
+              directory,
+              codeVersion,
+              include: options.include,
+              exclude: options.exclude,
+              reload: options.reload,
+            },
+            '[Cartridges] Deploying cartridges with computed options',
+          );
 
-        // Deploy cartridges
-        const result = await findAndDeployCartridgesFn(instance, directory, options);
+          // Deploy cartridges
+          const result = await findAndDeployCartridgesFn(instance, directory, options);
 
-        return result;
+          return result;
+        } catch (error) {
+          // Handle communication and authentication errors
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          throw new Error(
+            `Failed to communicate with B2C instance. Check your authentication credentials and network connection. ` +
+              `If no code version is specified, ensure the instance is accessible and has an active code version. ` +
+              `Original error: ${errorMessage}`,
+          );
+        }
       },
       formatOutput: (output) => jsonResult(output),
     },
diff --git a/packages/b2c-dx-mcp/src/tools/mrt/index.ts b/packages/b2c-dx-mcp/src/tools/mrt/index.ts
@@ -34,6 +34,8 @@ interface MrtBundlePushInput {
   ssrOnly?: string;
   /** Glob patterns for shared files (default: static/**\/*,client/**\/*) */
   ssrShared?: string;
+  /** Whether to deploy to an environment after push (default: false) */
+  deploy?: boolean;
 }
 
 /**
@@ -47,7 +49,7 @@ interface MrtToolInjections {
 /**
  * Creates the mrt_bundle_push tool.
  *
- * Creates a bundle from a pre-built PWA Kit project and pushes it to
+ * Creates a bundle from a pre-built PWA Kit or Storefront Next project and pushes it to
  * Managed Runtime (MRT). Optionally deploys to a target environment after push.
  * Expects the project to already be built (e.g., `npm run build` completed).
  * Shared across MRT, PWAV3, and STOREFRONTNEXT toolsets.
@@ -62,7 +64,7 @@ function createMrtBundlePushTool(loadServices: () => Services, injections?: MrtT
     {
       name: 'mrt_bundle_push',
       description:
-        'Bundle a pre-built PWA Kit project and push to Managed Runtime. Optionally deploy to a target environment.',
+        'Bundle a pre-built PWA Kit or Storefront Next project and push to Managed Runtime. Optionally deploy to a target environment.',
       toolsets: ['MRT', 'PWAV3', 'STOREFRONTNEXT'],
       isGA: false,
       // MRT operations use ApiKeyStrategy from SFCC_MRT_API_KEY or ~/.mobify
@@ -78,6 +80,11 @@ function createMrtBundlePushTool(loadServices: () => Services, injections?: MrtT
           .string()
           .optional()
           .describe('Glob patterns for shared files, comma-separated (default: static/**/*,client/**/*)'),
+        deploy: z
+          .boolean()
+          .optional()
+          .default(false)
+          .describe('Whether to deploy to an environment after push (default: false)'),
       },
       async execute(args, context) {
         // Get project from --project flag (required)
@@ -89,15 +96,30 @@ function createMrtBundlePushTool(loadServices: () => Services, injections?: MrtT
         }
 
         // Get environment from --environment flag (optional)
-        const environment = context.mrtConfig?.environment;
+        // When deploy is false, environment is undefined (bundle push only, no deployment)
+        // When deploy is true, environment is required
+        let environment: string | undefined;
+        if (args.deploy) {
+          environment = context.mrtConfig?.environment;
+          if (!environment) {
+            throw new Error(
+              'MRT deployment error: Environment is required when deploy=true. ' +
+                'Provide --environment flag, set SFCC_MRT_ENVIRONMENT environment variable, or set mrtEnvironment in dw.json.',
+            );
+          }
+        }
 
         // Get origin from --cloud-origin flag or mrtOrigin config (optional)
         const origin = context.mrtConfig?.origin;
 
         // Parse comma-separated glob patterns (same as CLI defaults)
         const ssrOnly = (args.ssrOnly || 'ssr.js,ssr.mjs,server/**/*').split(',').map((s) => s.trim());
         const ssrShared = (args.ssrShared || 'static/**/*,client/**/*').split(',').map((s) => s.trim());
-        const buildDirectory = args.buildDirectory || path.join(context.services.getWorkingDirectory(), 'build');
+        const buildDirectory = args.buildDirectory
+          ? path.isAbsolute(args.buildDirectory)
+            ? args.buildDirectory
+            : path.resolve(context.services.getWorkingDirectory(), args.buildDirectory)
+          : path.join(context.services.getWorkingDirectory(), 'build');
 
         // Log all computed variables before pushing bundle
         const logger = getLogger();
diff --git a/packages/b2c-dx-mcp/test/commands/mcp.test.ts b/packages/b2c-dx-mcp/test/commands/mcp.test.ts
@@ -9,6 +9,8 @@ import {createSandbox, type SinonStub, type SinonSandbox} from 'sinon';
 import {Telemetry} from '@salesforce/b2c-tooling-sdk/telemetry';
 import McpServerCommand from '../../src/commands/mcp.js';
 import {B2CDxMcpServer} from '../../src/server.js';
+import {Services} from '../../src/services.js';
+import {createMockResolvedConfig} from '../test-helpers.js';
 
 describe('McpServerCommand', () => {
   describe('static properties', () => {
@@ -505,6 +507,118 @@ describe('McpServerCommand', () => {
     });
   });
 
+  describe('loadServices', () => {
+    let sandbox: SinonSandbox;
+    let command: McpServerCommand;
+    let loadConfigurationStub: SinonStub;
+    let fromResolvedConfigStub: SinonStub;
+
+    beforeEach(() => {
+      sandbox = createSandbox();
+      command = new McpServerCommand([], {
+        name: 'test',
+        version: '1.0.0',
+        root: process.cwd(),
+        dataDir: '/tmp/test-data',
+      } as never);
+    });
+
+    afterEach(() => {
+      sandbox.restore();
+    });
+
+    it('should call loadConfiguration and Services.fromResolvedConfig', () => {
+      const mockConfig = createMockResolvedConfig();
+      const mockServices = new Services({
+        resolvedConfig: mockConfig,
+      });
+
+      // Stub loadConfiguration to return mock config
+      loadConfigurationStub = sandbox
+        .stub(command as unknown as Record<string, unknown>, 'loadConfiguration')
+        .returns(mockConfig);
+
+      // Stub Services.fromResolvedConfig to return mock services
+      fromResolvedConfigStub = sandbox.stub(Services, 'fromResolvedConfig').returns(mockServices);
+
+      // Call loadServices via protected access
+      const services = (command as unknown as {loadServices(): Services}).loadServices();
+
+      // Verify loadConfiguration was called
+      expect(loadConfigurationStub.calledOnce).to.be.true;
+
+      // Verify Services.fromResolvedConfig was called with the config from loadConfiguration
+      expect(fromResolvedConfigStub.calledOnce).to.be.true;
+      expect(fromResolvedConfigStub.firstCall.args[0]).to.equal(mockConfig);
+
+      // Verify the returned services instance
+      expect(services).to.equal(mockServices);
+    });
+
+    it('should return Services instance created from resolved config', () => {
+      const mockConfig = createMockResolvedConfig({
+        hostname: 'test-server',
+        mrtProject: 'test-project',
+      });
+      const mockServices = new Services({
+        resolvedConfig: mockConfig,
+      });
+
+      // Stub loadConfiguration
+      sandbox.stub(command as unknown as Record<string, unknown>, 'loadConfiguration').returns(mockConfig);
+
+      // Stub Services.fromResolvedConfig to return mock services
+      sandbox.stub(Services, 'fromResolvedConfig').returns(mockServices);
+
+      // Call loadServices
+      const services = (command as unknown as {loadServices(): Services}).loadServices();
+
+      // Verify the returned services instance
+      expect(services).to.equal(mockServices);
+      expect(services).to.be.instanceOf(Services);
+    });
+
+    it('should reload configuration on each call', () => {
+      const mockConfig1 = createMockResolvedConfig({hostname: 'server1'});
+      const mockConfig2 = createMockResolvedConfig({hostname: 'server2'});
+      const mockServices1 = new Services({resolvedConfig: mockConfig1});
+      const mockServices2 = new Services({resolvedConfig: mockConfig2});
+
+      // Stub loadConfiguration to return different configs on each call
+      const loadConfigurationStub = sandbox
+        .stub(command as unknown as Record<string, unknown>, 'loadConfiguration')
+        .onFirstCall()
+        .returns(mockConfig1)
+        .onSecondCall()
+        .returns(mockConfig2);
+
+      // Stub Services.fromResolvedConfig to return different services
+      const fromResolvedConfigStub = sandbox
+        .stub(Services, 'fromResolvedConfig')
+        .onFirstCall()
+        .returns(mockServices1)
+        .onSecondCall()
+        .returns(mockServices2);
+
+      // Call loadServices twice
+      const services1 = (command as unknown as {loadServices(): Services}).loadServices();
+      const services2 = (command as unknown as {loadServices(): Services}).loadServices();
+
+      // Verify loadConfiguration was called twice
+      expect(loadConfigurationStub.calledTwice).to.be.true;
+
+      // Verify Services.fromResolvedConfig was called with correct configs
+      expect(fromResolvedConfigStub.calledTwice).to.be.true;
+      expect(fromResolvedConfigStub.firstCall.args[0]).to.equal(mockConfig1);
+      expect(fromResolvedConfigStub.secondCall.args[0]).to.equal(mockConfig2);
+
+      // Verify different services instances were returned
+      expect(services1).to.equal(mockServices1);
+      expect(services2).to.equal(mockServices2);
+      expect(services1).to.not.equal(services2);
+    });
+  });
+
   describe('finally', () => {
     let sandbox: SinonSandbox;
     let command: McpServerCommand;
diff --git a/packages/b2c-dx-mcp/test/tools/cartridges/index.test.ts b/packages/b2c-dx-mcp/test/tools/cartridges/index.test.ts
diff --git a/packages/b2c-dx-mcp/test/tools/mrt/index.test.ts b/packages/b2c-dx-mcp/test/tools/mrt/index.test.ts
