Settings

Every extension setting uses the intellij-sfcc.* prefix. Open Settings (Cmd+, / Ctrl+,) and search for Intellij SFCC, or edit settings.json directly with Preferences: Open User Settings (JSON) or Preferences: Open Workspace Settings (JSON). You only need to add the settings you want to change; anything you leave out keeps the default shown on this page

Connection selection, code version, and Auto Upload are not settings. They belong to the active connection and are managed from the Connections panel and its status-bar actions

User or workspace settingsCopy Anchor Link

VS Code keeps two levels of settings, and the workspace level wins when both define the same key:

• User settings apply to every project you open. Use them for personal preferences such as tag colors, the formatter, or Log Center performance tuning
• Workspace settings live in .vscode/settings.json and apply to one project. Use them for values the whole team should share, such as custom completion rules, <ismodule/> file names, or a fixed MCP port

Some settings are also written for you by the extension:

When changes take effectCopy Anchor Link

Most settings apply as soon as you save. The exceptions are listed below

Workspace and deploymentCopy Anchor Link

SFCC MCPCopy Anchor Link

These settings control the local MCP server that lets AI clients such as Claude Code, Cursor, Codex, and GitHub Copilot use your project's SFCC knowledge. See SFCC MCP for connecting a client

Server and portCopy Anchor Link

The server listens on the loopback interface only, so it is never reachable from other machines. With mcp.port set to 0, the extension derives a port from the workspace path (in the 32768-57767 range) and remembers it, so the address in your client configuration stays the same between VS Code sessions

Set an explicit port when a client configuration must point to a known address, or when the automatic port collides with another service. Put it in workspace settings; a port in user settings applies to every window, and two open projects would then compete for the same port:

{
  "intellij-sfcc.mcp.port": 43210
}

Set mcp.enabled to false to stop the server completely, for example on a project where you do not use AI clients

AuthenticationCopy Anchor Link

By default, any local process can call the server. With mcp.auth.enabled set to true, clients must send a bearer token that is unique to the workspace. The token is generated on first use, stored in VS Code SecretStorage, and handed to clients through the INTELLIJ_SFCC_MCP_TOKEN environment variable. Generated client configuration snippets reference that variable and never contain the token itself

{
  "intellij-sfcc.mcp.auth.enabled": true
}

Enable it on shared machines or when other local tools should not reach your SFCC instance through MCP. Copy or rotate the token from the MCP panel

Tool profilesCopy Anchor Link

Profiles are cumulative: each one contains everything in the profile before it

Pick the smallest profile that covers the task. sfcc-readonly suits day-to-day coding, sfcc-operational adds sandbox debugging, and sfcc-full is for short, supervised sessions where the agent needs to deploy or upload. Choosing a profile in the MCP panel writes this setting to workspace settings for you

Enabling or disabling individual toolsCopy Anchor Link

mcp.tools.enabled and mcp.tools.disabled adjust the chosen profile tool by tool, using full intellijsfcc.* tool names. Each tool is resolved in this order:

1. Core tools (intellijsfcc.project.context, intellijsfcc.client.profile, intellijsfcc.skills.list, intellijsfcc.skills.read, intellijsfcc.task.plan, intellijsfcc.tools.policy.status, intellijsfcc.tools.recommend) are always available and cannot be disabled
2. A tool listed in mcp.tools.disabled is hidden
3. A tool listed in mcp.tools.enabled is shown
4. Otherwise the profile decides

Because disabled wins over enabled, listing a tool in both hides it. For example, keep an agent read-only on your code but let it search Log Center:

{
  "intellij-sfcc.mcp.tools.profile": "sfcc-readonly",
  "intellij-sfcc.mcp.tools.enabled": ["intellijsfcc.logs.center.search"]
}

Or allow everything except deployment:

{
  "intellij-sfcc.mcp.tools.profile": "sfcc-full",
  "intellij-sfcc.mcp.tools.disabled": ["intellijsfcc.deploy.execute"]
}

Switching individual tools on or off in the MCP panel updates these two lists in workspace settings

Legacy transport and analyticsCopy Anchor Link

Streamable HTTP is the normal transport. Enable mcp.allowDeprecatedSse only for an older client that can connect exclusively through the SSE endpoints

Request metadata such as tool names, timings, and status is always logged locally under .intellij-sfcc/mcp-analytics in the workspace. mcp.analytics.captureRaw additionally stores the complete request and response bodies, which helps when debugging a misbehaving client

mcp.tools.allowAgentProfileActivation no longer has any effect. Agents cannot change the profile; select it in the MCP panel, then refresh or reconnect the client

