@salesforce/b2c-dx-mcp 2.1.2 → 3.0.0

package/content/guidance/storefront-next/sfnext-testing/references/STORYBOOK-PATTERNS.md

@@ -0,0 +1,118 @@
+# Storybook Patterns Reference
+
+## Story File Structure
+
+```typescript
+// src/components/my-component/stories/index.stories.tsx
+import type { Meta, StoryObj } from '@storybook/react-vite';
+import { within, expect, userEvent } from 'storybook/test';
+import { waitForStorybookReady } from '@storybook/test-utils';
+import { MyComponent } from '../my-component';
+import { ConfigProvider } from '@/config/context';
+import { mockConfig } from '@/test-utils/config';
+
+const meta: Meta<typeof MyComponent> = {
+    title: 'Components/MyComponent',
+    component: MyComponent,
+    tags: ['autodocs', 'interaction'],
+    decorators: [
+        (Story) => (
+            <ConfigProvider config={mockConfig}>
+                <Story />
+            </ConfigProvider>
+        ),
+    ],
+};
+
+export default meta;
+type Story = StoryObj<typeof MyComponent>;
+```
+
+## Story Variants
+
+Create stories for different component states:
+
+```typescript
+export const Default: Story = {
+    args: { title: 'Default Title' },
+};
+
+export const Loading: Story = {
+    args: { isLoading: true },
+};
+
+export const Error: Story = {
+    args: { error: 'Something went wrong' },
+};
+
+export const Empty: Story = {
+    args: { items: [] },
+};
+```
+
+## Interaction Tests (Play Functions)
+
+```typescript
+export const WithInteraction: Story = {
+    args: { title: 'Interactive' },
+    play: async ({ canvasElement }) => {
+        await waitForStorybookReady(canvasElement);
+        const canvas = within(canvasElement);
+
+        // Assert initial state
+        await expect(canvas.getByText('Interactive')).toBeInTheDocument();
+
+        // Simulate user interaction
+        const button = canvas.getByRole('button');
+        await userEvent.click(button);
+
+        // Assert result
+        await expect(canvas.getByText('Clicked!')).toBeInTheDocument();
+    },
+};
+```
+
+## Decorators
+
+Wrap stories with required providers:
+
+```typescript
+// Single provider
+decorators: [
+    (Story) => (
+        <ConfigProvider config={mockConfig}>
+            <Story />
+        </ConfigProvider>
+    ),
+],
+
+// Multiple providers
+decorators: [
+    (Story) => (
+        <ConfigProvider config={mockConfig}>
+            <AuthProvider auth={mockAuth}>
+                <Story />
+            </AuthProvider>
+        </ConfigProvider>
+    ),
+],
+```
+
+## Responsive Testing
+
+Use Storybook's built-in viewport toolbar instead of creating separate Mobile/Tablet/Desktop stories. The viewport selector in the toolbar lets you test components at different screen sizes interactively.
+
+## Accessibility Testing
+
+Stories with the `autodocs` tag are automatically included in a11y test runs. Use `skip-a11y` only for stories that intentionally violate a11y rules (e.g., testing error states):
+
+```typescript
+export const ErrorState: Story = {
+    tags: ['skip-a11y'],
+    args: { error: 'Missing required field' },
+};
+```
+
+## Story Coverage
+
+Run `pnpm generate:story-tests:coverage` to check which components have stories and which need them. Every reusable component in `src/components/` should have a corresponding `.stories.tsx` file.

package/dist/commands/mcp.d.ts

@@ -23,7 +23,6 @@ export default class McpServerCommand extends BaseCommand<typeof McpServerComman
         toolsets: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         tools: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'docs-topics': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        'allow-non-ga-tools': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         server: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'webdav-server': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'code-version': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
@@ -33,6 +32,7 @@ export default class McpServerCommand extends BaseCommand<typeof McpServerComman
         passphrase: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         selfsigned: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         verify: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'api-backend': import("@oclif/core/interfaces").OptionFlag<"ocapi" | "scapi" | "auto" | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'client-id': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         'client-secret': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         'auth-scope': import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
