@salesforce/b2c-dx-mcp 0.3.2 → 0.4.0

package/dist/tools/scapi/scapi-custom-apis-status.d.ts

@@ -0,0 +1,9 @@
+import type { Services } from '../../services.js';
+import type { McpTool } from '../../utils/index.js';
+/**
+ * Creates the scapi_custom_apis_status tool.
+ *
+ * Mirrors CLI: b2c scapi custom status. All flags supported; agent chooses what to use.
+ * See: https://salesforcecommercecloud.github.io/b2c-developer-tooling/cli/custom-apis.html#b2c-scapi-custom-status
+ */
+export declare function createScapiCustomApisStatusTool(loadServices: () => Services): McpTool;

package/dist/tools/scapi/scapi-custom-apis-status.js

@@ -0,0 +1,152 @@
+/*
+ * Copyright (c) 2025, Salesforce, Inc.
+ * SPDX-License-Identifier: Apache-2
+ * For full license text, see the license.txt file in the repo root or http://www.apache.org/licenses/LICENSE-2.0
+ */
+/**
+ * SCAPI Custom API Status tool.
+ *
+ * Mirrors CLI: b2c scapi custom status. All CLI flags are supported; let the agent decide what to use.
+ * Returns raw endpoints from the API (no roll-up). Remote only.
+ *
+ * @module tools/scapi/scapi-custom-apis-status
+ */
+import { z } from 'zod';
+import { createToolAdapter, jsonResult } from '../adapter.js';
+import { getApiErrorMessage } from '@salesforce/b2c-tooling-sdk/clients';
+import { getApiType } from '@salesforce/b2c-tooling-sdk/schemas';
+// MCP-specific default columns (includes siteId since MCP returns raw endpoints per site)
+const DEFAULT_COLUMNS = ['type', 'apiName', 'cartridgeName', 'endpointPath', 'httpMethod', 'status', 'siteId'];
+function pickColumns(endpoint, columns) {
+    const out = {};
+    for (const key of columns) {
+        if (key in endpoint && endpoint[key] !== undefined) {
+            out[key] = endpoint[key];
+        }
+    }
+    return out;
+}
+function buildColumnList(args) {
+    // If columns specified, use those; otherwise use defaults (saves tokens)
+    if (args.columns?.trim()) {
+        return args.columns
+            .split(',')
+            .map((c) => c.trim())
+            .filter(Boolean);
+    }
+    return [...DEFAULT_COLUMNS];
+}
+function buildResponse(withMeta, args, columnList, activeCodeVersion) {
+    // Always filter to requested columns (saves tokens by not returning unused fields)
+    const toOutput = (e) => pickColumns(e, columnList);
+    if (args.groupBy) {
+        const groups = {};
+        if (args.groupBy === 'type') {
+            for (const endpoint of withMeta) {
+                const type = endpoint.type ?? '-';
+                if (!groups[type])
+                    groups[type] = [];
+                groups[type].push(toOutput(endpoint));
+            }
+        }
+        else {
+            for (const endpoint of withMeta) {
+                const site = endpoint.siteId ?? 'Global';
+                if (!groups[site])
+                    groups[site] = [];
+                groups[site].push(toOutput(endpoint));
+            }
+        }
+        return {
+            groups,
+            total: withMeta.length,
+            activeCodeVersion,
+            timestamp: new Date().toISOString(),
+            message: withMeta.length === 0 ? 'No Custom API endpoints found.' : `Found ${withMeta.length} endpoint(s).`,
+        };
+    }
+    return {
+        endpoints: withMeta.map((e) => toOutput(e)),
+        total: withMeta.length,
+        activeCodeVersion,
+        timestamp: new Date().toISOString(),
+        message: withMeta.length === 0 ? 'No Custom API endpoints found.' : `Found ${withMeta.length} endpoint(s).`,
+    };
+}
+/**
+ * Creates the scapi_custom_apis_status tool.
+ *
+ * Mirrors CLI: b2c scapi custom status. All flags supported; agent chooses what to use.
+ * See: https://salesforcecommercecloud.github.io/b2c-developer-tooling/cli/custom-apis.html#b2c-scapi-custom-status
+ */
+export function createScapiCustomApisStatusTool(loadServices) {
+    return createToolAdapter({
+        name: 'scapi_custom_apis_status',
+        description: `List Custom SCAPI endpoint registration status (active/not_registered). Returns one row per endpoint per site. For schemas, use scapi_schemas_list with apiFamily: "custom".
+
+Use cases: Check endpoint status, verify deployment, get per-site details. Use status: "active" to filter, groupBy: "site" to group, columns: "field1,field2" for specific fields, or omit columns for defaults.
+
+Output: Default (7 fields): type,apiName,cartridgeName,endpointPath,httpMethod,status,siteId. All fields: type,apiName,apiVersion,cartridgeName,endpointPath,httpMethod,status,siteId,securityScheme,operationId,schemaFile,implementationScript,errorReason,id.
+
+Requires OAuth (sfcc.custom-apis scope) and instance config (shortCode, tenantId). Returns remoteError on failure.
+
+CLI: b2c scapi custom status`,
+        toolsets: ['PWAV3', 'SCAPI', 'STOREFRONTNEXT'],
+        isGA: false,
+        requiresInstance: false,
+        inputSchema: {
+            status: z.enum(['active', 'not_registered']).optional().describe('Filter by status. Omit for all.'),
+            groupBy: z.enum(['site', 'type']).optional().describe('Group by siteId or type (Admin/Shopper).'),
+            columns: z
+                .string()
+                .optional()
+                .describe('Comma-separated fields. Omit for defaults (7 fields). All fields: type,apiName,apiVersion,cartridgeName,endpointPath,httpMethod,status,siteId,securityScheme,operationId,schemaFile,implementationScript,errorReason,id'),
+        },
+        async execute(args, { services: svc }) {
+            let endpoints = [];
+            let activeCodeVersion;
+            let remoteError;
+            try {
+                const client = svc.getCustomApisClient();
+                const organizationId = svc.getOrganizationId();
+                // Call Custom APIs DX API: list endpoints for this org, optional status filter.
+                const { data, error, response } = await client.GET('/organizations/{organizationId}/endpoints', {
+                    params: {
+                        path: { organizationId },
+                        query: args.status ? { status: args.status } : undefined,
+                    },
+                });
+                if (error) {
+                    remoteError = `Failed to fetch remote endpoints: ${getApiErrorMessage(error, response)}`;
+                }
+                else {
+                    endpoints = data?.data ?? [];
+                    activeCodeVersion = data?.activeCodeVersion;
+                }
+            }
+            catch (error) {
+                // Network/config errors: capture message for remoteError and return below.
+                remoteError = error instanceof Error ? error.message : 'Unknown error fetching remote endpoints';
+            }
+            // On any remote failure, return early with error details (no endpoints).
+            if (remoteError) {
+                return {
+                    total: 0,
+                    activeCodeVersion,
+                    remoteError,
+                    timestamp: new Date().toISOString(),
+                    message: `Failed to fetch Custom API endpoints: ${remoteError}. Check OAuth credentials and sfcc.custom-apis scope.`,
+                };
+            }
+            // Add type to each endpoint (no roll-up)
+            const withMeta = endpoints.map((e) => ({
+                ...e,
+                type: getApiType(e.securityScheme),
+            }));
+            const columnList = buildColumnList(args);
+            return buildResponse(withMeta, args, columnList, activeCodeVersion);
+        },
+        formatOutput: (output) => jsonResult(output),
+    }, loadServices);
+}
+//# sourceMappingURL=scapi-custom-apis-status.js.map

