@teardown/cli 1.2.34 → 1.2.36

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

@@ -0,0 +1,357 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketMessageServer = void 0;
+const node_url_1 = require("node:url");
+const web_socket_server_1 = require("../web-socket-server");
+/**
+ * Class for creating a WebSocket server and sending messages between development server
+ * and the React Native applications.
+ *
+ * Based on: https://github.com/react-native-community/cli/blob/v4.14.0/packages/cli-server-api/src/websocket/messageSocketServer.ts
+ *
+ * @category Development server
+ */
+class WebSocketMessageServer extends web_socket_server_1.WebSocketServer {
+    static PROTOCOL_VERSION = 2;
+    /**
+     * Check if message is a broadcast request.
+     *
+     * @param message Message to check.
+     * @returns True if message is a broadcast request and should be broadcasted
+     * with {@link sendBroadcast}.
+     */
+    static isBroadcast(message) {
+        return (typeof message.method === "string" &&
+            message.id === undefined &&
+            message.target === undefined);
+    }
+    /**
+     * Check if message is a method request.
+     *
+     * @param message Message to check.
+     * @returns True if message is a request.
+     */
+    static isRequest(message) {
+        return (typeof message.method === "string" && typeof message.target === "string");
+    }
+    /**
+     * Check if message is a response with results of performing some request.
+     *
+     * @param message Message to check.
+     * @returns True if message is a response.
+     */
+    static isResponse(message) {
+        return (typeof message.id === "object" &&
+            typeof message.id.requestId !== "undefined" &&
+            typeof message.id.clientId === "string" &&
+            (message.result !== undefined || message.error !== undefined));
+    }
+    clients = new Map();
+    nextClientId = 0;
+    /**
+     * Create new instance of WebSocketMessageServer 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, "/message");
+    }
+    /**
+     * Parse stringified message into a {@link ReactNativeMessage}.
+     *
+     * @param data Stringified message.
+     * @param binary Additional binary data if any.
+     * @returns Parsed message or `undefined` if parsing failed.
+     */
+    parseMessage(data, binary) {
+        console.log("parseMessage", data, binary);
+        if (binary) {
+            this.fastify.log.error({
+                msg: "Failed to parse message - expected text message, got binary",
+            });
+            return undefined;
+        }
+        try {
+            const message = JSON.parse(data);
+            if (message.version === WebSocketMessageServer.PROTOCOL_VERSION.toString()) {
+                return message;
+            }
+            this.fastify.log.error({
+                msg: "Received message had wrong protocol version",
+                message,
+            });
+        }
+        catch {
+            this.fastify.log.error({
+                msg: "Failed to parse the message as JSON",
+                data,
+            });
+        }
+        return undefined;
+    }
+    /**
+     * Get client's WebSocket connection for given `clientId`.
+     * Throws if no such client is connected.
+     *
+     * @param clientId Id of the client.
+     * @returns WebSocket connection.
+     */
+    getClientSocket(clientId) {
+        console.log("getClientSocket", clientId);
+        const socket = this.clients.get(clientId);
+        if (socket === undefined) {
+            throw new Error(`Could not find client with id "${clientId}"`);
+        }
+        return socket;
+    }
+    /**
+     * Process error by sending an error message to the client whose message caused the error
+     * to occur.
+     *
+     * @param clientId Id of the client whose message caused an error.
+     * @param message Original message which caused the error.
+     * @param error Concrete instance of an error that occurred.
+     */
+    handleError(clientId, message, error) {
+        console.log("handleError", clientId, message, error);
+        const errorMessage = {
+            id: message.id,
+            method: message.method,
+            target: message.target,
+            error: message.error === undefined ? "undefined" : "defined",
+            params: message.params === undefined ? "undefined" : "defined",
+            result: message.result === undefined ? "undefined" : "defined",
+        };
+        if (message.id === undefined) {
+            this.fastify.log.error({
+                msg: "Handling message failed",
+                clientId,
+                error,
+                errorMessage,
+            });
+        }
+        else {
+            try {
+                const socket = this.getClientSocket(clientId);
+                socket.send(JSON.stringify({
+                    version: WebSocketMessageServer.PROTOCOL_VERSION,
+                    error,
+                    id: message.id,
+                }));
+            }
+            catch (error) {
+                this.fastify.log.error("Failed to reply", {
+                    clientId,
+                    error,
+                    errorMessage,
+                });
+            }
+        }
+    }
+    /**
+     * Send given request `message` to it's designated client's socket based on `message.target`.
+     * The target client must be connected, otherwise it will throw an error.
+     *
+     * @param clientId Id of the client that requested the forward.
+     * @param message Message to forward.
+     */
+    forwardRequest(clientId, message) {
+        console.log("forwardRequest", clientId, message);
+        if (!message.target) {
+            this.fastify.log.error({
+                msg: "Failed to forward request - message.target is missing",
+                clientId,
+                message,
+            });
+            return;
+        }
+        const socket = this.getClientSocket(message.target);
+        socket.send(JSON.stringify({
+            version: WebSocketMessageServer.PROTOCOL_VERSION,
+            method: message.method,
+            params: message.params,
+            id: message.id === undefined
+                ? undefined
+                : { requestId: message.id, clientId },
+        }));
+    }
+    /**
+     * Send given response `message` to it's designated client's socket based
+     * on `message.id.clientId`.
+     * The target client must be connected, otherwise it will throw an error.
+     *
+     * @param message Message to forward.
+     */
+    forwardResponse(message) {
+        console.log("forwardResponse", message);
+        if (!message.id) {
+            return;
+        }
+        const socket = this.getClientSocket(message.id.clientId);
+        socket.send(JSON.stringify({
+            version: WebSocketMessageServer.PROTOCOL_VERSION,
+            result: message.result,
+            error: message.error,
+            id: message.id.requestId,
+        }));
+    }
+    /**
+     * Process request message targeted towards this {@link WebSocketMessageServer}
+     * and send back the results.
+     *
+     * @param clientId Id of the client who send the message.
+     * @param message The message to process by the server.
+     */
+    processServerRequest(clientId, message) {
+        console.log("processServerRequest", clientId, message);
+        let result;
+        switch (message.method) {
+            case "getid":
+                result = clientId;
+                break;
+            case "getpeers": {
+                const output = {};
+                this.clients.forEach((peerSocket, peerId) => {
+                    if (clientId !== peerId) {
+                        const { searchParams } = new node_url_1.URL(peerSocket.upgradeReq?.url || "");
+                        output[peerId] = [...searchParams.entries()].reduce((acc, [key, value]) => {
+                            acc[key] = value;
+                            return acc;
+                        }, {});
+                    }
+                });
+                result = output;
+                break;
+            }
+            default:
+                throw new Error(`Cannot process server request - unknown method ${JSON.stringify({
+                    clientId,
+                    message,
+                })}`);
+        }
+        const socket = this.getClientSocket(clientId);
+        socket.send(JSON.stringify({
+            version: WebSocketMessageServer.PROTOCOL_VERSION,
+            result,
+            id: message.id,
+        }));
+    }
+    /**
+     * Broadcast given message to all connected clients.
+     *
+     * @param broadcasterId Id of the client who is broadcasting.
+     * @param message Message to broadcast.
+     */
+    sendBroadcast(broadcasterId, message) {
+        const forwarded = {
+            version: WebSocketMessageServer.PROTOCOL_VERSION,
+            method: message.method,
+            params: message.params,
+        };
+        if (this.clients.size === 0) {
+            this.fastify.log.warn({
+                msg: 
+                // biome-ignore lint/style/useTemplate: <explanation>
+                "No apps connected. " +
+                    `Sending "${message.method}" to all React Native apps failed. ` +
+                    "Make sure your app is running in the simulator or on a phone connected via USB.",
+            });
+        }
+        for (const [clientId, socket] of this.clients) {
+            if (clientId !== broadcasterId) {
+                try {
+                    socket.send(JSON.stringify(forwarded));
+                }
+                catch (error) {
+                    this.fastify.log.error({
+                        msg: "Failed to send broadcast",
+                        clientId,
+                        error,
+                        forwarded,
+                    });
+                }
+            }
+        }
+    }
+    /**
+     * Send method broadcast to all connected clients.
+     *
+     * @param method Method name to broadcast.
+     * @param params Method parameters.
+     */
+    broadcast(method, params) {
+        this.sendBroadcast(undefined, { method, params });
+    }
+    /**
+     * Process new client's WebSocket connection.
+     *
+     * @param socket Incoming WebSocket connection.
+     * @param request Upgrade request for the connection.
+     */
+    onConnection(socket, request) {
+        const clientId = `client#${this.nextClientId++}`;
+        const client = socket;
+        client.upgradeReq = request;
+        this.clients.set(clientId, client);
+        this.fastify.log.debug({ msg: "Message client connected", clientId });
+        const cleanup = () => {
+            this.fastify.log.debug({ msg: "Cleaning up message client", clientId });
+            socket.removeAllListeners();
+            this.clients.delete(clientId);
+        };
+        const onClose = (close) => {
+            this.fastify.log.debug({
+                msg: "Message client closed",
+                clientId,
+                close,
+            });
+            cleanup();
+        };
+        const onError = (error) => {
+            this.fastify.log.error({ msg: "Message client error", clientId, error });
+            cleanup();
+        };
+        socket.addEventListener("error", onError);
+        socket.addEventListener("close", onClose);
+        socket.addEventListener("message", (event) => {
+            const message = this.parseMessage(event.data.toString(), 
+            // @ts-ignore
+            event.binary);
+            if (!message) {
+                this.fastify.log.error({
+                    msg: "Received message not matching protocol",
+                    clientId,
+                    message,
+                });
+                return;
+            }
+            try {
+                if (WebSocketMessageServer.isBroadcast(message)) {
+                    this.sendBroadcast(clientId, message);
+                }
+                else if (WebSocketMessageServer.isRequest(message)) {
+                    if (message.target === "server") {
+                        this.processServerRequest(clientId, message);
+                    }
+                    else {
+                        this.forwardRequest(clientId, message);
+                    }
+                }
+                else if (WebSocketMessageServer.isResponse(message)) {
+                    this.forwardResponse(message);
+                }
+                else {
+                    throw new Error(`Invalid message, did not match the protocol ${JSON.stringify({
+                        clientId,
+                        message,
+                    })}`);
+                }
+            }
+            catch (error) {
+                this.handleError(clientId, message, error);
+            }
+        });
+    }
+}
+exports.WebSocketMessageServer = WebSocketMessageServer;

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

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

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketRouter = void 0;
+/**
+ * Class for creating a WebSocket router to forward connections to the
+ * respective {@link WebSocketServer} as long as the connection is accepted for the upgrade by the
+ * server.
+ *
+ * If the connection is not accepted by any `WebSocketServer`, it will be destroyed to avoid
+ * creating handling connections and potentially throwing `ECONNRESET` errors.
+ *
+ * @category Development server
+ */
+class WebSocketRouter {
+    fastify;
+    /** The list of all register WebSocket servers. */
+    servers = [];
+    /**
+     * Create new instance of `WebSocketRouter` 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 router to.
+     */
+    constructor(fastify) {
+        this.fastify = fastify;
+        this.fastify.server.on("upgrade", (request, socket, head) => {
+            const { pathname } = new URL(request.url || "", "http://localhost");
+            let matched = false;
+            for (const server of this.servers) {
+                if (server.shouldUpgrade(pathname)) {
+                    matched = true;
+                    server.upgrade(request, socket, head);
+                    break;
+                }
+            }
+            if (!matched) {
+                this.fastify.log.debug({
+                    msg: "Destroying socket connection as no server was matched",
+                    pathname,
+                });
+                socket.destroy();
+            }
+        });
+    }
+    /**
+     * Register a new {@link WebSocketServer}. New connection will now
+     * check if the given server will accept them and forward them.
+     *
+     * @param server WebSocket server to register.
+     * @returns The same instance of the WebSocket server after it's been registered.
+     */
+    registerServer(server) {
+        this.servers.push(server);
+        return server;
+    }
+}
+exports.WebSocketRouter = WebSocketRouter;

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketServerAdapter = void 0;
+class WebSocketServerAdapter {
+    fastify;
+    path;
+    server;
+    constructor(fastify, path, server) {
+        this.fastify = fastify;
+        this.path = path;
+        this.server = server;
+    }
+    shouldUpgrade(pathname) {
+        if (!this.server) {
+            this.fastify.log.warn({ msg: `No handler active for ${this.path}` });
+            return false;
+        }
+        return this.path === pathname;
+    }
+    upgrade(request, socket, head) {
+        this.server?.handleUpgrade(request, socket, head, (webSocket) => {
+            this.server?.emit("connection", webSocket, request);
+        });
+    }
+}
+exports.WebSocketServerAdapter = WebSocketServerAdapter;

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketServer = void 0;
+const ws_1 = require("ws");
+/**
+/**
+ * Abstract class for providing common logic (eg routing) for all WebSocket servers.
+ *
+ * @category Development server
+ */
+class WebSocketServer {
+    /** An instance of the underlying WebSocket server. */
+    server;
+    /** Fastify instance from which {@link server} will receive upgrade connections. */
+    fastify;
+    paths;
+    /**
+     * Create a new instance of the WebSocketServer.
+     * Any logging information, will be passed through standard `fastify.log` API.
+     *
+     * @param fastify Fastify instance to which the WebSocket will be attached to.
+     * @param path Path on which this WebSocketServer will be accepting connections.
+     * @param wssOptions WebSocket Server options.
+     */
+    constructor(fastify, path, wssOptions = {}) {
+        this.fastify = fastify;
+        this.server = new ws_1.WebSocketServer({ noServer: true, ...wssOptions });
+        this.server.on("connection", this.onConnection.bind(this));
+        this.server.on("error", this.onError.bind(this));
+        this.server.on("message", this.onMessage.bind(this));
+        this.server.on("close", this.onClose.bind(this));
+        this.paths = Array.isArray(path) ? path : [path];
+    }
+    shouldUpgrade(pathname) {
+        return this.paths.includes(pathname);
+    }
+    upgrade(request, socket, head) {
+        this.server.handleUpgrade(request, socket, head, (webSocket) => {
+            this.server.emit("connection", webSocket, request);
+        });
+    }
+    onError(error) { }
+    onMessage(message) { }
+    onClose(socket) { }
+}
+exports.WebSocketServer = WebSocketServer;

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

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wssPlugin = void 0;
+const fastify_plugin_1 = __importDefault(require("fastify-plugin"));
+const web_socket_debugger_server_1 = require("./servers/web-socket-debugger.server");
+const web_socket_dev_client_server_1 = require("./servers/web-socket-dev-client.server");
+const web_socket_hmr_server_1 = require("./servers/web-socket-hmr.server");
+const web_socket_router_1 = require("./web-socket-router");
+const web_socket_server_adapter_1 = require("./web-socket-server-adapter");
+/**
+ * Defined in @react-native/dev-middleware
+ * Reference: https://github.com/facebook/react-native/blob/main/packages/dev-middleware/src/inspector-proxy/InspectorProxy.js
+ */
+const WS_DEVICE_URL = "/inspector/device";
+const WS_DEBUGGER_URL = "/inspector/debug";
+const WS_NETWORK_URL = "/inspector/network";
+exports.wssPlugin = (0, fastify_plugin_1.default)(async (instance, { metroConfig, metroServer, onClientConnected, endpoints, messageServer, eventsServer, apiServer, }) => {
+    const router = new web_socket_router_1.WebSocketRouter(instance);
+    const debuggerServer = new web_socket_debugger_server_1.WebSocketDebuggerServer(instance);
+    const devClientServer = new web_socket_dev_client_server_1.WebSocketDevClientServer(instance);
+    const hmrServer = new web_socket_hmr_server_1.WebSocketHMRServer(instance, {
+        metroConfig,
+        metroServer,
+        onClientConnected,
+    });
+    // @react-native/dev-middleware servers
+    const deviceConnectionServer = new web_socket_server_adapter_1.WebSocketServerAdapter(instance, WS_DEVICE_URL, endpoints[WS_DEVICE_URL]);
+    const debuggerConnectionServer = new web_socket_server_adapter_1.WebSocketServerAdapter(instance, WS_DEBUGGER_URL, endpoints[WS_DEBUGGER_URL]);
+    const networkConnectionServer = new web_socket_server_adapter_1.WebSocketServerAdapter(instance, WS_NETWORK_URL, endpoints[WS_NETWORK_URL]);
+    router.registerServer(debuggerServer);
+    router.registerServer(devClientServer);
+    router.registerServer(messageServer);
+    router.registerServer(eventsServer);
+    router.registerServer(apiServer);
+    router.registerServer(hmrServer);
+    router.registerServer(deviceConnectionServer);
+    router.registerServer(debuggerConnectionServer);
+    router.registerServer(networkConnectionServer);
+    instance.decorate("wss", {
+        debuggerServer,
+        devClientServer,
+        messageServer,
+        eventsServer,
+        apiServer,
+        hmrServer,
+        deviceConnectionServer,
+        debuggerConnectionServer,
+        router,
+    });
+}, {
+    name: "wss-plugin",
+});

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

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rawBodyPlugin = exports.symbolicatePlugin = void 0;
+const fastify_plugin_1 = __importDefault(require("fastify-plugin"));
+exports.symbolicatePlugin = (0, fastify_plugin_1.default)(async (instance, options) => {
+    instance.log.info("Symbolicate plugin registered");
+    instance.use((request, reply, next) => {
+        if (request.url !== "/symbolicate") {
+            next();
+            return;
+        }
+        instance.log.info("symbolicate onRequest", request.url);
+        const requestWithBody = request;
+        requestWithBody.rawBody = "";
+        requestWithBody.setEncoding("utf8");
+        requestWithBody.on("data", (chunk) => {
+            requestWithBody.rawBody += chunk;
+        });
+        requestWithBody.on("end", () => {
+            options.onSymbolicate(requestWithBody, reply);
+            next();
+        });
+    });
+}, {
+    name: "symbolicate-plugin",
+    dependencies: ["@fastify/sensible"],
+});
+exports.rawBodyPlugin = (0, fastify_plugin_1.default)((instance, options) => {
+    instance.addHook("preHandler", (request, reply, next) => {
+        // request.rawBody = "";
+        next();
+    });
+});

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

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

