Install AI Tools

B2C Commerce tools, documentation, and skills for your assistant.

Claude

Using Claude Desktop? See Claude Desktop (Cowork) setup.

Install the plugin Recommended

bash
claude plugin marketplace add SalesforceCommerceCloud/b2c-developer-tooling
claude plugin install b2c-dx-mcp@b2c-developer-tooling

Start a new Claude Code session. To install for the current project only, run it from your project directory with --scope project.

Turn on auto-update

Claude Code does not auto-update third-party marketplaces by default, so installed plugins stay on the version you installed. To get new releases automatically, run /plugin, open Marketplaces, select b2c-developer-tooling, and choose Enable auto-update. Claude Code then checks for updates when a session starts; run /reload-plugins or start a new session to load them.

Manual MCP setup
bash
claude mcp add --transport stdio --scope user b2c-dx-mcp -- npx -y @salesforce/b2c-dx-mcp@latest

Start a new session. To configure the current project only, run it from your project directory with --scope project. See Claude Code MCP setup.

Codex/ChatGPT

Using the ChatGPT desktop app (ChatGPT Work)? See ChatGPT Work setup.

Install the plugin Recommended

bash
codex plugin marketplace add SalesforceCommerceCloud/b2c-developer-tooling
codex plugin add b2c-dx-mcp@b2c-developer-tooling

Start a new Codex session in your project. Codex plugins also work in ChatGPT Work.

Manual MCP setup
bash
codex mcp add b2c-dx-mcp -- npx -y @salesforce/b2c-dx-mcp@latest

Or add this to ~/.codex/config.toml (or $CODEX_HOME/config.toml if customized):

toml
[mcp_servers.b2c-dx-mcp]
command = "npx"
args = ["-y", "@salesforce/b2c-dx-mcp@latest"]

Start a new session. See Codex MCP configuration.

VS Code

Install the plugin Recommended

  1. Open the Command Palette (Cmd/Ctrl+Shift+P) and run Chat: Install Plugin from Source.
  2. Enter SalesforceCommerceCloud/b2c-developer-tooling.
  3. Select b2c-dx-mcp and follow the installation prompts.
  4. Start a new chat in GitHub Copilot.
Manual MCP setup

Add this to .vscode/mcp.json in your workspace:

json
{
  "servers": {
    "b2c-dx-mcp": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@salesforce/b2c-dx-mcp@latest"]
    }
  }
}

See VS Code MCP setup.

Copilot CLI setup

Cursor

Reload the MCP server in Cursor after installation.

Manual MCP setup

Add this to .cursor/mcp.json in your project:

json
{
  "mcpServers": {
    "b2c-dx-mcp": {
      "command": "npx",
      "args": ["-y", "@salesforce/b2c-dx-mcp@latest"]
    }
  }
}

For all projects, use ~/.cursor/mcp.json instead.

See Cursor's MCP documentation.

OpenCode

Add this to opencode.json in your project:

json
{
  "mcp": {
    "b2c-dx-mcp": {
      "type": "local",
      "command": ["npx", "-y", "@salesforce/b2c-dx-mcp@latest"],
      "enabled": true
    }
  }
}

Restart OpenCode. For all projects, use ~/.config/opencode/opencode.json. See OpenCode MCP setup.

Gemini

Run:

bash
gemini mcp add --scope user b2c-dx-mcp -- npx -y @salesforce/b2c-dx-mcp@latest

Start a new Gemini CLI session. To configure the current project only, run it from your project directory with --scope project. See Gemini CLI MCP setup.

No separate skills plugins needed.

Other clients and manual setup →
Skip to content
View as Markdown
View as Markdown

Security Rules ​

The rules that b2c security scan runs. List them with b2c security rules. To suppress a finding, add // b2c-dx-disable-next-line <rule-id> on the line before it.

