locadot 1.4.1 → 1.5.0

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(process.cwd(), "core.js");
+            return {
+                command: "node",
+                path: [filePath],
+            };
+        }
+        const filePath = path_1.default.join(process.cwd(), "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;

package/dist/proxy.js

@@ -0,0 +1,139 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const http_proxy_1 = __importDefault(require("http-proxy"));
+const certs_1 = require("./utils/certs");
+const https_1 = __importDefault(require("https"));
+const http_1 = __importDefault(require("http"));
+const locadot_file_1 = __importDefault(require("./lib/locadot-file"));
+const child_process_1 = require("child_process");
+const file_1 = __importDefault(require("./utils/file"));
+const logger_1 = __importDefault(require("./utils/logger"));
+const http_2 = __importDefault(require("./lib/http"));
+class ProxyHandler {
+    async startCentralProxy() {
+        try {
+            let domainMap = await locadot_file_1.default.getRegistry();
+            const proxy = http_proxy_1.default.createProxyServer({});
+            const defaultCert = await (0, certs_1.createSSL)("localhost");
+            const watcher = await locadot_file_1.default.watchRegistry(async () => {
+                logger_1.default.info("🔄 Updated domain mapping");
+                domainMap = await locadot_file_1.default.getRegistry();
+            });
+            process.on("SIGINT", async (err) => {
+                logger_1.default.error("🛑 Proxy stopped. Proxy soft destroyed as process SIGINT", err);
+                await locadot_file_1.default.softDestroy(watcher);
+            });
+            process.on("SIGTERM", async (err) => {
+                logger_1.default.error("🛑 Proxy stopped. Proxy soft destroyed as process SIGTERM", err);
+                await locadot_file_1.default.softDestroy(watcher);
+            });
+            process.on("exit", (code, signal) => {
+                logger_1.default.error(`Process exited with error ${code} and signal ${signal}`);
+                locadot_file_1.default.softDestroy(watcher);
+            });
+            const httpsServer = https_1.default.createServer(defaultCert, (req, res) => {
+                http_2.default.requestHandler(req, res, proxy, domainMap);
+            });
+            const httpServer = http_1.default.createServer((req, res) => {
+                http_2.default.requestHandler(req, res, proxy, domainMap);
+            });
+            httpsServer.listen(443, () => {
+                logger_1.default.info("🛜 HTTPS proxy running on port 443");
+            });
+            httpsServer.on("upgrade", (req, res, head) => {
+                http_2.default.requestUpgrade(req, res, head, proxy, domainMap);
+            });
+            httpServer.listen(80, () => {
+                logger_1.default.info("🛜 HTTP proxy running on port 80");
+            });
+            httpServer.on("upgrade", (req, socket, head) => {
+                http_2.default.requestUpgrade(req, socket, head, proxy, domainMap);
+            });
+        }
+        catch (error) {
+            logger_1.default.error("Failed to start central proxy", error);
+        }
+    }
+    static async isProxyRunning() {
+        try {
+            const pid = Number(await locadot_file_1.default.getProcessId());
+            if (!pid || isNaN(pid)) {
+                return false;
+            }
+            process.kill(pid, 0);
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async startProxy() {
+        try {
+            if (await ProxyHandler.isProxyRunning()) {
+                logger_1.default.error("Proxy is already running");
+                return;
+            }
+            const command = locadot_file_1.default.getStartProxyFile();
+            const proxyProcess = (0, child_process_1.spawn)(command.command, command.path, {
+                detached: true,
+                stdio: ["ignore", "ignore", "pipe"],
+            });
+            const logStream = file_1.default.writeFileStream("LOGS", true);
+            proxyProcess.stderr.pipe(logStream);
+            proxyProcess.on("error", (err) => {
+                console.error("Failed to start child process:", err);
+            });
+            if (!proxyProcess.pid) {
+                logger_1.default.error("❌ Central proxy failed to start");
+                process.exit(1);
+            }
+            else {
+                locadot_file_1.default.createLockFile(proxyProcess.pid?.toString());
+            }
+            proxyProcess.unref();
+            logger_1.default.info("🚀 Central proxy started in background.");
+        }
+        catch (error) {
+            logger_1.default.error("Failed to start central proxy", error);
+        }
+    }
+    async addProxy(domain, port) {
+        if (!(await ProxyHandler.isProxyRunning())) {
+            await this.startProxy();
+        }
+        let registry = await locadot_file_1.default.getRegistry();
+        if (registry[domain]) {
+            console.error(`❌ ${domain} already mapped to port ${registry[domain]} use update instead.`);
+            process.exit(1);
+        }
+        await locadot_file_1.default.addRegistry(domain, port);
+        logger_1.default.info(`✅ ${domain} => http://localhost:${port}`);
+    }
+    async removeProxy(domain) {
+        if (!(await ProxyHandler.isProxyRunning())) {
+            await this.startProxy();
+        }
+        await locadot_file_1.default.deleteRegistry(domain);
+    }
+    async updateProxy(domain, port) {
+        if (!(await ProxyHandler.isProxyRunning())) {
+            await this.startProxy();
+        }
+        await locadot_file_1.default.updateRegistry(domain, port);
+    }
+    async stopProxy() {
+        await locadot_file_1.default.softDestroy();
+    }
+    async killProxy() {
+        await locadot_file_1.default.destroy();
+    }
+    async restartProxy() {
+        await locadot_file_1.default.softDestroy();
+        await this.startProxy();
+    }
+}
+const locadotProxy = new ProxyHandler();
+exports.default = locadotProxy;