@@ -60,9 +60,8 @@ export default class McpServerCommand extends BaseCommand<typeof McpServerComman
         environment: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         'cloud-origin': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         'credentials-file': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'mrt-backend': import("@oclif/core/interfaces").OptionFlag<"scapi" | "auto" | "legacy", import("@oclif/core/interfaces").CustomOptions>;
     };
-    /** Server-scoped persistent state (debug sessions, log watches, etc.) */
-    private serverContext?;
     /** Signal that triggered shutdown (if any) - used to exit process after finally() */
     private shutdownSignal?;
     /** Promise that resolves when stdin closes (MCP client disconnects) */

package/dist/commands/mcp.js

@@ -17,7 +17,6 @@
  * |------|--------------|-------------|
  * | `--toolsets` | `SFCC_TOOLSETS` | Comma-separated toolsets to enable (case-insensitive) |
  * | `--tools` | `SFCC_TOOLS` | Comma-separated individual tools to enable (case-insensitive) |
- * | `--allow-non-ga-tools` | `SFCC_ALLOW_NON_GA_TOOLS` | Enable experimental/non-GA tools |
  *
  * ### Environment Variables for Telemetry
  * | Env Variable | Description |
@@ -57,7 +56,6 @@
  *
  * **Note on `--project-directory`**: Many MCP clients (Cursor, Claude Code) spawn servers from the
  * user's home directory (`~`) rather than the project directory. This flag is used for:
- * - Auto-discovery (detecting project type when no `--toolsets` or `--tools` are provided)
  * - Scaffolding tools (creating files in the correct project location)
  * - Any tool that needs to operate on the project directory
  *
@@ -85,40 +83,40 @@
  * ## Toolset Validation
  *
  * - Invalid toolsets are ignored with a warning (server still starts)
- * - If all toolsets are invalid, auto-discovery kicks in
+ * - With no valid selection, all toolsets are enabled
  *
  * @example mcp.json - All toolsets
  * ```json
- * { "args": ["--toolsets", "all", "--allow-non-ga-tools"] }
+ * { "args": ["--toolsets", "all"] }
  * ```
  *
  * @example mcp.json - Specific toolsets
  * ```json
- * { "args": ["--toolsets", "CARTRIDGES,MRT", "--allow-non-ga-tools"] }
+ * { "args": ["--toolsets", "CARTRIDGES,MRT"] }
  * ```
  *
  * @example mcp.json - MRT tools with project, environment, and API key
  * ```json
  * {
- *   "args": ["--toolsets", "MRT", "--project", "my-project", "--environment", "staging", "--allow-non-ga-tools"],
+ *   "args": ["--toolsets", "MRT", "--project", "my-project", "--environment", "staging"],
  *   "env": { "MRT_API_KEY": "your-api-key" }
  * }
  * ```
  *
  * @example mcp.json - MRT tools with staging cloud origin (uses ~/.mobify--cloud-staging.mobify.com)
  * ```json
- * { "args": ["--toolsets", "MRT", "--project", "my-project", "--cloud-origin", "https://cloud-staging.mobify.com", "--allow-non-ga-tools"] }
+ * { "args": ["--toolsets", "MRT", "--project", "my-project", "--cloud-origin", "https://cloud-staging.mobify.com"] }
  * ```
  *
  * @example mcp.json - Cartridge tools with dw.json config
  * ```json
- * { "args": ["--toolsets", "CARTRIDGES", "--config", "/path/to/dw.json", "--allow-non-ga-tools"] }
+ * { "args": ["--toolsets", "CARTRIDGES", "--config", "/path/to/dw.json"] }
  * ```
  *
  * @example mcp.json - Cartridge tools with env vars
  * ```json
  * {
- *   "args": ["--toolsets", "CARTRIDGES", "--allow-non-ga-tools"],
+ *   "args": ["--toolsets", "CARTRIDGES"],
  *   "env": {
  *     "SFCC_HOSTNAME": "your-sandbox.demandware.net",
  *     "SFCC_CLIENT_ID": "your-client-id",
@@ -129,15 +127,14 @@
  *
  * @example mcp.json - Enable debug logging
  * ```json