Most rules check cartridge JavaScript. Metadata rules (csrf-allowlist, ocapi-*, preference-secret-value, secret-attribute-not-password, service-credential-password, service-insecure-url) check site import/export data wherever it is in the project, such as a site_template folder: services.xml, preferences.xml, attribute definitions (meta/*.xml), csrf-whitelists.xml, and OCAPI settings (ocapi-settings/wapi_*_config.json). Suppress a metadata finding with an XML comment, <!-- b2c-dx-disable-next-line <rule-id> - reason --> (XML comments can't contain --, so separate the optional reason with a single hyphen); JSON has no comments, so use the baseline.

Route rules understand SFRA (server.get/post/use, and server.extend with append, prepend, and replace across the cartridge path) and SiteGenesis (guard.ensure filters). They look at routes across all your cartridges, so a rule can tell, for example, that an overlay cartridge adds a CSRF check to a base route.

RuleSeverityFinds
csrf-allowlistmediumBusiness Manager CSRF exemptions (csrf-whitelists.xml)
dynamic-codehigh (critical from request)eval, new Function, require with a computed path
file-path-from-requesthighFile paths and upload names chosen by the client
get-mutates-statemediumGET routes that store request input in a transaction
hardcoded-credentialshighPasswords, API keys, and auth headers written into code
insecure-cookielowCookies without the Secure and HttpOnly flags
mass-assignmenthighRequest fields copied into persistent objects by key
object-query-injectionhighObject query strings built by concatenation
ocapi-broad-accessmediumOCAPI clients granted every resource, or any/http:// origins
ocapi-demo-client-idhighOCAPI settings for the demo client ID aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
open-redirectmediumRedirects to a host chosen through the request
pii-in-logsmediumPersonal or payment data written to logs
preference-secret-valuehighCredential values in preferences.xml
secret-attribute-not-passwordmediumSecret-named attributes that aren't the password type
service-credential-passwordhighPlaintext passwords in services.xml
service-insecure-urlmediumService credentials with http:// URLs
sfra-post-without-csrfhighSFRA POST routes without a CSRF token check
sfra-replace-drops-middlewarehighserver.replace() dropping security middleware
sg-post-without-csrfhighSiteGenesis POST actions without the csrf filter
weak-cryptomediumdw.crypto Weak* classes, MD5/SHA-1, DES/RC4, ECB mode

csrf-allowlist ​

Severity: medium · Confidence: medium · CWE: CWE-352

Finds entries in the Business Manager CSRF allowlist (csrf-whitelists.xml) that exempt requests from CSRF protection: every pipeline or controller entry, worded more strongly when no start-node is given (all start nodes are exempt), and user agents exempt on production or on every instance (legacy entries directly under <user-agents>). Development-only user agents are not reported.

Remove entries you no longer need, exempt a single start node rather than a whole pipeline, and avoid user-agent exemptions on production: a client can send any user agent.

dynamic-code ​

Severity: high · Confidence: high · CWE: CWE-95

Finds code that is built or loaded from strings at runtime: eval(), Function() or new Function(), and require() or importScript() with a computed path. A computed path with a fixed directory prefix, such as require('*/cartridge/experience/' + type), is allowed unless the variable part comes from the request. A path built only from string constants is allowed too, including constants from another module on the cartridge path, such as require(Constants.HELPER) or require(Constants.SCRIPTS + 'helper/Helper') where Constants.SCRIPTS = '~/cartridge/scripts/' (a constant assigned more than once doesn't count). When eval() or Function() compiles request input, such as a JSON-RPC body in a Business Manager terminal, the finding is critical.

js
// Finding
var helper = require(request.httpParameterMap.helper.stringValue);

// Fix: map known values to static requires
var HELPERS = {cart: require('*/cartridge/scripts/helpers/cartHelpers')};
var helper = HELPERS[name];

file-path-from-request ​

Severity: high · Confidence: medium · CWE: CWE-73, CWE-22, CWE-434

Finds dw.io.File paths built from request input. That includes the three values the platform passes to the HttpParameterMap.processMultipart() callback (field name, content type, and original file name), which all come from the client, as well as req.querystring, req.form, and request.httpParameterMap values used anywhere in a path.

When the callback returns a File that already exists, the platform deletes it and stores the upload in its place. A client-chosen name lets an attacker overwrite other files in the target directory (for example, files that import jobs read from IMPEX), pick extensions and special characters, and probe for traversal. Outside uploads, a request-controlled path lets the client choose which file is read, renamed, or deleted. Cleaning the name with replace() still leaves the choice of name to the client, so it is still reported.

js
// Finding
request.httpParameterMap.processMultipart(function (field, contentType, fileName) {
  return new File(File.IMPEX + '/src/upload/' + fileName);
});

// Fix: return a directory so the platform generates a unique name...
var dir = new File(File.TEMP + '/uploads');
request.httpParameterMap.processMultipart(function () {
  return dir;
});

// ...or generate the name and take the extension from an allowlist
var EXTENSIONS = {'image/png': 'png', 'image/jpeg': 'jpg'};
request.httpParameterMap.processMultipart(function (field, contentType) {
  var ext = EXTENSIONS[contentType];
  if (field !== 'attachment' || !ext) return null;
  return new File(File.TEMP + '/uploads/' + UUIDUtils.createUUID() + '.' + ext);
});