package/dist/tools/scapi/scapi-schemas-list.d.ts

@@ -0,0 +1,12 @@
+import type { Services } from '../../services.js';
+import type { McpTool } from '../../utils/index.js';
+/**
+ * Creates the scapi_schemas_list tool.
+ *
+ * Mirrors CLI: b2c scapi schemas list (discovery) and b2c scapi schemas get (fetch).
+ * Lists or fetches SCAPI schema specifications; includes standard SCAPI and custom API as schema types.
+ *
+ * @param loadServices - Function that loads configuration and returns Services instance
+ * @returns MCP tool for listing/fetching SCAPI schemas
+ */
+export declare function createScapiSchemasListTool(loadServices: () => Services): McpTool;

package/dist/tools/scapi/scapi-schemas-list.js

@@ -0,0 +1,248 @@
+/*
+ * Copyright (c) 2025, Salesforce, Inc.
+ * SPDX-License-Identifier: Apache-2
+ * For full license text, see the license.txt file in the repo root or http://www.apache.org/licenses/LICENSE-2.0
+ */
+/**
+ * SCAPI Schemas List tool.
+ *
+ * Lists available SCAPI schemas with optional filtering by apiFamily, apiName, apiVersion, and status.
+ * Optionally fetches full OpenAPI schemas when includeSchemas=true is provided along with all three identifiers.
+ * Matches the CLI command: b2c scapi schemas list
+ *
+ * @module tools/scapi/scapi-schemas-list
+ */
+import { z } from 'zod';
+import { createToolAdapter, jsonResult } from '../adapter.js';
+import { getApiErrorMessage } from '@salesforce/b2c-tooling-sdk/clients';
+import { collapseOpenApiSchema } from '@salesforce/b2c-tooling-sdk/schemas';
+/**
+ * Builds the base URL for a SCAPI API endpoint.
+ *
+ * Constructs the base URL for making SCAPI API calls based on the instance short code,
+ * API family, API name, and version.
+ *
+ * @param shortCode - SCAPI instance short code (e.g., "kv7kzm78")
+ * @param apiFamily - API family (e.g., "shopper", "checkout", "product")
+ * @param apiName - API name (e.g., "products", "baskets", "orders")
+ * @param apiVersion - API version (e.g., "v1", "v2")
+ * @returns Full base URL for the SCAPI API
+ *
+ * @example
+ * ```typescript
+ * const url = buildScapiApiUrl("kv7kzm78", "shopper", "products", "v1");
+ * // Returns: "https://kv7kzm78.api.commercecloud.salesforce.com/shopper/products/v1"
+ * ```
+ */
+function buildScapiApiUrl(shortCode, apiFamily, apiName, apiVersion) {
+    return `https://${shortCode}.api.commercecloud.salesforce.com/${apiFamily}/${apiName}/${apiVersion}`;
+}
+/**
+ * Fetches a specific schema from the SCAPI Schemas API.
+ *
+ * @param params - Fetch parameters
+ * @param params.client - SCAPI Schemas client
+ * @param params.organizationId - Organization ID
+ * @param params.args - Input arguments with API identifiers
+ * @param params.shortCode - Optional short code for building base URL
+ * @returns Schema fetch output
+ */
+async function fetchSpecificSchema(params) {
+    const { client, organizationId, args, shortCode } = params;
+    const { apiFamily, apiName, apiVersion, expandAll, status } = args;
+    // Warn if status filter was provided (it's ignored in fetch mode)
+    const warning = status
+        ? `Note: 'status' filter is ignored when fetching a specific schema. The API endpoint for retrieving a specific schema (${apiFamily}/${apiName}/${apiVersion}) does not support status filtering - you're already specifying the exact version. Use discovery mode (omit one or more of apiFamily/apiName/apiVersion) to filter by status.`
+        : undefined;
+    const { data, error, response } = await client.GET('/organizations/{organizationId}/schemas/{apiFamily}/{apiName}/{apiVersion}', {
+        params: {
+            path: { organizationId, apiFamily: apiFamily, apiName: apiName, apiVersion: apiVersion },
+        },
+    });
+    if (error) {
+        throw new Error(`Failed to fetch schema for ${apiFamily}/${apiName}/${apiVersion}: ${getApiErrorMessage(error, response)}`);
+    }
+    // Apply collapsing unless expandAll is requested
+    const collapsed = !expandAll;
+    const processedSchema = collapsed
+        ? collapseOpenApiSchema(data)
+        : data;
+    // Build base URL for the SCAPI API (where to call the API)
+    const baseUrl = shortCode && apiFamily && apiName && apiVersion
+        ? buildScapiApiUrl(shortCode, apiFamily, apiName, apiVersion)
+        : undefined;
+    return {
+        apiFamily: apiFamily,
+        apiName: apiName,
+        apiVersion: apiVersion,
+        schema: processedSchema,
+        timestamp: new Date().toISOString(),
+        collapsed,
+        warning,
+        baseUrl,
+    };
+}
+/**
+ * Fetches and filters schemas list from the SCAPI Schemas API.
+ *
+ * @param params - Fetch parameters
+ * @param params.client - SCAPI Schemas client
+ * @param params.organizationId - Organization ID
+ * @param params.args - Input parameters
+ * @param params.shortCode - Optional short code for building base URLs
+ * @returns Discovery mode output
+ */
+async function fetchSchemasList(params) {
+    const { client, organizationId, args, shortCode } = params;
+    const { data, error, response } = await client.GET('/organizations/{organizationId}/schemas', {
+        params: {
+            path: { organizationId },
+            query: {
+                apiFamily: args.apiFamily,
+                apiName: args.apiName,
+                apiVersion: args.apiVersion,
+                status: args.status,
+            },
+        },
+    });
+    if (error) {
+        throw new Error(`Failed to fetch SCAPI schemas: ${getApiErrorMessage(error, response)}`);
+    }
+    const schemas = data?.data ?? [];
+    const filteredSchemas = prepareSchemaListForConsumer(schemas, shortCode);
+    const discoveryMetadata = getAvailableFilters(schemas);
+    // Generate helpful message for empty results
+    const message = schemas.length === 0 ? generateEmptyResultMessage(args) : undefined;
+    return {
+        schemas: filteredSchemas,
+        total: data?.total ?? schemas.length,
+        timestamp: new Date().toISOString(),
+        ...discoveryMetadata,
+        message,
+    };
+}
+/**
+ * Generates helpful message when no schemas are found.
+ */
+function generateEmptyResultMessage(args) {
+    const hasFilters = args.apiFamily || args.apiName || args.apiVersion || args.status;
+    if (hasFilters) {
+        const activeFilters = [];
+        if (args.apiFamily)
+            activeFilters.push(`apiFamily="${args.apiFamily}"`);
+        if (args.apiName)
+            activeFilters.push(`apiName="${args.apiName}"`);
+        if (args.apiVersion)
+            activeFilters.push(`apiVersion="${args.apiVersion}"`);
+        if (args.status)
+            activeFilters.push(`status="${args.status}"`);
+        return `No SCAPI schemas match the filters: ${activeFilters.join(', ')}. Try removing some filters or check the filter values. Use discovery mode without filters to see all available schemas.`;
+    }
+    return 'No SCAPI schemas available. This could indicate: (1) Invalid tenant ID or organization ID, (2) Missing OAuth scopes (requires sfcc.scapi-schemas), or (3) No schemas published for this organization. Verify your credentials and tenant configuration.';
+}
+/**
+ * Prepares schema list for consumer: strips link, adds baseUrl when shortCode provided.
+ */
+function prepareSchemaListForConsumer(schemas, shortCode) {
+    return schemas.map((item) => {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { link, ...rest } = item;
+        const baseUrl = shortCode && item.apiFamily && item.apiName && item.apiVersion
+            ? buildScapiApiUrl(shortCode, item.apiFamily, item.apiName, item.apiVersion)
+            : undefined;
+        return { ...rest, baseUrl };
+    });
+}
+/**
+ * Extracts unique filter values (apiFamily, apiName, apiVersion) from a schema list.
+ */
+function getAvailableFilters(schemas) {
+    if (schemas.length === 0) {
+        return {};
+    }
+    const availableApiFamilies = [
+        ...new Set(schemas.map((s) => s.apiFamily).filter((v) => v !== undefined)),
+    ].sort();
+    const availableApiNames = [
+        ...new Set(schemas.map((s) => s.apiName).filter((v) => v !== undefined)),
+    ].sort();
+    const availableVersions = [
+        ...new Set(schemas.map((s) => s.apiVersion).filter((v) => v !== undefined)),
+    ].sort();
+    return {
+        availableApiFamilies: availableApiFamilies.length > 0 ? availableApiFamilies : undefined,
+        availableApiNames: availableApiNames.length > 0 ? availableApiNames : undefined,
+        availableVersions: availableVersions.length > 0 ? availableVersions : undefined,
+    };
+}
+/**
+ * Creates the scapi_schemas_list tool.
+ *
+ * Mirrors CLI: b2c scapi schemas list (discovery) and b2c scapi schemas get (fetch).
+ * Lists or fetches SCAPI schema specifications; includes standard SCAPI and custom API as schema types.
+ *
+ * @param loadServices - Function that loads configuration and returns Services instance
+ * @returns MCP tool for listing/fetching SCAPI schemas
+ */
+export function createScapiSchemasListTool(loadServices) {
+    return createToolAdapter({
+        name: 'scapi_schemas_list',
+        description: `List or fetch SCAPI schema metadata and OpenAPI specs for standard SCAPI (Shop/Admin/Shopper) and custom APIs (apiFamily: "custom"). For endpoint registration status, use scapi_custom_apis_status.
+
+**Modes:**
+- **List (discovery):** Omit includeSchemas or any identifier. Returns metadata: schemas[], total, availableApiFamilies/Names/Versions.
+- **Fetch:** Set includeSchemas=true + all three: apiFamily, apiName, apiVersion. Returns full OpenAPI schema (collapsed by default; set expandAll=true for full).
+
+**Rules:** includeSchemas requires all three identifiers. status only works in list mode (use "current" for active schemas, "deprecated" for phased-out schemas). Custom APIs use apiFamily: "custom".
+
+**Requirements:** OAuth with sfcc.scapi-schemas scope.`,
+        toolsets: ['PWAV3', 'SCAPI', 'STOREFRONTNEXT'],
+        isGA: false,
+        requiresInstance: false, // SCAPI uses OAuth directly, doesn't need B2CInstance (hostname)
+        inputSchema: {
+            apiFamily: z.string().optional().describe('API family (e.g., "checkout", "product", "custom").'),
+            apiName: z.string().optional().describe('API name (e.g., "shopper-baskets", "shopper-products").'),
+            apiVersion: z.string().optional().describe('API version (e.g., "v1", "v2").'),
+            status: z
+                .enum(['current', 'deprecated'])
+                .optional()
+                .describe('Filter by status (list mode only). Omit to return all schemas.'),
+            includeSchemas: z
+                .boolean()
+                .default(false)
+                .describe('Fetch full OpenAPI schema. Requires apiFamily+apiName+apiVersion. Default: false.'),
+            expandAll: z
+                .boolean()
+                .default(false)
+                .describe('Return full uncompressed schema. Only when includeSchemas=true. Default: false.'),
+        },
+        async execute(args, { services: svc }) {
+            // Get client and organization ID
+            const client = svc.getScapiSchemasClient();
+            const organizationId = svc.getOrganizationId();
+            // Get shortCode for building base URLs (optional)
+            let shortCode;
+            try {
+                shortCode = svc.getShortCode();
+            }
+            catch {
+                // Continue without shortCode if not available
+            }
+            // Determine operation mode
+            const hasAllIdentifiers = Boolean(args.apiFamily && args.apiName && args.apiVersion);
+            const isFetchMode = hasAllIdentifiers && args.includeSchemas;
+            // Validate includeSchemas flag
+            if (args.includeSchemas && !hasAllIdentifiers) {
+                throw new Error('includeSchemas=true requires all three identifiers: apiFamily, apiName, and apiVersion. ' +
+                    'Please provide all three to fetch a specific schema, or omit includeSchemas to discover available schemas.');
+            }
+            // Execute appropriate mode
+            if (isFetchMode) {
+                return fetchSpecificSchema({ client, organizationId, args, shortCode });
+            }
+            return fetchSchemasList({ client, organizationId, args, shortCode });
+        },
+        formatOutput: (output) => jsonResult(output),
+    }, loadServices);
+}
+//# sourceMappingURL=scapi-schemas-list.js.map

