@salesforce/b2c-dx-mcp 3.0.0 → 3.1.0

package/node_modules/@salesforce/b2c-agent-plugins/b2c-python-sdk/plugin.json

@@ -0,0 +1,45 @@
+{
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+  "name": "b2c-python-sdk",
+  "version": "0.1.0",
+  "description": "Consuming the salesforce-b2c-tooling-sdk Python SDK — authenticate to B2C Commerce, resolve dw.json config, and call OCAPI/SCAPI/WebDAV clients and operations from scripts or notebooks.",
+  "author": {
+    "name": "Salesforce"
+  },
+  "homepage": "https://salesforcecommercecloud.github.io/b2c-developer-tooling/",
+  "repository": "https://github.com/SalesforceCommerceCloud/b2c-developer-tooling",
+  "license": "Apache-2.0",
+  "keywords": [
+    "salesforce",
+    "b2c-commerce",
+    "commerce-cloud",
+    "python",
+    "sdk",
+    "scapi",
+    "ocapi"
+  ],
+  "extensions": {
+    "com.openai": {
+      "interface": {
+        "displayName": "B2C Python SDK",
+        "shortDescription": "Use the Salesforce B2C Commerce Python tooling SDK from your AI assistant.",
+        "longDescription": "Skills for consuming the salesforce-b2c-tooling-sdk Python SDK from scripts and Jupyter notebooks — install and import it, choose an authentication mechanism, resolve config from dw.json, and call the OCAPI/SCAPI/WebDAV clients and higher-level operations (code deploy, jobs, sites, catalogs, sandboxes, metrics, logs, SLAS shopper tokens).",
+        "developerName": "Salesforce",
+        "category": "Productivity",
+        "capabilities": [
+          "Read"
+        ],
+        "logo": "./assets/logo.svg",
+        "composerIcon": "./assets/logo.svg",
+        "brandColor": "#0D9DDA",
+        "websiteURL": "https://salesforcecommercecloud.github.io/b2c-developer-tooling/",
+        "defaultPrompt": [
+          "Write a Python script that deploys the cartridges in ./cartridges using the B2C tooling SDK",
+          "Use the Python SDK to authenticate from my dw.json and run a job",
+          "Show me how to mint a SLAS guest shopper token with the Python SDK",
+          "Read the latest error logs from my instance with the Python tooling SDK"
+        ]
+      }
+    }
+  }
+}

package/node_modules/@salesforce/b2c-agent-plugins/b2c-python-sdk/skills/using-b2c-tooling-sdk/SKILL.md

