@teardown/cli 1.2.34 → 1.2.35

package/dist/commands/dev/dev.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.DevServerCommand = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const commander_1 = require("commander");
+const dev_server_1 = require("../../modules/dev/dev-server/dev-server");
+class DevServerCommand {
+    createCommand() {
+        const command = new commander_1.Command("dev")
+            .description("Start the development server")
+            .option("-p, --port <number>", "Port to start the server on", "8081")
+            .option("-h, --host <string>", "Host to listen on", "127.0.0.1")
+            .option("--project-root <path>", "Path to project root", process.cwd())
+            .option("--watch-folders <list>", "Specify additional folders to watch", (val) => val.split(",").map((folder) => node_path_1.default.resolve(folder)))
+            .option("--asset-plugins <list>", "Specify additional asset plugins", (val) => val.split(","))
+            .option("--source-exts <list>", "Specify additional source extensions", (val) => val.split(","))
+            .option("--max-workers <number>", "Maximum number of workers for transformation", (val) => Number(val))
+            .option("--transformer <string>", "Specify a custom transformer")
+            .option("--entry-file <path>", "Path to entry file", "index.js")
+            .option("--reset-cache", "Reset the metro cache", false)
+            .option("--https", "Enable HTTPS connections")
+            .option("--key <path>", "Path to SSL key")
+            .option("--cert <path>", "Path to SSL certificate")
+            .option("--config <path>", "Path to config file", (val) => node_path_1.default.resolve(val))
+            .option("--no-interactive", "Disable interactive mode");
+        command.action(this.action);
+        return command;
+    }
+    async action(options) {
+        try {
+            const server = new dev_server_1.DevServer({
+                projectRoot: options.projectRoot,
+                host: options.host,
+                port: options.port,
+                logRequests: true,
+                https: options.https
+                    ? {
+                        key: options.key ?? "",
+                        cert: options.cert ?? "",
+                    }
+                    : undefined,
+            });
+            await server.initialize();
+            await server.start();
+        }
+        catch (error) {
+            console.error("Failed to start development server:", error);
+            throw error;
+        }
+    }
+}
+exports.DevServerCommand = DevServerCommand;

package/dist/commands/init/init-teardown.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InitTeardown = void 0;
+const bun_1 = require("bun");
+class InitTeardown {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async init() {
+        console.log("Initializing Teardown...");
+        const projectLocation = await this.getProjectLocation();
+        console.log(projectLocation);
+    }
+    async getProjectLocation() {
+        try {
+            const projectLocation = await (0, bun_1.$) `pwd`;
+            return projectLocation.text().trim();
+        }
+        catch (error) {
+            console.error("Error getting project location:", error);
+            throw error;
+        }
+    }
+}
+exports.InitTeardown = InitTeardown;

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const dev_1 = require("./commands/dev/dev");
+const program = new commander_1.Command();
+program
+    .name("Teardown CLI")
+    .description("CLI to use the Teardown")
+    .version("0.0.1");
+// program
+// 	.command("init")
+// 	.description("Initialize Teardown in the current project")
+// 	.action(async () => {
+// 		const project = await import("./commands/init/init-teardown");
+// 		await new project.InitTeardown({
+// 			projectName: "example ",
+// 		}).init();
+// 	});
+program.addCommand(new dev_1.DevServerCommand().createCommand());
+program.parse();

