@teardown/cli 1.2.28 → 1.2.30

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

@@ -0,0 +1,577 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Device = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_url_1 = require("node:url");
+const ws_1 = __importDefault(require("ws"));
+const device_event_reporter_1 = require("./device.event-reporter");
+const debug = require("debug")("Metro:InspectorProxy");
+const PAGES_POLLING_INTERVAL = 1000;
+// Constants for host rewriting
+const REWRITE_HOSTS_TO_LOCALHOST = [
+    "127.0.0.1",
+    "10.0.2.2",
+    "10.0.3.2",
+];
+const FILE_PREFIX = "file://";
+const REACT_NATIVE_RELOADABLE_PAGE_ID = "-1";
+class Device {
+    id;
+    name;
+    app;
+    messageFromDeviceQueue = Promise.resolve();
+    deviceSocket;
+    pages = new Map();
+    debuggerConnection = null;
+    lastConnectedLegacyReactNativePage = null;
+    isLegacyPageReloading = false;
+    lastGetPagesMessage = "";
+    scriptIdToSourcePathMapping = new Map();
+    projectRoot;
+    deviceEventReporter;
+    pagesPollingIntervalId;
+    createCustomMessageHandler;
+    connectedPageIds = new Set();
+    constructor(id, name, app, socket, projectRoot, eventReporter) {
+        this.id = id;
+        this.name = name;
+        this.app = app;
+        this.deviceSocket = socket;
+        this.projectRoot = projectRoot;
+        this.deviceEventReporter =
+            eventReporter != null
+                ? new device_event_reporter_1.DeviceEventReporter(eventReporter, {
+                    deviceId: id,
+                    deviceName: name,
+                    appId: app,
+                })
+                : null;
+        this.createCustomMessageHandler = null;
+        // Setup message handling
+        this.deviceSocket.on("message", (message) => {
+            this.messageFromDeviceQueue = this.messageFromDeviceQueue
+                .then(async () => {
+                const parsedMessage = JSON.parse(message);
+                if (parsedMessage.event === "getPages") {
+                    if (message !== this.lastGetPagesMessage) {
+                        debug(`(Debugger)    (Proxy) <- (Device), getPages ping has changed: ${message}`);
+                        this.lastGetPagesMessage = message;
+                    }
+                }
+                else {
+                    debug(`(Debugger)    (Proxy) <- (Device): ${message}`);
+                }
+                await this.handleMessageFromDevice(parsedMessage);
+            })
+                .catch((error) => {
+                debug("%O\nHandling device message: %s", error, message);
+                try {
+                    this.deviceEventReporter?.logProxyMessageHandlingError("device", error, message);
+                }
+                catch (loggingError) {
+                    debug("Error logging message handling error to reporter: %O", loggingError);
+                }
+            });
+        });
+        // Setup polling
+        this.pagesPollingIntervalId = setInterval(() => this.sendMessageToDevice({ event: "getPages" }), PAGES_POLLING_INTERVAL);
+        // Handle socket close
+        this.deviceSocket.on("close", () => {
+            if (socket === this.deviceSocket) {
+                this.deviceEventReporter?.logDisconnection("device");
+                this.terminateDebuggerConnection();
+                clearInterval(this.pagesPollingIntervalId);
+            }
+        });
+    }
+    terminateDebuggerConnection() {
+        const debuggerConnection = this.debuggerConnection;
+        if (debuggerConnection) {
+            this.sendDisconnectEventToDevice(this.mapToDevicePageId(debuggerConnection.pageId));
+            debuggerConnection.socket.close();
+            this.debuggerConnection = null;
+        }
+    }
+    dangerouslyRecreateDevice(id, name, app, socket, projectRoot, eventReporter) {
+        invariant(id === this.id, "dangerouslyRecreateDevice() can only be used for the same device ID");
+        const oldDebugger = this.debuggerConnection;
+        if (this.app !== app || this.name !== name) {
+            this.deviceSocket.close();
+            this.terminateDebuggerConnection();
+        }
+        this.debuggerConnection = null;
+        if (oldDebugger) {
+            oldDebugger.socket.removeAllListeners();
+            this.deviceSocket.close();
+            this.handleDebuggerConnection(oldDebugger.socket, oldDebugger.pageId, {
+                userAgent: oldDebugger.userAgent,
+            });
+        }
+        this.id = id;
+        this.name = name;
+        this.app = app;
+        this.deviceSocket = socket;
+        this.projectRoot = projectRoot;
+        this.deviceEventReporter = eventReporter
+            ? new device_event_reporter_1.DeviceEventReporter(eventReporter, {
+                deviceId: id,
+                deviceName: name,
+                appId: app,
+            })
+            : null;
+    }
+    getName() {
+        return this.name;
+    }
+    getApp() {
+        return this.app;
+    }
+    getPagesList() {
+        if (this.lastConnectedLegacyReactNativePage) {
+            return [...this.pages.values(), this.createSyntheticPage()];
+        }
+        return [...this.pages.values()];
+    }
+    handleDebuggerConnection(socket, pageId, metadata) {
+        const page = pageId === REACT_NATIVE_RELOADABLE_PAGE_ID
+            ? this.createSyntheticPage()
+            : this.pages.get(pageId);
+        if (!page) {
+            debug(`Got new debugger connection for page ${pageId} of ${this.name}, but no such page exists`);
+            socket.close();
+            return;
+        }
+        this.deviceEventReporter?.logDisconnection("debugger");
+        this.terminateDebuggerConnection();
+        this.deviceEventReporter?.logConnection("debugger", {
+            pageId,
+            frontendUserAgent: metadata.userAgent,
+        });
+        const debuggerInfo = {
+            socket,
+            prependedFilePrefix: false,
+            pageId,
+            userAgent: metadata.userAgent,
+            customHandler: null,
+        };
+        this.debuggerConnection = debuggerInfo;
+        if (this.debuggerConnection && this.createCustomMessageHandler) {
+            this.debuggerConnection.customHandler = this.createCustomMessageHandler({
+                page,
+                debugger: {
+                    userAgent: debuggerInfo.userAgent,
+                    sendMessage: (message) => {
+                        try {
+                            const payload = JSON.stringify(message);
+                            debug(`(Debugger) <- (Proxy)    (Device): ${payload}`);
+                            socket.send(payload);
+                        }
+                        catch { }
+                    },
+                },
+                device: {
+                    appId: this.app,
+                    id: this.id,
+                    name: this.name,
+                    sendMessage: (message) => {
+                        try {
+                            const payload = JSON.stringify({
+                                event: "wrappedEvent",
+                                payload: {
+                                    pageId: this.mapToDevicePageId(pageId),
+                                    wrappedEvent: JSON.stringify(message),
+                                },
+                            });
+                            debug(`(Debugger) -> (Proxy)    (Device): ${payload}`);
+                            this.deviceSocket.send(payload);
+                        }
+                        catch { }
+                    },
+                },
+            });
+        }
+        this.sendConnectEventToDevice(this.mapToDevicePageId(pageId));
+        socket.on("message", (message) => {
+            debug(`(Debugger) -> (Proxy)    (Device): ${message}`);
+            const debuggerRequest = JSON.parse(message);
+            this.deviceEventReporter?.logRequest(debuggerRequest, "debugger", {
+                pageId: this.debuggerConnection?.pageId ?? null,
+                frontendUserAgent: metadata.userAgent,
+                prefersFuseboxFrontend: this.isPageFuseboxFrontend(this.debuggerConnection?.pageId ?? null),
+            });
+            if (this.debuggerConnection?.customHandler?.handleDebuggerMessage(debuggerRequest) === true) {
+                return;
+            }
+            if (!this.pageHasCapability(page, "nativeSourceCodeFetching")) {
+                const processedReq = this.interceptClientMessageForSourceFetching(debuggerRequest, debuggerInfo, socket);
+                if (processedReq) {
+                    this.sendMessageToDevice({
+                        event: "wrappedEvent",
+                        payload: {
+                            pageId: this.mapToDevicePageId(pageId),
+                            wrappedEvent: JSON.stringify(processedReq),
+                        },
+                    });
+                }
+            }
+        });
+        socket.on("close", () => {
+            debug(`Debugger for page ${pageId} and ${this.name} disconnected.`);
+            this.deviceEventReporter?.logDisconnection("debugger");
+            if (this.debuggerConnection?.socket === socket) {
+                this.terminateDebuggerConnection();
+            }
+        });
+        const sendFunc = socket.send.bind(socket);
+        socket.send = (message) => {
+            debug(`(Debugger) <- (Proxy)    (Device): ${message}`);
+            return sendFunc(message);
+        };
+    }
+    sendConnectEventToDevice(devicePageId) {
+        if (this.connectedPageIds.has(devicePageId)) {
+            return;
+        }
+        this.connectedPageIds.add(devicePageId);
+        this.sendMessageToDevice({
+            event: "connect",
+            payload: { pageId: devicePageId },
+        });
+    }
+    sendDisconnectEventToDevice(devicePageId) {
+        if (!this.connectedPageIds.has(devicePageId)) {
+            return;
+        }
+        this.connectedPageIds.delete(devicePageId);
+        this.sendMessageToDevice({
+            event: "disconnect",
+            payload: { pageId: devicePageId },
+        });
+    }
+    pageHasCapability(page, flag) {
+        return page.capabilities[flag] === true;
+    }
+    createSyntheticPage() {
+        return {
+            id: REACT_NATIVE_RELOADABLE_PAGE_ID,
+            title: "React Native Experimental (Improved Chrome Reloads)",
+            vm: "don't use",
+            app: this.app,
+            capabilities: {},
+        };
+    }
+    async handleMessageFromDevice(message) {
+        if (message.event === "getPages") {
+            this.pages = new Map(message.payload.map((page) => {
+                const { capabilities = {}, ...rest } = page;
+                return [
+                    rest.id,
+                    {
+                        ...rest,
+                        capabilities,
+                    },
+                ];
+            }));
+            for (const page of this.pages.values()) {
+                if (this.pageHasCapability(page, "nativePageReloads")) {
+                    continue;
+                }
+                if (page.title.includes("React")) {
+                    if (page.id !== this.lastConnectedLegacyReactNativePage?.id) {
+                        this.newLegacyReactNativePage(page);
+                        break;
+                    }
+                }
+            }
+        }
+        else if (message.event === "disconnect") {
+            const pageId = message.payload.pageId;
+            const page = this.pages.get(pageId);
+            if (page && this.pageHasCapability(page, "nativePageReloads")) {
+                return;
+            }
+            const debuggerSocket = this.debuggerConnection?.socket;
+            if (debuggerSocket && debuggerSocket.readyState === ws_1.default.OPEN) {
+                if (this.debuggerConnection &&
+                    this.debuggerConnection.pageId !== REACT_NATIVE_RELOADABLE_PAGE_ID) {
+                    debug(`Legacy page ${pageId} is reloading.`);
+                    debuggerSocket.send(JSON.stringify({ method: "reload" }));
+                }
+            }
+        }
+        else if (message.event === "wrappedEvent") {
+            if (!this.debuggerConnection) {
+                return;
+            }
+            const debuggerSocket = this.debuggerConnection.socket;
+            if (!debuggerSocket || debuggerSocket.readyState !== ws_1.default.OPEN) {
+                return;
+            }
+            const parsedPayload = JSON.parse(message.payload.wrappedEvent);
+            const pageId = this.debuggerConnection.pageId;
+            if ("id" in parsedPayload) {
+                this.deviceEventReporter?.logResponse(parsedPayload, "device", {
+                    pageId,
+                    frontendUserAgent: this.debuggerConnection.userAgent,
+                    prefersFuseboxFrontend: this.isPageFuseboxFrontend(pageId),
+                });
+            }
+            if (this.debuggerConnection.customHandler?.handleDeviceMessage(parsedPayload) === true) {
+                return;
+            }
+            await this.processMessageFromDeviceLegacy(parsedPayload, this.debuggerConnection, pageId);
+            debuggerSocket.send(JSON.stringify(parsedPayload));
+        }
+    }
+    sendMessageToDevice(message) {
+        try {
+            if (message.event !== "getPages") {
+                debug(`(Debugger)    (Proxy) -> (Device): ${JSON.stringify(message)}`);
+            }
+            this.deviceSocket.send(JSON.stringify(message));
+        }
+        catch (error) { }
+    }
+    newLegacyReactNativePage(page) {
+        debug(`React Native page updated to ${page.id}`);
+        if (!this.debuggerConnection ||
+            this.debuggerConnection.pageId !== REACT_NATIVE_RELOADABLE_PAGE_ID) {
+            this.lastConnectedLegacyReactNativePage = page;
+            return;
+        }
+        const oldPageId = this.lastConnectedLegacyReactNativePage?.id;
+        this.lastConnectedLegacyReactNativePage = page;
+        this.isLegacyPageReloading = true;
+        if (oldPageId != null) {
+            this.sendDisconnectEventToDevice(oldPageId);
+        }
+        this.sendConnectEventToDevice(page.id);
+        const toSend = [
+            { method: "Runtime.enable", id: 1e9 },
+            { method: "Debugger.enable", id: 1e9 },
+        ];
+        for (const message of toSend) {
+            const pageId = this.debuggerConnection?.pageId ?? null;
+            this.deviceEventReporter?.logRequest(message, "proxy", {
+                pageId,
+                frontendUserAgent: this.debuggerConnection?.userAgent ?? null,
+                prefersFuseboxFrontend: this.isPageFuseboxFrontend(pageId),
+            });
+            this.sendMessageToDevice({
+                event: "wrappedEvent",
+                payload: {
+                    pageId: this.mapToDevicePageId(page.id),
+                    wrappedEvent: JSON.stringify(message),
+                },
+            });
+        }
+    }
+    async processMessageFromDeviceLegacy(payload, debuggerInfo, pageId) {
+        const page = pageId != null ? this.pages.get(pageId) : null;
+        if ((!page || !this.pageHasCapability(page, "nativeSourceCodeFetching")) &&
+            payload.method === "Debugger.scriptParsed" &&
+            // @ts-ignore
+            payload.params != null) {
+            // @ts-ignore
+            const params = payload.params;
+            if ("sourceMapURL" in params) {
+                for (const hostToRewrite of REWRITE_HOSTS_TO_LOCALHOST) {
+                    if (params.sourceMapURL.includes(hostToRewrite)) {
+                        // @ts-ignore
+                        payload.params.sourceMapURL = params.sourceMapURL.replace(hostToRewrite, "localhost");
+                        debuggerInfo.originalSourceURLAddress = hostToRewrite;
+                    }
+                }
+                const sourceMapURL = this.tryParseHTTPURL(params.sourceMapURL);
+                if (sourceMapURL) {
+                    try {
+                        const sourceMap = await this.fetchText(sourceMapURL);
+                        // @ts-ignore
+                        payload.params.sourceMapURL = `data:application/json;charset=utf-8;base64,${Buffer.from(sourceMap).toString("base64")}`;
+                    }
+                    catch (exception) {
+                        const exceptionMessage = exception instanceof Error
+                            ? exception.message
+                            : String(exception);
+                        this.sendErrorToDebugger(`Failed to fetch source map ${params.sourceMapURL}: ${exceptionMessage}`);
+                    }
+                }
+            }
+            if ("url" in params) {
+                for (const hostToRewrite of REWRITE_HOSTS_TO_LOCALHOST) {
+                    if (params?.url?.includes(hostToRewrite)) {
+                        payload.params.url = params.url.replace(hostToRewrite, "localhost");
+                        debuggerInfo.originalSourceURLAddress = hostToRewrite;
+                    }
+                }
+                if (payload.params.url.match(/^[0-9a-z]+$/)) {
+                    payload.params.url = FILE_PREFIX + payload.params.url;
+                    debuggerInfo.prependedFilePrefix = true;
+                }
+                if (params.scriptId != null) {
+                    this.scriptIdToSourcePathMapping.set(params.scriptId, params.url);
+                }
+            }
+        }
+        if (payload.method === "Runtime.executionContextCreated" &&
+            this.isLegacyPageReloading) {
+            debuggerInfo.socket.send(JSON.stringify({ method: "Runtime.executionContextsCleared" }));
+            const resumeMessage = { method: "Debugger.resume", id: 0 };
+            this.deviceEventReporter?.logRequest(resumeMessage, "proxy", {
+                pageId: this.debuggerConnection?.pageId ?? null,
+                frontendUserAgent: this.debuggerConnection?.userAgent ?? null,
+                prefersFuseboxFrontend: this.isPageFuseboxFrontend(this.debuggerConnection?.pageId ?? null),
+            });
+            this.sendMessageToDevice({
+                event: "wrappedEvent",
+                payload: {
+                    pageId: this.mapToDevicePageId(debuggerInfo.pageId),
+                    wrappedEvent: JSON.stringify(resumeMessage),
+                },
+            });
+            this.isLegacyPageReloading = false;
+        }
+    }
+    interceptClientMessageForSourceFetching(req, debuggerInfo, socket) {
+        switch (req.method) {
+            case "Debugger.setBreakpointByUrl":
+                return this.processDebuggerSetBreakpointByUrl(req, debuggerInfo);
+            case "Debugger.getScriptSource":
+                this.processDebuggerGetScriptSource(req, socket);
+                return null;
+            default:
+                return req;
+        }
+    }
+    processDebuggerSetBreakpointByUrl(req, debuggerInfo) {
+        if (debuggerInfo.originalSourceURLAddress != null) {
+            const processedReq = { ...req, params: { ...req.params } };
+            if (processedReq.params.url != null) {
+                processedReq.params.url = processedReq.params.url.replace("localhost", debuggerInfo.originalSourceURLAddress);
+                if (processedReq.params.url?.startsWith(FILE_PREFIX) &&
+                    debuggerInfo.prependedFilePrefix) {
+                    processedReq.params.url = processedReq.params.url.slice(FILE_PREFIX.length);
+                }
+            }
+            if (processedReq.params.urlRegex != null) {
+                processedReq.params.urlRegex = processedReq.params.urlRegex.replace(/localhost/g, debuggerInfo.originalSourceURLAddress);
+            }
+            return processedReq;
+        }
+        return req;
+    }
+    processDebuggerGetScriptSource(req, socket) {
+        const sendSuccessResponse = (scriptSource) => {
+            const result = { scriptSource };
+            const response = {
+                id: req.id,
+                result,
+            };
+            socket.send(JSON.stringify(response));
+            const pageId = this.debuggerConnection?.pageId ?? null;
+            this.deviceEventReporter?.logResponse(response, "proxy", {
+                pageId,
+                frontendUserAgent: this.debuggerConnection?.userAgent ?? null,
+                prefersFuseboxFrontend: this.isPageFuseboxFrontend(pageId),
+            });
+        };
+        const sendErrorResponse = (error) => {
+            const result = { error: { message: error } };
+            const response = { id: req.id, result };
+            socket.send(JSON.stringify(response));
+            this.sendErrorToDebugger(error);
+            const pageId = this.debuggerConnection?.pageId ?? null;
+            this.deviceEventReporter?.logResponse(response, "proxy", {
+                pageId,
+                frontendUserAgent: this.debuggerConnection?.userAgent ?? null,
+                prefersFuseboxFrontend: this.isPageFuseboxFrontend(pageId),
+            });
+        };
+        const pathToSource = this.scriptIdToSourcePathMapping.get(req.params.scriptId);
+        if (pathToSource != null) {
+            const httpURL = this.tryParseHTTPURL(pathToSource);
+            if (httpURL) {
+                this.fetchText(httpURL).then((text) => sendSuccessResponse(text), (err) => sendErrorResponse(`Failed to fetch source url ${pathToSource}: ${err.message}`));
+            }
+            else {
+                let file;
+                try {
+                    file = node_fs_1.default.readFileSync(node_path_1.default.resolve(this.projectRoot, pathToSource), "utf8");
+                    sendSuccessResponse(file);
+                }
+                catch (err) {
+                    const exceptionMessage = err instanceof Error ? err.message : String(err);
+                    sendErrorResponse(`Failed to fetch source file ${pathToSource}: ${exceptionMessage}`);
+                }
+            }
+        }
+    }
+    mapToDevicePageId(pageId) {
+        if (pageId === REACT_NATIVE_RELOADABLE_PAGE_ID &&
+            this.lastConnectedLegacyReactNativePage != null) {
+            return this.lastConnectedLegacyReactNativePage.id;
+        }
+        return pageId;
+    }
+    tryParseHTTPURL(url) {
+        let parsedURL = null;
+        try {
+            parsedURL = new node_url_1.URL(url);
+        }
+        catch { }
+        const protocol = parsedURL?.protocol;
+        if (protocol !== "http:" && protocol !== "https:") {
+            parsedURL = null;
+        }
+        return parsedURL;
+    }
+    async fetchText(url) {
+        const response = await fetch(url.toString());
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status} ${response.statusText}`);
+        }
+        const text = await response.text();
+        if (text.length > 350000000) {
+            throw new Error("file too large to fetch via HTTP");
+        }
+        return text;
+    }
+    sendErrorToDebugger(message) {
+        const debuggerSocket = this.debuggerConnection?.socket;
+        if (debuggerSocket && debuggerSocket.readyState === ws_1.default.OPEN) {
+            debuggerSocket.send(JSON.stringify({
+                method: "Runtime.consoleAPICalled",
+                params: {
+                    args: [
+                        {
+                            type: "string",
+                            value: message,
+                        },
+                    ],
+                    executionContextId: 0,
+                    type: "error",
+                },
+            }));
+        }
+    }
+    isPageFuseboxFrontend(pageId) {
+        const page = pageId == null ? null : this.pages.get(pageId);
+        if (page == null) {
+            return null;
+        }
+        return this.pageHasCapability(page, "prefersFuseboxFrontend");
+    }
+    dangerouslyGetSocket() {
+        return this.deviceSocket;
+    }
+}
+exports.Device = Device;
+const invariant = (condition, message) => {
+    if (!condition) {
+        throw new Error(message);
+    }
+};

package/dist/modules/dev/dev-server/inspector/inspector.d.ts

@@ -0,0 +1,27 @@
+import { WebSocketServer } from "ws";
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { EventReporter, PageDescription } from "./types";
+import type { CDPAdapter } from "../cdp/cdp.adapter";
+export interface InspectorOptions {
+    projectRoot: string;
+    serverBaseUrl: string;
+    eventReporter?: EventReporter;
+    cdpAdapter?: CDPAdapter;
+}
+export declare class Inspector {
+    private devices;
+    private deviceCounter;
+    private readonly projectRoot;
+    private readonly serverBaseUrl;
+    private readonly eventReporter?;
+    private readonly cdpAdapter?;
+    constructor(options: InspectorOptions);
+    getPageDescriptions(): PageDescription[];
+    handleHttpRequest: (req: IncomingMessage, res: ServerResponse, next: (error?: Error) => void) => void;
+    createWebSocketServers(): Record<string, WebSocketServer>;
+    private createPageDescription;
+    private createDeviceWebSocketServer;
+    private createDebuggerWebSocketServer;
+    private setupHeartbeat;
+    private sendJsonResponse;
+}