package/dist/tools/storefrontnext/developer-guidelines.d.ts

@@ -3,7 +3,7 @@ import type { Services } from '../../services.js';
 /**
  * Creates the developer guidelines tool for Storefront Next.
  *
- * @param services - MCP services
+ * @param loadServices - Function that loads configuration and returns Services instance
  * @returns The configured MCP tool
  */
-export declare function createDeveloperGuidelinesTool(services: Services): McpTool;
+export declare function createDeveloperGuidelinesTool(loadServices: () => Services): McpTool;

package/dist/tools/storefrontnext/developer-guidelines.js

@@ -77,10 +77,10 @@ const DEFAULT_SECTIONS = ['quick-reference', 'data-fetching', 'components', 'tes
 /**
  * Creates the developer guidelines tool for Storefront Next.
  *
- * @param services - MCP services
+ * @param loadServices - Function that loads configuration and returns Services instance
  * @returns The configured MCP tool
  */
-export function createDeveloperGuidelinesTool(services) {
+export function createDeveloperGuidelinesTool(loadServices) {
     return createToolAdapter({
         name: 'storefront_next_development_guidelines',
         description: 'ESSENTIAL FIRST STEP for Storefront Next development. Returns critical architecture rules, coding standards, and best practices. ' +
@@ -135,6 +135,6 @@ export function createDeveloperGuidelinesTool(services) {
             return fullContentInstruction + combinedContent + footerInstruction;
         },
         formatOutput: (output) => textResult(output),
-    }, services);
+    }, loadServices);
 }
 //# sourceMappingURL=developer-guidelines.js.map

