@webiny/mcp 6.2.0 → 6.3.0-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webiny/mcp",
-	"version": "6.2.0",
+	"version": "6.3.0-beta.0",
 	"type": "module",
 	"main": "./index.js",
 	"bin": {
@@ -25,13 +25,13 @@
 	"devDependencies": {
 		"@types/lodash": "4.17.24",
 		"@types/ncp": "2.0.8",
-		"@webiny/build-tools": "6.2.0",
+		"@webiny/build-tools": "6.3.0-beta.0",
 		"execa": "5.1.1",
 		"tsx": "4.21.0",
-		"typescript": "5.9.3"
+		"typescript": "6.0.3"
 	},
 	"scripts": {
 		"prepublishOnly": "bash ./prepublishOnly.sh"
 	},
-	"gitHead": "3d3148358b6febbc857371930871743bec3b3939"
+	"gitHead": "94c21e58aebc9855bf1ae972423281faa0f5c135"
 }

package/skills/admin/admin-architect/SKILL.md

@@ -317,27 +317,27 @@ import { makeAutoObservable, runInAction } from "mobx";
 import { WcpService as ServiceAbstraction, WcpGateway } from "./abstractions.js";
 
 class WcpServiceImpl implements ServiceAbstraction.Interface {
-    private project: ILicense | null = null;
+  private project: ILicense | null = null;
 
-    constructor(private gateway: WcpGateway.Interface) {
-        makeAutoObservable(this);
-    }
+  constructor(private gateway: WcpGateway.Interface) {
+    makeAutoObservable(this);
+  }
 
-    getProject(): ILicense {
-        return this.project;
-    }
+  getProject(): ILicense {
+    return this.project;
+  }
 
-    async loadProject(): Promise<void> {
-        const data = await this.gateway.fetchProject();
-        runInAction(() => {
-            this.project = data;
-        });
-    }
+  async loadProject(): Promise<void> {
+    const data = await this.gateway.fetchProject();
+    runInAction(() => {
+      this.project = data;
+    });
+  }
 }
 
 export const WcpService = ServiceAbstraction.createImplementation({
-    implementation: WcpServiceImpl,
-    dependencies: [WcpGateway]
+  implementation: WcpServiceImpl,
+  dependencies: [WcpGateway]
 });
 ```
 
@@ -352,37 +352,37 @@ Repositories own domain data and cache. They use MobX for reactivity:
 ```ts
 import { makeAutoObservable, runInAction } from "mobx";
 import {
-    NextjsConfigRepository as RepositoryAbstraction,
-    NextjsConfigGateway,
-    NextjsConfig
+  NextjsConfigRepository as RepositoryAbstraction,
+  NextjsConfigGateway,
+  NextjsConfig
 } from "./abstractions.js";
 
 class NextjsConfigRepositoryImpl implements RepositoryAbstraction.Interface {
-    private config: NextjsConfig | undefined = undefined;
-
-    constructor(private gateway: NextjsConfigGateway.Interface) {
-        makeAutoObservable(this);
-    }
+  private config: NextjsConfig | undefined = undefined;
 
-    getConfig(): NextjsConfig | undefined {
-        return this.config;
-    }
+  constructor(private gateway: NextjsConfigGateway.Interface) {
+    makeAutoObservable(this);
+  }
 
-    async loadConfig(): Promise<void> {
-        if (this.config) {
-            return; // Already loaded — cache hit
-        }
+  getConfig(): NextjsConfig | undefined {
+    return this.config;
+  }
 
-        const config = await this.gateway.getConfig();
-        runInAction(() => {
-            this.config = config;
-        });
+  async loadConfig(): Promise<void> {
+    if (this.config) {
+      return; // Already loaded — cache hit
     }
+
+    const config = await this.gateway.getConfig();
+    runInAction(() => {
+      this.config = config;
+    });
+  }
 }
 
 export const NextjsConfigRepository = RepositoryAbstraction.createImplementation({
-    implementation: NextjsConfigRepositoryImpl,
-    dependencies: [NextjsConfigGateway]
+  implementation: NextjsConfigRepositoryImpl,
+  dependencies: [NextjsConfigGateway]
 });
 ```
 
@@ -395,48 +395,53 @@ import { NextjsConfigGateway as GatewayAbstraction } from "./abstractions.js";
 import { GraphQLClient } from "@webiny/app/features/graphqlClient";
 
 const GET_NEXTJS_CONFIG = /* GraphQL */ `
-    query GetNextjsConfig {
-        websiteBuilder {
-            getNextjsConfig {
-                data
-                error { code message data }
-            }
+  query GetNextjsConfig {
+    websiteBuilder {
+      getNextjsConfig {
+        data
+        error {
+          code
+          message
+          data
         }
+      }
     }
+  }
 `;
 
 type GetNextjsConfigResponse = {
-    websiteBuilder: {
-        getNextjsConfig:
-            | { data: string; error: null }
-            | { data: null; error: { code: string; message: string; data: any } };
-    };
+  websiteBuilder: {
+    getNextjsConfig:
+      | { data: string; error: null }
+      | { data: null; error: { code: string; message: string; data: any } };
+  };
 };
 
 class NextjsGraphQLGateway implements GatewayAbstraction.Interface {
-    constructor(private client: GraphQLClient.Interface) {}
-
-    async getConfig(): Promise<string> {
-        const response = await this.client.execute<GetNextjsConfigResponse>({
-            query: GET_NEXTJS_CONFIG
-        });
+  constructor(private client: GraphQLClient.Interface) {}
 
-        const envelope = response.websiteBuilder.getNextjsConfig;
-        if (envelope.error) {
-            throw new Error(envelope.error.message);
-        }
+  async getConfig(): Promise<string> {
+    const response = await this.client.execute<GetNextjsConfigResponse>({
+      query: GET_NEXTJS_CONFIG
+    });
 
-        return envelope.data;
+    const envelope = response.websiteBuilder.getNextjsConfig;
+    if (envelope.error) {
+      throw new Error(envelope.error.message);
     }
+
+    return envelope.data;
+  }
 }
 
 export const NextjsConfigGateway = GatewayAbstraction.createImplementation({
-    implementation: NextjsGraphQLGateway,
-    dependencies: [GraphQLClient]
+  implementation: NextjsGraphQLGateway,
+  dependencies: [GraphQLClient]
 });
 ```
 
 **Key points:**
+
 - Define the GraphQL query as a string constant with `/* GraphQL */` comment for syntax highlighting
 - Type the response shape explicitly
 - Handle the `data`/`error` envelope pattern
@@ -450,12 +455,12 @@ When grouping related features, create a composite with no `resolve`:
 import { createFeature } from "webiny/admin";
 
 export const FoldersFeature = createFeature({
-    name: "Folders",
-    register(container) {
-        CreateFolderFeature.register(container);
-        UpdateFolderFeature.register(container);
-        DeleteFolderFeature.register(container);
-    }
+  name: "Folders",
+  register(container) {
+    CreateFolderFeature.register(container);
+    UpdateFolderFeature.register(container);
+    DeleteFolderFeature.register(container);
+  }
 });
 ```
 
@@ -465,17 +470,14 @@ Decorators add cross-cutting concerns without modifying the core implementation:
 
 ```ts
 class ListFoldersUseCaseWithLoading implements UseCaseAbstraction.Interface {
-    constructor(
-        private loadingRepository: FoldersLoadingRepository.Interface,
-        private decoratee: UseCaseAbstraction.Interface  // decoratee is LAST
-    ) {}
-
-    async execute() {
-        await this.loadingRepository.runCallBack(
-            this.decoratee.execute(),
-            LoadingActionsEnum.list
-        );
-    }
+  constructor(
+    private loadingRepository: FoldersLoadingRepository.Interface,
+    private decoratee: UseCaseAbstraction.Interface // decoratee is LAST
+  ) {}
+
+  async execute() {
+    await this.loadingRepository.runCallBack(this.decoratee.execute(), LoadingActionsEnum.list);
+  }
 }
 ```
 
@@ -483,14 +485,15 @@ Register with `container.registerDecorator()`:
 
 ```ts
 export const MyExtensionFeature = createFeature({
-    name: "MyExtension",
-    register(container) {
-        container.registerDecorator(MyPresenterDecorator);
-    }
+  name: "MyExtension",
+  register(container) {
+    container.registerDecorator(MyPresenterDecorator);
+  }
 });
 ```
 
 **Rules:**
+
 - Implements the same interface as the decorated abstraction
 - Constructor: extra dependencies first, `decoratee` **last**
 - The `dependencies` array does NOT include the decoratee

package/skills/api/event-handler-pattern/SKILL.md

@@ -90,7 +90,9 @@ class MyHandler implements SomeEventHandler.Interface {
   constructor(private someUseCase: SomeUseCase.Interface) {}
 
   async handle(event: SomeEventHandler.Event) {
-    const result = await this.someUseCase.execute({ /* ... */ });
+    const result = await this.someUseCase.execute({
+      /* ... */
+    });
   }
 }
 
@@ -120,30 +122,30 @@ import type { EntityBeforeDisableEvent, EntityAfterDisableEvent } from "./events
 
 // Event Payload Types
 export interface EntityBeforeDisablePayload {
-    entity: Entity;
+  entity: Entity;
 }
 
 export interface EntityAfterDisablePayload {
-    entity: Entity;
+  entity: Entity;
 }
 
 // Handler Abstractions — one per event
 export const EntityBeforeDisableEventHandler = createAbstraction<
-    IEventHandler<EntityBeforeDisableEvent>
+  IEventHandler<EntityBeforeDisableEvent>
 >("MyPackage/EntityBeforeDisableEventHandler");
 
 export namespace EntityBeforeDisableEventHandler {
-    export type Interface = IEventHandler<EntityBeforeDisableEvent>;
-    export type Event = EntityBeforeDisableEvent;
+  export type Interface = IEventHandler<EntityBeforeDisableEvent>;
+  export type Event = EntityBeforeDisableEvent;
 }
 
 export const EntityAfterDisableEventHandler = createAbstraction<
-    IEventHandler<EntityAfterDisableEvent>
+  IEventHandler<EntityAfterDisableEvent>
 >("MyPackage/EntityAfterDisableEventHandler");
 
 export namespace EntityAfterDisableEventHandler {
-    export type Interface = IEventHandler<EntityAfterDisableEvent>;
-    export type Event = EntityAfterDisableEvent;
+  export type Interface = IEventHandler<EntityAfterDisableEvent>;
+  export type Event = EntityAfterDisableEvent;
 }
 ```
 
@@ -154,29 +156,23 @@ Event classes import payload types and handler abstractions from `abstractions.t
 ```ts
 // features/disableEntity/events.ts
 import { DomainEvent } from "@webiny/api-core/features/EventPublisher";
-import {
-    EntityBeforeDisableEventHandler,
-    EntityAfterDisableEventHandler
-} from "./abstractions.js";
-import type {
-    EntityBeforeDisablePayload,
-    EntityAfterDisablePayload
-} from "./abstractions.js";
+import { EntityBeforeDisableEventHandler, EntityAfterDisableEventHandler } from "./abstractions.js";
+import type { EntityBeforeDisablePayload, EntityAfterDisablePayload } from "./abstractions.js";
 
 export class EntityBeforeDisableEvent extends DomainEvent<EntityBeforeDisablePayload> {
-    eventType = "entity.beforeDisable" as const;
+  eventType = "entity.beforeDisable" as const;
 
-    getHandlerAbstraction() {
-        return EntityBeforeDisableEventHandler;
-    }
+  getHandlerAbstraction() {
+    return EntityBeforeDisableEventHandler;
+  }
 }
 
 export class EntityAfterDisableEvent extends DomainEvent<EntityAfterDisablePayload> {
-    eventType = "entity.afterDisable" as const;
+  eventType = "entity.afterDisable" as const;
 
-    getHandlerAbstraction() {
-        return EntityAfterDisableEventHandler;
-    }
+  getHandlerAbstraction() {
+    return EntityAfterDisableEventHandler;
+  }
 }
 ```
 
@@ -188,35 +184,35 @@ import { EventPublisher } from "@webiny/api-core/features/EventPublisher";
 import { EntityBeforeDisableEvent, EntityAfterDisableEvent } from "./events.js";
 
 class DisableEntityUseCase implements UseCaseAbstraction.Interface {
-    constructor(
-        private eventPublisher: EventPublisher.Interface,
-        private getEntityById: GetEntityByIdUseCase.Interface,
-        private updateEntity: UpdateEntityUseCase.Interface
-    ) {}
+  constructor(
+    private eventPublisher: EventPublisher.Interface,
+    private getEntityById: GetEntityByIdUseCase.Interface,
+    private updateEntity: UpdateEntityUseCase.Interface
+  ) {}
 
-    async execute(entityId: string): Promise<Result<void, UseCaseAbstraction.Error>> {
-        const getResult = await this.getEntityById.execute(entityId);
-        if (getResult.isFail()) return Result.fail(getResult.error);
+  async execute(entityId: string): Promise<Result<void, UseCaseAbstraction.Error>> {
+    const getResult = await this.getEntityById.execute(entityId);
+    if (getResult.isFail()) return Result.fail(getResult.error);
 
-        const entity = getResult.value;
+    const entity = getResult.value;
 
-        // Publish BEFORE event (can be intercepted to reject)
-        await this.eventPublisher.publish(new EntityBeforeDisableEvent({ entity }));
+    // Publish BEFORE event (can be intercepted to reject)
+    await this.eventPublisher.publish(new EntityBeforeDisableEvent({ entity }));
 
-        // Perform the operation
-        const updateResult = await this.updateEntity.execute(entityId, { status: "disabled" });
-        if (updateResult.isFail()) return Result.fail(updateResult.error);
+    // Perform the operation
+    const updateResult = await this.updateEntity.execute(entityId, { status: "disabled" });
+    if (updateResult.isFail()) return Result.fail(updateResult.error);
 
-        // Publish AFTER event (for side effects)
-        await this.eventPublisher.publish(new EntityAfterDisableEvent({ entity: updateResult.value }));
+    // Publish AFTER event (for side effects)
+    await this.eventPublisher.publish(new EntityAfterDisableEvent({ entity: updateResult.value }));
 
-        return Result.ok();
-    }
+    return Result.ok();
+  }
 }
 
 export default UseCaseAbstraction.createImplementation({
-    implementation: DisableEntityUseCase,
-    dependencies: [EventPublisher, GetEntityByIdUseCase, UpdateEntityUseCase]
+  implementation: DisableEntityUseCase,
+  dependencies: [EventPublisher, GetEntityByIdUseCase, UpdateEntityUseCase]
 });
 ```
 
@@ -233,23 +229,23 @@ import { CleanupService } from "../cleanupService/abstractions.js";
 import { MY_MODEL_ID } from "~/shared/constants.js";
 
 class CleanupOnEntryDeleteHandler implements EntryAfterDeleteEventHandler.Interface {
-    constructor(private cleanupService: CleanupService.Interface) {}
+  constructor(private cleanupService: CleanupService.Interface) {}
 
-    async handle(event: EntryAfterDeleteEventHandler.Event): Promise<void> {
-        const { entry, model } = event.payload;
+  async handle(event: EntryAfterDeleteEventHandler.Event): Promise<void> {
+    const { entry, model } = event.payload;
 
-        // ALWAYS filter by model — handler fires for ALL models
-        if (model.modelId !== MY_MODEL_ID) return;
+    // ALWAYS filter by model — handler fires for ALL models
+    if (model.modelId !== MY_MODEL_ID) return;
 
-        if (!event.payload.permanent) return;
+    if (!event.payload.permanent) return;
 
-        await this.cleanupService.cleanup(entry.entryId);
-    }
+    await this.cleanupService.cleanup(entry.entryId);
+  }
 }
 
 export default EntryAfterDeleteEventHandler.createImplementation({
-    implementation: CleanupOnEntryDeleteHandler,
-    dependencies: [CleanupService]
+  implementation: CleanupOnEntryDeleteHandler,
+  dependencies: [CleanupService]
 });
 ```
 
@@ -257,11 +253,11 @@ export default EntryAfterDeleteEventHandler.createImplementation({
 
 ## Event Naming Conventions
 
-| Artifact           | Pattern                                        | Example                            |
-| ------------------ | ---------------------------------------------- | ---------------------------------- |
-| `eventType`        | `"entity.beforeAction"` / `"entity.afterAction"` | `"tenant.beforeDisable"`          |
-| Handler abstraction | `{Entity}{Before\|After}{Action}EventHandler` | `TenantBeforeDisableEventHandler` |
-| Event class        | `{Entity}{Before\|After}{Action}Event`         | `TenantBeforeDisableEvent`        |
+| Artifact            | Pattern                                          | Example                           |
+| ------------------- | ------------------------------------------------ | --------------------------------- |
+| `eventType`         | `"entity.beforeAction"` / `"entity.afterAction"` | `"tenant.beforeDisable"`          |
+| Handler abstraction | `{Entity}{Before\|After}{Action}EventHandler`    | `TenantBeforeDisableEventHandler` |
+| Event class         | `{Entity}{Before\|After}{Action}Event`           | `TenantBeforeDisableEvent`        |
 
 ## Registration
 

package/skills/api/http-route/SKILL.md

@@ -106,7 +106,6 @@ reply.code(201).header("X-Custom", "value").send({ created: true });
 The `<Api.Route>` extension does two things at build/deploy time:
 
 1. **Build time** — injects two entries into `apps/api/graphql/src/extensions.ts`:
-
    - A `createContextPlugin` that registers your handler in the DI container
    - A `createRoute` that registers the Fastify route with the hardcoded `path` and `method`