@teardown/cli 1.2.20 → 1.2.23

package/dist/modules/dev/dev-server/dev-server.js

@@ -0,0 +1,220 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevServer = void 0;
+exports.makeLogEntryFromFastifyLog = makeLogEntryFromFastifyLog;
+const middie_1 = __importDefault(require("@fastify/middie"));
+const sensible_1 = __importDefault(require("@fastify/sensible"));
+const compress_1 = __importDefault(require("@fastify/compress"));
+const cli_server_api_1 = require("@react-native-community/cli-server-api");
+const dev_middleware_1 = require("@react-native/dev-middleware");
+const metro_config_1 = require("@react-native/metro-config");
+const fastify_1 = __importDefault(require("fastify"));
+const metro_1 = __importDefault(require("metro"));
+const node_stream_1 = require("node:stream");
+const terminal_reporter_1 = require("../terminal/terminal.reporter");
+const devtools_plugin_1 = require("./plugins/devtools.plugin");
+// import { faviconPlugin } from "./plugins/favicon.plugin";
+const multipart_plugin_1 = require("./plugins/multipart.plugin");
+const symbolicate_1 = require("./plugins/symbolicate");
+const wss_1 = require("./plugins/wss");
+const web_socket_events_server_1 = require("./plugins/wss/servers/web-socket-events.server");
+const web_socket_message_server_1 = require("./plugins/wss/servers/web-socket-message.server");
+const keyboard_handler_1 = require("../dev-menu/keyboard-handler");
+class DevServer {
+    config;
+    terminalReporter;
+    instance;
+    messageServer;
+    eventsServer;
+    keyboardHandler;
+    constructor(config) {
+        this.config = config;
+        this.terminalReporter = new terminal_reporter_1.TeardownTerminalReporter(this);
+        this.instance = (0, fastify_1.default)({
+            // disableRequestLogging: false,
+            logger: {
+                level: "trace",
+                stream: new node_stream_1.Writable({
+                    write: (chunk, _encoding, callback) => {
+                        const log = JSON.parse(chunk.toString());
+                        this.onMessage(log);
+                        this.instance.wss?.apiServer.send(log);
+                        callback();
+                    },
+                }),
+            },
+            ...(config.https ? { https: config.https } : undefined),
+        });
+        this.messageServer = new web_socket_message_server_1.WebSocketMessageServer(this.instance);
+        this.eventsServer = new web_socket_events_server_1.WebSocketEventsServer(this.instance, {
+            webSocketMessageServer: this.messageServer,
+        });
+        this.keyboardHandler = new keyboard_handler_1.KeyboardHandlerManager(this);
+    }
+    getDevServerUrl() {
+        const https = this.config.https ? "https" : "http";
+        return `${https}://${this.config.host}:${this.config.port}`;
+    }
+    onInitializeDone() {
+        this.keyboardHandler.initialize();
+    }
+    reportMetroEvent(event) {
+        // this.messageServer.broadcast("report_event", event);
+        // console.log("Metro event", event);
+    }
+    onBundleBuilt(bundlePath) {
+        console.log("onBundleBuilt", bundlePath);
+    }
+    onMessage(log) {
+        this.terminalReporter.update({
+            type: "client_log",
+            level: "info",
+            data: [log.msg],
+        });
+    }
+    onClientConnected(platform, clientId) {
+        console.log("onClientConnected", platform, clientId);
+        // this.instance.wss.router.onClientConnected(platform, clientId);
+        // this.onMessage({
+        // 	level: 30,
+        // 	time: Date.now(),
+        // 	pid: 1,
+        // 	hostname: "localhost",
+        // });
+    }
+    async loadMetroConfig() {
+        const config = await metro_1.default.loadConfig({
+            cwd: this.config.projectRoot,
+            ...this.config,
+        });
+        const reactNativeConfig = (0, metro_config_1.getDefaultConfig)(this.config.projectRoot);
+        return (0, metro_config_1.mergeConfig)(reactNativeConfig, config);
+    }
+    _metroConfig = null;
+    async getMetroConfig() {
+        if (!this._metroConfig) {
+            this._metroConfig = await this.loadMetroConfig();
+        }
+        return (0, metro_config_1.mergeConfig)(this._metroConfig, {
+            reporter: this.terminalReporter,
+        });
+    }
+    async registerPlugins() {
+        const metroConfig = await this.getMetroConfig();
+        const serverInstance = await metro_1.default.createConnectMiddleware(metroConfig, {
+            watch: true,
+            onBundleBuilt: this.onBundleBuilt.bind(this),
+        });
+        // console.log("Registering plugins");
+        const devMiddleware = (0, dev_middleware_1.createDevMiddleware)({
+            projectRoot: this.config.projectRoot,
+            serverBaseUrl: `http://${this.config.host}:${this.config.port}`,
+            logger: this.instance.log,
+            unstable_experiments: {
+            // enableNewDebugger: this.config.experiments?.experimentalDebugger,
+            },
+        });
+        await this.instance.register(compress_1.default);
+        await this.instance.register(sensible_1.default);
+        await this.instance.register(middie_1.default);
+        await this.instance.register(wss_1.wssPlugin, {
+            metroConfig,
+            metroServer: serverInstance.metroServer,
+            onClientConnected: this.onClientConnected.bind(this),
+            messageServer: this.messageServer,
+            eventsServer: this.eventsServer,
+            endpoints: {
+                "/inspector/debug": devMiddleware.websocketEndpoints["/inspector/debug"],
+                "/inspector/device": devMiddleware.websocketEndpoints["/inspector/device"],
+                "/inspector/network": devMiddleware.websocketEndpoints["/inspector/debug"], // Uses same endpoint as debugger to handle Network-related CDP events
+            },
+        });
+        await this.instance.register(multipart_plugin_1.multipartPlugin);
+        await this.instance.register(devtools_plugin_1.devtoolsPlugin, {
+            host: this.config.host,
+            port: this.config.port,
+            https: this.config.https,
+        });
+        await this.instance.register(symbolicate_1.symbolicatePlugin);
+        // await this.instance.register(faviconPlugin);
+        // Register middleware
+        this.instance.use("/open-url", cli_server_api_1.openURLMiddleware);
+        this.instance.use("/open-stack-frame", (0, cli_server_api_1.openStackFrameInEditorMiddleware)({
+            watchFolders: [this.config.projectRoot],
+        }));
+        this.instance.use(devMiddleware.middleware);
+        // Convert Metro middleware to Fastify middleware format
+        this.instance.use((req, res, next) => {
+            const middleware = serverInstance.middleware;
+            middleware(req, res, next);
+        });
+        // console.log("Plugins registered");
+    }
+    registerHooks() {
+        // console.log("Registering hooks");
+        this.instance.addHook("onSend", async (request, reply, payload) => {
+            reply.header("X-Content-Type-Options", "nosniff");
+            reply.header("X-React-Native-Project-Root", this.config.projectRoot);
+            const [pathname] = request.url.split("?");
+            if (pathname.endsWith(".map")) {
+                reply.header("Access-Control-Allow-Origin", "devtools://devtools");
+            }
+            return payload;
+        });
+    }
+    registerRoutes() {
+        // console.log("Registering routes");
+        this.instance.get("/", async () => "React Native packager is running");
+        this.instance.get("/status", async () => "packager-status:running");
+    }
+    async initialize() {
+        console.log("Initializing dev server");
+        await this.registerPlugins();
+        this.registerHooks();
+        this.registerRoutes();
+    }
+    async start() {
+        this.instance.log.info("Starting dev server", this.config);
+        await this.instance.listen({
+            port: this.config.port,
+            host: this.config.host,
+        });
+        console.log("Dev server started", this.instance.server.address());
+    }
+    async stop() {
+        console.log("Stopping dev server");
+        await this.instance.close();
+    }
+    getInstance() {
+        return this.instance;
+    }
+}
+exports.DevServer = DevServer;
+const levelToTypeMapping = {
+    10: "debug",
+    20: "debug",
+    30: "info",
+    40: "warn",
+    50: "error",
+    60: "error",
+};
+function makeLogEntryFromFastifyLog(data) {
+    const { level, time, pid, hostname, ...rest } = data;
+    const levelToTypeMapping = {
+        10: "debug",
+        20: "debug",
+        30: "info",
+        40: "warn",
+        50: "error",
+        60: "error",
+    };
+    return {
+        type: levelToTypeMapping[level] ?? "log",
+        timestamp: time,
+        issuer: "",
+        message: [rest],
+    };
+}

