locadot 1.1.1 → 1.2.2

package/dist/core.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const server_1 = __importDefault(require("./server"));
+async function run() {
+    await server_1.default.startCentralProxy();
+}
+run();

package/dist/index.js

@@ -4,68 +4,48 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isValidLocalhostDomain = isValidLocalhostDomain;
-exports.isDomainRunning = isDomainRunning;
-const https_1 = __importDefault(require("https"));
 const yargs_1 = __importDefault(require("yargs"));
 const helpers_1 = require("yargs/helpers");
-const server_1 = require("./server");
-function isValidLocalhostDomain(domain) {
-    const localhostPattern = /^(?:[a-zA-Z0-9-]+\.)*localhost$/;
-    return localhostPattern.test(domain);
-}
-function isDomainRunning(domain, port = 443) {
-    return new Promise((resolve) => {
-        const req = https_1.default.request({
-            hostname: "localhost", // we're always connecting to localhost
-            port,
-            method: "HEAD",
-            rejectUnauthorized: false, // ignore self-signed certs
-            timeout: 1000,
-            headers: {
-                Host: domain, // 👈 critical: ask the proxy "Do you know this host?"
-            },
-        }, (res) => {
-            // Only return true if it returns a valid 2xx or 3xx status
-            resolve(res.statusCode >= 200 && res.statusCode < 400);
-            res.destroy();
-        });
-        req.on("error", () => resolve(false));
-        req.on("timeout", () => {
-            req.destroy();
-            resolve(false);
-        });
-        req.end();
-    });
-}
+const commands_1 = __importDefault(require("./lib/commands"));
+const constants_1 = require("./utils/constants");
 async function run() {
-    const argv = await (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
-        .option("host", {
-        alias: "h",
-        describe: "Domain to map (must point to 127.0.0.1 in hosts file)",
-        demandOption: true,
-        type: "string",
+    await (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
+        .usage("Usage: npx locadot --host local.dev --port 3350")
+        .command("stop", "Stop all kill all locadot hosts", () => { }, async (argv) => {
+        await commands_1.default.stop();
+        console.log(constants_1.errorConstants.proxyClose);
+        process.exit(0);
     })
-        .option("port", {
-        alias: "p",
-        describe: "Local port to forward to",
-        demandOption: true,
-        type: "number",
+        .command("logs", "Watch logs", () => { }, async (argv) => {
+        commands_1.default.watchLogs();
+    })
+        .command("clear logs", "Clear logs", () => { }, async (argv) => {
+        commands_1.default.clearLogs();
+    })
+        .command("restart", "Restart locadot", () => { }, async (argv) => {
+        commands_1.default.restart();
+    })
+        .command("hosts", "Show all hosts.", () => {
+        commands_1.default.getRegistry();
+    })
+        .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",
+        })
+            .usage("Usage: npx locadot --host local.dev --port 3350");
+    }, async (argv) => {
+        await commands_1.default.start(argv);
     })
-        .usage("Usage: npx locadot --host local.dev --port 3350")
         .help().argv;
-    if (!isValidLocalhostDomain(argv.host)) {
-        console.error("❌ Invalid domain. Please use a valid localhost domain like dev.localhost, localhost, test.localhost, etc.");
-        process.exit(1);
-    }
-    const isRunning = await isDomainRunning(argv.host);
-    if (isRunning) {
-        console.error("❌ Domain already in use. Please choose another domain or stop the existing instance.");
-        process.exit(1);
-    }
-    const domain = argv.host;
-    const port = argv.port;
-    await (0, server_1.startCentralProxy)();
-    await (0, server_1.registerDomain)(domain, port);
 }
 run();

package/dist/lib/commands.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": 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 locadot_file_1 = __importDefault(require("./locadot-file"));
+class Commands {
+    static async start(argv) {
+        if (!localhost_1.default.isValidLocalhostDomain(argv.host)) {
+            console.error(constants_1.errorConstants.invalidHost);
+            process.exit(1);
+        }
+        if (await localhost_1.default.isLocalhostOpen(argv.host, argv.port)) {
+            console.error(constants_1.errorConstants.hostExist);
+        }
+        try {
+            await server_1.default.registerDomain(argv.host, argv.port);
+        }
+        catch (error) { }
+    }
+    static async stop() {
+        try {
+            await server_1.default.stopProxy();
+        }
+        catch (error) { }
+    }
+    static async restart() {
+        await server_1.default.restartProxy();
+        console.log("☑️ Proxy successfully restarted.");
+    }
+    static async getRegistry() {
+        try {
+            const registry = await locadot_file_1.default.getRegistry();
+            Object.entries(registry).forEach(([value, key]) => console.log(`Port: ${key} => ${value} \n`));
+            console.log(`☑️ Total: ${Object.keys(registry).length}.`);
+        }
+        catch (error) { }
+    }
+    static watchLogs() {
+        try {
+            console.log("☑️ Watching logs files.");
+            locadot_file_1.default.watchLogs();
+        }
+        catch (error) { }
+    }
+    static clearLogs() {
+        try {
+            locadot_file_1.default.clearLogs();
+            console.log("☑️ Logs successfully cleared.");
+        }
+        catch (error) { }
+    }
+}
+exports.default = Commands;

package/dist/lib/locadot-file.js

@@ -0,0 +1,124 @@
+"use strict";
+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");
+class locadotFile {
+    static async createLockFile(processId) {
+        fs_1.default.writeFileSync(constants_1.locadotPath.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();
+            }
+        }
+        catch (err) {
+            return;
+        }
+    }
+    static async deleteLockFile() {
+        fs_1.default.rmSync(constants_1.locadotPath.LOCK_FILE);
+    }
+    static async getRegistry() {
+        if (!fs_1.default.existsSync(constants_1.locadotPath.REGISTRY_FILE)) {
+            fs_1.default.writeFileSync(constants_1.locadotPath.REGISTRY_FILE, "{}");
+        }
+        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));
+    }
+    static async removeAllRegistry() {
+        fs_1.default.writeFileSync(constants_1.locadotPath.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));
+    }
+    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));
+    }
+    static async watchRegistry() {
+        return fs_1.default.watch(constants_1.locadotPath.REGISTRY_FILE, async (eventType) => {
+            if (eventType === "change") {
+                console.log("🔄 Updated domain mappings:", await locadotFile.getRegistry());
+            }
+        });
+    }
+    static async getLogs() {
+        if (!fs_1.default.existsSync(constants_1.locadotPath.LOGS)) {
+            fs_1.default.writeFileSync(constants_1.locadotPath.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, "{}");
+        }
+        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`);
+    }
+    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) => {
+            if (eventType === "change") {
+                const newLog = await locadotFile.getLogs();
+                newLog.logs?.forEach((log, i) => {
+                    if (i > length - 2) {
+                        this.printLogs(log);
+                    }
+                });
+                length = newLog.logs?.length || 0;
+            }
+        });
+    }
+    static async destroy(watcher) {
+        try {
+            const pid = await locadotFile.getProcessId();
+            locadotFile.deleteLockFile();
+            locadotFile.removeAllRegistry();
+            locadotFile.clearLogs();
+            watcher?.close();
+            if (pid) {
+                process.kill(parseInt(pid));
+            }
+        }
+        catch (error) { }
+    }
+    static async softDestroy(watcher) {
+        try {
+            const pid = await locadotFile.getProcessId();
+            locadotFile.deleteLockFile();
+            watcher?.close();
+            if (pid) {
+                process.kill(parseInt(pid));
+            }
+        }
+        catch (error) { }
+    }
+}
+exports.default = locadotFile;

package/dist/lib/localhost.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const https_1 = __importDefault(require("https"));
+class Localhost {
+    static async isLocalhostOpen(domain, port) {
+        return new Promise((resolve) => {
+            const req = https_1.default.request({
+                hostname: "localhost",
+                port,
+                method: "HEAD",
+                rejectUnauthorized: false,
+                timeout: 1000,
+                headers: {
+                    Host: domain,
+                },
+            }, (res) => {
+                resolve(res.statusCode >= 200 && res.statusCode < 400);
+                res.destroy();
+            });
+            req.on("error", () => resolve(false));
+            req.on("timeout", () => {
+                req.destroy();
+                resolve(false);
+            });
+            req.end();
+        });
+    }
+    static isValidLocalhostDomain(domain) {
+        const localhostPattern = /^(?:[a-zA-Z0-9-]+\.)*localhost$/;
+        return localhostPattern.test(domain);
+    }
+}
+exports.default = Localhost;

package/dist/server.js

@@ -3,118 +3,99 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cleanUp = exports.REGISTRY_FILE = exports.LOCK_FILE = void 0;
-exports.startCentralProxy = startCentralProxy;
-exports.registerDomain = registerDomain;
-exports.isProxyAlreadyRunning = isProxyAlreadyRunning;
 const http_proxy_1 = __importDefault(require("http-proxy"));
 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"));
-exports.LOCK_FILE = path_1.default.join(require("os").homedir(), ".locadot.lock");
-exports.REGISTRY_FILE = path_1.default.join(require("os").homedir(), ".locadot-registry.json");
-async function startCentralProxy() {
-    if (await isProxyAlreadyRunning()) {
-        console.log("🔌 Proxy is already running");
-        return;
-    }
-    let domainMap = {};
-    // Create lock file
-    fs_1.default.writeFileSync(exports.LOCK_FILE, process.pid.toString());
-    if (!fs_1.default.existsSync(exports.REGISTRY_FILE)) {
-        fs_1.default.writeFileSync(exports.REGISTRY_FILE, "{}");
-    }
-    if (fs_1.default.existsSync(exports.REGISTRY_FILE)) {
-        domainMap = JSON.parse(fs_1.default.readFileSync(exports.REGISTRY_FILE, "utf-8"));
-    }
-    const proxy = http_proxy_1.default.createProxyServer({});
-    const defaultCert = await (0, certs_1.createSSL)("localhost");
-    const watcher = fs_1.default.watch(exports.REGISTRY_FILE, (eventType) => {
-        if (eventType === "change") {
-            domainMap = JSON.parse(fs_1.default.readFileSync(exports.REGISTRY_FILE, "utf-8"));
-            console.log("🔄 Updated domain mappings:", domainMap);
-        }
-    });
-    process.on("SIGINT", cleanupFn);
-    process.on("SIGTERM", cleanupFn);
-    function cleanupFn() {
-        watcher.close();
-        (0, exports.cleanUp)();
-        process.exit();
+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();
+        process.on("SIGINT", async () => await locadot_file_1.default.destroy(watcher));
+        process.on("SIGTERM", async () => await locadot_file_1.default.destroy(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));
+                locadot_file_1.default.updateLogs(host || "", "warn", "Proxy not exist.");
+            }
+            proxy.web(req, res, { target: `http://localhost:${targetPort}` }, (err) => {
+                console.error("Proxy error:", err);
+                locadot_file_1.default.updateLogs(host || "", "warn", "Host not found.");
+                res.writeHead(502);
+                res.end("Connection failed. Host not found.");
+            });
+        };
+        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");
+        });
+        httpServer.listen(80, () => {
+            locadot_file_1.default.updateLogs("🛜 HTTP proxy running on port 80");
+        });
     }
