@epicgames-ps/lib-pixelstreamingsignalling-ue5.8 0.1.0

package/src/SignallingServer.ts

@@ -0,0 +1,214 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+import http from 'http';
+import https from 'https';
+import * as wslib from 'ws';
+import { StreamerConnection } from './StreamerConnection';
+import { PlayerConnection } from './PlayerConnection';
+import { SFUConnection } from './SFUConnection';
+import { Logger } from './Logger';
+import { StreamerRegistry, StreamerIdAuthorizer } from './StreamerRegistry';
+import { PlayerRegistry } from './PlayerRegistry';
+import {
+    Messages,
+    MessageHelpers,
+    SignallingProtocol,
+    KeepaliveMonitor
+} from '@epicgames-ps/lib-pixelstreamingcommon-ue5.8';
+import { stringify } from './Utils';
+
+/**
+ * An interface describing the possible options to pass when creating
+ * a new SignallingServer object.
+ */
+export interface IServerConfig {
+    // An http server to use for player connections rather than a port. Not needed if playerPort or httpsServer supplied.
+    httpServer?: http.Server;
+
+    // An https server to use for player connections rather than a port. Not needed if playerPort or httpServer supplied.
+    httpsServer?: https.Server;
+
+    // The port to listen on for streamer connections.
+    streamerPort: number;
+
+    // The port to listen on for player connections. Not needed if httpServer or httpsServer supplied.
+    playerPort?: number;
+
+    // The port to listen on for SFU connections. If not supplied SFU connections will be disabled.
+    sfuPort?: number;
+
+    // The peer configuration object to send to peers in the config message when they connect.
+    peerOptions: unknown;
+
+    // Additional websocket options for the streamer listening websocket.
+    streamerWsOptions?: wslib.ServerOptions;
+
+    // Additional websocket options for the player listening websocket.
+    playerWsOptions?: wslib.ServerOptions;
+
+    // Additional websocket options for the SFU listening websocket.
+    sfuWsOptions?: wslib.ServerOptions;
+
+    // Max number of players per streamer.
+    maxSubscribers?: number;
+
+    // Idle timeout in milliseconds after which a player that has stopped responding to keepalive
+    // pings is forcibly disconnected. 0 (the default) disables the check.
+    playerKeepaliveTimeout?: number;
+
+    // Optional hook to authorize (or override) the id a streamer registers as when it identifies
+    // itself. This is the seam for consumer-supplied anti-squatting / ownership policy; the project
+    // ships no authentication of its own. See StreamerIdAuthorizer. When omitted, the default
+    // behaviour is unchanged (requested id accepted, numeric suffix appended on collision).
+    authorizeStreamerId?: StreamerIdAuthorizer;
+}
+
+export type ProtocolConfig = {
+    [key: string]: any;
+};
+
+/**
+ * The main signalling server object.
+ * Contains a streamer and player registry and handles setting up of websockets
+ * to listen for incoming connections.
+ */
+export class SignallingServer {
+    config: IServerConfig;
+    protocolConfig: ProtocolConfig;
+    streamerRegistry: StreamerRegistry;
+    playerRegistry: PlayerRegistry;
+    startTime: Date;
+
+    /**
+     * Initializes the server object and sets up listening sockets for streamers
+     * players and optionally SFU connections.
+     * @param config - A collection of options for this server.
+     */
+    constructor(config: IServerConfig) {
+        Logger.debug('Started SignallingServer with config: %s', stringify(config));
+
+        this.config = config;
+        this.streamerRegistry = new StreamerRegistry(config.authorizeStreamerId);
+        this.playerRegistry = new PlayerRegistry();
+        this.protocolConfig = {
+            protocolVersion: SignallingProtocol.SIGNALLING_VERSION,
+            peerConnectionOptions: this.config.peerOptions || {}
+        };
+        this.startTime = new Date();
+
+        if (!config.playerPort && !config.httpServer && !config.httpsServer) {
+            Logger.error('No player port, http server or https server supplied to SignallingServer.');
+            return;
+        }
+
+        // Streamer connections
+        const streamerServer = new wslib.WebSocketServer({
+            port: config.streamerPort,
+            backlog: 1,
+            ...config.streamerWsOptions
+        });
+        streamerServer.on('connection', this.onStreamerConnected.bind(this));
+        Logger.info(`Listening for streamer connections on port ${config.streamerPort}`);
+
+        // Player connections
+        const server = config.httpsServer || config.httpServer;
+        const playerServer = new wslib.WebSocketServer({
+            server: server,
+            port: server ? undefined : config.playerPort,
+            ...config.playerWsOptions
+        });
+        playerServer.on('connection', this.onPlayerConnected.bind(this));
+        if (!config.httpServer && !config.httpsServer) {
+            Logger.info(`Listening for player connections on port ${config.playerPort}`);
+        }
+
+        // Optional SFU connections
+        if (config.sfuPort) {
+            const sfuServer = new wslib.WebSocketServer({
+                port: config.sfuPort,
+                backlog: 1,
+                ...config.sfuWsOptions
+            });
+            sfuServer.on('connection', this.onSFUConnected.bind(this));
+            Logger.info(`Listening for SFU connections on port ${config.sfuPort}`);
+        }
+    }
+
+    private sendConfigMessage(connection: { sendMessage(msg: Messages.config): void }): void {
+        // peer connection options is a general field with all optional fields;
+        // it doesnt play nice with mergePartial so we just add it verbatim
+        const message: Messages.config = MessageHelpers.createMessage(Messages.config, this.protocolConfig);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        message.peerConnectionOptions = this.protocolConfig['peerConnectionOptions'];
+        connection.sendMessage(message);
+    }
+
+    private onStreamerConnected(ws: wslib.WebSocket, request: http.IncomingMessage) {
+        Logger.info(`New streamer connection: %s`, request.socket.remoteAddress);
+
+        const newStreamer = new StreamerConnection(this, ws, request.socket.remoteAddress, request);
+        newStreamer.maxSubscribers = this.config.maxSubscribers || 0;
+
+        // add it to the registry and when the transport closes, remove it.
+        this.streamerRegistry.add(newStreamer);
+        newStreamer.transport.on('close', () => {
+            this.streamerRegistry.remove(newStreamer);
+            Logger.info(
+                `Streamer %s (%s) disconnected.`,
+                newStreamer.streamerId,
+                request.socket.remoteAddress
+            );
+        });
+
+        this.sendConfigMessage(newStreamer);
+    }
+
+    private onPlayerConnected(ws: wslib.WebSocket, request: http.IncomingMessage) {
+        Logger.info(`New player connection: %s (%s)`, request.socket.remoteAddress, request.url);
+
+        const newPlayer = new PlayerConnection(this, ws, request.socket.remoteAddress, request);
+
+        // add it to the registry and when the transport closes, remove it
+        this.playerRegistry.add(newPlayer);
+        newPlayer.transport.on('close', () => {
+            this.playerRegistry.remove(newPlayer);
+            Logger.info(`Player %s (%s) disconnected.`, newPlayer.playerId, request.socket.remoteAddress);
+        });
+
+        // Optionally monitor the player connection for liveness. A player whose socket dies without
+        // a clean close frame (sleeping laptop, dropped Wi-Fi, killed tab) is otherwise only removed
+        // once the OS TCP keepalive eventually reaps it, leaving it subscribed in the meantime. When
+        // maxSubscribers is set this can hold a slot that no live player is using. We use
+        // ws.terminate() rather than a graceful close because a dead peer never completes the close
+        // handshake. The monitor stops itself on transport 'close', so no manual teardown is needed.
+        const keepaliveTimeout = this.config.playerKeepaliveTimeout || 0;
+        if (keepaliveTimeout > 0) {
+            const keepalive = new KeepaliveMonitor(newPlayer.protocol, keepaliveTimeout);
+            keepalive.onTimeout = () => {
+                Logger.info(
+                    `Player %s (%s) failed keepalive - terminating dead connection.`,
+                    newPlayer.playerId,
+                    request.socket.remoteAddress
+                );
+                ws.terminate();
+            };
+        }
+
+        this.sendConfigMessage(newPlayer);
+    }
+
+    private onSFUConnected(ws: wslib.WebSocket, request: http.IncomingMessage) {
+        Logger.info(`New SFU connection: %s`, request.socket.remoteAddress);
+        const newSFU = new SFUConnection(this, ws, request.socket.remoteAddress, request);
+
+        // SFU acts as both a streamer and player
+        this.streamerRegistry.add(newSFU);
+        this.playerRegistry.add(newSFU);
+        newSFU.transport.on('close', () => {
+            this.streamerRegistry.remove(newSFU);
+            this.playerRegistry.remove(newSFU);
+            Logger.info(`SFU %s (%s) disconnected.`, newSFU.streamerId, request.socket.remoteAddress);
+        });
+
+        this.sendConfigMessage(newSFU);
+    }
+}