@@ -0,0 +1,226 @@
+---
+name: using-b2c-tooling-sdk
+description: Consuming the salesforce-b2c-tooling-sdk Python SDK from scripts or Jupyter notebooks — installation, choosing an authentication mechanism, and the available OCAPI/SCAPI/WebDAV clients and operations. Use when writing Python (or notebook) code that authenticates to a B2C Commerce instance, resolves config from dw.json, deploys code, runs jobs, reads sites/catalogs/logs/metrics, provisions sandboxes, or mints SLAS shopper tokens.
+---
+
+# Using the B2C Tooling SDK (Python)
+
+`salesforce-b2c-tooling-sdk` is the Python SDK for Salesforce B2C Commerce
+tooling. **Import name is `b2c_tooling_sdk`; distribution name is
+`salesforce-b2c-tooling-sdk`.** It is async-first with a complete synchronous
+facade. Python 3.10+.
+
+This skill covers **consuming** the SDK. For developing the SDK itself, see
+`python/b2c-tooling-sdk/CLAUDE.md`. For the full symbol catalog, read
+[references/api-catalog.md](references/api-catalog.md).
+
+## 1. Install
+
+Not on PyPI yet — install from git during development:
+
+```bash
+pip install "git+https://github.com/SalesforceCommerceCloud/b2c-developer-tooling.git@main#subdirectory=python/b2c-tooling-sdk"
+# or pin a release tag: ...@<tag>#subdirectory=python/b2c-tooling-sdk
+```
+
+For notebooks also install a kernel: `pip install ipykernel`. Once published this
+becomes `pip install salesforce-b2c-tooling-sdk`.
+
+## 2. Async vs. sync — pick the import root
+
+The two surfaces are identical **except one word**: sync drops `await`.
+
+| Context | Import from | Style |
+| --- | --- | --- |
+| Scripts / notebooks / REPL | `b2c_tooling_sdk.sync` | blocking, no `await` |
+| Inside an existing event loop (web server, async app) | `b2c_tooling_sdk` | `await` |
+
+**Notebooks: use the sync facade** — it is the frictionless path (no
+`asyncio.run`, no `await`). All sync calls run on one shared background loop, so
+token caching still works.
+
+```python
+# Notebook / script (sync)
+from b2c_tooling_sdk.sync import resolve_config
+from b2c_tooling_sdk.sync import list_code_versions
+
+config = resolve_config()                       # blocks
+instance = config.create_b2c_instance()
+for v in list_code_versions(instance):
+    print(v.id, "active" if v.active else "")
+```
+
+```python
+# Async
+import asyncio
+from b2c_tooling_sdk import resolve_config
+from b2c_tooling_sdk.operations.code import list_code_versions
+
+async def main() -> None:
+    config = await resolve_config()
+    instance = config.create_b2c_instance()
+    for v in await list_code_versions(instance):
+        print(v.id)
+
+asyncio.run(main())
+```
+
+> **Never call the sync facade from inside a running event loop** (including
+> async notebook cells / `await`-ing cells) — it waits on a background loop and
+> can deadlock. In async code, import from `b2c_tooling_sdk` and `await`.
+>
+> **Streaming APIs (`tail_logs`, cartridge watching) are async-only** — not in
+> the sync facade. Use the async API for those.
+
+The examples below use the **async** form. For sync, import the same names from
+`b2c_tooling_sdk.sync` and drop `await`.
+
+## 3. Authenticate — choose by use case
+
+Credentials usually come from a `dw.json` via `resolve_config()` (see §4). If you
+already have a `dw.json`, **prefer `resolve_config` + `create_b2c_instance()`** —
+it selects the auth mechanism for you. Reach for an explicit strategy only when
+you have no config file or need a specific flow.
+
+| Use case | Mechanism | How |
+| --- | --- | --- |
+| Server-to-server automation (CI, scripts) | OAuth **client-credentials** | `OAuthStrategy(OAuthConfig(client_id, client_secret, scopes))` |
+| Server-to-server with a cert instead of a secret | **JWT Bearer** | `JwtOAuthStrategy(JwtOAuthConfig(client_id, cert_path, key_path, ...))` |
+| Interactive user login (opens a browser) | **PKCE** (+ implicit fallback) | `create_user_auth_strategy(PkceOAuthConfig(client_id=..., account_manager_host=...))` |
+| Reuse a session created by `b2c auth login` | shared session store | `resolve_config()` picks it up automatically; or `find_auth_session(client_id)` |
+| WebDAV / OCAPI Basic auth | **Basic** | `BasicAuthStrategy(username, password)` |
+| Static API key header | **API key** | `ApiKeyStrategy("my-key")` |
+| Storefront **shopper** tokens (guest/registered) | **SLAS** | `b2c_tooling_sdk.slas.get_guest_token(...)` — see §6 |
+
+```python
+from b2c_tooling_sdk.auth import OAuthStrategy, OAuthConfig
+
+auth = OAuthStrategy(OAuthConfig(
+    client_id="...", client_secret="...", scopes=["sfcc.products"],
+))
+```
+
+**CLI interoperability:** the SDK shares the *same* on-disk `auth-sessions.json`
+and config files as the `@salesforce/b2c-cli`. Recommended interactive workflow:
+run `b2c auth login <clientId>` once, then run non-interactive Python — it reuses
+the session with no browser prompt. `find_auth_session`,
+`is_auth_session_token_valid`, and `list_auth_sessions` inspect the store.
+
+Don't know which methods a credential bundle supports? Use
+`resolve_auth_strategy(AuthCredentials(...), allowed_methods=[...])` to pick the
+best available, or `check_available_auth_methods(...)` to probe without side
+effects.
+
+## 4. Resolve config from `dw.json`
+
+`resolve_config()` merges the same sources the CLI reads (`dw.json` walking up
+from cwd, `~/.mobify`, `package.json`, `settings.json`) into a resolved config
+whose `.create_b2c_instance()` builds an authenticated `B2CInstance`.
+
+```python
+from b2c_tooling_sdk import resolve_config, NormalizedConfig
+
+config = await resolve_config()                     # from dw.json etc.
+instance = config.create_b2c_instance()
+
+# ...or pass explicit overrides instead of a file:
+config = await resolve_config(NormalizedConfig(
+    hostname="example.demandware.net",
+    client_id="...", client_secret="...", scopes=["sfcc.products"],
+))
+```
+
+Multi-environment `dw.json` (a `configs` array of named envs): select one with
+`resolve_config(options=ResolveConfigOptions(instance="staging"))` (priority:
+requested name → `active: true` → root). Manage entries with `add_instance` /
+`remove_instance` / `set_active_instance` from `b2c_tooling_sdk.config`.
+
+## 5. Call the APIs — two layers
+
+**Choose the layer by how you want errors handled:**
+
+- **Operations** (`b2c_tooling_sdk.operations.*`, common ones re-exported at top
+  level) — task-oriented, **success-or-raise**. Straight-line code; failures
+  raise typed exceptions (`JobExecutionError`, sandbox polling errors, ...).
+  **Prefer this for most work.**
+- **Clients** (`instance.ocapi`, `instance.webdav`, SCAPI `create_*_client`) —
+  low-level. Every call returns a `ClientResult(data, error, response)` and
+  **never raises on 4xx/5xx** (only a genuine network failure raises
+  `NetworkError`). Use when you want to inspect status codes yourself.
+
+```python
+# Operation (raises on failure)
+from b2c_tooling_sdk.operations.jobs import execute_job, wait_for_job
+execution = await execute_job(instance, "MyJob")
+finished = await wait_for_job(instance, "MyJob", execution.id)   # raises JobExecutionError on failure
+
+# Client (never raises on HTTP status)
+result = await instance.ocapi.get("/sites")
+if result.error is not None:
+    print("failed:", result.response.status_code, result.error)
+else:
+    for site in result.data.get("data", []):
+        print(site["id"])
+```
+
+**What's available** (full lists in [references/api-catalog.md](references/api-catalog.md)):
+
+- **Code** — `find_and_deploy_cartridges`, `list_code_versions`,
+  `create_code_version`, `activate_code_version`. Deploy needs
+  `instance.config.code_version` set.
+- **Jobs** — `execute_job`, `wait_for_job`, `site_archive_import`,
+  `site_archive_export_to_path` (+ `scapi_*` native variants).
+- **Sites** — `get_cartridge_path`, `add_cartridge`.
+- **Catalogs / BM users / BM roles** — dual-backend (SCAPI→OCAPI) façades:
+  `create_catalogs_backend`, `create_users_backend`, `create_roles_backend`.
+- **ODS (sandboxes)** — `create_ods_client` + `wait_for_sandbox`.
+- **Metrics** — `create_metrics_client` + `get_overall_metrics`,
+  `get_sales_metrics`, `get_scapi_metrics`, ...
+- **Logs** — `list_log_files`, `get_recent_logs`; `tail_logs` (async-only).
+- **Account Manager** — `create_user`, `grant_role`, `list_orgs`, ...
+- **Raw HTTP** — `instance.ocapi` (OCAPI Data API), `instance.webdav`
+  (`put`/`get`/`delete`/`propfind`).
+
+**SCAPI Admin clients** need system auth (client-credentials or JWT) **and** a
+`short_code` + `tenant_id`. Get the coordinates from `instance.scapi_client_config`
+(it's `None` when the instance can't do SCAPI):
+
+```python
+from b2c_tooling_sdk.clients import create_metrics_client, MetricsClientConfig
+
+scapi = instance.scapi_client_config
+if scapi is not None:
+    metrics = create_metrics_client(
+        MetricsClientConfig(short_code=scapi.short_code, tenant_id=scapi.tenant_id),
+        scapi.auth,
+    )
+```
+
+## 6. SLAS shopper tokens (storefront)
+
+For **shopper**-facing storefront tokens (not admin/tooling). Subpath import only
+— not in the top-level barrel:
+
+```python
+from b2c_tooling_sdk.slas import get_guest_token, SlasTokenConfig
+
+token = await get_guest_token(SlasTokenConfig(
+    short_code="abcd1234", organization_id="f_ecom_zzte_053",
+    slas_client_id="...", site_id="RefArch",
+    redirect_uri="http://localhost:3000/callback",
+    # slas_client_secret="..."   # omit for a public PKCE client
+))
+print(token.access_token)   # shopper JWT
+```
+
+`get_registered_token(SlasRegisteredLoginConfig(...))` for logged-in customers.
+Blocking twins are in `b2c_tooling_sdk.sync`. The tooling SDK has **no** dedicated
+storefront client — after minting the token, call Shopper endpoints with plain
+`httpx` using `token.access_token` as a bearer.
+
+## Runnable examples
+
+`python/samples/` has runnable scripts (`code/*_async.py` + `*_sync.py`) and
+notebooks (`notebook/*.ipynb`) for each scenario above (oauth_ocapi, oauth_scapi,
+basic_webdav, cli_session, browser_login, slas_shopper, multi_env). Point users
+there; copy `dw.example.json` → `dw.json` and fill in credentials.