-    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));
+    async startProxy() {
+        if (await locadot_file_1.default.getProcessId()) {
+            console.error("Proxy is already running");
             return;
         }
-        proxy.web(req, res, { target: `http://localhost:${targetPort}` }, (err) => {
-            console.error("Proxy error:", err);
-            res.writeHead(502);
-            res.end("Connection failed. Host not found.");
+        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",
         });
-    };
-    const httpsServer = https_1.default.createServer(defaultCert, requestHandler);
-    const httpServer = http_1.default.createServer(requestHandler);
-    httpsServer.listen(443, () => {
-        console.log("🌐 HTTPS proxy running on port 443");
-    });
-    httpServer.listen(80, () => {
-        console.log("🌐 HTTP proxy running on port 80");
-    });
-}
-async function registerDomain(domain, port) {
-    if (!(await isProxyAlreadyRunning())) {
-        console.error('❌ Proxy is not running. Start it first with "locadot start"');
-        process.exit(1);
-    }
-    let registry = {};
-    if (!fs_1.default.existsSync(exports.REGISTRY_FILE)) {
-        fs_1.default.writeFileSync(exports.REGISTRY_FILE, "{}");
-    }
-    if (fs_1.default.existsSync(exports.REGISTRY_FILE)) {
-        registry = JSON.parse(fs_1.default.readFileSync(exports.REGISTRY_FILE, "utf-8"));
-    }
-    if (registry[domain]) {
-        console.error(`❌ ${domain} already mapped to port ${registry[domain]}`);
-        process.exit(1);
+        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);
+        }
+        else {
+            locadot_file_1.default.createLockFile(proxyProcess.pid?.toString());
+        }
+        proxyProcess.unref();
+        console.log("🚀 Central proxy started in background.");
     }