Log CenterCopy Anchor Link

These settings tune how Log Center downloads, parses, indexes, and displays instance logs. The Settings tab in Log Center edits the same values, and changes apply without a reload. Values outside the allowed range are clamped to the nearest limit

How the values work togetherCopy Anchor Link

• Throughput versus CPU. parseConcurrency limits all worker jobs, including tails that mostly wait on the network. initialParseConcurrency limits only the CPU-bound work of parsing freshly downloaded files. Raise the second one on a machine with many cores to import a day of logs faster; lower it when VS Code feels sluggish during an import
• Chunk size. Initial parses of remote files normally download a ZIP first. rangeChunkSizeMb sets the size of each ranged read used for tailing, for the fallback when a ZIP download is not possible, and for streaming local files. Larger chunks mean fewer requests but more memory per job
• Freshness versus load. tailIntervalMs sets how quickly new lines appear in a watched file, and autoRefreshIntervalSec sets how quickly newly created log files appear in the list. Shorter intervals send more requests to the instance
• Memory. maxRawExamples and maxIndexedOccurrences bound the memory used by detail views, reports, and fallback search. Older entries are dropped first; parsed results already stored on disk are not affected
• Filter menus. maxFacetValues caps how many distinct values a filter menu can list. Typing an exact value still filters correctly beyond the cap. filterOptionBatchSize only affects how quickly a long menu opens

{
  "intellij-sfcc.logs.initialParseConcurrency": 6,
  "intellij-sfcc.logs.rangeChunkSizeMb": 16,
  "intellij-sfcc.logs.maxRawExamples": 20000,
  "intellij-sfcc.logs.maxFacetValues": 30000
}

Getting started, releases, and pipelinesCopy Anchor Link

Without gettingStarted.doNotOpenAutomatically, the Getting Started page opens every time a window starts on an SFCC project whose setup is unfinished. The page has the same switch as a Don't open automatically checkbox, and the Setup item in the status bar always opens it. With gettingStarted.statusBarIconOnly the item keeps its tooltip with the setup progress

releases.notifications checks at startup and every five minutes while the window is focused. Release history stays available in the Account view when it is off. Both settings are application wide, so they apply to every window

pipelines.nodeGutterIcons uses the same icons as the Pipeline Editor (start, pipelet, script, decision, join, interaction, and more), so you can read a pipeline's XML source at a glance

ISML editingCopy Anchor Link

FormatterCopy Anchor Link

The ISML language server formats .isml files, so Format Document, Format Selection, and format on save use it. If another extension also formats ISML, choose the formatter with Format Document With.... The two engines behave differently:

• Indentation re-indents ISML and HTML structure (block tags, <iselse>/<iselseif> branches, nested markup) and leaves everything else exactly as written: tag text, attributes, ${...} expressions, and one-line markup. A bare # is the one exception, escaped while formatter.escapeHash is on. It follows editor.tabSize and editor.insertSpaces. wrapAttributes has no effect on this engine
• JS-Beautify is the legacy engine. It rewrites markup with js-beautify and reads VS Code's html.format.* settings (such as html.format.wrapLineLength and html.format.indentInnerHtml) in addition to wrapAttributes

wrapAttributes accepts the js-beautify values preserve, auto, force, force-aligned, force-expand-multiline, aligned-multiple, and preserve-aligned. With preserve, line wrapping is turned off completely so existing attribute layout is kept. For example, to put each attribute on its own line when a tag is too long:

{
  "intellij-sfcc.isml.formatter.type": "JS-Beautify",
  "intellij-sfcc.isml.formatter.wrapAttributes": "force-expand-multiline",
  "html.format.wrapLineLength": 120
}

Set formatter.enabled to false when your team formats ISML with another tool, such as Prettier. See Formatting for before-and-after examples

Linter and custom tagsCopy Anchor Link

isml.linter turns the ISML server's template checks on or off: unclosed and misplaced ISML tags, missing required attributes, and the bare # error with its quick fixes. A change applies without a restart. Problems inside ${...} and <isscript> come from the Script server either way. See ISML diagnostics

isml.modules.files lists the file names the ISML server scans for <ismodule/> declarations. Tags declared in matching files complete with their attributes in every template, and the tag name links to the module template. Add your own file names if your project declares custom tags elsewhere, and keep the defaults you still use, because the list replaces the default:

{
  "intellij-sfcc.isml.modules.files": ["modules.isml", "module.isml", "brandmodules.isml"]
}

See Custom tags for how module declarations are resolved

Tag colorsCopy Anchor Link