package/node_modules/@salesforce/b2c-agent-plugins/b2c-python-sdk/skills/using-b2c-tooling-sdk/references/api-catalog.md

@@ -0,0 +1,154 @@
+# B2C Tooling SDK — symbol catalog
+
+The full public surface of `b2c_tooling_sdk`, grouped by subsystem. Everything
+listed under "top-level barrel" is importable directly from `b2c_tooling_sdk`
+(async) and, unless noted, has a blocking twin in `b2c_tooling_sdk.sync` with an
+identical signature minus `await`. Submodule-only APIs (SLAS, `operations.sites`,
+log streaming) must be imported from their submodule and are called out below.
+
+Async source is the truth; for sync, import the same name from
+`b2c_tooling_sdk.sync` and drop `await`. See the SKILL for the async/sync rules
+and the operations-vs-clients error contract.
+
+## Auth (`b2c_tooling_sdk.auth`)
+
+Strategies: `OAuthStrategy`, `JwtOAuthStrategy`, `PkceOAuthStrategy`,
+`ImplicitOAuthStrategy`, `BasicAuthStrategy`, `ApiKeyStrategy`.
+Base/protocol: `AuthStrategy`, `AuthConfig`, `AuthCredentials`, `AuthMethod`,
+`ALL_AUTH_METHODS`, `AccessTokenResponse`, `DecodedJWT`.
+Helpers: `resolve_auth_strategy`, `check_available_auth_methods`, `decode_jwt`.
+
+Session store (from `b2c_tooling_sdk.auth`, shared byte-for-byte with the CLI's
+`auth-sessions.json`): `find_auth_session`, `is_auth_session_token_valid`,
+`list_auth_sessions`. Interactive user-login helper: `create_user_auth_strategy`.
+
+## Config (`b2c_tooling_sdk.config`)
+
+`resolve_config`, `create_config_resolver`, `ConfigResolver`,
+`create_instance_from_config`, `find_dw_json`, `load_dw_json`.
+Types/options: `NormalizedConfig`, `ResolvedB2CConfig`, `ResolveConfigOptions`,
+`CreateB2CInstanceOptions`, `CreateOAuthOptions`, `ConfigSource`,
+`ConfigSourceInfo`, `ConfigWarning`.
+Multi-env `dw.json` management (from `b2c_tooling_sdk.config`): `add_instance`,
+`remove_instance`, `set_active_instance`.
+
+## Instance (`b2c_tooling_sdk.instance`)
+
+`B2CInstance`, `B2CInstanceOptions`, `InstanceConfig`, `ScapiClientConfig`.
+`B2CInstance` exposes lazy typed clients: `.ocapi` (OCAPI Data API), `.webdav`,
+and `.scapi_client_config` (`ScapiClientConfig | None` — `None` when the instance
+can't do SCAPI; carries `short_code`, `tenant_id`, `auth`).
+
+## Clients (`b2c_tooling_sdk.clients`)
+
+Low-level, **openapi-fetch semantics**: every call returns
+`ClientResult(data, error, response)` and never raises on 4xx/5xx (only a real
+network failure raises `NetworkError`).
+
+Factories: `create_ocapi_client`, `create_metrics_client`, `create_ods_client`,
+`create_custom_apis_client`, `create_preferences_client`, `create_cdn_zones_client`,
+`create_granular_replications_client`, `create_slas_client`,
+`create_account_manager_users_client`, `create_account_manager_roles_client`,
+`create_account_manager_orgs_client`, `create_account_manager_api_clients_client`.
+Client classes: `OcapiClient`, `WebDavClient`, `MetricsClient`, `OdsClient`,
+`CustomApisClient`, `PreferencesClient`, `CdnZonesClient`,
+`GranularReplicationsClient`, `SlasClient`, `AccountManager*Client`.
+Configs: `MetricsClientConfig`, `OdsClientConfig`, `CustomApisClientConfig`,
+`PreferencesClientConfig`, `CdnZonesClientConfig`,
+`GranularReplicationsClientConfig`, `SlasClientConfig`,
+`AccountManagerClientConfig`.
+Middleware: `create_auth_middleware`, `create_extra_params_middleware`.
+Errors/helpers: `OcapiDeprecatedError`, `get_api_error_message`,
+`throw_ocapi_error`, `is_ocapi_deprecated_fault`, `ocapi_deprecated_message`.
+Scope/tenant helpers: `to_organization_id`, `normalize_tenant_id`,
+`build_tenant_scope`, `resolve_to_internal_role`, `resolve_from_internal_role`,
+`fetch_role_mapping`, `is_valid_role_tenant_filter`.
+Scope constants: `METRICS_DEFAULT_SCOPES`, `CUSTOM_APIS_DEFAULT_SCOPES`,
+`PREFERENCES_READ_SCOPES`, `PREFERENCES_RW_SCOPES`, `CDN_ZONES_READ_SCOPES`,
+`CDN_ZONES_RW_SCOPES`.
+`WebDavClient`: `put`, `get`, `delete`, `propfind` (`PropfindEntry`).
+
+## Operations (task-oriented, **success-or-raise**)
+
+### Code (`operations.code`)
+`find_and_deploy_cartridges`, `find_cartridges`, `upload_cartridges`,
+`delete_cartridges`, `watch_cartridges` (`WatchOptions`/`WatchResult`),
+`list_code_versions`, `get_active_code_version`, `create_code_version`,
+`activate_code_version`, `reload_code_version`, `delete_code_version`.
+Backend factory: `create_scripts_backend` (`ScriptsBackend`,
+`Ocapi`/`ScapiScriptsBackend`). Types: `DeployOptions`, `DeployResult`,
+`FindCartridgesOptions`, `CartridgeMapping`, `CodeVersion`, `CodeVersionInfo`,
+`CodeVersionResult`, `CodeVersionActivationResult`.
+Deploy requires `instance.config.code_version` set.
+
+### Jobs (`operations.jobs`)
+`execute_job`, `wait_for_job`, `wait_for_job_execution`, `get_job_execution`,
+`get_job_log`, `search_job_executions`, `find_running_job_execution`,
+`get_job_error_message`. Site archive: `site_archive_import`,
+`site_archive_export`, `site_archive_export_to_path`. Native SCAPI variants:
+`scapi_execute_job`, `scapi_get_job_execution`, `scapi_get_job_log`,
+`scapi_search_job_executions`, `scapi_delete_job_execution`.
+Errors: `JobExecutionError`, `CanonicalJobExecutionError`. Types:
+`JobExecution`, `JobExecutionStatus`, `JobStepExecution`, `ExecuteJobOptions`,
+`WaitForJobOptions`, `SiteArchive{Import,Export}Options`/`Result`, plus the
+`Export*Configuration` structures.
+
+### Sites (`operations.sites` — submodule import only)
+`get_cartridge_path`, `set_cartridge_path`, `add_cartridge`, `remove_cartridge`,
+`create_sites_backend`. Types: `SiteInfo`, `SitesBackend`, `CartridgePathResult`,
+`CartridgePosition`, `AddCartridgeOptions`, `ListSitesOptions`, `BM_SITE_ID`.
+
+### Catalogs (`operations.catalogs`)
+`create_catalogs_backend` (dual-backend SCAPI→OCAPI). Types: `CatalogInfo`,
+`CatalogsBackend`, `ListCatalogsOptions`, `Ocapi`/`ScapiCatalogsBackend`.
+
+### BM users / BM roles (`operations.bm_users`, `operations.bm_roles`)
+`create_users_backend`, `create_roles_backend` (dual-backend). Types:
+`UserInfo`/`RoleInfo`, `CreateUserInput`/`CreateRoleInput`,
+`UpdateUserChanges`, `ListUsersOptions`, `SearchUsersOptions`, backends and
+their configs.
+
+### ODS / sandboxes (`operations.ods`)
+`wait_for_sandbox`, `wait_for_clone`, `wait_for_clones`, `build_sandbox_settings`,
+`resolve_sandbox_id`, `parse_friendly_sandbox_id`, `is_friendly_sandbox_id`,
+`is_uuid`. Pair with `create_ods_client`. States: `SandboxState`, `CloneState`.
+Errors: `SandboxNotFoundError`, `SandboxPollingError`,
+`SandboxPollingTimeoutError`, `SandboxTerminalStateError`, `CloneFailedError`,
+`ClonePollingError`/`TimeoutError`, `CloneBatch*Error`.
+
+### Metrics (`operations.metrics`)
+`get_overall_metrics`, `get_sales_metrics`, `get_scapi_metrics`,
+`get_scapi_hooks_metrics`, `get_ocapi_metrics`, `get_controller_metrics`,
+`get_ecdn_metrics`, `get_mrt_metrics`, `get_third_party_metrics`,
+`get_metrics_by_category`. Pair with `create_metrics_client`. Window helpers:
+`resolve_metrics_window`, `parse_metrics_bound`, `parse_series_tags`,
+`enrich_metrics_tags`. Constants: `METRIC_CATEGORIES`,
+`METRICS_DEFAULT_WINDOW_MS`, `METRICS_RETENTION_MS`.
+
+### Logs (`operations.logs`)
+`list_log_files`, `get_recent_logs`. **`tail_logs` is async-only** (streaming;
+not in `b2c_tooling_sdk.sync`) — import from `operations.logs` and use the async
+API. Filters/parsers: `filter_by_level`, `filter_by_search`, `filter_by_since`,
+`parse_log_entry`, `aggregate_log_entries`, `create_path_normalizer`. Types:
+`LogEntry`, `LogFile`, `TailLogsOptions`, `TailLogsCallbacks`, `TailLogsResult`.
+
+### Account Manager (`operations.users`, `operations.roles`, `operations.orgs`)
+Users: `create_user`, `get_user`, `get_user_by_login`, `update_user`,
+`delete_user`, `purge_user`, `reset_user`, `grant_role`, `revoke_role`,
+`list_users`. Roles: `list_roles`, `get_role`. Orgs: `list_orgs`, `get_org`,
+`get_org_by_name`.
+
+## SLAS shopper tokens (`b2c_tooling_sdk.slas` — submodule import only)
+
+Not in the top-level barrel; blocking twins live in `b2c_tooling_sdk.sync`.
+`get_guest_token`, `get_registered_token`, `generate_code_verifier`,
+`generate_code_challenge`. Types: `SlasTokenConfig`, `SlasTokenResponse`,
+`SlasRegisteredLoginConfig`.
+The tooling SDK has no dedicated storefront client — after minting a token, call
+Shopper endpoints with plain `httpx` using `token.access_token` as a bearer.
+
+## Version / defaults / logging (top-level)
+
+`SDK_NAME`, `SDK_VERSION`, `SDK_USER_AGENT`; `DEFAULT_ACCOUNT_MANAGER_HOST`,
+`DEFAULT_ODS_HOST`, `DEFAULT_PUBLIC_CLIENT_ID`, `get_default_public_client_id`;
+`get_logger`, `configure_logger`.

package/node_modules/@salesforce/b2c-agent-plugins/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salesforce/b2c-agent-plugins",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "description": "B2C Commerce agent skills plugins for development and operations. Private — distributed via GitHub release zips.",
   "private": true
 }