package/dist/modules/dev/dev-menu/keyboard-handler.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyboardHandlerManager = void 0;
+const node_readline_1 = __importDefault(require("node:readline"));
+const node_tty_1 = require("node:tty");
+// @ts-ignore
+const chalk_1 = __importDefault(require("chalk"));
+const open_debugger_keyboard_handler_1 = __importDefault(require("./open-debugger-keyboard-handler"));
+class KeyboardHandlerManager {
+    devServer;
+    static CTRL_C = "\u0003";
+    static CTRL_D = "\u0004";
+    static RELOAD_TIMEOUT = 500;
+    openDebuggerKeyboardHandler;
+    previousCallTimestamp = 0;
+    constructor(devServer) {
+        this.devServer = devServer;
+        this.openDebuggerKeyboardHandler = new open_debugger_keyboard_handler_1.default({
+            reporter: this.devServer.terminalReporter,
+            devServerUrl: this.devServer.getDevServerUrl(),
+        });
+    }
+    async initialize() {
+        if (!this.isTTYSupported()) {
+            this.devServer.terminalReporter.update({
+                type: "client_log",
+                level: "info",
+                data: ["Interactive mode is not supported in this environment"],
+            });
+            return;
+        }
+        this.setupKeyboardHandlers();
+        this.printAvailableCommands();
+    }
+    isTTYSupported() {
+        return process.stdin.isTTY === true;
+    }
+    setupKeyboardHandlers() {
+        node_readline_1.default.emitKeypressEvents(process.stdin);
+        this.setRawMode(true);
+        process.stdin.on("keypress", (str, key) => {
+            this.handleKeyPress(key);
+        });
+    }
+    handleKeyPress(key) {
+        if (this.openDebuggerKeyboardHandler.maybeHandleTargetSelection(key.name)) {
+            return;
+        }
+        switch (key.sequence) {
+            case "r":
+                this.handleReload();
+                break;
+            case "d":
+                this.handleDevMenu();
+                break;
+            case "j":
+                void this.handleOpenDebugger();
+                break;
+            case KeyboardHandlerManager.CTRL_C:
+            case KeyboardHandlerManager.CTRL_D:
+                this.handleExit();
+                break;
+        }
+    }
+    handleReload() {
+        const currentCallTimestamp = new Date().getTime();
+        if (currentCallTimestamp - this.previousCallTimestamp >
+            KeyboardHandlerManager.RELOAD_TIMEOUT) {
+            this.previousCallTimestamp = currentCallTimestamp;
+            this.devServer.terminalReporter.update({
+                type: "client_log",
+                level: "info",
+                data: ["Reloading connected app(s)..."],
+            });
+            this.devServer.messageServer.broadcast("reload");
+        }
+    }
+    handleDevMenu() {
+        this.devServer.terminalReporter.update({
+            type: "client_log",
+            level: "info",
+            data: ["Opening Dev Menu..."],
+        });
+        this.devServer.messageServer.broadcast("devMenu");
+    }
+    async handleOpenDebugger() {
+        await this.openDebuggerKeyboardHandler.handleOpenDebugger();
+    }
+    handleExit() {
+        this.openDebuggerKeyboardHandler.dismiss();
+        this.devServer.terminalReporter.update({
+            type: "client_log",
+            level: "info",
+            data: ["Stopping server"],
+        });
+        this.setRawMode(false);
+        process.stdin.pause();
+        process.emit("SIGINT");
+        process.exit();
+    }
+    isRawModeSupported() {
+        return process.stdin instanceof node_tty_1.ReadStream;
+    }
+    setRawMode(enable) {
+        if (!this.isRawModeSupported()) {
+            return;
+        }
+        process.stdin.setRawMode(enable);
+    }
+    printAvailableCommands() {
+        if (!this.isRawModeSupported()) {
+            return;
+        }
+        this.devServer.terminalReporter.update({
+            type: "client_log",
+            level: "info",
+            data: [
+                "Key commands available:",
+                "\n",
+                "\n",
+                `${chalk_1.default.bold.inverse(" r ")} - reload app(s)`,
+                "\n",
+                `${chalk_1.default.bold.inverse(" d ")} - open Dev Menu`,
+                // "\n",
+                // `${chalk.bold.inverse(" j ")} - open DevTools`,
+            ],
+        });
+    }
+}
+exports.KeyboardHandlerManager = KeyboardHandlerManager;
+const invariant = (condition, message) => {
+    if (!condition) {
+        throw new Error(message);
+    }
+};

