@teardown/cli 1.2.31 → 1.2.34

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

@@ -1,577 +0,0 @@
-"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

@@ -1,27 +0,0 @@
-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;
-}