package/dist/tools/storefrontnext/index.d.ts

@@ -7,7 +7,7 @@ import type { Services } from '../../services.js';
  * toolsets: ["MRT", "PWAV3", "STOREFRONTNEXT"] and will
  * automatically appear in STOREFRONTNEXT.
  *
- * @param services - MCP services
+ * @param loadServices - Function that loads configuration and returns Services instance
  * @returns Array of MCP tools
  */
-export declare function createStorefrontNextTools(services: Services): McpTool[];
+export declare function createStorefrontNextTools(loadServices: () => Services): McpTool[];

package/dist/tools/storefrontnext/index.js

@@ -16,7 +16,6 @@
  * - `storefront_next_figma_to_component_workflow` - Convert Figma to components
  * - `storefront_next_generate_component` - Generate new components
  * - `storefront_next_map_tokens_to_theme` - Map design tokens
- * - `storefront_next_design_decorator` - Apply design decorators
  * - `storefront_next_generate_page_designer_metadata` - Generate Page Designer metadata
  *
  * @module tools/storefrontnext
@@ -24,6 +23,7 @@
 import { z } from 'zod';
 import { createToolAdapter, jsonResult } from '../adapter.js';
 import { createDeveloperGuidelinesTool } from './developer-guidelines.js';
+import { createPageDesignerDecoratorTool } from '../page-designer-decorator/index.js';
 /**
  * Creates a placeholder tool for Storefront Next development.
  *
@@ -32,10 +32,10 @@ import { createDeveloperGuidelinesTool } from './developer-guidelines.js';
  *
  * @param name - Tool name
  * @param description - Tool description
- * @param services - MCP services
+ * @param loadServices - Function that loads configuration and returns Services instance
  * @returns The configured MCP tool
  */
