locadot 1.4.1 → 1.5.1

package/README.md

@@ -14,7 +14,7 @@
 ## 🚀 Usage
 
 ```bash
-npx locadot --host dev.localhost --port 3350
+npx locadot add --host dev.localhost --port 3350
 ```
 
 ---
@@ -26,7 +26,24 @@ npx locadot --host dev.localhost --port 3350
 ###### Starts a reverse proxy to the specified localhost port.
 
 ```bash
-npx locadot --host <custom.localhost> --port <localhost-port>
+npx locadot add --host <custom.localhost> --port <localhost-port>
+```
+
+##### 🧾 Update existing host
+
+###### Update domains currently registered with locadot.
+
+```bash
+npx locadot update --host <your.localhost> --port <localhost-port>
+```
+
+
+##### 🧾 Remove existing host
+
+###### Remove domains currently registered with locadot.
+
+```bash
+npx locadot remove --host <your.localhost>
 ```
 
 ##### 🧾 View Registered Hosts
@@ -42,7 +59,7 @@ npx locadot host
 ###### Continuously watches and outputs proxy logs in real time.
 
 ```bash
-npx locadot watch logs
+npx locadot watch:logs
 ```
 
 ##### 🧹 Clear Logs
@@ -50,15 +67,42 @@ npx locadot watch logs
 ###### Clears all saved logs.
 
 ```bash
-npx locadot clear logs
+npx locadot clear:logs
 ```
+
+##### 🧹 Clear Hosts
+
+###### Clears all existing hosts.
+
+```bash
+npx locadot clear:hosts
+```
+
+##### 🧹 Show Config Path
+
+###### Print the path of config files used.
+
+```bash
+npx locadot path
+```
+
 ##### 🧹 Show Logs Path
 
 ###### Print the path of logged files used.
 
 ```bash
-npx locadot path logs
+npx locadot path:logs
 ```
+
+
+##### 🧹 Show Hosts Path
+
+###### Print the path of hosts files used.
+
+```bash
+npx locadot path:hosts
+```
+
 ##### 🔄 Restart Proxy
 
 ###### Restarts the proxy server and reloads configuration.

package/dist/{utils/constants.js → constants/index.js}

@@ -3,21 +3,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.errorConstants = exports.locadotPath = void 0;
 const appdata_path_1 = __importDefault(require("appdata-path"));
 const path_1 = __importDefault(require("path"));
 const PACKAGE_PATH = (0, appdata_path_1.default)("locadot");
+const LOGS = path_1.default.join(PACKAGE_PATH, ".locadot.log");
 const LOCK_FILE = path_1.default.join(PACKAGE_PATH, ".locadot.lock");
 const REGISTRY_FILE = path_1.default.join(PACKAGE_PATH, ".locadot-registry.json");