package/dist/modules/dev/dev-server/plugins/devtools.plugin.d.ts

@@ -0,0 +1,10 @@
+type Options = {
+    host: string | undefined;
+    port: number;
+    https?: {
+        key: string;
+        cert: string;
+    };
+};
+export declare const devtoolsPlugin: import("fastify").FastifyPluginCallback<Options, import("fastify").RawServerDefault, import("fastify").FastifyTypeProviderDefault, import("fastify").FastifyBaseLogger>;
+export {};

package/dist/modules/dev/dev-server/plugins/devtools.plugin.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.devtoolsPlugin = void 0;
+const fastify_plugin_1 = __importDefault(require("fastify-plugin"));
+const open_1 = __importDefault(require("open"));
+exports.devtoolsPlugin = (0, fastify_plugin_1.default)(async (instance, options) => {
+    instance.route({
+        method: ["GET", "POST", "PUT"],
+        url: "/reload",
+        handler: (_request, reply) => {
+            console.log("Reload endpoint hit", instance.wss.messageServer.broadcast != null);
+            instance.wss.messageServer.broadcast("reload");
+            reply.send("OK");
+        },
+    });
+    instance.route({
+        method: ["GET", "POST", "PUT"],
+        url: "/launch-js-devtools",
+        handler: async (request, reply) => {
+            const customDebugger = process.env.REACT_DEBUGGER;
+            if (customDebugger) {
+                // NOOP for now
+                // TODO implement opening teardown here
+            }
+            else if (!instance.wss.debuggerServer.isDebuggerConnected()) {
+                const url = `${options.https ? "https" : "http"}://${options.host || "localhost"}:${options.port}/debugger-ui`;
+                try {
+                    request.log.info({ msg: "Opening debugger UI", url });
+                    await (0, open_1.default)(url);
+                }
+                catch (error) {
+                    if (error) {
+                        request.log.error({
+                            msg: "Cannot open debugger UI",
+                            url,
+                            error,
+                        });
+                    }
+                }
+            }
+            reply.send("OK");
+        },
+    });
+}, {
+    name: "devtools-plugin",
+    dependencies: ["wss-plugin"],
+});