package/dist/modules/dev/dev-menu/open-debugger-keyboard-handler.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore
+const chalk_1 = __importDefault(require("chalk"));
+const open_1 = __importDefault(require("open"));
+class OpenDebuggerKeyboardHandler {
+    reporter;
+    devServerUrl;
+    isTargetSelectionActive = false;
+    targets = [];
+    constructor(config) {
+        this.reporter = config.reporter;
+        this.devServerUrl = config.devServerUrl;
+    }
+    async handleOpenDebugger() {
+        try {
+            const response = await fetch(`${this.devServerUrl}/json`);
+            const pages = await response.json();
+            this.targets = pages.map((page) => ({
+                name: page.title,
+                url: page.devtoolsFrontendUrl,
+            }));
+            if (this.targets.length === 0) {
+                this.reporter.update({
+                    type: "client_log",
+                    level: "info",
+                    data: ["No available debugging targets"],
+                });
+                return;
+            }
+            if (this.targets.length === 1) {
+                await this.openTarget(this.targets[0]);
+                return;
+            }
+            this.showTargetSelection();
+        }
+        catch (error) {
+            this.reporter.update({
+                type: "client_log",
+                level: "warn",
+                data: [
+                    `Failed to open debugger: ${error instanceof Error ? error.message : String(error)}`,
+                ],
+            });
+        }
+    }
+    maybeHandleTargetSelection(key) {
+        if (!this.isTargetSelectionActive) {
+            return false;
+        }
+        const targetIndex = Number.parseInt(key, 10) - 1;
+        if (targetIndex >= 0 && targetIndex < this.targets.length) {
+            void this.openTarget(this.targets[targetIndex]);
+            this.dismiss();
+            return true;
+        }
+        if (key === "escape") {
+            this.dismiss();
+            return true;
+        }
+        return false;
+    }
+    dismiss() {
+        this.isTargetSelectionActive = false;
+        this.targets = [];
+    }
+    async openTarget(target) {
+        try {
+            console.log("openTarget", target.url);
+            await (0, open_1.default)(target.url);
+            this.reporter.update({
+                type: "client_log",
+                level: "info",
+                data: [`Opening debugger for: ${target.name}`],
+            });
+        }
+        catch (error) {
+            this.reporter.update({
+                type: "client_log",
+                // @ts-ignore
+                level: "error",
+                data: [
+                    `Failed to open debugger: ${error instanceof Error ? error.message : String(error)}`,
+                ],
+            });
+        }
+    }
+    showTargetSelection() {
+        this.isTargetSelectionActive = true;
+        const targetList = this.targets
+            .map((target, i) => `  ${chalk_1.default.bold.inverse(` ${i + 1} `)} ${target.name}`)
+            .join("\n");
+        this.reporter.update({
+            type: "client_log",
+            level: "info",
+            data: [
+                `Select a target to debug:\n${targetList}\n\n  ${chalk_1.default.bold.inverse(" ESC ")} to cancel\n`,
+            ],
+        });
+    }
+}
+exports.default = OpenDebuggerKeyboardHandler;

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CDPAdapter = void 0;
+// import type { DevServer } from "devtools-protocol";
+class CDPAdapter {
+    instance;
+    constructor(instance) {
+        this.instance = instance;
+    }
+    enable() { }
+}
+exports.CDPAdapter = CDPAdapter;

package/dist/modules/dev/dev-server/cdp/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("./cdp.adapter"), exports);
+__exportStar(require("./types"), exports);

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

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

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

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevServerChecker = exports.DevServerStatusEnum = exports.DevServerStatusResultEnum = void 0;
+const bun_1 = require("bun");
+const node_net_1 = __importDefault(require("node:net"));
+var DevServerStatusResultEnum;
+(function (DevServerStatusResultEnum) {
+    DevServerStatusResultEnum["PACKAGER_STATUS_RUNNING"] = "packager-status:running";
+})(DevServerStatusResultEnum || (exports.DevServerStatusResultEnum = DevServerStatusResultEnum = {}));
+var DevServerStatusEnum;
+(function (DevServerStatusEnum) {
+    DevServerStatusEnum["NOT_RUNNING"] = "not_running";
+    DevServerStatusEnum["MATCHED_SERVER_RUNNING"] = "matched_server_running";
+    DevServerStatusEnum["PORT_TAKEN"] = "port_taken";
+    DevServerStatusEnum["UNKNOWN"] = "unknown";
+})(DevServerStatusEnum || (exports.DevServerStatusEnum = DevServerStatusEnum = {}));
+class DevServerChecker {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    getUrl() {
+        const devServerStatusPath = this.options.devServerStatusPath ?? "/status";
+        return `${this.options.host}:${this.options.port}${devServerStatusPath}`;
+    }
+    async getServerStatus() {
+        try {
+            if (!(await this.isPortInUse(this.options.host, this.options.port))) {
+                return DevServerStatusEnum.NOT_RUNNING;
+            }
+            const statusResponse = await (0, bun_1.fetch)(this.getUrl());
+            const body = await statusResponse.text();
+            if (body !== DevServerStatusResultEnum.PACKAGER_STATUS_RUNNING) {
+                return DevServerStatusEnum.PORT_TAKEN;
+            }
+            const projectRoot = statusResponse.headers.get("X-React-Native-Project-Root");
+            if (projectRoot !== this.options.projectRoot) {
+                return DevServerStatusEnum.PORT_TAKEN;
+            }
+            return DevServerStatusEnum.MATCHED_SERVER_RUNNING;
+        }
+        catch (error) {
+            console.error(error);
+            return DevServerStatusEnum.UNKNOWN;
+        }
+    }
+    async isPortInUse(hostname, port) {
+        return new Promise((resolve) => {
+            const server = node_net_1.default.createServer();
+            server.once("error", (e) => {
+                console.log("Server error:", e);
+                server.close();
+                if (e.code === "EADDRINUSE") {
+                    resolve(true);
+                }
+                else {
+                    // For any other errors, assume port is not in use
+                    resolve(false);
+                }
+            });
+            server.once("listening", () => {
+                server.close();
+                resolve(false);
+            });
+            server.listen(port, hostname);
+        });
+    }
+}
+exports.DevServerChecker = DevServerChecker;