-const LOGS = path_1.default.join(PACKAGE_PATH, ".locadot.log");
-exports.locadotPath = {
-    LOCK_FILE,
-    REGISTRY_FILE,
-    LOGS,
+class Constants {
+}
+Constants.paths = {
+    LOCK_FILE: LOCK_FILE,
+    REGISTRY_FILE: REGISTRY_FILE,
+    LOGS: LOGS,
 };
-exports.errorConstants = {
+Constants.proxyInfo = {
     invalidHost: "❌ Invalid domain. Please use a valid localhost domain like dev.localhost, localhost, test.localhost, etc.",
     hostExist: "❌ Domain already in use. Please choose another domain or stop the existing instance.",
+    hostNotFound: "❌ Domain not found. Please choose another domain or stop the existing instance.",
     proxyClose: "☑️ Successfully stopped all locadot instances.",
     softClose: "☑️ Successfully stopped central proxy..",
 };
+exports.default = Constants;

package/dist/core.js

@@ -3,11 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const locadot_file_1 = __importDefault(require("./lib/locadot-file"));
-const server_1 = __importDefault(require("./server"));
+const proxy_1 = __importDefault(require("./proxy"));
+const logger_1 = __importDefault(require("./utils/logger"));
 async function run() {
-    locadot_file_1.default.updateLogs("🔄 Starting central proxy.");
-    await server_1.default.startCentralProxy();
-    locadot_file_1.default.updateLogs("☑️ Central proxy started.");
+    logger_1.default.info(`🔄 Starting central proxy.`);
+    await proxy_1.default.startCentralProxy();
+    logger_1.default.info("☑️ Central proxy started.");
 }
 run();

package/dist/index.js

@@ -4,56 +4,97 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const yargs_1 = __importDefault(require("yargs"));
-const helpers_1 = require("yargs/helpers");
+const commander_1 = require("commander");
 const commands_1 = __importDefault(require("./lib/commands"));
-const constants_1 = require("./utils/constants");
-async function run() {
-    await (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
-        .scriptName("locadot")
-        .usage("Usage: npx locadot --host local.dev --port 3350")
-        .command("$0", "Run the proxy with a domain and port", (yargs) => {
-        return yargs
-            .option("host", {
-            alias: "h",
-            describe: "Domain to map (must point to 127.0.0.1 in hosts file)",
-            demandOption: true,
-            type: "string",
-        })
-            .option("port", {
-            alias: "p",
-            describe: "Local port to forward to",
-            demandOption: true,
-            type: "number",
-        });
-    }, async (argv) => {
-        await commands_1.default.start(argv);
-    })
-        .command("host", "Show all hosts.", () => {
-        commands_1.default.getRegistry();
-    })
-        .command("watch logs", "Watch log files", () => { }, async (argv) => {
-        commands_1.default.watchLogs();
-    })
-        .command("clear logs", "Clear logs", () => { }, async (argv) => {
-        commands_1.default.clearLogs();
-    })
-        .command("path logs", "Show log path", () => { }, async (argv) => {
-        commands_1.default.logPath();
-    })
-        .command("restart", "Restart locadot", () => { }, async (argv) => {
-        commands_1.default.restart();
-    })
-        .command("stop", "Stop central proxy and logs.", () => { }, async (argv) => {
-        await commands_1.default.stop();
-        console.log(constants_1.errorConstants.proxyClose);
-        process.exit(0);
-    })
-        .command("kill", "Stop central proxy and clear all logs and also port mapping.", () => { }, async (argv) => {
-        await commands_1.default.kill();
-        console.log(constants_1.errorConstants.proxyClose);
-        process.exit(0);
-    })
-        .help().argv;
-}
-run();
+const logger_1 = __importDefault(require("./utils/logger"));
+const package_json_1 = require("../package.json");
+const constants_1 = __importDefault(require("./constants"));
+const program = new commander_1.Command();
+program
+    .name("locadot")
+    .description("Locadot CLI - Local domain proxy manager")
+    .version(package_json_1.version);
+program
+    .command("add")
+    .description("Add a new localhost domain and port")
+    .requiredOption("-h, --host <host>", "Domain to map must be ends with localhost. Example: dev.localhost, localhost, test.localhost, etc.")
+    .requiredOption("-p, --port <port>", "Local port to forward to")
+    .action(async (options) => {
+    await commands_1.default.add(options);
+});
+program
+    .command("update")
+    .requiredOption("-h, --host <host>", "Domain to map must be ends with localhost. Example: dev.localhost, localhost, test.localhost, etc.")
+    .requiredOption("-p, --port <port>", "Local port to forward to")
+    .description("Update a domain")
+    .action(async (options) => await commands_1.default.update(options));
+program
+    .command("remove")
+    .requiredOption("-h, --host <host>", "Host must ends with localhost. Example: dev.localhost, localhost, test.localhost, etc.")
+    .description("Remove a domain")
+    .action(async (options) => await commands_1.default.remove(options));
+program
+    .command("host")
+    .description("Show all hosts")
+    .action(() => {
+    commands_1.default.getRegistry();
+});
+program
+    .command("watch:logs")
+    .description("Watch log files")
+    .action(() => {
+    commands_1.default.watchLogs();
+});
+program
+    .command("clear:logs")
+    .description("Clear logs")
+    .action(() => {
+    commands_1.default.clearLogs();
+});
+program
+    .command("clear:hosts")
+    .description("Clear all host file.")
+    .action(() => {
+    commands_1.default.clearHosts();
+});
+program
+    .command("path")
+    .description("Show configuration paths.")
+    .action(() => {
+    commands_1.default.configPath();
+});
+program
+    .command("path:logs")
+    .description("Show logs path file.")
+    .action(() => {
+    commands_1.default.logPath();
+});
+program
+    .command("path:hosts")
+    .description("Show hosts path file.")
+    .action(() => {
+    commands_1.default.hostPath();
+});
+program
+    .command("restart")
+    .description("Restart locadot")
+    .action(() => {
+    commands_1.default.restart();
+});
+program
+    .command("stop")
+    .description("Stop central proxy and logs")
+    .action(async () => {
+    await commands_1.default.stop();
+    logger_1.default.info(constants_1.default.proxyInfo.softClose);
+    process.exit(0);
+});
+program
+    .command("kill")
+    .description("Stop proxy, clear logs, and hosts file.")
+    .action(async () => {
+    await commands_1.default.kill();
+    logger_1.default.info(constants_1.default.proxyInfo.softClose);
+    process.exit(0);
+});
+program.parse(process.argv);

package/dist/lib/commands.js

@@ -4,37 +4,74 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const localhost_1 = __importDefault(require("./localhost"));
-const constants_1 = require("../utils/constants");
-const server_1 = __importDefault(require("../server"));
+const proxy_1 = __importDefault(require("../proxy"));
 const locadot_file_1 = __importDefault(require("./locadot-file"));
+const constants_1 = __importDefault(require("../constants"));
 class Commands {
-    static async start(argv) {
+    static async add(argv) {
         if (!localhost_1.default.isValidLocalhostDomain(argv.host)) {
-            console.error(constants_1.errorConstants.invalidHost);
+            console.error(constants_1.default.proxyInfo.invalidHost);
             process.exit(1);
         }
         if (await localhost_1.default.isLocalhostOpen(argv.host, argv.port)) {
-            console.error(constants_1.errorConstants.hostExist);
+            console.error(constants_1.default.proxyInfo.hostExist);
+            process.exit(1);
         }
         try {
-            await server_1.default.registerDomain(argv.host, argv.port);
+            await proxy_1.default.addProxy(argv.host, argv.port);
+        }
+        catch (error) {
+            console.error(error);
+        }
+    }
+    static async remove(argv) {
+        if (!localhost_1.default.isValidLocalhostDomain(argv.host)) {
+            console.error(constants_1.default.proxyInfo.invalidHost);
+            process.exit(1);
+        }
+        try {
+            await proxy_1.default.removeProxy(argv.host);
+        }
+        catch (error) {
+            console.error(error);
+        }
+    }
+    static async update(argv) {
+        if (!localhost_1.default.isValidLocalhostDomain(argv.host)) {
+            console.error(constants_1.default.proxyInfo.invalidHost);
+            process.exit(1);
+        }
+        if (!(await localhost_1.default.isLocalhostOpen(argv.host, argv.port))) {
+            console.error(constants_1.default.proxyInfo.hostNotFound);
+            process.exit(1);
+        }
+        try {
+            await proxy_1.default.updateProxy(argv.host, argv.port);
+        }
+        catch (error) {
+            console.error(error);
         }
-        catch (error) { }
     }
     static async stop() {
         try {
-            await server_1.default.stopProxy();
+            await proxy_1.default.stopProxy();
+        }
+        catch (error) { }
+    }
+    static async clearHosts() {
+        try {
+            await locadot_file_1.default.removeAllRegistry();
         }
         catch (error) { }
     }
     static async kill() {
         try {
-            await server_1.default.killProxy();
+            await proxy_1.default.killProxy();
         }
         catch (error) { }
     }
     static async restart() {
-        await server_1.default.restartProxy();
+        await proxy_1.default.restartProxy();
         console.log("☑️ Proxy successfully restarted.");
     }
     static async getRegistry() {
@@ -47,7 +84,6 @@ class Commands {
     }
     static watchLogs() {
         try {
-            console.log("☑️ Watching logs files.");
             locadot_file_1.default.watchLogs();
         }
         catch (error) { }
@@ -60,7 +96,14 @@ class Commands {
         catch (error) { }
     }
     static async logPath() {
-        console.log(constants_1.locadotPath.LOGS);
+        console.log(constants_1.default.paths.LOGS);
+    }
+    static async hostPath() {
+        console.log(constants_1.default.paths.REGISTRY_FILE);
+    }
+    static async configPath() {
+        console.log(constants_1.default.paths.REGISTRY_FILE);
+        console.log(constants_1.default.paths.LOGS);
     }
 }
 exports.default = Commands;

package/dist/lib/http.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const template_1 = require("../constants/template");
+const logger_1 = __importDefault(require("../utils/logger"));
+class HttpModule {
+    static requestHandler(req, res, proxy, domainMap) {
+        try {
+            const host = req.headers.host?.split(":")[0];
+            const targetPort = domainMap[host];
+            if (!targetPort) {
+                res.writeHead(502, { "Content-Type": "text/html" });
+                res.end((0, template_1.proxyNotFound)(host));
+            }
+            proxy.web(req, res, {
+                target: `http://localhost:${targetPort}`,
+                changeOrigin: true,
+                headers: {
+                    "X-Original-Host": host || "localhost",
+                },
+            }, (err) => {
+                logger_1.default.warn(host || "", "warn", `${err.name}=> ${err.message}`);
+                res.writeHead(502);
+                res.end("Connection failed. Host not found.");
+            });
+        }
+        catch (error) {
+            logger_1.default.error(error);
+        }
+    }
+}
+HttpModule.requestUpgrade = (req, socket, head, proxy, domainMap) => {
+    try {
+        const host = req.headers.host?.split(":")[0];
+        const targetPort = domainMap[host];
+        if (!targetPort) {
+            socket.end();
+            return;
+        }
+        logger_1.default.info(host || "", "log", `WebSocket upgrade request for ${host}`);
+        proxy.ws(req, socket, head, {
+            target: `ws://localhost:${targetPort}`,
+            ws: true,
+            changeOrigin: true,
+            headers: {
+                host: `localhost:${targetPort}`,
+                "X-Original-Host": host || "localhost",
+            },
+        }, (err) => {
+            // locadotFile.updateLogs(
+            //   host || "",
+            //   "warn",
+            //   `WebSocket Error: ${err.name}=> ${err.message}`
+            // );
+            socket.end();
+        });
+    }
+    catch (error) {
+        logger_1.default.error(error);
+    }
+};
+exports.default = HttpModule;

package/dist/lib/locadot-file.js

@@ -3,110 +3,92 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const constants_1 = require("../utils/constants");
-const fs_1 = __importDefault(require("fs"));
-const date_fns_1 = require("date-fns");
+const file_1 = __importDefault(require("../utils/file"));
+const logger_1 = __importDefault(require("../utils/logger"));
+const path_1 = __importDefault(require("path"));
 class locadotFile {
     static async createLockFile(processId) {
-        fs_1.default.writeFileSync(constants_1.locadotPath.LOCK_FILE, processId);
+        await file_1.default.writeFileSync("LOCK_FILE", processId);
     }
     static async getProcessId() {
         try {
-            if (fs_1.default.existsSync(constants_1.locadotPath.LOCK_FILE)) {
-                const pid = parseInt(fs_1.default.readFileSync(constants_1.locadotPath.LOCK_FILE, "utf-8"));
-                return pid.toString();
-            }
+            const lockFile = await file_1.default.readFileSync("LOCK_FILE");
+            return parseInt(lockFile).toString();
         }
         catch (err) {
+            await file_1.default.removeFileSync("LOCK_FILE");
             return;
         }
     }
     static async deleteLockFile() {
-        fs_1.default.rmSync(constants_1.locadotPath.LOCK_FILE);
+        await file_1.default.removeFileSync("LOCK_FILE");
     }
     static async getRegistry() {
-        if (!fs_1.default.existsSync(constants_1.locadotPath.REGISTRY_FILE)) {
-            fs_1.default.writeFileSync(constants_1.locadotPath.REGISTRY_FILE, "{}");
+        try {
+            return JSON.parse(await file_1.default.readFileSync("REGISTRY_FILE"));
+        }
+        catch (error) {
+            logger_1.default.error(error);
+            return {};
         }
-        return JSON.parse(fs_1.default.readFileSync(constants_1.locadotPath.REGISTRY_FILE, "utf-8"));
     }
     static async addRegistry(domain, port) {
         const registry = await locadotFile.getRegistry();
         registry[domain] = port;
-        fs_1.default.writeFileSync(constants_1.locadotPath.REGISTRY_FILE, JSON.stringify(registry, null, 2));
+        file_1.default.writeFileSync("REGISTRY_FILE", JSON.stringify(registry));
     }
     static async removeAllRegistry() {
-        fs_1.default.writeFileSync(constants_1.locadotPath.REGISTRY_FILE, "{}");
+        file_1.default.writeFileSync("REGISTRY_FILE", "{}");
     }
     static async updateRegistry(domain, port) {
         const registry = await locadotFile.getRegistry();
         registry[domain] = port;
-        fs_1.default.writeFileSync(constants_1.locadotPath.REGISTRY_FILE, JSON.stringify(registry, null, 2));
+        file_1.default.writeFileSync("REGISTRY_FILE", JSON.stringify(registry));
     }
     static async deleteRegistry(domain) {
         const registry = await locadotFile.getRegistry();
         delete registry[domain];
-        fs_1.default.writeFileSync(constants_1.locadotPath.REGISTRY_FILE, JSON.stringify(registry, null, 2));
+        file_1.default.writeFileSync("REGISTRY_FILE", JSON.stringify(registry));
     }
     static async watchRegistry(callBackOnChange) {
-        return fs_1.default.watch(constants_1.locadotPath.REGISTRY_FILE, async (eventType) => {
-            if (eventType === "change") {
-                this.updateLogs("🔄 Updated domain mappings.");
-                callBackOnChange && callBackOnChange();
-            }
-        });
+        return file_1.default.watchFileWithInit("REGISTRY_FILE", () => callBackOnChange?.());
     }
     static async getLogs() {
-        if (!fs_1.default.existsSync(constants_1.locadotPath.LOGS)) {
-            fs_1.default.writeFileSync(constants_1.locadotPath.LOGS, "{}");
+        try {
+            return await file_1.default.readFileSync("LOGS");
         }
-        return JSON.parse(fs_1.default.readFileSync(constants_1.locadotPath.LOGS, "utf-8"));
-    }
-    static async updateLogs(message, status = "log", description) {
-        const logs = (await locadotFile.getLogs()).logs || [];
-        if (!Array.isArray(logs)) {
-            fs_1.default.writeFileSync(constants_1.locadotPath.LOGS, "{}");
+        catch (error) {
+            file_1.default.removeFileSync("LOGS");
+            return "";
         }
-        logs.push({
-            message,
-            timestamp: Date.now(),
-            status: status,
-            description,
-        });
-        fs_1.default.writeFileSync(constants_1.locadotPath.LOGS, JSON.stringify({ logs: logs }));
     }
     static async clearLogs() {
-        fs_1.default.writeFileSync(constants_1.locadotPath.LOGS, "{}");
-    }
-    static async printLogs(log) {
-        console[log.status || "log"](`${(0, date_fns_1.format)(log.timestamp, "yyyy-MM-dd HH:mm:ss")}: ${log.message} ${log.description ? "==> " : ""}${log.description ? log.description : ""}\n`);
+        file_1.default.writeFileSync("LOGS", "");
     }
     static async watchLogs() {
-        const logs = await locadotFile.getLogs();
-        let length = logs.logs?.length || 0;
-        logs.logs?.forEach((log) => this.printLogs(log));
-        fs_1.default.watch(constants_1.locadotPath.LOGS, async (eventType) => {
-            try {
-                if (eventType === "change") {
-                    const newLog = await locadotFile.getLogs();
-                    newLog.logs?.forEach((log, i) => {
-                        if (i > length - 1) {
-                            this.printLogs(log);
-                        }
-                    });
-                    length = newLog.logs?.length || 0;
-                }
-            }
-            catch (error) { }
-        });
+        file_1.default.tailFile("LOGS");
+    }
+    static getStartProxyFile() {
+        if (process.env.NODE_ENV === "production") {
+            const filePath = path_1.default.join(__dirname, "..", "core.js");
+            return {
+                command: "node",
+                path: [filePath],
+            };
+        }
+        const filePath = path_1.default.join(__dirname, "../../", "dist", "core.js");
+        return {
+            command: "node",
+            path: [filePath],
+        };
     }
     static async destroy(watcher) {
         try {
             const pid = await locadotFile.getProcessId();
-            locadotFile.deleteLockFile();
-            locadotFile.removeAllRegistry();
-            locadotFile.clearLogs();
-            watcher?.close();
+            await locadotFile.deleteLockFile();
+            await locadotFile.removeAllRegistry();
+            await locadotFile.clearLogs();
+            await watcher?.close();
             if (pid) {
                 process.kill(parseInt(pid));
             }
@@ -116,14 +98,16 @@ class locadotFile {
     static async softDestroy(watcher) {
         try {
             const pid = await locadotFile.getProcessId();
-            locadotFile.deleteLockFile();
-            locadotFile.clearLogs();
-            watcher?.close();
+            await locadotFile.deleteLockFile();
+            await locadotFile.clearLogs();
+            await watcher?.close();
             if (pid) {
                 process.kill(parseInt(pid));
             }
         }
-        catch (error) { }
+        catch (error) {
+            logger_1.default.error(error);
+        }
     }
 }
 exports.default = locadotFile;