package/src/StreamerConnection.ts

@@ -0,0 +1,194 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+import type { IncomingMessage } from 'http';
+import WebSocket from 'ws';
+import {
+    ITransport,
+    SignallingProtocol,
+    WebSocketTransportNJS,
+    BaseMessage,
+    Messages,
+    EventEmitter,
+    MessageHelpers
+} from '@epicgames-ps/lib-pixelstreamingcommon-ue5.8';
+import { IStreamer, IStreamerInfo } from './StreamerRegistry';
+import { stringify } from './Utils';
+import { Logger } from './Logger';
+import * as LogUtils from './LoggingUtils';
+import { SignallingServer } from './SignallingServer';
+
+/**
+ * A connection between the signalling server and a streamer connection.
+ * This is where messages expected to be handled by the streamer come in
+ * and where messages are sent to the streamer.
+ *
+ * Interesting internals:
+ * streamerId: The unique id string of this streamer.
+ * transport: The ITransport where transport events can be subscribed to
+ * protocol: The SignallingProtocol where signalling messages can be
+ * subscribed to.
+ * streaming: True when the streamer is ready to accept subscriptions.
+ */
+export class StreamerConnection extends EventEmitter implements IStreamer, LogUtils.IMessageLogger {
+    // The streamer id related to this SFU connection.
+    streamerId: string;
+    // The websocket transport used by this connection.
+    transport: ITransport;
+    // The protocol abstraction on this connection. Used for sending/receiving signalling messages.
+    protocol: SignallingProtocol;
+    // True when this streamer is ready to be subscribed to.
+    streaming: boolean;
+    // A descriptive string describing the remote address of this connection.
+    remoteAddress?: string;
+    // The HTTP upgrade request that opened this connection, if available.
+    request?: IncomingMessage;
+    // The max number of subscribed players at a time.
+    maxSubscribers: number;
+    // A list of all the current subscribed players.
+    subscribers: Set<string>;
+
+    private server: SignallingServer;
+
+    /**
+     * Initializes a new connection with given and sane values. Adds listeners for the
+     * websocket close and error and will emit a disconnected event when disconneted.
+     * @param server - The signalling server object that spawned this streamer.
+     * @param ws - The websocket coupled to this streamer connection.
+     * @param remoteAddress - The remote address of this connection. Only used as display.
+     * @param request - The HTTP upgrade request that opened this connection, if available.
+     */
+    constructor(server: SignallingServer, ws: WebSocket, remoteAddress?: string, request?: IncomingMessage) {
+        super();
+
+        this.server = server;
+        this.streamerId = '';
+        this.transport = new WebSocketTransportNJS(ws);
+        this.protocol = new SignallingProtocol(this.transport);
+        this.streaming = false;
+        this.remoteAddress = remoteAddress;
+        this.request = request;
+        this.maxSubscribers = 0;
+        this.subscribers = new Set();
+
+        this.transport.on('error', this.onTransportError.bind(this));
+        this.transport.on('close', this.onTransportClose.bind(this));
+
+        this.registerMessageHandlers();
+
+        this.protocol.on('unhandled', (message: BaseMessage) => {
+            Logger.warn(`Unhandled streamer protocol message: ${JSON.stringify(message)}`);
+        });
+    }
+
+    /**
+     * Returns an identifier that is displayed in logs.
+     * @returns A string describing this connection.
+     */
+    getReadableIdentifier(): string {
+        return this.streamerId;
+    }
+
+    /**
+     * Sends a signalling message to the player.
+     * @param message - The message to send.
+     */
+    sendMessage(message: BaseMessage): void {
+        LogUtils.logOutgoing(this, message);
+        this.protocol.sendMessage(message);
+    }
+
+    /**
+     * Returns a descriptive object for the REST API inspection operations.
+     * @returns An IStreamerInfo object containing viewable information about this connection.
+     */
+    getStreamerInfo(): IStreamerInfo {
+        return {
+            streamerId: this.streamerId,
+            type: 'Streamer',
+            streaming: this.streaming,
+            remoteAddress: this.remoteAddress,
+            subscribers: this.server.playerRegistry
+                .listPlayers()
+                .filter((player) => player.subscribedStreamer == this)
+                .map((player) => player.getPlayerInfo())
+        };
+    }
+
+    private registerMessageHandlers(): void {
+        /* eslint-disable @typescript-eslint/unbound-method */
+        this.protocol.on(
+            Messages.endpointId.typeName,
+            LogUtils.createHandlerListener(this, this.onEndpointId)
+        );
+        this.protocol.on(
+            Messages.disconnectPlayer.typeName,
+            LogUtils.createHandlerListener(this, this.onDisconnectPlayerRequest)
+        );
+        this.protocol.on(
+            Messages.layerPreference.typeName,
+            LogUtils.createHandlerListener(this, this.onLayerPreference)
+        );
+        this.protocol.on(Messages.ping.typeName, LogUtils.createHandlerListener(this, this.onPingMessage));
+        /* eslint-enable @typescript-eslint/unbound-method */
+
+        this.protocol.on(Messages.offer.typeName, this.forwardMessage.bind(this));
+        this.protocol.on(Messages.answer.typeName, this.forwardMessage.bind(this));
+        this.protocol.on(Messages.iceCandidate.typeName, this.forwardMessage.bind(this));
+    }
+
+    private forwardMessage(message: BaseMessage): void {
+        if (!message.playerId) {
+            Logger.warn(`No playerId specified, cannot forward message: ${stringify(message)}`);
+        } else if (!this.subscribers.has(message.playerId)) {
+            // Only forward to players that are actually subscribed to this streamer. Without this
+            // check a streamer could target any player on the server (resolved via the global player
+            // registry), allowing cross-tenant signalling on a shared signalling server.
+            Logger.warn(
+                `Streamer ${this.streamerId} tried to forward a message to player ${message.playerId} which is not subscribed to it. Ignoring.`
+            );
+        } else {
+            const player = this.server.playerRegistry.get(message.playerId);
+            if (player) {
+                LogUtils.logForward(this, player, message);
+                player.protocol.sendMessage(message);
+            }
+        }
+    }
+
+    private onTransportError(error: ErrorEvent): void {
+        Logger.error(`Streamer (${this.streamerId}) transport error ${error.message}`);
+    }
+
+    private onTransportClose(): void {
+        Logger.info(`Streamer '${this.streamerId}' - websocket disconnected.`);
+        this.emit('disconnect');
+    }
+
+    private onEndpointId(_message: Messages.endpointId): void {
+        this.streaming = true; // we're ready to stream when we id ourselves
+    }
+
+    private onDisconnectPlayerRequest(message: Messages.disconnectPlayer): void {
+        if (message.playerId) {
+            if (!this.subscribers.has(message.playerId)) {
+                // A streamer may only disconnect its own subscribed players. Otherwise any streamer
+                // could forcibly close arbitrary player connections on a shared signalling server.
+                Logger.warn(
+                    `Streamer ${this.streamerId} tried to disconnect player ${message.playerId} which is not subscribed to it. Ignoring.`
+                );
+                return;
+            }
+            const player = this.server.playerRegistry.get(message.playerId);
+            if (player) {
+                player.protocol.disconnect(1011, message.reason);
+            }
+        }
+    }
+
+    private onLayerPreference(message: Messages.layerPreference): void {
+        this.emit('layer_preference', message);
+    }
+
+    private onPingMessage(message: Messages.ping): void {
+        this.sendMessage(MessageHelpers.createMessage(Messages.pong, { time: message.time }));
+    }
+}

