@project-chip/matter.js 0.12.6-alpha.0-20250304-03716637c → 0.13.0-alpha.0-20250307-ebf84a05a

package/src/cluster/server/AccessControlServer.ts

@@ -1,342 +0,0 @@
-/**
- * @license
- * Copyright 2022-2025 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { AccessControl, AccessControlCluster } from "#clusters";
-import { InternalError, isDeepEqual, Logger, SyncStorage } from "#general";
-import { MatterDevice } from "#MatterDevice.js";
-import {
-    AclExtensionEntry,
-    assertSecureSession,
-    FabricSensitiveEventServer,
-    genericFabricScopedAttributeGetter,
-    genericFabricScopedAttributeGetterFromFabric,
-    genericFabricScopedAttributeSetterForFabric,
-} from "#protocol";
-import {
-    CaseAuthenticatedTag,
-    ClusterId,
-    DeviceTypeId,
-    EndpointNumber,
-    GroupId,
-    NodeId,
-    StatusCode,
-    StatusResponseError,
-    TlvTaggedList,
-    TlvType,
-    TypeFromBitmapSchema,
-} from "#types";
-import { ClusterServer } from "./ClusterServer.js";
-import { ClusterServerHandlers } from "./ClusterServerTypes.js";
-
-const logger = Logger.get("AccessControlClusterServer");
-
-export const AccessControlClusterHandler: () => ClusterServerHandlers<typeof AccessControlCluster> = () => {
-    let accessControlEntryChangedEvent:
-        | FabricSensitiveEventServer<AccessControl.AccessControlEntryChangedEvent, SyncStorage>
-        | undefined = undefined;
-    let accessControlExtensionChangedEvent:
-        | FabricSensitiveEventServer<AccessControl.AccessControlExtensionChangedEvent, SyncStorage>
-        | undefined = undefined;
-
-    return {
-        initializeClusterServer: ({ events: { accessControlEntryChanged, accessControlExtensionChanged } }) => {
-            if (accessControlEntryChanged !== undefined) {
-                accessControlEntryChangedEvent = accessControlEntryChanged;
-            }
-            if (accessControlExtensionChanged !== undefined) {
-                accessControlExtensionChangedEvent = accessControlExtensionChanged;
-            }
-        },
-
-        aclAttributeGetter: ({ session, isFabricFiltered }) => {
-            return genericFabricScopedAttributeGetter(
-                session,
-                !!isFabricFiltered,
-                AccessControlCluster,
-                "acl",
-                new Array<TypeFromBitmapSchema<typeof AccessControl.TlvAccessControlEntry>>(),
-                MatterDevice.of(session).getFabrics(),
-            );
-        },
-
-        aclAttributeValidator: (
-            value,
-            {
-                attributes: {
-                    accessControlEntriesPerFabric,
-                    subjectsPerAccessControlEntry,
-                    targetsPerAccessControlEntry,
-                },
-            },
-        ) => {
-            if (value.length > accessControlEntriesPerFabric.getLocal()) {
-                throw new StatusResponseError("AccessControlEntriesPerFabric exceeded", StatusCode.ResourceExhausted);
-            }
-
-            for (const entry of value) {
-                const { subjects, targets, privilege, authMode } = entry;
-                if (privilege < 1 || privilege > 5) {
-                    throw new StatusResponseError(
-                        "Privilege must be a valid enum value between 1 and 5",
-                        StatusCode.ConstraintError,
-                    );
-                }
-                if (authMode < 1 || authMode > 3) {
-                    throw new StatusResponseError(
-                        "AuthMode must be a valid enum value between 1 and 3",
-                        StatusCode.ConstraintError,
-                    );
-                }
-
-                if (subjects !== null && subjects.length > subjectsPerAccessControlEntry.getLocal()) {
-                    throw new StatusResponseError(
-                        "SubjectsPerAccessControlEntry exceeded",
-                        StatusCode.ResourceExhausted,
-                    );
-                }
-
-                if (targets !== null && targets.length > targetsPerAccessControlEntry.getLocal()) {
-                    throw new StatusResponseError(
-                        "TargetsPerAccessControlEntry exceeded",
-                        StatusCode.ResourceExhausted,
-                    );
-                }
-
-                if (authMode === AccessControl.AccessControlEntryAuthMode.Pase) {
-                    throw new StatusResponseError("AuthMode for ACL must not be PASE", StatusCode.ConstraintError);
-                } else if (authMode === AccessControl.AccessControlEntryAuthMode.Case) {
-                    if (subjects !== null) {
-                        for (const subject of subjects) {
-                            if (NodeId.isCaseAuthenticatedTag(subject)) {
-                                const cat = NodeId.extractAsCaseAuthenticatedTag(subject);
-                                if (CaseAuthenticatedTag.getVersion(cat) === 0) {
-                                    throw new StatusResponseError(
-                                        "CaseAuthenticatedTag version 0 is not allowed",
-                                        StatusCode.ConstraintError,
-                                    );
-                                }
-                            } else if (!NodeId.isOperationalNodeId(subject)) {
-                                throw new StatusResponseError(
-                                    "Subject must be a valid OperationalNodeId or CaseAuthenticatedTag",
-                                    StatusCode.ConstraintError,
-                                );
-                            }
-                        }
-                    }
-                } else if (authMode === AccessControl.AccessControlEntryAuthMode.Group) {
-                    if (privilege === AccessControl.AccessControlEntryPrivilege.Administer) {
-                        throw new StatusResponseError(
-                            "Group ACLs must not have Administer privilege",
-                            StatusCode.ConstraintError,
-                        );
-                    }
-
-                    if (subjects !== null) {
-                        for (const subject of subjects) {
-                            if (GroupId(subject) === GroupId.UNSPECIFIED_GROUP_ID) {
-                                throw new StatusResponseError(
-                                    "Subject must be a valid GroupId for Group ACLs",
-                                    StatusCode.ConstraintError,
-                                );
-                            }
-                        }
-                    }
-                    // TODO For Group authentication, the Group ID identifies the required group, as defined in the Group Key Management Cluster.
-                }
-
-                if (targets !== null) {
-                    for (const target of targets) {
-                        const { deviceType, endpoint, cluster } = target;
-                        if (deviceType !== null && endpoint !== null) {
-                            throw new StatusResponseError(
-                                "DeviceType and Endpoint are mutually exclusive",
-                                StatusCode.ConstraintError,
-                            );
-                        }
-                        if (cluster === null && endpoint === null && deviceType === null) {
-                            throw new StatusResponseError(
-                                "At least one field must be present",
-                                StatusCode.ConstraintError,
-                            );
-                        }
-                        if (cluster !== null && !ClusterId.isValid(cluster)) {
-                            throw new StatusResponseError(
-                                "Cluster must be a valid ClusterId",
-                                StatusCode.ConstraintError,
-                            );
-                        }
-                        if (endpoint !== null && !EndpointNumber.isValid(endpoint)) {
-                            throw new StatusResponseError(
-                                "Endpoint must be a valid OperationalNodeId",
-                                StatusCode.ConstraintError,
-                            );
-                        }
-                        if (deviceType !== null && !DeviceTypeId.isValid(deviceType)) {
-                            throw new StatusResponseError(
-                                "DeviceType must be a valid DeviceType",
-                                StatusCode.ConstraintError,
-                            );
-                        }
-                    }
-                }
-            }
-        },
-
-        aclAttributeSetter: (value, { session }) => {
-            assertSecureSession(session);
-            // it can happen internally that we set a value for another fabricIndex, so handle this here
-            const fabric = MatterDevice.of(session).getFabricByIndex(
-                value[0]?.fabricIndex ?? session.associatedFabric.fabricIndex,
-            );
-            if (fabric === undefined) {
-                throw new InternalError("Fabric not found. SHould never happen");
-            }
-            const oldValue =
-                genericFabricScopedAttributeGetterFromFabric(
-                    fabric,
-                    AccessControlCluster,
-                    "acl",
-                    new Array<TypeFromBitmapSchema<typeof AccessControl.TlvAccessControlEntry>>(),
-                ) ?? [];
-
-            const changed = genericFabricScopedAttributeSetterForFabric(fabric, AccessControlCluster, "acl", value, []);
-
-            if (changed && accessControlEntryChangedEvent !== undefined) {
-                const adminPasscodeId = session.isPase ? 0 : null;
-                const adminNodeId = adminPasscodeId === null ? session.associatedFabric.rootNodeId : null;
-
-                let i = 0;
-                for (; i < value.length; i++) {
-                    if (!isDeepEqual(value[i], oldValue[i])) {
-                        const changeType =
-                            oldValue[i] === undefined
-                                ? AccessControl.ChangeType.Added
-                                : value[i] === undefined
-                                  ? AccessControl.ChangeType.Removed
-                                  : AccessControl.ChangeType.Changed;
-                        accessControlEntryChangedEvent.triggerEvent({
-                            changeType,
-                            adminNodeId,
-                            adminPasscodeId,
-                            latestValue:
-                                (changeType === AccessControl.ChangeType.Removed ? oldValue[i] : value[i]) ?? null,
-                            fabricIndex: session.associatedFabric.fabricIndex,
-                        });
-                    }
-                }
-                if (oldValue.length > i) {
-                    for (let j = oldValue.length - 1; j >= i; j--) {
-                        accessControlEntryChangedEvent.triggerEvent({
-                            changeType: AccessControl.ChangeType.Removed,
-                            adminNodeId,
-                            adminPasscodeId,
-                            latestValue: oldValue[j],
-                            fabricIndex: session.associatedFabric.fabricIndex,
-                        });
-                    }
-                }
-            }
-            return changed;
-        },
-
-        extensionAttributeGetter: ({ session }) => {
-            return genericFabricScopedAttributeGetter(
-                session,
-                true,
-                AccessControlCluster,
-                "extension",
-                new Array<AclExtensionEntry>(),
-                MatterDevice.of(session).getFabrics(),
-            );
-        },
-
-        extensionAttributeValidator: value => {
-            if (value.length === 0) {
-                return;
-            }
-            if (value.length > 1) {
-                throw new StatusResponseError("Extension list must contain a single entry", StatusCode.ConstraintError);
-            }
-
-            // we have exactly one entry
-            const { data } = value[0];
-            if (data.length < 2 || data[0] !== TlvType.List || data[data.length - 1] !== TlvType.EndOfContainer) {
-                // Easier to check that way that it is an Listen without any tags in general
-                throw new StatusResponseError("Extension must be a valid TLV", StatusCode.ConstraintError);
-            }
-            try {
-                const decoded = TlvTaggedList({}, true).decode(data);
-                logger.info(`Extension TLV decoded:`, decoded);
-            } catch (error) {
-                logger.debug(`Extension TLV decoding failed:`, error);
-                throw new StatusResponseError("Extension must be a valid TLV", StatusCode.ConstraintError);
-            }
-        },
-
-        extensionAttributeSetter: (value, { session }) => {
-            assertSecureSession(session);
-            // it can happen internally that we set a value for another fabricIndex, so handle this here
-            const fabric = MatterDevice.of(session).getFabricByIndex(
-                value[0]?.fabricIndex ?? session.associatedFabric.fabricIndex,
-            );
-            if (fabric === undefined) {
-                throw new InternalError("Fabric not found. Should never happen");
-            }
-            const oldValue =
-                genericFabricScopedAttributeGetterFromFabric(
-                    fabric,
-                    AccessControlCluster,
-                    "extension",
-                    new Array<AclExtensionEntry>(),
-                ) ?? [];
-
-            const changed = genericFabricScopedAttributeSetterForFabric(
-                fabric,
-                AccessControlCluster,
-                "extension",
-                value,
-                [],
-            );
-
-            if (changed && accessControlExtensionChangedEvent !== undefined) {
-                const changeType =
-                    value.length > oldValue.length
-                        ? AccessControl.ChangeType.Added
-                        : value.length < oldValue.length
-                          ? AccessControl.ChangeType.Removed
-                          : AccessControl.ChangeType.Changed;
-                const adminPasscodeId = session.isPase ? 0 : null;
-                const adminNodeId = adminPasscodeId === null ? session.associatedFabric.rootNodeId : null;
-                accessControlExtensionChangedEvent.triggerEvent({
-                    changeType,
-                    adminNodeId,
-                    adminPasscodeId,
-                    latestValue: (changeType === AccessControl.ChangeType.Removed ? oldValue[0] : value[0]) ?? null,
-                    fabricIndex: session.associatedFabric.fabricIndex,
-                });
-            }
-
-            return changed;
-        },
-    };
-};
-
-export const createDefaultAccessControlClusterServer = () =>
-    ClusterServer(
-        AccessControlCluster,
-        {
-            acl: [],
-            extension: [],
-            subjectsPerAccessControlEntry: 4,
-            targetsPerAccessControlEntry: 4,
-            accessControlEntriesPerFabric: 4,
-        },
-        AccessControlClusterHandler(),
-        {
-            accessControlEntryChanged: true,
-            accessControlExtensionChanged: true,
-        },
-    );

package/src/cluster/server/AdministratorCommissioningServer.ts

@@ -1,305 +0,0 @@
-/**
- * @license
- * Copyright 2022-2025 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { AdministratorCommissioning } from "#clusters";
-import { InternalError, Logger, Time, Timer } from "#general";
-import { MatterDevice } from "#MatterDevice.js";
-import { AccessLevel } from "#model";
-import { AttributeServer, PaseServer, Session } from "#protocol";
-import {
-    Command,
-    FabricIndex,
-    MAXIMUM_COMMISSIONING_TIMEOUT_S,
-    MINIMUM_COMMISSIONING_TIMEOUT_S,
-    PAKE_PASSCODE_VERIFIER_LENGTH,
-    StatusCode,
-    StatusResponseError,
-    TlvByteString,
-    TlvField,
-    TlvNoResponse,
-    TlvObject,
-    TlvUInt16,
-    TlvUInt32,
-    VendorId,
-} from "#types";
-import { ClusterServerHandlers } from "./ClusterServerTypes.js";
-
-const logger = Logger.get("AdministratorCommissioningServer");
-
-/**
- * Monkey patching Tlv Structure of openCommissioningWindow command to prevent data validation of the fields to be
- * handled as ConstraintError because we need to return a special error.
- * We do this to leave the model in fact for other validations and only apply the change for our Schema-aware Tlv parsing.
- */
-AdministratorCommissioning.Cluster.commands = {
-    ...AdministratorCommissioning.Cluster.commands,
-    openCommissioningWindow: Command(
-        0x0,
-        TlvObject({
-            commissioningTimeout: TlvField(0, TlvUInt16),
-            pakePasscodeVerifier: TlvField(1, TlvByteString),
-            discriminator: TlvField(2, TlvUInt16.bound({ max: 4095 })),
-            iterations: TlvField(3, TlvUInt32),
-            salt: TlvField(4, TlvByteString),
-        }),
-        0x0,
-        TlvNoResponse,
-        {
-            invokeAcl: AccessLevel.Administer,
-            timed: true,
-        },
-    ),
-};
-
-// General:
-// TODO If any format or validity errors related to the PAKEPasscodeVerifier, Iterations or Salt arguments arise, this command SHALL fail with a cluster specific status code of PAKEParameterError.
-// TODO In case of any other parameter error, this command SHALL fail with a status code of COMMAND_INVALID.
-
-/** Class which executed the cluster commands for the AdministratorCommissioning cluster. */
-class AdministratorCommissioningManager {
-    private commissioningWindowTimeout?: Timer;
-    private fabricRemoveHandler = async () => this.adminFabricIndexAttribute.setLocal(null);
-
-    constructor(
-        private readonly windowStatusAttribute: AttributeServer<AdministratorCommissioning.CommissioningWindowStatus>,
-        private readonly adminFabricIndexAttribute: AttributeServer<FabricIndex | null>,
-        private readonly adminVendorIdAttribute: AttributeServer<VendorId | null>,
-    ) {
-        windowStatusAttribute.setLocal(AdministratorCommissioning.CommissioningWindowStatus.WindowNotOpen);
-    }
-
-    /**
-     * Called whenever a Commissioning/Announcement Window is opened by this cluster. This method starts the timer and
-     * adjusts the needed attributes.
-     */
-    initializeCommissioningWindow(commissioningTimeout: number, session: Session) {
-        if (this.commissioningWindowTimeout !== undefined) {
-            // Should never happen, but let's make sure
-            throw new InternalError("Commissioning window already initialized.");
-        }
-        logger.debug(`Commissioning window timer started for ${commissioningTimeout} seconds for ${session.name}.`);
-        this.commissioningWindowTimeout = Time.getTimer(
-            "Commissioning timeout",
-            commissioningTimeout * 1000,
-            async () => await this.closeCommissioningWindow(session),
-        ).start();
-
-        this.adminFabricIndexAttribute.setLocal(session.associatedFabric.fabricIndex);
-        this.adminVendorIdAttribute.setLocal(session.associatedFabric.rootVendorId);
-        session.associatedFabric.addRemoveCallback(async () => this.fabricRemoveHandler());
-    }
-
-    /**
-     * This method validates if a commissioning window can be opened and throws various exceptions in case of failures.
-     */
-    assertCommissioningWindowRequirements(commissioningTimeout: number, device: MatterDevice) {
-        if (this.commissioningWindowTimeout !== undefined) {
-            throw new StatusResponseError(
-                "A commissioning window is already opened.",
-                StatusCode.Failure,
-                AdministratorCommissioning.StatusCode.Busy,
-            );
-        }
-
-        if (commissioningTimeout > MAXIMUM_COMMISSIONING_TIMEOUT_S) {
-            throw new StatusResponseError(
-                `Commissioning timeout must not exceed ${MAXIMUM_COMMISSIONING_TIMEOUT_S} seconds.`,
-                StatusCode.InvalidCommand,
-            );
-        }
-        if (commissioningTimeout < MINIMUM_COMMISSIONING_TIMEOUT_S) {
-            throw new StatusResponseError(
-                `Commissioning timeout must not be lower then ${MINIMUM_COMMISSIONING_TIMEOUT_S} seconds.`,
-                StatusCode.InvalidCommand,
-            );
-        }
-
-        if (device.isFailsafeArmed()) {
-            throw new StatusResponseError(
-                "Failsafe timer armed, assume commissioning in progress.",
-                StatusCode.Failure,
-                AdministratorCommissioning.StatusCode.Busy,
-            );
-        }
-    }
-
-    /**
-     * This method opens an Enhanced Commissioning Window (A dynamic passcode is used which was provided by the caller).
-     */
-    async openEnhancedCommissioningWindow(
-        pakeVerifier: Uint8Array,
-        discriminator: number,
-        iterations: number,
-        salt: Uint8Array,
-        commissioningTimeout: number,
-        session: Session,
-    ) {
-        // We monkey patched the Tlv definition above, so take care about correct error handling
-        if (pakeVerifier.length !== PAKE_PASSCODE_VERIFIER_LENGTH) {
-            throw new StatusResponseError(
-                "PAKE Passcode verifier length is invalid.",
-                StatusCode.Failure,
-                AdministratorCommissioning.StatusCode.PakeParameterError,
-            );
-        }
-        if (iterations < 1000 || iterations > 100_000) {
-            throw new StatusResponseError(
-                "PAKE iterations invalid.",
-                StatusCode.Failure,
-                AdministratorCommissioning.StatusCode.PakeParameterError,
-            );
-        }
-        if (salt.length < 16 || salt.length > 32) {
-            throw new StatusResponseError(
-                "PAKE salt has invalid length.",
-                StatusCode.Failure,
-                AdministratorCommissioning.StatusCode.PakeParameterError,
-            );
-        }
-
-        const device = MatterDevice.of(session);
-
-        this.assertCommissioningWindowRequirements(commissioningTimeout, device);
-
-        this.windowStatusAttribute.setLocal(AdministratorCommissioning.CommissioningWindowStatus.EnhancedWindowOpen);
-        this.initializeCommissioningWindow(commissioningTimeout, session);
-
-        await device.allowEnhancedCommissioning(
-            discriminator,
-            PaseServer.fromVerificationValue(device.sessionManager, pakeVerifier, { iterations, salt }),
-            () => {
-                session.associatedFabric.deleteRemoveCallback(this.fabricRemoveHandler);
-                this.endCommissioning();
-            },
-        );
-    }
-
-    /** This method opens a Basic Commissioning Window. The default passcode is used. */
-    async openBasicCommissioningWindow(commissioningTimeout: number, session: Session) {
-        const device = MatterDevice.of(session);
-
-        this.assertCommissioningWindowRequirements(commissioningTimeout, device);
-
-        this.windowStatusAttribute.setLocal(AdministratorCommissioning.CommissioningWindowStatus.BasicWindowOpen);
-        this.initializeCommissioningWindow(commissioningTimeout, session);
-
-        await device.allowBasicCommissioning(() => {
-            session.associatedFabric.deleteRemoveCallback(this.fabricRemoveHandler);
-            this.endCommissioning();
-        });
-    }
-
-    /**
-     * This method is used internally when the commissioning window timer expires or the commissioning was completed.
-     */
-    private endCommissioning() {
-        if (this.commissioningWindowTimeout === undefined) {
-            return;
-        }
-        this.commissioningWindowTimeout.stop();
-        this.commissioningWindowTimeout = undefined;
-
-        logger.debug("End commissioning window.");
-        this.windowStatusAttribute.setLocal(AdministratorCommissioning.CommissioningWindowStatus.WindowNotOpen);
-        this.adminFabricIndexAttribute.setLocal(null);
-        this.adminVendorIdAttribute.setLocal(null);
-    }
-
-    /** This method is used to close a commissioning window. */
-    async closeCommissioningWindow(session: Session) {
-        this.endCommissioning();
-        await MatterDevice.of(session).endCommissioning();
-    }
-
-    /** This method is used to revoke a commissioning window. */
-    async revokeCommissioning(session: Session) {
-        if (this.commissioningWindowTimeout === undefined) {
-            throw new StatusResponseError(
-                "No commissioning window is opened that could be revoked.",
-                StatusCode.Failure,
-                AdministratorCommissioning.StatusCode.WindowNotOpen,
-            );
-        }
-        logger.debug("Revoking commissioning window.");
-        await this.closeCommissioningWindow(session);
-
-        const device = MatterDevice.of(session);
-        if (device.isFailsafeArmed()) {
-            await device.failsafeContext.close();
-        }
-    }
-
-    /** Cleanup resources and stop the timer when the ClusterServer is destroyed. */
-    close() {
-        if (this.commissioningWindowTimeout !== undefined) {
-            this.commissioningWindowTimeout.stop();
-            this.commissioningWindowTimeout = undefined;
-        }
-    }
-}
-
-export const AdministratorCommissioningHandler: () => ClusterServerHandlers<
-    typeof AdministratorCommissioning.Cluster
-> = () => {
-    let manager: AdministratorCommissioningManager;
-
-    return {
-        initializeClusterServer: ({ attributes: { windowStatus, adminVendorId, adminFabricIndex } }) => {
-            manager = new AdministratorCommissioningManager(windowStatus, adminFabricIndex, adminVendorId);
-        },
-
-        openCommissioningWindow: async ({
-            request: { pakePasscodeVerifier: pakeVerifier, discriminator, iterations, salt, commissioningTimeout },
-            session /* attributes: { windowStatus } */,
-        }) =>
-            manager.openEnhancedCommissioningWindow(
-                pakeVerifier,
-                discriminator,
-                iterations,
-                salt,
-                commissioningTimeout,
-                session,
-            ),
-
-        revokeCommissioning: async ({ session }) => await manager.revokeCommissioning(session),
-
-        destroyClusterServer: () => manager?.close(),
-    };
-};
-
-const AdministratorCommissioningBasicCluster = AdministratorCommissioning.Cluster.with("Basic");
-
-export const BasicAdminCommissioningHandler: () => ClusterServerHandlers<
-    typeof AdministratorCommissioningBasicCluster
-> = () => {
-    let manager: AdministratorCommissioningManager;
-
-    return {
-        initializeClusterServer: ({ attributes: { windowStatus, adminVendorId, adminFabricIndex } }) => {
-            manager = new AdministratorCommissioningManager(windowStatus, adminFabricIndex, adminVendorId);
-        },
-
-        openCommissioningWindow: async ({
-            request: { pakePasscodeVerifier: pakeVerifier, discriminator, iterations, salt, commissioningTimeout },
-            session,
-        }) =>
-            manager.openEnhancedCommissioningWindow(
-                pakeVerifier,
-                discriminator,
-                iterations,
-                salt,
-                commissioningTimeout,
-                session,
-            ),
-
-        openBasicCommissioningWindow: async ({ request: { commissioningTimeout }, session }) =>
-            manager.openBasicCommissioningWindow(commissioningTimeout, session),
-
-        revokeCommissioning: async ({ session }) => await manager.revokeCommissioning(session),
-
-        destroyClusterServer: () => manager?.close(),
-    };
-};