-function createPlaceholderTool(name, description, services) {
+function createPlaceholderTool(name, description, loadServices) {
     return createToolAdapter({
         name,
         description: `[PLACEHOLDER] ${description}`,
@@ -57,7 +57,7 @@ function createPlaceholderTool(name, description, services) {
             };
         },
         formatOutput: (output) => jsonResult(output),
-    }, services);
+    }, loadServices);
 }
 /**
  * Creates all tools for the STOREFRONTNEXT toolset.
@@ -66,18 +66,18 @@ function createPlaceholderTool(name, description, services) {
  * toolsets: ["MRT", "PWAV3", "STOREFRONTNEXT"] and will
  * automatically appear in STOREFRONTNEXT.
  *
- * @param services - MCP services
+ * @param loadServices - Function that loads configuration and returns Services instance
  * @returns Array of MCP tools
  */
-export function createStorefrontNextTools(services) {
+export function createStorefrontNextTools(loadServices) {
     return [
-        createDeveloperGuidelinesTool(services),
-        createPlaceholderTool('storefront_next_site_theming', 'Configure and manage site theming for Storefront Next', services),
-        createPlaceholderTool('storefront_next_figma_to_component_workflow', 'Convert Figma designs to Storefront Next components', services),
-        createPlaceholderTool('storefront_next_generate_component', 'Generate a new Storefront Next component', services),
-        createPlaceholderTool('storefront_next_map_tokens_to_theme', 'Map design tokens to Storefront Next theme configuration', services),
-        createPlaceholderTool('storefront_next_design_decorator', 'Apply design decorators to Storefront Next components', services),
-        createPlaceholderTool('storefront_next_generate_page_designer_metadata', 'Generate Page Designer metadata for Storefront Next components', services),
+        createDeveloperGuidelinesTool(loadServices),
+        createPageDesignerDecoratorTool(loadServices),
+        createPlaceholderTool('storefront_next_site_theming', 'Configure and manage site theming for Storefront Next', loadServices),
+        createPlaceholderTool('storefront_next_figma_to_component_workflow', 'Convert Figma designs to Storefront Next components', loadServices),
+        createPlaceholderTool('storefront_next_generate_component', 'Generate a new Storefront Next component', loadServices),
+        createPlaceholderTool('storefront_next_map_tokens_to_theme', 'Map design tokens to Storefront Next theme configuration', loadServices),
+        createPlaceholderTool('storefront_next_generate_page_designer_metadata', 'Generate Page Designer metadata for Storefront Next components', loadServices),
     ];
 }
 //# sourceMappingURL=index.js.map

package/oclif.manifest.json

@@ -54,12 +54,23 @@
           "type": "boolean"
         },
         "json": {
-          "description": "Output logs as JSON lines",
+          "description": "Output result as JSON",
           "helpGroup": "GLOBAL",
           "name": "json",
           "allowNo": false,
           "type": "boolean"
         },