- * { "args": ["--toolsets", "all", "--allow-non-ga-tools", "--debug"] }
+ * { "args": ["--toolsets", "all", "--debug"] }
  * ```
  */
 import path from 'node:path';
 import { Flags } from '@oclif/core';
 import { BaseCommand, MrtCommand, InstanceCommand, loadConfig, extractInstanceFlags, extractMrtFlags, } from '@salesforce/b2c-tooling-sdk/cli';
+import { serveStdio } from '@modelcontextprotocol/server/stdio';
 import { EnvSource, readProjectEnvironment } from '@salesforce/b2c-tooling-sdk/config';
-// eslint-disable-next-line import/no-unresolved -- SDK 1.30's types export misresolves runtime .js subpaths.
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { B2CDxMcpServer } from '../server.js';
 import { Services } from '../services.js';
 import { ServerContext } from '../server-context.js';
@@ -159,23 +156,23 @@ export default class McpServerCommand extends BaseCommand {
     static examples = [
         {
             description: 'All toolsets',
-            command: '<%= config.bin %> --toolsets all --allow-non-ga-tools',
+            command: '<%= config.bin %> --toolsets all',
         },
         {
             description: 'MRT tools with project and API key',
-            command: '<%= config.bin %> --toolsets MRT --project my-project --api-key your-api-key --allow-non-ga-tools',
+            command: '<%= config.bin %> --toolsets MRT --project my-project --api-key your-api-key',
         },
         {
             description: 'MRT tools with project, environment, and API key',
-            command: '<%= config.bin %> --toolsets MRT --project my-project --environment staging --api-key your-api-key --allow-non-ga-tools',
+            command: '<%= config.bin %> --toolsets MRT --project my-project --environment staging --api-key your-api-key',
         },
         {
             description: 'Cartridge tools with explicit config',
-            command: '<%= config.bin %> --toolsets CARTRIDGES --config /path/to/dw.json --allow-non-ga-tools',
+            command: '<%= config.bin %> --toolsets CARTRIDGES --config /path/to/dw.json',
         },
         {
             description: 'Debug logging',
-            command: '<%= config.bin %> --toolsets all --allow-non-ga-tools --debug',
+            command: '<%= config.bin %> --toolsets all --debug',
         },
     ];
     static flags = {
@@ -187,7 +184,7 @@ export default class McpServerCommand extends BaseCommand {
         ...InstanceCommand.baseFlags,
         // MCP-specific toolset selection flags
         toolsets: Flags.string({
-            description: `Toolsets to enable (comma-separated). Options: all, ${TOOLSETS.join(', ')}`,
+            description: `Toolsets to enable (comma-separated; default: all). Options: all, ${TOOLSETS.join(', ')}`,
             env: 'SFCC_TOOLSETS',
             parse: async (input) => input.toUpperCase(),
         }),
@@ -203,15 +200,7 @@ export default class McpServerCommand extends BaseCommand {
                 'Bounds the whole docs corpus; per-call category/storefront narrow within it. Unknown names are ignored.',
             env: 'SFCC_DOCS_TOPICS',
         }),
-        // Feature flags
-        'allow-non-ga-tools': Flags.boolean({
-            description: 'Enable non-GA (experimental) tools',
-            env: 'SFCC_ALLOW_NON_GA_TOOLS',
-            default: false,
-        }),
     };
-    /** Server-scoped persistent state (debug sessions, log watches, etc.) */
-    serverContext;
     /** Signal that triggered shutdown (if any) - used to exit process after finally() */
     shutdownSignal;
     /** Promise that resolves when stdin closes (MCP client disconnects) */
@@ -363,9 +352,8 @@ export default class McpServerCommand extends BaseCommand {
         const startupFlags = {
             toolsets: this.flags.toolsets ? this.flags.toolsets.split(',').map((s) => s.trim()) : undefined,
             tools: this.flags.tools ? this.flags.tools.split(',').map((s) => s.trim()) : undefined,
-            allowNonGaTools: this.flags['allow-non-ga-tools'],
             configPath: this.flags.config,
-            // Project directory for auto-discovery. oclif handles flag with env fallback.
+            // Default project directory for tool calls. oclif handles the environment fallback.
             projectDirectory: this.flags['project-directory'],
             // Docs topic allowlist (bounds the docs corpus at startup). Flag first
             // (--docs-topics / SFCC_DOCS_TOPICS), else config `docsCategories`
@@ -376,32 +364,49 @@ export default class McpServerCommand extends BaseCommand {
         if (this.telemetry && startupFlags.toolsets) {
             this.telemetry.addAttributes({ toolsets: startupFlags.toolsets.join(', ') });
         }
-        // Create MCP server with telemetry from BaseCommand
-        const server = new B2CDxMcpServer({
-            name: this.config.name,
-            version: this.config.version,
-        }, {
-            capabilities: {
-                resources: {},
-                tools: {},
-            },
-            telemetry: this.telemetry,
-        });
-        // Create server context for persistent state (debug sessions, log watches)
-        this.serverContext = new ServerContext();
-        // Register toolsets with loader function that loads config and creates Services on each tool call
-        // This allows tools to pick up changes to config files (dw.json, ~/.mobify) between invocations
         const loadServices = this.loadServices.bind(this);
-        await registerToolsets(startupFlags, server, loadServices, this.serverContext);
-        // Connect to stdio transport
-        const transport = new StdioServerTransport();
-        await server.connect(transport);
+        let activeServer;
+        const handle = serveStdio(async () => {
+            // A protocol probe may be discarded; each factory instance owns its state.
+            const context = new ServerContext();
+            const server = new B2CDxMcpServer({
+                name: this.config.name,
+                version: this.config.version,
+            }, {
+                capabilities: {
+                    resources: {},
+                    tools: {},
+                },
+                telemetry: this.telemetry,
+                cleanup: () => context.destroyAll(),
+                cacheHints: {
+                    'tools/list': { ttlMs: 300_000, cacheScope: 'private' },
+                    'resources/list': { ttlMs: 300_000, cacheScope: 'private' },
+                    'resources/templates/list': { ttlMs: 300_000, cacheScope: 'private' },
+                    'resources/read': { ttlMs: 300_000, cacheScope: 'private' },
+                },
+                instructions: 'Discover tool schemas before calling. Prefer dedicated tools; otherwise scapi_search/scapi_execute for Commerce APIs. ' +
+                    'Read skill:// URIs as MCP resources, or skill files with skills_read({uri: "<URI>"}) when enabled; not native skill commands. ' +
+                    'SCAPI: first read skill://mcp/scapi/SKILL.md. ' +
+                    'Analytics: cip_discover/cip_query; skill://mcp/cip/SKILL.md. ' +
+                    'Skills: config skill://mcp/b2c-config/SKILL.md; debugging skill://mcp/debugger/SKILL.md; ' +
+                    'setup/toolsets skill://mcp/server/SKILL.md; catalog skill://index (look for b2c-ops runbooks for operations and incidents).',
+            });
+            activeServer = server;
+            await registerToolsets(startupFlags, server, loadServices, context);
+            return server;
+        }, { onerror: (error) => this.logger.error({ err: error }, 'MCP transport error') });
         // Create promise that resolves when server stops (stdin close or signal)
         // This allows finally() to wait for SERVER_STOPPED before stopping telemetry
         this.stdinClosePromise = new Promise((resolve) => {
+            let stopping = false;
             const sendStopAndResolve = (signal) => {
+                if (stopping)
+                    return;
+                stopping = true;
                 this.shutdownSignal = signal;
-                const cleanup = this.serverContext?.destroyAll() ?? Promise.resolve();
+                // EOF may already have started SDK teardown; await the same cleanup before telemetry stops.
+                const cleanup = handle.close().then(() => activeServer?.close());
                 cleanup
                     .catch(() => { })
                     .then(() => {

package/dist/guidance.d.ts

@@ -0,0 +1,6 @@
+import type { B2CDxMcpServer } from './server.js';
+import type { McpTool } from './utils/types.js';
+/** Read-only guidance does not load instance configuration or credentials. */
+export declare function createGuidanceTool(): McpTool;
+/** Advertise an index and featured skills; the template reads the entire available catalog. */
+export declare function registerGuidanceResources(server: B2CDxMcpServer, includeSharedSkills?: boolean): void;

package/dist/guidance.js

@@ -0,0 +1,157 @@
+/*
+ * 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
+ */
+import { ResourceTemplate, ProtocolError, ProtocolErrorCode } from '@modelcontextprotocol/server';
+import { fileURLToPath } from 'node:url';
+import { GuidanceCatalog, GuidanceError, GUIDANCE_INDEX_URI } from '@salesforce/b2c-tooling-sdk/guidance';
+import { z } from 'zod';
+import { TOOLSETS } from './utils/constants.js';
+const inputSchema = {
+    workspace: z
+        .enum(['cartridges', 'sfra', 'pwa-kit-v3', 'storefront-next'])
+        .optional()
+        .describe('Optional storefront ranking preference; no project detection.'),
+    query: z.string().trim().min(1).max(512).optional().describe('Search skills; returns five hits by default.'),
+    id: z.string().min(1).max(256).optional().describe('Exact skill ID from discovery.'),
+    uri: z.string().max(1024).optional().describe('Skill resource URI; replaces id and file.'),
+    file: z.string().max(512).optional().describe('Relative reference path listed by an entrypoint.'),
+    section: z.string().max(256).optional().describe('Exact heading ID returned by a read.'),
+    collection: z.string().max(128).optional().describe('Filter by collection.'),
+    limit: z.number().int().min(1).max(20).optional().describe('Page size: directory 20, search 5; maximum 20.'),
+    maxLength: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe('Read character limit; defaults to the full file or section.'),
+    offset: z
+        .number()
+        .int()
+        .nonnegative()
+        .optional()
+        .describe('Entry offset for discovery; character offset for reads. Default 0.'),
+};
+const collectionSchema = z.object({
+    id: z.string(),
+    title: z.string(),
+    isGA: z.boolean(),
+    workspaces: z.array(z.string()).optional(),
+});
+const pageFields = {
+    collections: z.array(collectionSchema),
+    entries: z.array(z.object({
+        id: z.string(),
+        title: z.string(),
+        description: z.string(),
+        uri: z.string(),
+        score: z.number().optional(),
+    })),
+    total: z.number().int(),
+    offset: z.number().int(),
+    nextOffset: z.number().int().optional(),
+};
+const outputSchema = {
+    result: z.discriminatedUnion('kind', [
+        z.object({ kind: z.literal('directory'), ...pageFields }),
+        z.object({ kind: z.literal('search'), ...pageFields }),
+        z.object({
+            kind: z.literal('read'),
+            id: z.string(),
+            uri: z.string(),
+            source: z.string(),
+            content: z.string(),
+            totalLength: z.number().int(),
+            offset: z.number().int(),
+            truncated: z.boolean().optional(),
+            nextOffset: z.number().int().optional(),
+            sections: z.array(z.object({ id: z.string(), title: z.string() })),
+            references: z.array(z.string()),
+        }),
+    ]),
+};
+function catalogLoader(collections) {
+    let catalog;
+    return () => {
+        catalog ??= new GuidanceCatalog(fileURLToPath(new URL('../content/guidance/', import.meta.url)), {
+            allowNonGa: true,
+            collections,
+        });
+        return catalog;
+    };
+}
+function errorResult(error) {
+    const detail = error instanceof GuidanceError
+        ? error
+        : new GuidanceError('SKILLS_UNAVAILABLE', 'Packaged skills are unavailable. Rebuild or reinstall the MCP.');
+    const structuredContent = {
+        error: {
+            code: detail.code,
+            message: detail.message,
+            ...(detail.sections
+                ? { sections: detail.sections }
+                : { suggestions: ['Use skills_read({}) to discover available IDs.'] }),
+        },
+    };
+    return { isError: true, structuredContent, content: [{ type: 'text', text: JSON.stringify(structuredContent) }] };
+}
+/** Read-only guidance does not load instance configuration or credentials. */
+export function createGuidanceTool() {
+    const getCatalog = catalogLoader();
+    return {
+        name: 'skills_read',
+        effect: 'read',
+        idempotent: true,
+        openWorld: false,
+        title: 'Read B2C Skills',
+        description: 'Read skill files: b2c (development), b2c-cli, b2c-ops (operations), storefront-next, mcp (setup/workflows). MCP resource fallback and full catalog. Omit args to list; query to search; collection to filter; id or uri to read.',
+        inputSchema,
+        outputSchema,
+        toolsets: [...TOOLSETS],
+        async handler(args) {
+            const parsed = z.object(inputSchema).strict().safeParse(args);
+            if (!parsed.success)
+                return errorResult(new GuidanceError('INVALID_REQUEST', parsed.error.issues.map((issue) => `${issue.path.join('.')}: ${issue.message}`).join('; ')));
+            try {
+                const structuredContent = { result: getCatalog().read(parsed.data) };
+                return { structuredContent, content: [{ type: 'text', text: JSON.stringify(structuredContent) }] };
+            }
+            catch (error) {
+                return errorResult(error);
+            }
+        },
+    };
+}
+/** Advertise an index and featured skills; the template reads the entire available catalog. */
+export function registerGuidanceResources(server, includeSharedSkills = true) {
+    const catalog = catalogLoader(includeSharedSkills ? undefined : ['mcp'])();
+    const read = async (uri) => {
+        try {
+            return { contents: [{ uri, mimeType: 'text/markdown', text: catalog.readResource(uri) }] };
+        }
+        catch (error) {
+            const detail = error instanceof GuidanceError
+                ? error
+                : new GuidanceError('SKILLS_UNAVAILABLE', 'Packaged skills are unavailable.');
+            throw new ProtocolError(ProtocolErrorCode.InvalidParams, detail.message, { code: detail.code });
+        }
+    };
+    server.registerResource('skill-index', GUIDANCE_INDEX_URI, {
+        title: 'B2C Skill Index',
+        description: 'Available skills by collection, with summaries and file URIs.',
+        mimeType: 'text/markdown',
+    }, async (uri) => read(uri.toString()));
+    for (const resource of catalog.resources()) {
+        server.registerResource(resource.name, resource.uri, { title: resource.title, description: resource.description, mimeType: resource.mimeType }, async (uri) => read(uri.toString()));
+    }
+    server.registerResource('skill-file', new ResourceTemplate('skill://{collection}/{entry}/{+path}', { list: undefined }), {
+        title: 'B2C Skill Files',
+        description: includeSharedSkills
+            ? 'Available skills and references. Discover file URIs in skill://index or skills_read results.'
+            : 'MCP skills and references. Discover file URIs in skill://index.',
+        mimeType: 'text/markdown',
+    }, async (uri) => read(uri.toString()));
+    server.addResourceReader('skill://', read);
+}
+//# sourceMappingURL=guidance.js.map

package/dist/registry.d.ts

@@ -1,4 +1,4 @@
-import { type ProjectType } from '@salesforce/b2c-tooling-sdk/discovery';
+import type { ProjectType } from '@salesforce/b2c-tooling-sdk/discovery';
 import { type DocCategory } from '@salesforce/b2c-tooling-sdk/docs';
 import type { McpTool, Toolset, StartupFlags } from './utils/index.js';
 import type { B2CDxMcpServer } from './server.js';
@@ -18,4 +18,5 @@ export type ToolRegistry = Record<Toolset, McpTool[]>;
  * @returns Complete tool registry
  */
 export declare function createToolRegistry(loadServices: ServicesLoader, serverContext?: ServerContext, detectedWorkspaces?: readonly ProjectType[], enabledDocCategories?: readonly DocCategory[]): ToolRegistry;
+/** Register all toolsets by default, or only explicitly selected toolsets/tools. */
 export declare function registerToolsets(flags: StartupFlags, server: B2CDxMcpServer, loadServices: ServicesLoader, serverContext?: ServerContext): Promise<void>;