Returning null from the callback skips a part, so check the field name and content type and skip anything you don't expect.

get-mutates-state ​

Severity: medium · Confidence: medium · CWE: CWE-352, CWE-650

Finds GET routes (SFRA server.get, SiteGenesis actions with the get filter) that write request input inside Transaction.wrap() or after Transaction.begin(): an assignment of a request value, or a set*, create*, remove*, delete*, add*, or update* call with one. GET requests carry no CSRF token, so another site can make the change by linking to the URL or loading it in an image. Routes that check a CSRF token (a token passed as a query parameter) are not reported, and recalculating a basket without request input is fine.

js
// Finding
server.get('AddCoupon', function (req, res, next) {
  Transaction.wrap(function () {
    basket.createCouponLineItem(req.querystring.couponCode, true);
  });
  next();
});

// Fix: accept POST and check the token
server.post('AddCoupon', csrfProtection.validateAjaxRequest, function (req, res, next) {
  Transaction.wrap(function () {
    basket.createCouponLineItem(req.form.couponCode, true);
  });
  next();
});

hardcoded-credentials ​

Severity: high · Confidence: medium · CWE: CWE-798

Finds credentials written into code: literal values assigned to names ending in password, secret, apiKey, accessToken, privateKey, and similar; the user and password arguments of HTTPClient.open(); and literal Authorization or API key headers. Placeholders, empty strings, and dotted preference IDs are ignored.

js
// Finding
client.setRequestHeader('Authorization', 'Bearer eyJhbGciOiJIUzI1NiJ9abc');

// Fix: keep credentials in a service credential and read it in the service callback
var service = LocalServiceRegistry.createService('payment.http', {
  createRequest: function (svc, args) {
    var credential = svc.configuration.credential;
    svc.addHeader('Authorization', 'Bearer ' + credential.password);
    return args;
  },
});

Rotate any credential that was committed, even after you remove it.

Severity: low · Confidence: medium · CWE: CWE-614, CWE-1004

Finds dw.web.Cookie objects that are created without both setSecure(true) and setHttpOnly(true) (or the secure and httpOnly properties) in the same file. Cookies being deleted with setMaxAge(0) are ignored.

js
// Fix
var cookie = new Cookie('remember', value);
cookie.setSecure(true);
cookie.setHttpOnly(true); // leave off only for cookies that client-side script must read
response.addHttpCookie(cookie);

mass-assignment ​

Severity: high · Confidence: medium · CWE: CWE-915

Finds request input copied into persistent objects with property names the client chooses: loops over req.form, request.httpParameterMap, or Object.keys()/Object.entries() of them that assign obj.custom[key]; computed keys taken directly from the request; and Object.assign() of request input into a custom attributes object, profile, customer, order, basket, address, or line item. The client can then set any attribute, including ones that control discounts, roles, or loyalty status.

js
// Finding
Object.keys(req.form).forEach(function (key) {
  profile.custom[key] = req.form[key];
});

// Fix: copy only the fields you expect
profile.custom.newsletter = req.form.newsletter === 'true';

object-query-injection ​

Severity: high · Confidence: medium · CWE: CWE-943

Finds query strings for CustomObjectMgr, SystemObjectMgr, OrderMgr, and CustomerMgr query and search methods that are built by concatenation, template literals, or .concat(), including through a local variable. Concatenated values can change the meaning of the query.

js
// Finding
CustomObjectMgr.queryCustomObject('Subscription', "custom.email = '" + email + "'");

// Fix: use placeholders and pass values as arguments
CustomObjectMgr.queryCustomObject('Subscription', 'custom.email = {0}', email);

ocapi-broad-access ​

Severity: medium · Confidence: medium · CWE: CWE-284, CWE-942

Finds OCAPI settings (Shop or Data API) that grant a client every resource ("resource_id": "/**" or "/*"), and Shop API clients whose allowed_origins include "*" or a plain http:// origin other than localhost.

jsonc
// Finding
{"client_id": "...", "allowed_origins": ["*"], "resources": [{"resource_id": "/**", "methods": ["get", "post", "delete"]}]}

// Fix: list what the client needs and your own HTTPS origins
{"client_id": "...", "allowed_origins": ["https://www.example.com"], "resources": [{"resource_id": "/baskets/*", "methods": ["get", "patch"]}]}