+        "jsonl": {
+          "aliases": [
+            "json-logs"
+          ],
+          "description": "Output log messages as JSON lines",
+          "env": "SFCC_JSON_LOGS",
+          "helpGroup": "GLOBAL",
+          "name": "jsonl",
+          "allowNo": false,
+          "type": "boolean"
+        },
         "lang": {
           "char": "L",
           "description": "Language for messages (e.g., en, de). Also respects LANGUAGE env var.",
@@ -373,5 +384,5 @@
       "enableJsonFlag": false
     }
   },
-  "version": "0.3.2"
+  "version": "0.4.0"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salesforce/b2c-dx-mcp",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "MCP server for B2C Commerce Cloud developer experience tools",
   "author": "Salesforce",
   "license": "MIT",
@@ -75,8 +75,11 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.26.0",
     "@oclif/core": "4.8.0",
+    "glob": "13.0.0",
+    "ts-morph": "^27.0.0",
+    "yaml": "2.8.1",
     "zod": "3.25.76",
-    "@salesforce/b2c-tooling-sdk": "0.4.1"
+    "@salesforce/b2c-tooling-sdk": "0.5.0"
   },
   "devDependencies": {
     "@eslint/compat": "^1",
@@ -86,8 +89,9 @@
     "@salesforce/dev-config": "^4.3.2",
     "@types/chai": "^4",
     "@types/mocha": "^10",
-    "@types/node": "^22.16.5",
+    "@types/node": "^22",
     "@types/sinon": "^21.0.0",
+    "c8": "^10.1.3",
     "chai": "^4",
     "eslint": "^9",
     "eslint-config-oclif": "^6",
@@ -118,9 +122,10 @@
     "inspect": "mcp-inspector node bin/run.js --toolsets all --allow-non-ga-tools",
     "inspect:dev": "mcp-inspector node --conditions development bin/dev.js --toolsets all --allow-non-ga-tools",
     "pretest": "tsc --noEmit -p test",
-    "test": "mocha --forbid-only \"test/**/*.test.ts\"",
+    "test": "c8 mocha --forbid-only \"test/**/*.test.ts\"",
+    "test:ci": "c8 mocha --forbid-only --reporter json --reporter-option output=test-results.json \"test/**/*.test.ts\"",
     "test:agent": "mocha --forbid-only --reporter min \"test/**/*.test.ts\"",
-    "test:ci": "mocha --forbid-only --reporter json --reporter-option output=test-results.json \"test/**/*.test.ts\"",
+    "coverage": "c8 report",
     "posttest": "pnpm run lint"
   }
 }