customTagColorDark and customTagColorLight color every tag that starts with <is, so ISML logic stands out from HTML. Dark themes use customTagColorDark; light themes and both high contrast themes use customTagColorLight. The extension applies the color through editor.semanticTokenColorCustomizations for the active theme in your user settings, and changing the theme or either color updates the editor immediately

{
  "intellij-sfcc.customTagColorDark": "#c792ea",
  "intellij-sfcc.customTagColorLight": "#7c4dff"
}

Scripting completion rulesCopy Anchor Link

The scripting language server offers route, hook, template, and resource completions inside string arguments of specific functions. These rules tell it which functions and which argument to watch, so you can extend completions to your project's own helpers

Rule formatCopy Anchor Link

Each setting is an array of rules. A rule has three fields:

Without className, a rule matches both a plain call (myHelper('...')) and a method call on any object (helpers.myHelper('...')). With className, it matches only ClassName.method('...') where the receiver is written as that identifier. Completion triggers inside a string literal, including a string that is part of a + concatenation

ExamplesCopy Anchor Link

A project wraps URLUtils in its own helper, urlHelper.getUrl(action, params). To get route completion in that helper, add one rule. The built-in route rules stay on after it:

{
  "intellij-sfcc.completions.routes": [
    { "methods": ["getUrl"], "paramIndex": 0 }
  ]
}

The same route rules drive go to definition, references and the usage counts of the route CodeLens. A list that still repeats the built-in rules works too, each rule is used once. The JetBrains plugin reads this setting from the project's .vscode/settings.json as well, see SFCC Route Calls

A custom email service takes the template as its second argument, emailService.send(recipient, templatePath, context):

{
  "intellij-sfcc.completions.templates": [
    { "methods": ["render", "renderTemplate"], "paramIndex": 0 },
    { "methods": ["sendEmail"], "paramIndex": 1 },
    { "className": "emailService", "methods": ["send"], "paramIndex": 1 }
  ]
}

A localization wrapper, i18n.t(key, bundle), mirrors Resource.msg. Add it to both resource rules so keys and bundles complete:

{
  "intellij-sfcc.completions.resources.properties": [
    { "methods": ["msg", "msgf"], "paramIndex": 0 },
    { "methods": ["t"], "paramIndex": 0 }
  ],
  "intellij-sfcc.completions.resources.bundles": [
    { "methods": ["msg", "msgf"], "paramIndex": 1 },
    { "methods": ["t"], "paramIndex": 1 }
  ]
}

Rule changes are sent to the language server as soon as you save. See Code completion for everything else the scripting server completes

Unused settingCopy Anchor Link

intellij-sfcc.editor.scripts.hooks-identifiers appears in the Settings UI but is not read by the extension. Its declaration duplicates the resource-bundle rule and has a mismatched type, so leave it unset

Defaults the extension setsCopy Anchor Link

Installing the extension also changes a few VS Code defaults. They behave like any default: a value in your user or workspace settings wins. The one exception is the ISML default formatter, which the extension writes into your user settings on every start

To open pipelines as text by default, map the pattern back to the text editor in your settings:

{
  "workbench.editorAssociations": {
    "**/cartridge/pipelines/*.xml": "default",
    "**/pipelines/*.xml": "default"
  }
}

Theme colorsCopy Anchor Link

The extension contributes theme colors that you can override with workbench.colorCustomizations:

{
  "workbench.colorCustomizations": {
    "intellijsfcc.metadataAttribute.unusedForeground": "#e06c75",
    "intellijsfcc.metadataAttribute.highUsageForeground": "#7aa2f7"
  }
}

Complete exampleCopy Anchor Link

A shared .vscode/settings.json for a team project, with no connection or credential values:

{
  // Keep deployments gentle on a small sandbox
  "intellij-sfcc.concurrentRequestsPerSecond": 3,

  // Find dead custom attributes in metadata XML
  "intellij-sfcc.metadataAttributes.colorMode": "unusedOnly",

  // AI clients can read code and the sandbox, but never change it
  "intellij-sfcc.mcp.port": 43210,
  "intellij-sfcc.mcp.auth.enabled": true,
  "intellij-sfcc.mcp.tools.profile": "sfcc-operational",

  // Project-specific ISML custom tag declarations
  "intellij-sfcc.isml.modules.files": ["modules.isml", "module.isml", "brandmodules.isml"],

  // Route completion inside the project's URL helper, before the built-in rules
  "intellij-sfcc.completions.routes": [
    { "methods": ["getUrl"], "paramIndex": 0 }
  ]
}

VS Code accepts comments in settings.json. See Set Up Your Project for connections and cartridges, and SFCC MCP for connecting AI clients