locadot 2.1.0 → 2.3.0

package/dist/proxy/tunnel.js

@@ -11,8 +11,10 @@ const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
 const constants_1 = __importDefault(require("../constants"));
 const logger_1 = __importDefault(require("../utils/logger"));
+const hub_tunnel_1 = require("./hub-tunnel");
 /**
- * Public sharing through Cloudflare quick tunnels (https://<random>.trycloudflare.com, no account).
+ * Public sharing through Cloudflare quick tunnels (https://<random>.trycloudflare.com, no account),
+ * or through a named tunnel per mapping on the user's own hostname (`tunnelDomain`).
  * cloudflared forwards to the proxy's HTTP port with the public Host header, and the proxy maps
  * that name back to the mapping, so redirects and cookies stay on the public name.
  */
@@ -20,6 +22,7 @@ const exe = os_1.default.platform() === "win32" ? "cloudflared.exe" : "cloudflar
 const BIN_DIR = path_1.default.join(constants_1.default.paths.HOME, "bin");
 const RELEASES = "https://github.com/cloudflare/cloudflared/releases/latest/download/";
 const URL_PATTERN = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/i;
+const REGISTERED_PATTERN = /Registered tunnel connection/i;
 const onPath = () => {
     const finder = os_1.default.platform() === "win32" ? "where" : "which";
     const result = (0, child_process_1.spawnSync)(finder, ["cloudflared"], { encoding: "utf8", windowsHide: true });
@@ -37,11 +40,12 @@ const cloudflaredInfo = (fresh = false) => {
     if (!fresh && cached && Date.now() - cached.at < 60000)
         return cached.info;
     const file = (0, exports.cloudflaredPath)();
-    let info = { installed: false };
+    const loggedIn = fs_1.default.existsSync(path_1.default.join(os_1.default.homedir(), ".cloudflared", "cert.pem"));
+    let info = { installed: false, loggedIn };
     if (file) {
         const result = (0, child_process_1.spawnSync)(file, ["--version"], { encoding: "utf8", timeout: 5000, windowsHide: true });
         const version = `${result.stdout || ""}${result.stderr || ""}`.match(/version\s+(\S+)/i)?.[1];
-        info = { installed: result.status === 0, path: file, ...(version ? { version } : {}) };
+        info = { installed: result.status === 0, loggedIn, path: file, ...(version ? { version } : {}) };
     }
     cached = { at: Date.now(), info };
     return info;
@@ -121,7 +125,7 @@ class TunnelManager {
         this.origin = origin;
         this.tunnels = new Map();
     }
-    /** The mapping a public trycloudflare.com Host belongs to. */
+    /** The mapping a public Host (trycloudflare.com or a custom hostname) belongs to. */
     hostFor(publicHost) {
         for (const [host, tunnel] of this.tunnels)
             if (tunnel.publicHost === publicHost)
@@ -137,38 +141,73 @@ class TunnelManager {
     }
     /** Starts and stops tunnels to match the registry; `retry` also restarts ones that failed. */
     sync(hosts, retry = false) {
-        for (const [host, tunnel] of [...this.tunnels])
-            if (!hosts[host]?.tunnel || (retry && tunnel.status === "error"))
+        for (const [host, tunnel] of [...this.tunnels]) {
+            const entry = hosts[host];
+            if (!entry?.tunnel || (retry && tunnel.status === "error") || tunnel.domain !== (entry.tunnelDomain || undefined))
                 this.stop(host);
+        }
         for (const [host, entry] of Object.entries(hosts))
             if (entry.tunnel && !this.tunnels.has(host))
-                this.start(host);
+                this.start(host, entry.tunnelDomain);
     }
-    start(host) {
+    start(host, domain) {
+        const mode = domain ? "custom" : "quick";
         const file = (0, exports.cloudflaredPath)();
         if (!file) {
-            this.tunnels.set(host, { enabled: true, status: "error", error: "cloudflared is not installed. Run `locadot tunnel:install`." });
+            this.tunnels.set(host, { enabled: true, status: "error", mode, domain, error: "cloudflared is not installed. Run `locadot tunnel:install`." });
             return;
         }
-        const tunnel = { enabled: true, status: "starting" };
+        const tunnel = { enabled: true, status: "starting", mode, domain };
         this.tunnels.set(host, tunnel);
+        if (domain) {
+            this.startCustom(file, host, domain, tunnel);
+            return;
+        }
         // An empty config file keeps a user's ~/.cloudflared/config.yml (named tunnels) out of the way.
         const config = path_1.default.join(constants_1.default.paths.HOME, "cloudflared-quick.yml");
         fs_1.default.writeFileSync(config, "");
-        const child = (0, child_process_1.spawn)(file, ["tunnel", "--no-autoupdate", "--config", config, "--url", this.origin()], {
-            stdio: ["ignore", "pipe", "pipe"],
-            windowsHide: true,
+        this.run(host, tunnel, file, ["tunnel", "--no-autoupdate", "--config", config, "--url", this.origin()], (text) => {
+            const url = text.match(URL_PATTERN)?.[0];
+            if (url)
+                Object.assign(tunnel, { status: "up", url, publicHost: new URL(url).hostname });
+        });
+    }
+    /** Logs in if needed, creates the mapping's own named tunnel and points the hostname's DNS at it, then runs it. */
+    startCustom(file, host, domain, tunnel) {
+        const name = `locadot-${host.replace(/[^a-z0-9-]/gi, "-")}`;
+        tunnel.publicHost = domain;
+        (0, hub_tunnel_1.setupNamedTunnel)(domain, name, (loginUrl) => {
+            if (this.tunnels.get(host) === tunnel)
+                Object.assign(tunnel, { status: "login", loginUrl });
+        })
+            .then(() => {
+            if (this.tunnels.get(host) !== tunnel)
+                return;
+            Object.assign(tunnel, { status: "starting", loginUrl: undefined });
+            this.run(host, tunnel, file, ["tunnel", "--no-autoupdate", "run", "--url", this.origin(), name], (text) => {
+                if (REGISTERED_PATTERN.test(text))
+                    Object.assign(tunnel, { status: "up", url: `https://${domain}` });
+            });
+        })
+            .catch((error) => {
+            if (this.tunnels.get(host) !== tunnel)
+                return;
+            Object.assign(tunnel, { status: "error", error: error?.message || String(error), loginUrl: undefined });
+            logger_1.default.warn(`🌍 tunnel for ${host} failed: ${tunnel.error}`);
         });
+    }
+    run(host, tunnel, file, args, onData) {
+        const child = (0, child_process_1.spawn)(file, args, { stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
         tunnel.child = child;
         let tail = "";
         const read = (chunk) => {
             const text = chunk.toString("utf8");
             tail = (tail + text).slice(-2000);
-            const url = text.match(URL_PATTERN)?.[0];
-            if (url && tunnel.status !== "up") {
-                Object.assign(tunnel, { status: "up", url, publicHost: new URL(url).hostname });
-                logger_1.default.info(`🌍 ${host} is public at ${url}`);
-            }
+            if (tunnel.status === "up")
+                return;
+            onData(text);
+            if (tunnel.status === "up")
+                logger_1.default.info(`🌍 ${host} is public at ${tunnel.url}`);
         };
         child.stdout?.on("data", read);
         child.stderr?.on("data", read);
@@ -177,17 +216,18 @@ class TunnelManager {
             if (this.tunnels.get(host) !== tunnel)
                 return;
             const reason = tail.split(/\r?\n/).filter((line) => /ERR|error|failed/i.test(line)).pop()?.trim();
-            Object.assign(tunnel, { status: "error", error: reason || `cloudflared exited (${code})`, url: undefined, publicHost: undefined, child: undefined });
+            Object.assign(tunnel, { status: "error", error: reason || `cloudflared exited (${code})`, url: undefined, child: undefined });
+            if (!tunnel.domain)
+                tunnel.publicHost = undefined;
             logger_1.default.warn(`🌍 tunnel for ${host} stopped: ${tunnel.error}`);
         });
     }
     stop(host) {
         const tunnel = this.tunnels.get(host);
         this.tunnels.delete(host);
-        if (tunnel?.child) {
-            tunnel.child.kill();
+        if (tunnel?.child || tunnel?.status === "login")
             logger_1.default.info(`🌍 ${host} is no longer public`);
-        }
+        tunnel?.child?.kill();
     }
     stopAll() {
         for (const host of [...this.tunnels.keys()])

package/dist/server/index.js

@@ -67,6 +67,7 @@ async function startCentralProxy() {
         stats,
         lookup: (host) => registry.get().hosts[tunnels.hostFor(host) ?? host],
         tunnelFor: (host) => tunnels.hostFor(host),
+        ownPorts: () => [info.httpPort, info.httpsPort],
         remoteFor: remote_1.remoteFor,
         localFor: remote_1.localFor,
         remoteHosts: (name) => Object.entries(registry.get().hosts)
@@ -76,6 +77,7 @@ async function startCentralProxy() {
         hub: {
             classify: (req) => (0, hub_1.classify)(req, hub.publicHost(), registry.get().hosts, {
                 localhost: hub_config_1.default.readCached()?.localhost !== false,
+                panel: hub_config_1.default.readCached()?.panel === true,
                 blockedPorts: [info.httpPort, info.httpsPort],
             }),
             api: (req, res) => {

package/dist/utils/startup.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.windowsLauncherScript = void 0;
+exports.windowsLauncherScript = exports.macPlist = exports.macDirs = void 0;
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const fs_1 = __importDefault(require("fs"));
@@ -16,11 +16,87 @@ const SERVICE_NAME = "locadot-proxy";
 const MAC_LABEL = "com.locadot.proxy";
 const CRON_MARK = "# locadot-proxy";
 const MARKER = path_1.default.join(constants_1.default.paths.HOME, "startup.json");
+const markerIn = (state) => path_1.default.join(state, "startup.json");
 // Per-user Startup folder: unlike an ONLOGON scheduled task it needs no admin rights.
 const windowsLauncher = () => path_1.default.join(process.env.APPDATA || path_1.default.join(os_1.default.homedir(), "AppData", "Roaming"), "Microsoft", "Windows", "Start Menu", "Programs", "Startup", `${SERVICE_NAME}.vbs`);
 // Earlier versions registered an ONLOGON scheduled task and kept the script in the state dir.
 const LEGACY_LAUNCHER = path_1.default.join(constants_1.default.paths.HOME, "startup-hidden.vbs");
-const plistPath = () => path_1.default.join(os_1.default.homedir(), "Library", "LaunchAgents", `${MAC_LABEL}.plist`);
+// Tests point these elsewhere.
+exports.macDirs = { daemons: "/Library/LaunchDaemons" };
+const agentPath = (home = os_1.default.homedir()) => path_1.default.join(home, "Library", "LaunchAgents", `${MAC_LABEL}.plist`);
+const daemonPath = () => path_1.default.join(exports.macDirs.daemons, `${MAC_LABEL}.plist`);
+const xml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+/** Home of the user behind `sudo`, so root mode starts their proxy, not root's. */
+const sudoUserHome = (user) => {
+    try {
+        const out = (0, child_process_1.execFileSync)("dscl", [".", "-read", `/Users/${user}`, "NFSHomeDirectory"], { encoding: "utf8", windowsHide: true });
+        const home = out.split(":").slice(1).join(":").trim();
+        if (home)
+            return home;
+    }
+    catch { }
+    return path_1.default.join("/Users", user);
+};
+/**
+ * Who the boot job runs as and which state dir it uses. As root under plain `sudo`, HOME is /var/root, so the
+ * state dir is re-derived for SUDO_USER; LOCADOT_HOME or `sudo -E` already point at the right one.
+ */
+const macTarget = () => {
+    const root = process.getuid?.() === 0;
+    const user = root ? process.env.SUDO_USER : undefined;
+    if (!user || user === "root")
+        return { root, user: undefined, home: os_1.default.homedir(), state: constants_1.default.paths.HOME };
+    const home = sudoUserHome(user);
+    const own = process.env.LOCADOT_HOME || constants_1.default.paths.HOME.startsWith(`${home}/`);
+    return { root, user, home, state: own ? constants_1.default.paths.HOME : path_1.default.join(home, "Library", "Application Support", "locadot") };
+};
+const macPlist = (label, argv, opts) => {
+    const env = { ...(opts.home ? { HOME: opts.home } : {}), ...opts.env };
+    const dict = (entries) => Object.entries(entries).map(([k, v]) => `    <key>${xml(k)}</key>\n    <string>${xml(v)}</string>`).join("\n");
+    const log = path_1.default.join(opts.state, ".locadot.log");
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${xml(label)}</string>
+  <key>ProgramArguments</key>
+  <array>
+    ${argv.map((arg) => `<string>${xml(arg)}</string>`).join("\n    ")}
+  </array>${opts.user ? `\n  <key>UserName</key>\n  <string>${xml(opts.user)}</string>` : ""}${Object.keys(env).length ? `\n  <key>EnvironmentVariables</key>\n  <dict>\n${dict(env)}\n  </dict>` : ""}
+  <key>RunAtLoad</key>
+  <true/>
+  <!-- A dashboard restart spawns the new proxy and exits; launchd must not take it down with the old one. -->
+  <key>AbandonProcessGroup</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${xml(log)}</string>
+  <key>StandardErrorPath</key>
+  <string>${xml(log)}</string>
+</dict>
+</plist>
+`;
+};
+exports.macPlist = macPlist;
+/** Port vars only when the user set them; otherwise the proxy reads the ports saved in the state dir. */
+const userPortVars = () => {
+    const set = constants_1.default.userPortEnv();
+    if (set === "none")
+        return {};
+    const vars = { LOCADOT_USER_PORTS: set };
+    if (set.includes("LOCADOT_HTTP_PORT"))
+        vars.LOCADOT_HTTP_PORT = String(constants_1.default.server.httpPort);
+    if (set.includes("LOCADOT_HTTPS_PORT"))
+        vars.LOCADOT_HTTPS_PORT = String(constants_1.default.server.httpsPort);
+    return vars;
+};
+/** Clears a disabled override (left by `launchctl unload -w`), which would keep the job from ever running. */
+const launchctlEnable = (domain) => {
+    try {
+        (0, child_process_1.execFileSync)("launchctl", ["enable", `${domain}/${MAC_LABEL}`], { stdio: "ignore", windowsHide: true });
+    }
+    catch { }
+};
 const quote = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
 // Resolved on use, not import: the entry path depends on how locadot was launched.
 const launchArgs = () => {
@@ -102,30 +178,40 @@ class Startup {
                 break;
             }
             case "mac": {
-                // macOS (10.14+) lets unprivileged processes bind 80/443, so a user LaunchAgent is enough.
-                const plist = `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-  <key>Label</key>
-  <string>${MAC_LABEL}</string>
-  <key>ProgramArguments</key>
-  <array>
-    ${[command, ...args].map((arg) => `<string>${arg}</string>`).join("\n    ")}
-  </array>
-  <key>RunAtLoad</key>
-  <true/>
-  <key>StandardOutPath</key>
-  <string>${constants_1.default.paths.LOGS}</string>
-  <key>StandardErrorPath</key>
-  <string>${constants_1.default.paths.LOGS}</string>
-</dict>
-</plist>`;
-                fs_1.default.mkdirSync(path_1.default.dirname(plistPath()), { recursive: true });
-                fs_1.default.writeFileSync(plistPath(), plist);
-                (0, child_process_1.execFileSync)("launchctl", ["load", "-w", plistPath()], { stdio: "inherit", windowsHide: true });
-                method = "launch-agent";
-                break;
+                // Not loaded now: a second proxy would only fail to bind next to the running one. launchd reads
+                // LaunchAgents at login and LaunchDaemons at boot on its own.
+                const target = macTarget();
+                const argv = [command, ...args.slice(0, -1), target.state];
+                if (target.root) {
+                    // Root mode: a LaunchDaemon starts at boot, before anyone logs in, as the sudo user when there is one.
+                    fs_1.default.mkdirSync(exports.macDirs.daemons, { recursive: true });
+                    fs_1.default.writeFileSync(daemonPath(), (0, exports.macPlist)(MAC_LABEL, argv, { state: target.state, user: target.user, home: target.user ? target.home : undefined, env: userPortVars() }));
+                    // launchd skips daemon plists that aren't root-owned or are group/world writable.
+                    fs_1.default.chmodSync(daemonPath(), 0o644);
+                    fs_1.default.rmSync(agentPath(target.home), { force: true });
+                    launchctlEnable("system");
+                    method = "launch-daemon";
+                }
+                else {
+                    // macOS (10.14+) lets unprivileged processes bind 80/443, so a user LaunchAgent is enough. It starts at login.
+                    fs_1.default.mkdirSync(path_1.default.dirname(agentPath()), { recursive: true });
+                    fs_1.default.writeFileSync(agentPath(), (0, exports.macPlist)(MAC_LABEL, argv, { state: target.state, env: userPortVars() }));
+                    fs_1.default.chmodSync(agentPath(), 0o644);
+                    if (fs_1.default.existsSync(daemonPath()))
+                        await execSudo(`rm -f ${quote(daemonPath())}`);
+                    launchctlEnable(`gui/${process.getuid?.()}`);
+                    method = "launch-agent";
+                }
+                fs_1.default.mkdirSync(target.state, { recursive: true });
+                fs_1.default.writeFileSync(markerIn(target.state), JSON.stringify({ platform, method, enabledAt: new Date().toISOString() }, null, 2));
+                if (target.user) {
+                    // Written as root into the user's state dir; the user's own proxy has to be able to replace them.
+                    const { uid, gid } = fs_1.default.statSync(target.home);
+                    for (const file of [target.state, markerIn(target.state)])
+                        fs_1.default.chownSync(file, uid, gid);
+                }
+                logger_1.default.info(`✅ locadot will start at ${method === "launch-daemon" ? "boot" : "login"} (${method}).`);
+                return;
             }
             default:
                 throw new Error("Unknown platform");
@@ -148,15 +234,19 @@ class Startup {
                 else
                     (0, child_process_1.execFileSync)("sh", ["-c", cronEdit()], { stdio: "inherit", windowsHide: true });
                 break;
-            case "mac":
-                if (fs_1.default.existsSync(plistPath())) {
-                    try {
-                        (0, child_process_1.execFileSync)("launchctl", ["unload", "-w", plistPath()], { stdio: "ignore", windowsHide: true });
-                    }
-                    catch { }
-                    fs_1.default.rmSync(plistPath(), { force: true });
+            case "mac": {
+                // Only the plist goes: unloading the job would also stop a proxy launchd started.
+                const target = macTarget();
+                fs_1.default.rmSync(agentPath(target.home), { force: true });
+                if (fs_1.default.existsSync(daemonPath())) {
+                    if (target.root)
+                        fs_1.default.rmSync(daemonPath(), { force: true });
+                    else
+                        await execSudo(`rm -f ${quote(daemonPath())}`);
                 }
+                fs_1.default.rmSync(markerIn(target.state), { force: true });
                 break;
+            }
             default:
                 throw new Error("Unknown platform");
         }
@@ -188,7 +278,7 @@ class Startup {
                         return true;
                     return (0, child_process_1.execFileSync)("sh", ["-c", "crontab -l 2>/dev/null || true"], { encoding: "utf8", windowsHide: true }).includes(CRON_MARK);
                 case "mac":
-                    return fs_1.default.existsSync(plistPath());
+                    return fs_1.default.existsSync(agentPath()) || fs_1.default.existsSync(daemonPath());
                 case "windows":
                     return fs_1.default.existsSync(windowsLauncher());
                 default:

package/dist/utils/trust.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.macSecurity = macSecurity;
 exports.isCATrusted = isCATrusted;
 exports.trustCA = trustCA;
 exports.untrustCA = untrustCA;
@@ -126,11 +127,60 @@ function isTrustedLinux(certPath) {
         return false;
     }
 }
+const MAC_KEYCHAIN = "/Library/Keychains/System.keychain";
+const macRootError = () => new Error(`Run \`locadot trust\` without sudo; it asks for your password itself. Under sudo it would trust root's own CA ` +
+    `(${(0, certs_1.caCertPath)()}), not the one your proxy serves.`);
+// Plain `sudo` sets HOME to /var/root; `sudo -E` or LOCADOT_HOME keep the user's state dir, so those are fine.
+const sudoAsRoot = () => {
+    const user = process.env.SUDO_USER;
+    return process.getuid?.() === 0 && Boolean(user) && !process.env.LOCADOT_HOME && !path_1.default.resolve(constants_1.default.paths.HOME).startsWith(`/Users/${user}/`);
+};
+// Changing admin trust settings needs macOS to show a password dialog. sudo-prompt elevates through
+// `osascript ... with administrator privileges`, which can't, so it fails with "no user interaction was possible".
+// A Terminal's sudo or the user's own session can.
+// Async: from the dashboard the dialog can stay open for a while, and the proxy has to keep serving meanwhile.
+async function macSecurity(args) {
+    const viaSudo = process.getuid?.() !== 0 && Boolean(process.stdin.isTTY);
+    const detail = await new Promise((resolve) => {
+        const child = viaSudo
+            ? (0, child_process_1.spawn)("sudo", ["security", ...args], { stdio: ["inherit", "inherit", "pipe"], windowsHide: true })
+            : (0, child_process_1.spawn)("security", args, { stdio: ["ignore", "inherit", "pipe"], windowsHide: true });
+        let stderr = "";
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+            if (viaSudo)
+                process.stderr.write(chunk);
+        });
+        child.on("error", (error) => resolve(error.message));
+        child.on("close", (code) => resolve(code === 0 ? undefined : stderr.trim() || `security exited with ${code}`));
+    });
+    if (detail === undefined)
+        return;
+    if (/no user interaction was possible/i.test(detail)) {
+        throw new Error("macOS needs to show a password dialog to change certificate trust, and couldn't from here. " +
+            "Run `locadot trust` in Terminal on the Mac itself (not over SSH), or run:\n  " +
+            `sudo security ${args.map((a) => (/\s/.test(a) ? `"${a}"` : a)).join(" ")}`);
+    }
+    throw new Error(detail);
+}
 async function trustMac(certPath) {
-    await execSudo(`security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain "${certPath}"`);
+    if (sudoAsRoot())
+        throw macRootError();
+    await macSecurity(["add-trusted-cert", "-d", "-r", "trustRoot", "-k", MAC_KEYCHAIN, certPath]);
 }
 async function untrustMac() {
-    await execSudo(`security delete-certificate -c "${CA_NAME}"`);
+    if (sudoAsRoot())
+        throw macRootError();
+    const certPath = (0, certs_1.caCertPath)();
+    if (fs_1.default.existsSync(certPath)) {
+        try {
+            await macSecurity(["remove-trusted-cert", "-d", certPath]);
+        }
+        catch {
+            // No trust settings left for it; deleting the certificate below is what matters.
+        }
+    }
+    await macSecurity(["delete-certificate", "-c", CA_NAME, MAC_KEYCHAIN]);
 }
 function isTrustedMac(certPath) {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "locadot",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "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",