locadot 2.0.0 → 2.1.0-beta.0

package/dist/index.js

@@ -9,6 +9,8 @@ const commands_1 = __importDefault(require("./cli/commands"));
 const localhost_1 = require("./lib/localhost");
 const registry_1 = require("./lib/registry");
 const proxy_control_1 = require("./lib/proxy-control");
+const links_1 = require("./lib/links");
+const remotes_1 = require("./lib/remotes");
 const logger_1 = __importDefault(require("./utils/logger"));
 const package_json_1 = require("../package.json");
 const program = new commander_1.Command();
@@ -20,7 +22,11 @@ const run = (fn, { exit = true } = {}) => async (...args) => {
             process.exit(process.exitCode ?? 0);
     }
     catch (error) {
-        const known = error instanceof localhost_1.InputError || error instanceof proxy_control_1.ProxyError || error instanceof registry_1.RegistryError;
+        const known = error instanceof localhost_1.InputError ||
+            error instanceof proxy_control_1.ProxyError ||
+            error instanceof registry_1.RegistryError ||
+            error instanceof links_1.LinkError ||
+            error instanceof remotes_1.RemoteError;
         logger_1.default.error(known ? error.message : `❌ ${error?.stack || error}`);
         process.exit(1);
     }
@@ -104,4 +110,83 @@ program.command("path:hosts").description("Show the registry file path").action(
 program.command("startup:enable").description("Start locadot on boot/logon").action(run(() => commands_1.default.enableStartup()));
 program.command("startup:disable").description("Don't start locadot on boot/logon").action(run(() => commands_1.default.disableStartup()));
 program.command("startup:status").description("Is start on boot enabled?").action(run(() => commands_1.default.statusStartup()));
+const roleOption = () => new commander_1.Option("-r, --role <role>", "viewer, editor or admin").choices(["viewer", "editor", "admin"]).makeOptionMandatory();
+program
+    .command("hub")
+    .description("Show remote access status")
+    .option("--json", "Machine-readable output")
+    .action(run((options) => commands_1.default.hub(options)));
+program
+    .command("hub:setup")
+    .description("Share this locadot on your own domain via a named Cloudflare tunnel")
+    .requiredOption("-d, --domain <domain>", "Public domain, e.g. hub.example.com")
+    .option("-t, --tunnel <name>", "Cloudflare tunnel name", "locadot")
+    .action(run((options) => commands_1.default.hubSetup(options)));
+program
+    .command("hub:quick")
+    .description("Share this locadot on a random trycloudflare.com URL (no account, URL changes on restart)")
+    .action(run(() => commands_1.default.hubQuick()));
+program
+    .command("hub:manual")
+    .description("Share this locadot behind a URL something else already forwards (ngrok, a reverse proxy, tests)")
+    .requiredOption("-u, --url <url>", "Public base URL that forwards to this proxy's HTTP port")
+    .action(run((options) => commands_1.default.hubManual(options)));
+program.command("hub:off").description("Turn off remote access").action(run(() => commands_1.default.hubOff()));
+program
+    .command("share")
+    .description("Create a one-time pairing code for someone to connect to this locadot")
+    .addOption(roleOption())
+    .option("--hosts <hosts>", "Comma separated hosts the viewer may see (viewer role only)")
+    .action(run((options) => commands_1.default.share(options)));
+program
+    .command("peers")
+    .description("List everyone paired with this locadot")
+    .option("--json", "Machine-readable output")
+    .action(run((options) => commands_1.default.peers(options)));
+program
+    .command("peers:role <id> <role>")
+    .description("Change a peer's role")
+    .option("--hosts <hosts>", "Comma separated hosts (viewer role only)")
+    .action(run((id, role, options) => commands_1.default.peersRole(id, role, options)));
+program.command("peers:revoke <id>").description("Revoke a peer").action(run((id) => commands_1.default.peersRevoke(id)));
+program
+    .command("connect <string>")
+    .description("Connect to a remote locadot using its pairing string")
+    .option("--name <name>", "Local name for this remote (defaults to the sender's hostname)")
+    .action(run((value, options) => commands_1.default.connect(value, options)));
+program
+    .command("remotes")
+    .description("List remotes this locadot is connected to")
+    .option("--json", "Machine-readable output")
+    .action(run((options) => commands_1.default.remotes(options)));
+program.command("remote:sync <name>").description("Refresh role and available hosts for a remote").action(run((name) => commands_1.default.remoteSync(name)));
+program
+    .command("remote:alias <name> <remoteHost> <localHost>")
+    .description("Map a local .localhost name to a host on a remote")
+    .action(run((name, remoteHost, localHost) => commands_1.default.remoteAlias(name, remoteHost, localHost)));
+program
+    .command("remote:url <name> <url>")
+    .description("Update a remote's URL (e.g. after its quick tunnel changed)")
+    .action(run((name, url) => commands_1.default.remoteUrl(name, url)));
+program
+    .command("remote:add <name>")
+    .description("Add a mapping on a remote")
+    .addOption(hostOption())
+    .requiredOption("-t, --target <url>", "Any upstream: 3000, 127.0.0.1:8080, http://192.168.1.5:8080, https://google.com")
+    .option("-k, --insecure", "Don't verify the TLS certificate of an https target")
+    .option("--cors", "Send Origin/Referer as the target's own and let any origin call this domain")
+    .action(run((name, options) => commands_1.default.remoteAdd(name, options)));
+program
+    .command("remote:update <name>")
+    .description("Update a mapping on a remote")
+    .addOption(hostOption())
+    .option("-t, --target <url>", "New upstream")
+    .option("--cors", "Send Origin/Referer as the target's own and let any origin call this domain")
+    .option("--no-cors", "Turn --cors off again")
+    .action(run((name, options) => commands_1.default.remoteUpdate(name, options)));
+program
+    .command("remote:rm <name> <host>")
+    .description("Remove a mapping on a remote")
+    .action(run((name, host) => commands_1.default.remoteRm(name, host)));
+program.command("disconnect <name>").description("Disconnect from a remote").action(run((name) => commands_1.default.disconnect(name)));
 program.parseAsync(process.argv);

package/dist/lib/hub-config.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const file_1 = __importDefault(require("../utils/file"));
+/** Persists how the sender is reachable (`HUB_FILE`). No secrets in here; see links.ts for those. */
+class HubConfigStore {
+    static read() {
+        const raw = file_1.default.read("HUB_FILE");
+        if (!raw)
+            return undefined;
+        try {
+            const data = JSON.parse(raw);
+            return data && typeof data === "object" ? data : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    static write(config) {
+        file_1.default.writeAtomic("HUB_FILE", JSON.stringify(config, null, 2));
+    }
+    static clear() {
+        file_1.default.remove("HUB_FILE");
+    }
+}
+exports.default = HubConfigStore;

package/dist/lib/links.js

@@ -0,0 +1,163 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkError = exports.INVITE_TTL_MS = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const constants_1 = __importDefault(require("../constants"));
+const file_1 = __importDefault(require("../utils/file"));
+exports.INVITE_TTL_MS = 5 * 60000;
+class LinkError extends Error {
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+exports.LinkError = LinkError;
+const sha256Hex = (value) => crypto_1.default.createHash("sha256").update(value).digest("hex");
+/** Constant-time compare of a stored hex digest against a fresh secret. */
+const matchesHash = (storedHex, secret) => {
+    const stored = Buffer.from(storedHex, "hex");
+    const candidate = Buffer.from(sha256Hex(secret), "hex");
+    return stored.length === candidate.length && crypto_1.default.timingSafeEqual(stored, candidate);
+};
+const load = () => {
+    const raw = file_1.default.read("LINKS_FILE");
+    if (!raw)
+        return { invites: [], peers: [] };
+    try {
+        const data = JSON.parse(raw);
+        return {
+            invites: Array.isArray(data?.invites) ? data.invites : [],
+            peers: Array.isArray(data?.peers) ? data.peers : [],
+        };
+    }
+    catch {
+        return { invites: [], peers: [] };
+    }
+};
+const save = (data) => {
+    file_1.default.writeAtomic("LINKS_FILE", JSON.stringify(data, null, 2));
+    fs_1.default.chmodSync(constants_1.default.paths.LINKS_FILE, 0o600);
+};
+const CODE_PATTERN = /^lnk_([0-9a-f]{8})\.(.+)$/i;
+const TOKEN_PATTERN = /^lpt_([0-9a-f]{8})\.(.+)$/i;
+class Links {
+    static createInvite(input) {
+        const id = crypto_1.default.randomBytes(4).toString("hex");
+        const secret = crypto_1.default.randomBytes(32).toString("base64url");
+        const now = new Date();
+        const invite = {
+            id,
+            codeHash: sha256Hex(secret),
+            role: input.role,
+            hosts: input.hosts,
+            createdAt: now.toISOString(),
+            expiresAt: new Date(now.getTime() + exports.INVITE_TTL_MS).toISOString(),
+        };
+        const data = load();
+        data.invites.push(invite);
+        save(data);
+        return { invite, code: `lnk_${id}.${secret}` };
+    }
+    static inviteString(baseUrl, code) {
+        return `${baseUrl.replace(/\/$/, "")}/#${code}`;
+    }
+    /** One-time: the invite is removed once a matching id is resolved, success or not. */
+    static redeem(code, name) {
+        const match = CODE_PATTERN.exec(String(code || "").trim());
+        if (!match)
+            throw new LinkError(401, "Invalid or expired code.");
+        const [, id, secret] = match;
+        const data = load();
+        const index = data.invites.findIndex((invite) => invite.id === id);
+        if (index === -1)
+            throw new LinkError(401, "Invalid or expired code.");
+        const invite = data.invites[index];
+        data.invites.splice(index, 1);
+        save(data);
+        if (Date.parse(invite.expiresAt) < Date.now())
+            throw new LinkError(401, "Invalid or expired code.");
+        if (!matchesHash(invite.codeHash, secret))
+            throw new LinkError(401, "Invalid or expired code.");
+        const peerId = crypto_1.default.randomBytes(4).toString("hex");
+        const tokenSecret = crypto_1.default.randomBytes(32).toString("base64url");
+        const peer = {
+            id: peerId,
+            name: String(name || "peer"),
+            role: invite.role,
+            hosts: invite.hosts,
+            tokenHash: sha256Hex(tokenSecret),
+            createdAt: new Date().toISOString(),
+        };
+        const fresh = load();
+        fresh.peers.push(peer);
+        save(fresh);
+        return { peer, token: `lpt_${peerId}.${tokenSecret}` };
+    }
+    /** Updates lastSeen at most once a minute so every proxied request doesn't rewrite the file. */
+    static authenticate(token) {
+        if (!token)
+            return undefined;
+        const match = TOKEN_PATTERN.exec(token.trim());
+        if (!match)
+            return undefined;
+        const [, id, secret] = match;
+        const data = load();
+        const peer = data.peers.find((p) => p.id === id);
+        if (!peer || !matchesHash(peer.tokenHash, secret))
+            return undefined;
+        const now = Date.now();
+        if (!peer.lastSeen || now - Date.parse(peer.lastSeen) >= 60000) {
+            peer.lastSeen = new Date(now).toISOString();
+            save(data);
+        }
+        return peer;
+    }
+    static list() {
+        const data = load();
+        const now = Date.now();
+        const invites = data.invites.filter((invite) => Date.parse(invite.expiresAt) >= now);
+        if (invites.length !== data.invites.length)
+            save({ ...data, invites });
+        return { invites, peers: data.peers };
+    }
+    static setRole(peerId, role, hosts) {
+        const data = load();
+        const peer = data.peers.find((p) => p.id === peerId);
+        if (!peer)
+            throw new LinkError(404, "Peer not found.");
+        peer.role = role;
+        peer.hosts = hosts;
+        save(data);
+        return peer;
+    }
+    static revoke(peerId) {
+        const data = load();
+        const peers = data.peers.filter((p) => p.id !== peerId);
+        if (peers.length !== data.peers.length)
+            save({ ...data, peers });
+    }
+    static revokeInvite(id) {
+        const data = load();
+        const invites = data.invites.filter((invite) => invite.id !== id);
+        if (invites.length !== data.invites.length)
+            save({ ...data, invites });
+    }
+    static can(peer, permission) {
+        if (permission === "read")
+            return true;
+        if (permission === "write")
+            return peer.role === "editor" || peer.role === "admin";
+        return peer.role === "admin"; // delete, settings
+    }
+    static visibleHosts(peer, all) {
+        if (peer.role !== "viewer")
+            return all;
+        const mine = new Set(peer.hosts || []);
+        return all.filter((host) => mine.has(host));
+    }
+}
+exports.default = Links;

package/dist/lib/localhost.js

@@ -76,7 +76,7 @@ class Localhost {
         return ["localhost", "127.0.0.1", "::1", "[::1]"].includes(hostname) || hostname.endsWith(".localhost");
     }
     /** Any HTTP response (even 404/500) counts as up: the upstream is reachable. */
-    static probe(target, timeoutMs = 1500, insecure = false) {
+    static probe(target, timeoutMs = 1500, insecure = false, headers = {}) {
         const started = Date.now();
         return new Promise((resolve) => {
             let url;
@@ -87,7 +87,7 @@ class Localhost {
                 return resolve({ up: false, error: "invalid target" });
             }
             const client = url.protocol === "https:" ? https_1.default : http_1.default;
-            const req = client.request(url, { method: "HEAD", timeout: timeoutMs, rejectUnauthorized: !insecure }, (res) => {
+            const req = client.request(url, { method: "HEAD", timeout: timeoutMs, rejectUnauthorized: !insecure, headers }, (res) => {
                 res.resume();
                 resolve({ up: true, status: res.statusCode, ms: Date.now() - started });
             });

package/dist/lib/remotes.js

@@ -0,0 +1,272 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoteError = void 0;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const constants_1 = __importDefault(require("../constants"));
+const file_1 = __importDefault(require("../utils/file"));
+const registry_1 = __importDefault(require("./registry"));
+const localhost_1 = __importDefault(require("./localhost"));
+const hosts_1 = require("./hosts");
+class RemoteError extends Error {
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+exports.RemoteError = RemoteError;
+const apiBase = (url) => `${url}/_locadot/v1`;
+const safeJson = (text) => {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+};
+/** Talks to a sender's `/_locadot/v1` API. Never logs the body: it may carry the token. */
+async function call(url, opts = {}) {
+    let res;
+    try {
+        res = await fetch(url, {
+            method: opts.method || "GET",
+            headers: {
+                "Content-Type": "application/json",
+                ...(opts.token ? { Authorization: `Bearer ${opts.token}` } : {}),
+            },
+            body: opts.body !== undefined ? JSON.stringify(opts.body) : undefined,
+            signal: AbortSignal.timeout(10000),
+        });
+    }
+    catch (error) {
+        throw new RemoteError(0, `can't reach ${url}: ${error?.message || error}`);
+    }
+    const text = await res.text();
+    const data = text ? safeJson(text) : undefined;
+    if (!res.ok)
+        throw new RemoteError(res.status, (data && data.error) || res.statusText);
+    return data;
+}
+const readFile = () => {
+    const raw = file_1.default.read("REMOTES_FILE");
+    if (!raw)
+        return { remotes: {} };
+    const data = safeJson(raw);
+    if (data && typeof data.remotes === "object")
+        return data;
+    return { remotes: {} };
+};
+const writeFile = (data) => {
+    file_1.default.writeAtomic("REMOTES_FILE", JSON.stringify(data, null, 2));
+    fs_1.default.chmodSync(constants_1.default.paths.REMOTES_FILE, 0o600);
+};
+const toLabel = (raw) => {
+    const label = raw
+        .toLowerCase()
+        .replace(/[^a-z0-9-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 30);
+    return label || "remote";
+};
+const uniqueName = (base, existing) => {
+    if (!existing.has(base))
+        return base;
+    let i = 2;
+    while (existing.has(`${base}-${i}`))
+        i++;
+    return `${base}-${i}`;
+};
+class Remotes {
+    static parseInvite(value) {
+        const trimmed = String(value || "").trim();
+        const idx = trimmed.lastIndexOf("/#");
+        if (idx === -1)
+            throw new RemoteError(400, "Invalid pairing string.");
+        const url = trimmed.slice(0, idx).replace(/\/+$/, "");
+        const code = trimmed.slice(idx + 2);
+        if (!/^lnk_[0-9a-f]{8}\.[A-Za-z0-9_-]+$/.test(code))
+            throw new RemoteError(400, "Invalid pairing code.");
+        let parsed;
+        try {
+            parsed = new URL(url);
+        }
+        catch {
+            throw new RemoteError(400, "Invalid pairing URL.");
+        }
+        if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
+            throw new RemoteError(400, "Invalid pairing URL.");
+        return { url, code };
+    }
+    static list() {
+        return Object.values(readFile().remotes);
+    }
+    static get(name) {
+        return readFile().remotes[name];
+    }
+    static mustGet(name) {
+        const remote = Remotes.get(name);
+        if (!remote)
+            throw new RemoteError(404, `No remote named "${name}".`);
+        return remote;
+    }
+    static async connect(value, opts = {}) {
+        const { url, code } = Remotes.parseInvite(value);
+        // Checked before redeeming: the code works once, and the name ends up in hostnames (app.<name>.localhost).
+        const wanted = opts.name?.trim().toLowerCase();
+        if (wanted && !/^[a-z0-9](?:[a-z0-9-]{0,28}[a-z0-9])?$/.test(wanted)) {
+            throw new RemoteError(400, "Name must be a DNS label: a-z, 0-9 and -, up to 30 characters.");
+        }
+        const data = await call(`${apiBase(url)}/connect`, { method: "POST", body: { code, name: os_1.default.hostname() } });
+        const store = readFile();
+        const existingNames = new Set(Object.keys(store.remotes));
+        const base = wanted || toLabel(data.sender.hostname);
+        const name = uniqueName(base, existingNames);
+        const remote = {
+            name,
+            url,
+            token: data.token,
+            peerId: data.peer.id,
+            role: data.peer.role,
+            hosts: data.peer.hosts,
+            sender: data.sender,
+            connectedAt: new Date().toISOString(),
+        };
+        store.remotes[name] = remote;
+        writeFile(store);
+        const hostsRes = await call(`${apiBase(url)}/hosts`, { token: remote.token });
+        const hosts = hostsRes.hosts;
+        const now = new Date().toISOString();
+        const mapped = [];
+        const skipped = [];
+        await registry_1.default.mutate((registry) => {
+            const taken = new Set(Object.keys(registry.hosts));
+            for (const h of hosts) {
+                const local = Remotes.localName(name, h.host, taken);
+                if (!local) {
+                    skipped.push(h.host);
+                    continue;
+                }
+                taken.add(local);
+                registry.hosts[local] = { target: remote.url, remote: { name, host: h.host }, createdAt: now, updatedAt: now };
+                mapped.push({ local, host: h.host });
+            }
+        });
+        return { remote, hosts, mapped, skipped };
+    }
+    static async sync(name) {
+        const remote = Remotes.mustGet(name);
+        const who = await call(`${apiBase(remote.url)}/whoami`, { token: remote.token });
+        const updated = { ...remote, role: who.peer.role, hosts: who.peer.hosts, sender: who.sender };
+        const store = readFile();
+        store.remotes[name] = updated;
+        writeFile(store);
+        const hostsRes = await call(`${apiBase(remote.url)}/hosts`, { token: remote.token });
+        const hosts = hostsRes.hosts;
+        const now = new Date().toISOString();
+        await registry_1.default.mutate((registry) => {
+            const already = new Set();
+            for (const entry of Object.values(registry.hosts)) {
+                if (entry.remote?.name === name)
+                    already.add(entry.remote.host);
+            }
+            const taken = new Set(Object.keys(registry.hosts));
+            for (const h of hosts) {
+                if (already.has(h.host))
+                    continue;
+                const local = Remotes.localName(name, h.host, taken);
+                if (!local)
+                    continue;
+                taken.add(local);
+                registry.hosts[local] = { target: updated.url, remote: { name, host: h.host }, createdAt: now, updatedAt: now };
+            }
+        });
+        const registry = registry_1.default.read();
+        const mapped = Object.entries(registry.hosts)
+            .filter(([, e]) => e.remote?.name === name)
+            .map(([local, e]) => ({ local, host: e.remote.host }));
+        return { remote: updated, hosts, mapped };
+    }
+    static async alias(name, remoteHost, localHost) {
+        const remote = Remotes.mustGet(name);
+        const local = localhost_1.default.requireHost(localHost);
+        const hostsRes = await call(`${apiBase(remote.url)}/hosts`, { token: remote.token });
+        const hosts = hostsRes.hosts;
+        if (!hosts.some((h) => h.host === remoteHost))
+            throw new hosts_1.NotFoundError(`"${remoteHost}" is not available on "${name}".`);
+        const now = new Date().toISOString();
+        await registry_1.default.mutate((registry) => {
+            if (registry.hosts[local])
+                throw new hosts_1.ConflictError(`❌ ${local} is already mapped to ${registry.hosts[local].target}.`);
+            registry.hosts[local] = { target: remote.url, remote: { name, host: remoteHost }, createdAt: now, updatedAt: now };
+        });
+    }
+    static setUrl(name, url) {
+        const store = readFile();
+        const remote = store.remotes[name];
+        if (!remote)
+            throw new RemoteError(404, `No remote named "${name}".`);
+        store.remotes[name] = { ...remote, url: url.replace(/\/+$/, "") };
+        writeFile(store);
+    }
+    static async disconnect(name) {
+        const store = readFile();
+        delete store.remotes[name];
+        writeFile(store);
+        await registry_1.default.mutate((registry) => {
+            for (const [host, entry] of Object.entries(registry.hosts)) {
+                if (entry.remote?.name === name)
+                    delete registry.hosts[host];
+            }
+        });
+    }
+    static async addHost(name, input) {
+        const remote = Remotes.mustGet(name);
+        const data = await call(`${apiBase(remote.url)}/hosts`, { method: "POST", token: remote.token, body: input });
+        const created = data.host;
+        const now = new Date().toISOString();
+        await registry_1.default.mutate((registry) => {
+            const taken = new Set(Object.keys(registry.hosts));
+            const local = Remotes.localName(name, created.host, taken);
+            if (local)
+                registry.hosts[local] = { target: remote.url, remote: { name, host: created.host }, createdAt: now, updatedAt: now };
+        });
+        return created;
+    }
+    static async updateHost(name, host, input) {
+        const remote = Remotes.mustGet(name);
+        const data = await call(`${apiBase(remote.url)}/hosts/${encodeURIComponent(host)}`, {
+            method: "PUT",
+            token: remote.token,
+            body: input,
+        });
+        return data.host;
+    }
+    static async removeHost(name, host) {
+        const remote = Remotes.mustGet(name);
+        await call(`${apiBase(remote.url)}/hosts/${encodeURIComponent(host)}`, { method: "DELETE", token: remote.token });
+        await registry_1.default.mutate((registry) => {
+            for (const [local, entry] of Object.entries(registry.hosts)) {
+                if (entry.remote?.name === name && entry.remote?.host === host)
+                    delete registry.hosts[local];
+            }
+        });
+    }
+    /** app.localhost → itself if free, else the remote name inserted before "localhost"; undefined if both are taken. */
+    static localName(remoteName, host, taken) {
+        const direct = localhost_1.default.normalizeHost(host);
+        if (!direct)
+            return undefined;
+        if (!taken.has(direct))
+            return direct;
+        const labels = direct.split(".");
+        labels.splice(labels.length - 1, 0, remoteName);
+        const candidate = localhost_1.default.normalizeHost(labels.join("."));
+        if (!candidate || taken.has(candidate))
+            return undefined;
+        return candidate;
+    }
+}
+exports.default = Remotes;