locadot 1.4.0 → 1.5.0

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;

package/dist/server.js

@@ -8,121 +8,118 @@ const certs_1 = require("./certs");
 const https_1 = __importDefault(require("https"));
 const http_1 = __importDefault(require("http"));
 const fs_1 = __importDefault(require("fs"));
-const utils_1 = require("./utils");
-const constants_1 = require("./utils/constants");
 const locadot_file_1 = __importDefault(require("./lib/locadot-file"));
 const child_process_1 = require("child_process");
-const path_1 = __importDefault(require("path"));
+const file_1 = __importDefault(require("./utils/file"));
+const logger_1 = __importDefault(require("./utils/logger"));
+const constants_1 = __importDefault(require("./constants"));
+const http_2 = __importDefault(require("./lib/http"));
 class ProxyHandler {
     async startCentralProxy() {
-        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 () => {
-            locadot_file_1.default.updateLogs("🔄 Updated domain mappings.");
-            domainMap = await locadot_file_1.default.getRegistry();
-        });
-        process.on("SIGINT", async () => {
-            locadot_file_1.default.updateLogs("🛑 Proxy stopped.", "error", "Proxy soft destroyed as process SIGINT");
-            await locadot_file_1.default.softDestroy(watcher);
-        });
-        process.on("SIGTERM", async () => {
-            locadot_file_1.default.updateLogs("🛑 Proxy stopped.", "error", "Proxy soft destroyed as process SIGTERM");
-            await locadot_file_1.default.softDestroy(watcher);
-        });
-        const requestHandler = (req, res) => {
-            const host = req.headers.host?.split(":")[0];
-            const targetPort = domainMap[host];
-            if (!targetPort) {
-                res.writeHead(502, { "Content-Type": "text/html" });
-                res.end((0, utils_1.proxyNotFound)(host));
-            }
-            proxy.web(req, res, {
-                target: `http://localhost:${targetPort}`,
-                changeOrigin: true,
-            }, (err) => {
-                locadot_file_1.default.updateLogs(host || "", "warn", `${err.name}=> ${err.message}`);
-                res.writeHead(502);
-                res.end("Connection failed. Host not found.");
+        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();
             });
-        };
-        const requestUpgrade = (req, socket, head) => {
-            const host = req.headers.host?.split(":")[0];
-            const targetPort = domainMap[host];
-            if (!targetPort) {
-                socket.end();
-                return;
-            }
-            // locadotFile.updateLogs(
-            //   host || "",
-            //   "log",
-            //   `WebSocket upgrade request for ${host} → localhost:${targetPort}`
-            // );
-            proxy.ws(req, socket, head, {
-                target: `ws://localhost:${targetPort}`,
-                ws: true,
-                changeOrigin: true,
-                headers: {
-                    host: `localhost:${targetPort}`,
-                },
-            }, (err) => {
-                locadot_file_1.default.updateLogs(host || "", "warn", `WebSocket Error: ${err.name}=> ${err.message}`);
-                socket.end();
+            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);
             });
-        };
-        const httpsServer = https_1.default.createServer(defaultCert, requestHandler);
-        const httpServer = http_1.default.createServer(requestHandler);
-        httpsServer.listen(443, () => {
-            locadot_file_1.default.updateLogs("🛜 HTTPS proxy running on port 443");
-        });
-        httpsServer.on("upgrade", requestUpgrade);
-        httpServer.listen(80, () => {
-            locadot_file_1.default.updateLogs("🛜 HTTP proxy running on port 80");
-        });
-        httpServer.on("upgrade", requestUpgrade);
+            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);
+        }
     }