package/src/StreamerRegistry.ts

@@ -0,0 +1,252 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+import {
+    ITransport,
+    SignallingProtocol,
+    Messages,
+    MessageHelpers,
+    BaseMessage,
+    EventEmitter
+} from '@epicgames-ps/lib-pixelstreamingcommon-ue5.8';
+import type { IncomingMessage } from 'http';
+import { Logger } from './Logger';
+import { IMessageLogger } from './LoggingUtils';
+import { IPlayerInfo } from './PlayerRegistry';
+
+/**
+ * An interface that describes a streamer that can be added to the
+ * streamer registry.
+ */
+export interface IStreamer extends EventEmitter, IMessageLogger {
+    streamerId: string;
+    transport: ITransport;
+    protocol: SignallingProtocol;
+    streaming: boolean;
+    maxSubscribers: number;
+    subscribers: Set<string>;
+    // The HTTP upgrade request that opened this connection, if available. The signalling server
+    // itself does not read this, but it lets a consumer-supplied verifyClient (or other front door)
+    // attach an authenticated identity to the request and recover it here for authorization
+    // decisions. The project intentionally ships no authentication of its own.
+    request?: IncomingMessage;
+
+    sendMessage(message: BaseMessage): void;
+    getStreamerInfo(): IStreamerInfo;
+}
+
+/**
+ * The details of a streamer's request to be known by a given id, passed to a
+ * {@link StreamerIdAuthorizer} so a consumer can decide whether to allow it.
+ */
+export interface IStreamerIdAuthRequest {
+    // The streamer connection requesting the id. Use `streamer.request` to recover any identity a
+    // consumer attached at connection time.
+    streamer: IStreamer;
+    // The raw id the streamer asked to be known by (the value it sent in its endpointId message).
+    requestedId: string;
+    // The unique id the registry would assign by default (the requested id, with a numeric suffix
+    // appended if it collided with an existing streamer).
+    sanitizedId: string;
+    // True when the requested id was already taken and so differs from the id the registry would
+    // otherwise commit. This is the condition an id-squatting attacker relies on.
+    collided: boolean;
+}
+
+/**
+ * An optional consumer-supplied hook that decides the id a streamer is allowed to register as.
+ * Return the id to commit (the sanitized id to accept the default, or any other unique id to
+ * override, e.g. to namespace per tenant), or null to reject the streamer and disconnect it.
+ * This is the seam for implementing anti-squatting / ownership policy without the project
+ * providing an authentication scheme.
+ */
+export type StreamerIdAuthorizer = (request: IStreamerIdAuthRequest) => string | null;
+
+/**
+ * Used by the API to describe a streamer.
+ */
+export interface IStreamerInfo {
+    streamerId: string;
+    type: string;
+    streaming: boolean;
+    remoteAddress: string | undefined;
+    subscribers: IPlayerInfo[];
+}
+
+/**
+ * Handles all the streamer connections of a signalling server and
+ * can be used to lookup connections by id etc.
+ * Fires events when streamers are added or removed.
+ * Events:
+ *   'added': (playerId: string) Player was added.
+ *   'removed': (playerId: string) Player was removed.
+ */
+export class StreamerRegistry extends EventEmitter {
+    streamers: IStreamer[];
+    defaultStreamerIdPrefix: string = 'UnknownStreamer';
+    // Optional consumer hook to authorize/override the id a streamer registers as. See
+    // {@link StreamerIdAuthorizer}. When unset the registry keeps its default behaviour of
+    // accepting the requested id and appending a numeric suffix on collision.
+    authorizeStreamerId?: StreamerIdAuthorizer;
+
+    constructor(authorizeStreamerId?: StreamerIdAuthorizer) {
+        super();
+        this.streamers = [];
+        this.authorizeStreamerId = authorizeStreamerId;
+    }
+
+    /**
+     * Adds a streamer to the registry. If the streamer already has an id
+     * it will be sanitized (checked against existing ids and altered if
+     * there are collisions), or if it has no id it will be assigned a
+     * default unique id.
+     * @returns True if the add was successful.
+     */
+    add(streamer: IStreamer): boolean {
+        streamer.streamerId = this.sanitizeStreamerId(streamer.streamerId);
+
+        if (this.find(streamer.streamerId)) {
+            Logger.error(
+                `StreamerRegistry: Tried to register streamer ${streamer.streamerId} but that id already exists.`
+            );
+            return false;
+        }
+
+        this.streamers.push(streamer);
+
+        // request that the new streamer id itself.
+        streamer.protocol.on(Messages.endpointId.typeName, this.onEndpointId.bind(this, streamer));
+        streamer.sendMessage(MessageHelpers.createMessage(Messages.identify));
+
+        this.emit('added', streamer.streamerId);
+
+        return true;
+    }
+
+    /**
+     * Removes a streamer from the registry. If the streamer isn't found
+     * it does nothing.
+     * @returns True if the streamer was removed.
+     */
+    remove(streamer: IStreamer): boolean {
+        const index = this.streamers.indexOf(streamer);
+        if (index === -1) {
+            Logger.debug(
+                `StreamerRegistry: Tried to remove streamer ${streamer.streamerId} but it doesn't exist`
+            );
+            return false;
+        }
+        this.streamers.splice(index, 1);
+        this.emit('removed', streamer.streamerId);
+        return true;
+    }
+
+    /**
+     * Attempts to find the given streamer id in the registry.
+     */
+    find(streamerId: string): IStreamer | undefined {
+        return this.streamers.find((streamer) => streamer.streamerId === streamerId);
+    }
+
+    /**
+     * Used by players who haven't subscribed but try to send a message.
+     * This is to cover legacy connections that do not know how to subscribe.
+     * The player will be assigned the first streamer in the list.
+     * @returns The first streamerId in the registry or null if there are none.
+     */
+    getFirstStreamerId(): string | null {
+        if (this.empty()) {
+            return null;
+        }
+        return this.streamers[0].streamerId;
+    }
+
+    /**
+     * Returns true when the registry is empty.
+     */
+    empty(): boolean {
+        return this.streamers.length === 0;
+    }
+
+    /**
+     * Returns the total number of connected streamers.
+     */
+    count(): number {
+        return this.streamers.length;
+    }
+
+    private onEndpointId(streamer: IStreamer, message: Messages.endpointId): void {
+        const oldId = streamer.streamerId;
+
+        // id might conflict or be invalid so here we sanitize it
+        const sanitizedId = this.sanitizeStreamerId(message.id);
+
+        let committedId: string | null = sanitizedId;
+        if (this.authorizeStreamerId) {
+            // Let the consumer accept the default id, override it (e.g. namespace per tenant), or
+            // reject the registration entirely. This is where anti-squatting policy lives.
+            committedId = this.authorizeStreamerId({
+                streamer,
+                requestedId: message.id,
+                sanitizedId,
+                collided: !!message.id && sanitizedId !== message.id
+            });
+
+            if (committedId === null) {
+                Logger.warn(
+                    `StreamerRegistry: streamer id '${message.id}' (was ${oldId}) rejected by authorizer. Disconnecting.`
+                );
+                this.remove(streamer);
+                streamer.protocol.disconnect(1008, 'streamer id not authorized');
+                return;
+            }
+
+            // An override must remain unique or it would corrupt id-based lookups. If the consumer
+            // hands back an id already held by a different streamer we reject rather than clobber.
+            const existing = this.find(committedId);
+            if (existing && existing !== streamer) {
+                Logger.error(
+                    `StreamerRegistry: authorizer returned id '${committedId}' which is already in use. Disconnecting.`
+                );
+                this.remove(streamer);
+                streamer.protocol.disconnect(1008, 'streamer id not authorized');
+                return;
+            }
+        }
+
+        streamer.streamerId = committedId;
+
+        Logger.debug(`StreamerRegistry: Streamer id change. ${oldId} -> ${streamer.streamerId}`);
+        streamer.emit('id_changed', streamer.streamerId);
+
+        // because we might have sanitized the id, we confirm the id back to the streamer
+        streamer.sendMessage(
+            MessageHelpers.createMessage(Messages.endpointIdConfirm, { committedId: streamer.streamerId })
+        );
+    }
+
+    private sanitizeStreamerId(id: string): string {
+        // create a default id if none supplied
+        if (!id) {
+            id = this.defaultStreamerIdPrefix;
+        }
+
+        // search for existing streamerId and optionally append a numeric value
+        let maxPostfix = -1;
+        for (const streamer of this.streamers) {
+            const idMatchRegex = /^(.*?)(\d*)$/;
+
+            const [, baseId, postfix] = streamer.streamerId.match(idMatchRegex)!;
+            // if the id is numeric then base id will be empty and we need to compare with the postfix
+            if ((baseId !== '' && baseId !== id) || (baseId === '' && postfix !== id)) {
+                continue;
+            }
+            const numPostfix = Number(postfix);
+            if (numPostfix > maxPostfix) {
+                maxPostfix = numPostfix;
+            }
+        }
+        if (maxPostfix >= 0) {
+            return id + (maxPostfix + 1);
+        }
+        return id;
+    }
+}

package/src/Utils.ts

@@ -0,0 +1,16 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+import { jsonc } from 'jsonc';
+
+/**
+ * Cirular reference safe version of JSON.stringify
+ */
+export function stringify(obj: any): string {
+    return jsonc.stringify(obj);
+}
+
+/**
+ * Circular reference save version of JSON.stringify with extra formatting.
+ */
+export function beautify(obj: any): string {
+    return jsonc.stringify(obj, undefined, '\t');
+}