package/dist/modules/dev/terminal/base.terminal.reporter.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseTerminalReporter = void 0;
+const metro_1 = require("metro");
+class BaseTerminalReporter extends metro_1.TerminalReporter {
+    // constructor(terminal: Terminal) {
+    // 	super(terminal);
+    // }
+    update(event) {
+        // @ts-ignore
+        super.update(event);
+    }
+    _getElapsedTime(startTime) {
+        // @ts-ignore
+        return super._getElapsedTime(startTime);
+    }
+    _log(event) {
+        // @ts-ignore
+        super._log(event);
+    }
+    _logInitializing(port, hasReducedPerformance) {
+        // @ts-ignore
+        super._logInitializing(port, hasReducedPerformance);
+    }
+    _logInitializingFailed(port, error) {
+        // @ts-ignore
+        super._logInitializingFailed(port, error);
+    }
+    _logBundleBuildDone(buildID) {
+        // @ts-ignore
+        super._logBundleBuildDone(buildID);
+    }
+    _logBundleBuildFailed(buildID) {
+        // @ts-ignore
+        super._logBundleBuildFailed(buildID);
+    }
+    _logBundlingError(error) {
+        // @ts-ignore
+        super._logBundlingError(error);
+    }
+    _logWorkerChunk(origin, chunk) {
+        // @ts-ignore
+        super._logWorkerChunk(origin, chunk);
+    }
+    _logHmrClientError(error) {
+        // @ts-ignore
+        super._logHmrClientError(error);
+    }
+    _logWarning(message) {
+        // @ts-ignore
+        super._logWarning(message);
+    }
+    _logWatcherHealthCheckResult(result) {
+        // @ts-ignore
+        super._logWatcherHealthCheckResult(result);
+    }
+    _logWatcherStatus(status) {
+        // @ts-ignore
+        super._logWatcherStatus(status);
+    }
+    _getBundleStatusMessage(progress, phase) {
+        // @ts-ignore
+        return super._getBundleStatusMessage(progress, phase);
+    }
+    _updateBundleProgress(data) {
+        // @ts-ignore
+        super._updateBundleProgress(data);
+    }
+    _updateState(event) {
+        // @ts-ignore
+        super._updateState(event);
+    }
+    _getStatusMessage() {
+        // @ts-ignore
+        return super._getStatusMessage();
+    }
+}
+exports.BaseTerminalReporter = BaseTerminalReporter;