package/node_modules/@salesforce/b2c-agent-plugins/plugins.json

@@ -18,6 +18,9 @@
     },
     {
       "name": "figma-to-sfnext-pagedesigner"
+    },
+    {
+      "name": "b2c-python-sdk"
     }
   ]
 }

package/node_modules/@salesforce/b2c-agent-plugins/storefront-next/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "storefront-next",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "description": "Storefront Next development skills for building React 19 storefronts on Salesforce B2C Commerce.",
   "author": {
     "name": "Salesforce"

package/node_modules/@salesforce/b2c-agent-plugins/storefront-next/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "storefront-next",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "description": "Storefront Next development skills for building React 19 storefronts on Salesforce B2C Commerce.",
   "author": {
     "name": "Salesforce"

package/oclif.manifest.json

@@ -420,6 +420,13 @@
           ],
           "type": "option"
         },
+        "allow-non-ga-tools": {
+          "description": "Deprecated compatibility flag; has no effect",
+          "hidden": true,
+          "name": "allow-non-ga-tools",
+          "allowNo": false,
+          "type": "boolean"
+        },
         "toolsets": {
           "description": "Toolsets to enable (comma-separated; default: all). Options: all, CARTRIDGES, DIAGNOSTICS, MRT, PWAV3, SCAPI, STOREFRONTNEXT, CIP",
           "env": "SFCC_TOOLSETS",
@@ -455,5 +462,5 @@
       "enableJsonFlag": false
     }
   },
-  "version": "3.0.0"
+  "version": "3.1.0"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@salesforce/b2c-dx-mcp",
   "description": "MCP server for B2C Commerce developer experience tools",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "author": "Salesforce",
   "license": "Apache-2.0",
   "repository": "SalesforceCommerceCloud/b2c-developer-tooling",
@@ -80,8 +80,8 @@
     "ts-morph": "27.0.2",
     "yaml": "2.9.0",
     "zod": "4.5.4",
-    "@salesforce/b2c-agent-plugins": "1.9.0",
-    "@salesforce/b2c-tooling-sdk": "2.0.0"
+    "@salesforce/b2c-agent-plugins": "1.10.0",
+    "@salesforce/b2c-tooling-sdk": "2.1.0"
   },
   "bundledDependencies": [
     "@modelcontextprotocol/server",