Command-Line Interface (CLI) Reference

The sfnext CLI is your primary tool for developing and deploying Storefront Next projects. It's provided by the @salesforce/storefront-next-dev package, which is installed as a project dependency—not globally.

Running CLI Commands

Using Project package.json Scripts

Storefront Next projects include pre-configured scripts in package.json for common tasks:

pnpm dev        # Start the development server
pnpm build      # Create a production build
pnpm start      # Preview the production build locally
pnpm push       # Deploy to Managed Runtime

Running Commands Directly

For commands that don't have a package.json script, or when you need to pass specific options, run pnpm sfnext from your project's root directory:

pnpm sfnext <command> [options]

For example:

pnpm sfnext dev --port 3000
pnpm sfnext extensions list

You can also view all available commands and options:

pnpm sfnext --help
pnpm sfnext <command> --help

This works because pnpm automatically resolves binaries installed in your project's node_modules/.bin. Running sfnext this way ensures the CLI version always matches your project's dependencies.

important: Don’t install @salesforce/storefront-next-dev globally. Always run commands from within your project directory so that the CLI version stays in sync with your dependencies.

Creating a Storefront Without a Project

The create-storefront command is the one exception—it runs before a project exists, so there's no local node_modules to resolve from. For this command, use pnpm dlx to download and execute the package directly:

pnpm dlx @salesforce/storefront-next-dev create-storefront

For all other commands, use pnpm sfnext from within your project.

Commands

create-storefront

Scaffold a new Storefront Next project. The command clones a template repository, walks you through extension selection, and configures your environment variables.

Because this command creates a new project, it's the one CLI command you run before a project exists. Use pnpm dlx to download and run it without a prior installation:

pnpm dlx @salesforce/storefront-next-dev create-storefront [options]

Options

Examples

Create a storefront interactively:

pnpm dlx @salesforce/storefront-next-dev create-storefront

Create a storefront with a specific name:

pnpm dlx @salesforce/storefront-next-dev create-storefront --name my-storefront

After the command completes, follow the on-screen instructions to install dependencies and start developing:

cd my-storefront
pnpm install
pnpm build
pnpm dev

For a walkthrough of creating a storefront with the CLI, see Explore Storefront Next Code Locally.

dev

Start a local development server powered by Vite with full server-side rendering (SSR) support. The server includes hot module replacement (HMR) for both client and server code, and an API proxy to B2C Commerce.

pnpm dev

Or with options:

pnpm sfnext dev [options]

Options

Examples

Start the dev server:

pnpm dev

Start the dev server on a custom port:

pnpm sfnext dev --port 3000

Start with the Node.js debugger attached:

pnpm dev:debug

What the Dev Server Does

• Runs Vite in middleware mode within an Express server for full SSR support.
• Proxies B2C Commerce API requests through /mobify/proxy/api so that you can develop against live data without CORS issues.
• Loads environment variables from your .env file.
• Prints your Commerce API configuration (short code, organization ID, site ID) at startup.

preview / start

Start a local server that serves your production build. Use this to test production behavior before deploying. If no build exists, the command automatically runs pnpm build first.

The CLI command is preview. In package.json, it's mapped to pnpm start.

pnpm start

Or with options:

pnpm sfnext preview [options]

Options

Examples

Preview the production build:

pnpm start

Preview on a custom port:

pnpm sfnext preview --port 8080

How Preview Differs from Dev

push

Create a deployment bundle from your production build and push it to Managed Runtime (MRT). You must build your project before running this command.

pnpm push

Or with options:

pnpm sfnext push [options]

Options

Authentication

Authenticate with Managed Runtime using one of these methods:

• Credentials file (default): The CLI reads stored credentials automatically. Use --credentials-file to specify a custom path.
• API key: Pass --api-key on the command line or set the SFCC_MRT_API_KEY environment variable.

Setting Up MRT Resources

Before you can deploy, you need a Managed Runtime project and SLAS client credentials. Use the B2C CLI to create these resources.

Examples

Build and deploy to MRT:

pnpm build
pnpm push

Deploy to a specific environment and wait for completion:

pnpm sfnext push --environment staging --wait

Deploy with an API key:

pnpm sfnext push --api-key your-api-key

create-bundle

Create a deployment bundle and save it to disk without pushing to Managed Runtime. This is useful for inspecting bundle contents or integrating with custom deployment pipelines.

pnpm sfnext create-bundle -d <project-directory> [options]

Options

Output

The command generates two files in the output directory:

• bundle.tgz — The compressed deployment bundle.
• bundle.json — Bundle metadata (message, SSR parameters, file sizes).

Example

pnpm build
pnpm sfnext create-bundle -d . -o ./my-bundle

extensions

Manage feature extensions for your storefront project. Extensions add pre-built functionality, such as store locators or theme switchers.

pnpm sfnext extensions <subcommand> [options]

extensions list

List all extensions currently installed in your project.

pnpm sfnext extensions list [options]

Example

pnpm sfnext extensions list

extensions install

Install an extension from a source template repository. The CLI clones the source repository, lets you select an extension, and copies the extension files into your project.

pnpm sfnext extensions install [options]

If the extension has dependencies on other extensions, the CLI detects them and installs the full dependency chain in the correct order.

Examples

Install an extension interactively:

pnpm sfnext extensions install

Install a specific extension by marker:

pnpm sfnext extensions install -e SFDC_EXT_STORE_LOCATOR

extensions remove

Remove one or more installed extensions from your project. The CLI automatically detects and removes dependent extensions.

pnpm sfnext extensions remove [options]

Example

Remove extensions interactively:

pnpm sfnext extensions remove

Remove specific extensions by marker:

pnpm sfnext extensions remove -e SFDC_EXT_STORE_LOCATOR

extensions create

Scaffold a new extension in your project. This command creates the extension directory structure with placeholder folders for components, hooks, locales, and routes.

pnpm sfnext extensions create [options]

Example

pnpm sfnext extensions create --name "Store Locator" --description "Find nearby stores"

The generated directory structure:

src/extensions/store-locator/
  components/
  hooks/
  locales/
  routes/
  README.md

Environment Variables

Several CLI commands read configuration from environment variables defined in your .env file.

See Also

• Build Tools — Vite configuration and build system details.
• Project Configuration — Environment variables and storefront configuration.
• B2C CLI: Storefront Next — Create SLAS clients and Managed Runtime resources.