ocapi-demo-client-id ​

Severity: high · Confidence: high · CWE: CWE-1188, CWE-798

Finds OCAPI settings that grant anything to the demo client ID aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa. That ID appears in OCAPI documentation, tutorials, and sample site data (including SiteGenesis), so settings copied from them grant access to a client everyone knows about. Any permission granted to it is reported.

Create a dedicated API client in Account Manager for each integration, grant it only the resources it needs, and remove the demo client ID from OCAPI settings (Administration > Site Development > Open Commerce API Settings) on every instance, not only in your site data.

open-redirect ​

Severity: medium · Confidence: medium · CWE: CWE-601

Finds res.redirect() and response.redirect() calls whose destination host can be chosen through request parameters, headers, or form fields. Appending request values after a fixed origin, path, or ? is fine, as is a value that the code checks in a condition (for example allowed.test(url)) before redirecting.

js
// Finding
res.redirect(req.querystring.returnUrl);

// Fix: redirect only to known destinations
var target = req.querystring.returnUrl;
res.redirect(isAllowedRedirect(target) ? target : URLUtils.url('Home-Show').toString());

pii-in-logs ​

Severity: medium · Confidence: low · CWE: CWE-532

Finds dw.system.Logger calls (including loggers from Logger.getLogger()) whose arguments include personal or payment data: properties such as email, phone, firstName, lastName, address1, postalCode, birthday, password, or creditCardNumber, or whole customer, profile, address, payment instrument, order, or basket objects passed to JSON.stringify(). Log files are readable by anyone with Business Manager log access. Confidence is low: check whether the value is really personal data.

js
// Finding
Logger.info('Customer login {0}', customer.profile.email);

// Fix: log an identifier
Logger.info('Customer login {0}', customer.profile.customerNo);

preference-secret-value ​

Severity: high · Confidence: medium · CWE: CWE-798, CWE-312

Finds site and global preference values in preferences.xml that look like credentials: a preference whose ID ends in password, secret, apiKey, token, privateKey, and similar, with a value that isn't empty, masked, a placeholder, or a dotted ID. A preference set for several instance types (development, staging, production) is reported once per file, at its first value, listing those types. Site data in source control is read by everyone with repository access and imported into every instance.

Remove the value from the site data and set it per instance in Business Manager, using a password-type preference or a service credential. Rotate any credential that was committed.

secret-attribute-not-password ​

Severity: medium · Confidence: medium · CWE: CWE-312

Finds custom attribute definitions (site preferences, system object extensions, custom object types) whose ID names a secret (paymentApiKey, erpClientSecret) but whose <type> is not password. Business Manager shows other types in clear text and site exports include their values unencrypted.

xml
<!-- Finding -->
<attribute-definition attribute-id="paymentApiKey">
    <type>string</type>
</attribute-definition>

<!-- Fix -->
<attribute-definition attribute-id="paymentApiKey">
    <type>password</type>
</attribute-definition>

service-credential-password ​

Severity: high · Confidence: high · CWE: CWE-256, CWE-798