package/dist/modules/dev/dev-server/plugins/favicon.plugin.d.ts

@@ -0,0 +1 @@
+export declare const faviconPlugin: (instance: import("fastify").FastifyInstance<import("fastify").RawServerDefault, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault>) => Promise<void>;

package/dist/modules/dev/dev-server/plugins/favicon.plugin.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.faviconPlugin = void 0;
+const fastify_favicon_1 = __importDefault(require("fastify-favicon"));
+const fastify_plugin_1 = __importDefault(require("fastify-plugin"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_url_1 = require("node:url");
+// @ts-ignore
+const dirname = node_path_1.default.dirname((0, node_url_1.fileURLToPath)(import.meta.url));
+const pathToImgDir = node_path_1.default.join(dirname, "../img");
+exports.faviconPlugin = (0, fastify_plugin_1.default)(async (instance) => {
+    console.log("pathToImgDir", pathToImgDir);
+    instance.register(fastify_favicon_1.default, { path: pathToImgDir });
+}, {
+    name: "favicon-plugin",
+});

package/dist/modules/dev/dev-server/plugins/multipart.plugin.d.ts

@@ -0,0 +1 @@
+export declare const multipartPlugin: (instance: import("fastify").FastifyInstance<import("fastify").RawServerDefault, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault>) => Promise<void>;

package/dist/modules/dev/dev-server/plugins/multipart.plugin.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.multipartPlugin = void 0;
+const fastify_plugin_1 = __importDefault(require("fastify-plugin"));
+const node_stream_1 = require("node:stream");
+/**
+ * Implementation is based on:
+ * https://github.com/facebook/metro/blob/347b1d7ed87995d7951aaa9fd597c04b06013dac/packages/metro/src/Server/MultipartResponse.js
+ */
+const CRLF = "\r\n";
+const BOUNDARY = "3beqjf3apnqeu3h5jqorms4i";
+exports.multipartPlugin = (0, fastify_plugin_1.default)(async (instance) => {
+    function asMultipart() {
+        // We should check if is included in accept or if accept has multipart/* or */*,
+        // but React Native will set accept to exactly `multipart/mixed`, so a simple check
+        // will suffice.
+        if (this.request.headers.accept !== "multipart/mixed") {
+            return undefined;
+        }
+        const headers = {};
+        const stream = new node_stream_1.PassThrough();
+        this.code(200)
+            .header("Content-Type", `multipart/mixed; boundary="${BOUNDARY}"`)
+            .send(stream);
+        function serializeHeaders(headers) {
+            return Object.keys(headers)
+                .map((key) => `${key}: ${headers[key]}`)
+                .join(CRLF);
+        }
+        function writeChunk(headers, data, isLast) {
+            let chunk = `${CRLF}--${BOUNDARY}${CRLF}`;
+            if (headers) {
+                chunk += serializeHeaders(headers) + CRLF + CRLF;
+            }
+            if (data) {
+                chunk += data;
+            }
+            if (isLast) {
+                chunk += `${CRLF}--${BOUNDARY}--${CRLF}`;
+            }
+            stream.write(chunk);
+        }
+        function setHeader(name, value) {
+            headers[name] = value;
+        }
+        function end(data) {
+            writeChunk(headers, data, true);
+            stream.end();
+        }
+        return {
+            writeChunk,
+            setHeader,
+            end,
+        };
+    }
+    instance.decorateReply("asMultipart", asMultipart);
+}, {
+    name: "multipart-plugin",
+});

package/dist/modules/dev/dev-server/plugins/symbolicate/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./sybmolicatePlugin";
+export * from "./types";

package/dist/modules/dev/dev-server/plugins/symbolicate/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./sybmolicatePlugin"), exports);
+__exportStar(require("./types"), exports);

package/dist/modules/dev/dev-server/plugins/symbolicate/sybmolicatePlugin.d.ts

@@ -0,0 +1 @@
+export declare const symbolicatePlugin: (instance: import("fastify").FastifyInstance<import("fastify").RawServerDefault, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault>) => Promise<void>;

package/dist/modules/dev/dev-server/plugins/symbolicate/sybmolicatePlugin.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.symbolicatePlugin = void 0;
+const fastify_plugin_1 = __importDefault(require("fastify-plugin"));
+exports.symbolicatePlugin = (0, fastify_plugin_1.default)(async (instance) => {
+    instance.post("/symbolicate", async (request, reply) => {
+        instance.log.info("Symbolicate endpoint hit", request.body);
+        const requestWithBody = request;
+        requestWithBody.rawBody = "";
+        requestWithBody.raw.setEncoding("utf8");
+        request.raw.on("data", (chunk) => {
+            requestWithBody.rawBody += chunk;
+        });
+        requestWithBody.raw.on("end", () => {
+            reply.send(requestWithBody.rawBody);
+        });
+    });
+}, {
+    name: "symbolicate-plugin",
+    dependencies: ["@fastify/sensible"],
+});

package/dist/modules/dev/dev-server/plugins/symbolicate/types.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Raw React Native stack frame.
+ */
+export interface ReactNativeStackFrame {
+    lineNumber: number | null;
+    column: number | null;
+    file: string | null;
+    methodName: string;
+}
+/**
+ * React Native stack frame used as input when processing by {@link Symbolicator}.
+ */
+export interface InputStackFrame extends ReactNativeStackFrame {
+    file: string;
+}
+/**
+ * Final symbolicated stack frame.
+ */
+export interface StackFrame extends InputStackFrame {
+    collapse: boolean;
+}
+/**
+ * Represents [@babel/core-frame](https://babeljs.io/docs/en/babel-code-frame).
+ */
+export interface CodeFrame {
+    content: string;
+    location: {
+        row: number;
+        column: number;
+    };
+    fileName: string;
+}
+/**
+ * Represents results of running {@link process} method on {@link Symbolicator} instance.
+ */
+export interface SymbolicatorResults {
+    codeFrame: CodeFrame | null;
+    stack: StackFrame[];
+}
+/**
+ * Delegate with implementation for symbolication functions.
+ */
+export interface SymbolicatorDelegate {
+    /**
+     * Get source code of file in the URL.
+     *
+     * @param fileUrl A full URL pointing to a file.
+     */
+    getSource: (fileUrl: string) => Promise<string | Buffer>;
+    /**
+     * Get source map for the file in the URL.
+     *
+     * @param fileUrl A full (usually `http:`) URL pointing to a compiled file.
+     * The URL points to a file for which to return source map, not to the source map file itself,
+     * e.g: `http://localhost:8081/index.bundle?platform=ios`.
+     */
+    getSourceMap: (fileUrl: string) => Promise<string | Buffer>;
+    /**
+     * Check if given stack frame should be included in the new symbolicated stack.
+     *
+     * @param frame Stack frame to check.
+     */
+    shouldIncludeFrame: (frame: StackFrame) => boolean;
+}

package/dist/modules/dev/dev-server/plugins/symbolicate/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/modules/dev/dev-server/plugins/types.d.ts

@@ -0,0 +1,11 @@
+import type { IncomingHttpHeaders } from 'node:http';
+export interface MultipartHandler {
+    writeChunk: <T>(headers: IncomingHttpHeaders, data: T, isLast?: boolean) => void;
+    setHeader: (name: string, value: string | string[] | undefined) => void;
+    end: <T>(data: T) => void;
+}
+declare module 'fastify' {
+    interface FastifyReply {
+        asMultipart: () => MultipartHandler | undefined;
+    }
+}

package/dist/modules/dev/dev-server/plugins/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/modules/dev/dev-server/plugins/wss/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./wss.plugin";
+export * from "./web-socket-server";
+export * from "./types";

package/dist/modules/dev/dev-server/plugins/wss/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./wss.plugin"), exports);
+__exportStar(require("./web-socket-server"), exports);
+__exportStar(require("./types"), exports);

package/dist/modules/dev/dev-server/plugins/wss/servers/web-socket-api.server.d.ts

@@ -0,0 +1,32 @@
+import type { FastifyInstance } from "fastify";
+import type WebSocket from "ws";
+import { WebSocketServer } from "../web-socket-server";
+/**
+ * Class for creating a WebSocket server for API clients.
+ * Useful to listening for compilation events and new logs.
+ *
+ * @category Development server
+ */
+export declare class WebSocketApiServer extends WebSocketServer {
+    private clients;
+    private nextClientId;
+    /**
+     * Create new instance of WebSocketApiServer and attach it to the given Fastify instance.
+     * Any logging information, will be passed through standard `fastify.log` API.
+     *
+     * @param fastify Fastify instance to attach the WebSocket server to.
+     */
+    constructor(fastify: FastifyInstance);
+    /**
+     * Send message to all connected API clients.
+     *
+     * @param event Event string or object to send.
+     */
+    send(event: any): void;
+    /**
+     * Process new WebSocket connection from client application.
+     *
+     * @param socket Incoming client's WebSocket connection.
+     */
+    onConnection(socket: WebSocket): void;
+}

package/dist/modules/dev/dev-server/plugins/wss/servers/web-socket-api.server.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketApiServer = void 0;
+const web_socket_server_1 = require("../web-socket-server");
+/**
+ * Class for creating a WebSocket server for API clients.
+ * Useful to listening for compilation events and new logs.
+ *
+ * @category Development server
+ */
+class WebSocketApiServer extends web_socket_server_1.WebSocketServer {
+    clients = new Map();
+    nextClientId = 0;
+    /**
+     * Create new instance of WebSocketApiServer and attach it to the given Fastify instance.
+     * Any logging information, will be passed through standard `fastify.log` API.
+     *
+     * @param fastify Fastify instance to attach the WebSocket server to.
+     */
+    constructor(fastify) {
+        super(fastify, "/api-console");
+    }
+    /**
+     * Send message to all connected API clients.
+     *
+     * @param event Event string or object to send.
+     */
+    send(event) {
+        const data = typeof event === "string" ? event : JSON.stringify(event);
+        for (const [, socket] of this.clients.entries()) {
+            try {
+                socket.send(data);
+            }
+            catch {
+                // NOOP
+            }
+        }
+    }
+    /**
+     * Process new WebSocket connection from client application.
+     *
+     * @param socket Incoming client's WebSocket connection.
+     */
+    onConnection(socket) {
+        const clientId = `client#${this.nextClientId++}`;
+        console.log("WebSocketApiServer onConnection", clientId, socket);
+        this.clients.set(clientId, socket);
+        this.fastify.log.debug({ msg: "API client connected", clientId });
+        this.clients.set(clientId, socket);
+        const onClose = () => {
+            this.fastify.log.debug({
+                msg: "API client disconnected",
+                clientId,
+            });
+            this.clients.delete(clientId);
+        };
+        socket.addEventListener("error", onClose);
+        socket.addEventListener("close", onClose);
+    }
+}
+exports.WebSocketApiServer = WebSocketApiServer;