-    async startProxy() {
-        if (await locadot_file_1.default.getProcessId()) {
-            console.error("Proxy is already running");
-            return;
+    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;
         }
-        const proxyProcess = (0, child_process_1.spawn)("node", [
-            path_1.default.join(__dirname, process.env.NODE_ENV === "production" ? "core.js" : "../dist/core.js"),
-        ], {
-            detached: true,
-            stdio: "ignore",
-        });
-        proxyProcess.on("error", (err) => {
-            console.error("Failed to start child process:", err);
-        });
-        if (!proxyProcess.pid) {
-            console.error("❌ Central proxy failed to start");
-            process.exit(1);
+        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.");
         }
-        else {
-            locadot_file_1.default.createLockFile(proxyProcess.pid?.toString());
+        catch (error) {
+            logger_1.default.error("Failed to start central proxy", error);
         }
-        proxyProcess.unref();
-        console.log("🚀 Central proxy started in background.");
     }
     async registerDomain(domain, port) {
-        if (!(await locadot_file_1.default.getProcessId())) {
+        if (!(await ProxyHandler.isProxyRunning())) {
             await this.startProxy();
         }
         let registry = await locadot_file_1.default.getRegistry();
-        if (!fs_1.default.existsSync(constants_1.locadotPath.REGISTRY_FILE)) {
-            fs_1.default.writeFileSync(constants_1.locadotPath.REGISTRY_FILE, "{}");
+        if (!fs_1.default.existsSync(constants_1.default.paths.REGISTRY_FILE)) {
+            fs_1.default.writeFileSync(constants_1.default.paths.REGISTRY_FILE, "{}");
         }
-        if (fs_1.default.existsSync(constants_1.locadotPath.REGISTRY_FILE)) {
-            registry = JSON.parse(fs_1.default.readFileSync(constants_1.locadotPath.REGISTRY_FILE, "utf-8"));
+        if (fs_1.default.existsSync(constants_1.default.paths.REGISTRY_FILE)) {
+            registry = JSON.parse(fs_1.default.readFileSync(constants_1.default.paths.REGISTRY_FILE, "utf-8"));
         }
         if (registry[domain]) {
             console.error(`❌ ${domain} already mapped to port ${registry[domain]}`);
             process.exit(1);
         }
         registry[domain] = port;
-        fs_1.default.writeFileSync(constants_1.locadotPath.REGISTRY_FILE, JSON.stringify(registry, null, 2));
-        console.log(`✅ ${domain} => http://localhost:${port}`);
+        fs_1.default.writeFileSync(constants_1.default.paths.REGISTRY_FILE, JSON.stringify(registry, null, 2));
+        logger_1.default.info(`✅ ${domain} => http://localhost:${port}`);
     }
     async stopProxy() {
         await locadot_file_1.default.softDestroy();

package/dist/utils/certs.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSSL = createSSL;
+const appdata_path_1 = __importDefault(require("appdata-path"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const CERT_PATH = (0, appdata_path_1.default)("locadot");
+const mkcert_1 = require("mkcert");
+const logger_1 = __importDefault(require("./logger"));
+async function createSSL(domain) {
+    logger_1.default.info(`🔐 Preparing SSL cert for ${domain}`);
+    const KEY_FILE = path_1.default.join(CERT_PATH, domain + ".key");
+    const CERT_FILE = path_1.default.join(CERT_PATH, domain + ".pem");
+    if (fs_1.default.existsSync(KEY_FILE) && fs_1.default.existsSync(CERT_FILE)) {
+        logger_1.default.info(`🔄 Using existing certificate for ${domain}`);
+        const key = fs_1.default.readFileSync(KEY_FILE, "utf-8");
+        const cert = fs_1.default.readFileSync(CERT_FILE, "utf-8");
+        return { key, cert };
+    }
+    // Otherwise, generate a new one
+    logger_1.default.info(`🔐 Generating SSL cert for ${domain}`);
+    const ca = await (0, mkcert_1.createCA)({
+        organization: "Locadot",
+        countryCode: "IN",
+        state: "DevState",
+        locality: "DevTown",
+        validity: 365,
+    });
+    const cert = await (0, mkcert_1.createCert)({
+        domains: [domain],
+        ca: ca,
+        validity: 365,
+        organization: "Locadot",
+    });
+    if (!fs_1.default.existsSync(CERT_PATH))
+        fs_1.default.mkdirSync(CERT_PATH, { recursive: true });
+    fs_1.default.writeFileSync(KEY_FILE, cert.key);
+    fs_1.default.writeFileSync(CERT_FILE, cert.cert);
+    return { key: cert.key, cert: cert.cert };
+}