Finds service credentials in services.xml with a plaintext <password> (not encrypted="true" or masked="true"), and credential URLs with a user name and password embedded (https://user:pass@host).

Commit services.xml without passwords and set them per instance in Business Manager (Administration > Operations > Services > Credentials), or keep encrypted exports only. Rotate any password that was committed.

service-insecure-url ​

Severity: medium · Confidence: high · CWE: CWE-319

Finds service credentials in services.xml whose <url> uses plain http:// (other than localhost), so requests, responses, and credentials travel unencrypted. Use the service's https:// endpoint.

sfra-post-without-csrf ​

Severity: high · Confidence: medium · CWE: CWE-352

Finds SFRA routes that accept POST without checking a CSRF token: server.post() routes, and server.use() or server.replace() routes (which accept any method) that read req.form, when neither the route's middleware (csrfProtection.validateRequest or validateAjaxRequest) nor its handler (CSRFProtection.validateRequest()) checks the token. With the project index, a check that an overlay cartridge prepends counts, and routes that a later cartridge replaces are judged by the replacement.

js
// Finding
server.post('Subscribe', server.middleware.https, function (req, res, next) { ... });

// Fix
var csrfProtection = require('*/cartridge/scripts/middleware/csrf');
server.post('Subscribe', server.middleware.https, csrfProtection.validateAjaxRequest, function (req, res, next) { ... });

To fix a route that SFRA's app_storefront_base defines, prepend the check from your own cartridge:

js
server.extend(module.superModule);
server.prepend('AddProduct', csrfProtection.validateAjaxRequest);

Server-to-server callbacks (routes that read the raw request body, such as request.httpParameterMap.requestBodyAsString or req.body, and never use the shopper's customer, basket, session, or form) can't carry a shopper's CSRF token, so this rule leaves them to webhook-without-verification.

Routes that only hand out a token (such as CSRF-Generate) or that are protected by a single-use token sent by email (such as a password reset confirmation) don't need the check; suppress them with a reason.

sfra-replace-drops-middleware ​

Severity: high · Confidence: high · CWE: CWE-862, CWE-352

Finds server.replace() calls in overlay cartridges that drop security middleware the replaced route had: CSRF checks, login checks (userLoggedIn.validateLoggedIn, validateLoggedInAjax), server.middleware.https, or the GET/POST method restriction. server.replace() registers the new chain with server.use(), so a replaced server.post() route accepts GET too unless you add server.middleware.post back. This rule needs the project index, so it runs in b2c security scan but not when the rules run in ESLint or oxlint without one.

js
// Finding: the base route had server.middleware.post, https, login, and CSRF checks
server.replace('SaveProfile', function (req, res, next) { ... });

// Fix: repeat the security middleware
server.replace(
    'SaveProfile',
    server.middleware.post,
    server.middleware.https,
    userLoggedIn.validateLoggedInAjax,
    csrfProtection.validateAjaxRequest,
    function (req, res, next) { ... }
);

Where you only need to change the response, server.append() keeps the base chain.

sg-post-without-csrf ​

Severity: high · Confidence: medium · CWE: CWE-352

Finds SiteGenesis controller actions exposed with guard.ensure(['post', ...]) or guard.httpsPost() without the csrf filter, and actions with no method filter whose action function handles a form submission (handleAction()), unless the action calls CSRFProtection.validateRequest() itself. Actions limited to remote includes (include filter) are skipped.

js
// Finding
exports.Submit = guard.ensure(['post', 'https'], submit);

// Fix
exports.Submit = guard.ensure(['post', 'https', 'csrf'], submit);

Include the CSRF token field (dw.web.CSRFProtection.getTokenName() and generateToken()) in the form that submits to the action.

webhook-without-verification ​

Severity: high · Confidence: medium · CWE: CWE-306, CWE-345

Finds SFRA POST routes shaped like server-to-server callbacks (payment notifications, order management events, partner integrations) that don't check who is calling. A route counts as a callback when it reads the raw request body (request.httpParameterMap.requestBodyAsString or req.body) and never uses the shopper's session (customer, session, req.currentCustomer, req.form, the current basket, or res.render). It is reported unless a handler compares a request value with a secret (a site preference or a token), reads an Authorization or signature header, calls a function named like verification (verifySignature, validateRequest, authenticate), runs middleware named that way, or checks a CSRF token.

js
// Finding: anyone can post a notification and change orders
server.post('Notification', server.middleware.https, function (req, res, next) {
  var event = JSON.parse(request.httpParameterMap.requestBodyAsString);
  updateOrder(event);
  ...
});

// Fix: verify the provider's signature before acting
server.post('Notification', server.middleware.https, function (req, res, next) {
  var body = request.httpParameterMap.requestBodyAsString;
  if (!signatures.verify(body, req.httpHeaders.get('x-signature'), secret)) {
    res.setStatusCode(401);
    return next();
  }
  ...
});

Prefer a signature over the raw body (HMAC with a secret kept in a site preference or service credential) to a shared token. Compare secrets with a constant-time check. Allowlisting the caller's IP address is not enough on its own. A JSON endpoint that the storefront's own pages call is reported too, because it has neither a caller check nor a CSRF check; add csrfProtection.validateAjaxRequest.

weak-crypto ​

Severity: medium · Confidence: high · CWE: CWE-327, CWE-328

Finds the deprecated dw.crypto Weak* classes (WeakCipher, WeakMac, WeakMessageDigest, WeakSignature), MD5 and SHA-1 for MessageDigest and Mac, and DES, 3DES, RC2, RC4, Blowfish, or ECB-mode cipher transformations.

js
// Finding
new Cipher().encrypt(value, key, 'AES/ECB/PKCS5Padding', null, 0);

// Fix
new Cipher().encrypt(value, key, 'AES/GCM/NoPadding', iv, 0);

Use the Weak* classes only to interoperate with legacy systems that require them.