-    registry[domain] = port;
-    fs_1.default.writeFileSync(exports.REGISTRY_FILE, JSON.stringify(registry, null, 2));
-    console.log(`✅ ${domain} => http://localhost:${port}`);
-}
-async function isProxyAlreadyRunning() {
-    try {
-        if (fs_1.default.existsSync(exports.LOCK_FILE)) {
-            const pid = parseInt(fs_1.default.readFileSync(exports.LOCK_FILE, "utf-8"));
-            try {
-                process.kill(pid, 0); // Check if process exists
-                return true;
-            }
-            catch {
-                // PID doesn't exist, remove stale lock file
-                (0, exports.cleanUp)();
-                return false;
-            }
+    async registerDomain(domain, port) {
+        if (!(await locadot_file_1.default.getProcessId())) {
+            await this.startProxy();
+        }
+        let registry = await locadot_file_1.default.getRegistry();
+        console.log(registry);
+        if (!fs_1.default.existsSync(constants_1.locadotPath.REGISTRY_FILE)) {
+            fs_1.default.writeFileSync(constants_1.locadotPath.REGISTRY_FILE, "{}");
         }
-        (0, exports.cleanUp)();
-        return false;
+        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 (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}`);
     }
-    catch (err) {
-        (0, exports.cleanUp)();
-        return false;
+    async stopProxy() {
+        await locadot_file_1.default.destroy();
     }
-}
-const cleanUp = () => {
-    try {
-        fs_1.default.unlinkSync(exports.LOCK_FILE);
-        fs_1.default.rmSync(exports.REGISTRY_FILE);
+    async restartProxy() {
+        await locadot_file_1.default.softDestroy();
+        await this.startProxy();
     }
-    catch (error) { }
-};
-exports.cleanUp = cleanUp;
+}
+const locadotProxy = new ProxyHandler();
+exports.default = locadotProxy;

package/dist/utils/constants.js

@@ -0,0 +1,22 @@
+"use strict";
+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 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,
+};
+exports.errorConstants = {
+    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.",
+    proxyClose: "☑️ Successfully stopped all locadot instances.",
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "locadot",
-  "version": "1.1.1",
+  "version": "1.2.2",
   "description": "Secure your local development environment with HTTPS and custom domains like dev.localhost.",
   "homepage": "https://www.npmjs.com/package/locadot",
   "main": "dist/index.js",
@@ -32,6 +32,7 @@
     "@types/http-proxy": "^1.17.16",
     "@types/yargs": "^17.0.33",
     "appdata-path": "^1.0.0",
+    "date-fns": "^4.1.0",
     "detect-port": "^2.1.0",
     "http-proxy": "^1.18.1",
     "https": "^1.0.0",