locadot 2.0.0 → 2.1.0-beta.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 2.1.0-beta.0 (2026-09-27)
+
+### Added
+- Remote access: share your whole locadot with another locadot over a Cloudflare named tunnel, a quick tunnel, or any URL.
+  Receivers pair with a one-time string (5 minutes) and get viewer, editor or admin access, which the sender can change or
+  revoke. The sender's mappings appear in the receiver's locadot; clashing names become `<host>.<remote>.localhost`.
+  New commands: `hub*`, `share`, `peers*`, `connect`, `remotes`, `remote:*` and `disconnect`. There are also new dashboard cards.
+- Dashboard: a collapsible sidebar with section links, active-section highlighting and counts. Collapse it to an icon rail
+  (remembered per browser); on small screens it is a slide-out drawer.
+
 ## 2.0.0 (2026-09-26)
 
 ### Changed

package/README.md

@@ -101,6 +101,30 @@ pass-through calls may only go to public addresses: loopback, LAN, link-local an
 on the address actually dialled, so the tunnel can't be used to reach your machine or network. The dashboard can also do this:
 use **Share** / **Unshare** on a row.
 
+### Remote access (locadot to locadot)
+
+One machine (the sender) publishes its whole locadot on a Cloudflare hostname. Other machines (receivers) connect with a
+short-lived pairing string, and the sender's mappings then show up in the receiver's own locadot and dashboard.
+
+| Command | What it does |
+| --- | --- |
+| `locadot hub:setup --domain dev.example.com` | Sender: publish through your own named tunnel on your Cloudflare domain (runs `cloudflared` login, creates the tunnel and routes DNS). The address stays the same. |
+| `locadot hub:quick` | Sender: publish on a trycloudflare URL. No account is needed, but **the URL changes if the tunnel restarts**, so receivers have to run `remote:url`. |
+| `locadot hub` / `hub:off` | Show the hub status and URL, or stop it. |
+| `locadot share --role viewer\|editor\|admin [--hosts a.localhost,b.localhost]` | Sender: print a pairing string. It works once and expires after 5 minutes. `--hosts` limits a viewer to those mappings. |
+| `locadot peers` / `peers:role <id> <role>` / `peers:revoke <id>` | Sender: list the connected machines, change a role, or cut one off. |
+| `locadot connect "<pairing string>" [--name alice]` | Receiver: connect and import the sender's mappings. If a name clashes, `app.localhost` becomes `app.alice.localhost`. |
+| `locadot remotes` / `remote:sync <name>` / `disconnect <name>` | Receiver: list the connections, pull new mappings, or remove the connection and its names. |
+| `locadot remote:alias <name> <remote host> <local host>` | Receiver: give a sender mapping another local name, e.g. `he.localhost`. |
+| `locadot remote:add\|remote:update\|remote:rm <name> …` | Receiver: change mappings on the sender (editor or admin). |
+| `locadot remote:url <name> <url>` | Receiver: point a connection at the sender's new URL. |
+
+Roles: **viewer** can only browse (optionally limited to the mappings picked on the invite). **editor** can also add and change
+mappings on the sender. **admin** can also delete them and change sharing. Traffic goes receiver → Cloudflare → sender →
+target, so an editor can reach anything the sender's machine can reach. Only give that role to people you trust. Only hashes
+of the tokens are stored, and failed attempts are rate limited. The sender's dashboard is never reachable through the hub.
+The dashboard has **Remote access** and **Connected machines** cards for all of this.
+
 ### Certificates
 
 | Command | What it does |

package/dist/cli/commands/index.js

@@ -38,6 +38,7 @@ const proxy = __importStar(require("./proxy"));
 const files = __importStar(require("./files"));
 const system = __importStar(require("./system"));
 const tunnel = __importStar(require("./tunnel"));
+const remote = __importStar(require("./remote"));
 const doctor_1 = require("./doctor");
-const Commands = { ...hosts, ...proxy, ...files, ...system, ...tunnel, doctor: doctor_1.doctor };
+const Commands = { ...hosts, ...proxy, ...files, ...system, ...tunnel, ...remote, doctor: doctor_1.doctor };
 exports.default = Commands;

package/dist/cli/commands/remote.js

@@ -0,0 +1,276 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hub = hub;
+exports.hubSetup = hubSetup;
+exports.hubQuick = hubQuick;
+exports.hubManual = hubManual;
+exports.hubOff = hubOff;
+exports.share = share;
+exports.peers = peers;
+exports.peersRole = peersRole;
+exports.peersRevoke = peersRevoke;
+exports.connect = connect;
+exports.remotes = remotes;
+exports.remoteSync = remoteSync;
+exports.remoteAlias = remoteAlias;
+exports.remoteUrl = remoteUrl;
+exports.remoteAdd = remoteAdd;
+exports.remoteUpdate = remoteUpdate;
+exports.remoteRm = remoteRm;
+exports.disconnect = disconnect;
+const http_1 = __importDefault(require("http"));
+const constants_1 = __importDefault(require("../../constants"));
+const proxy_control_1 = __importDefault(require("../../lib/proxy-control"));
+const localhost_1 = require("../../lib/localhost");
+const urls_1 = require("../../lib/urls");
+const registry_1 = __importDefault(require("../../lib/registry"));
+const file_1 = __importDefault(require("../../utils/file"));
+const links_1 = __importDefault(require("../../lib/links"));
+const hub_config_1 = __importDefault(require("../../lib/hub-config"));
+const hub_tunnel_1 = require("../../proxy/hub-tunnel");
+const remotes_1 = __importDefault(require("../../lib/remotes"));
+const shared_1 = require("../shared");
+const ROLES = ["viewer", "editor", "admin"];
+const requireRole = (value) => {
+    if (typeof value !== "string" || !ROLES.includes(value)) {
+        throw new localhost_1.InputError(`❌ Invalid role "${value}". Use viewer, editor or admin.`);
+    }
+    return value;
+};
+const splitHosts = (value) => value
+    ? value
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean)
+    : undefined;
+const requireRunning = () => {
+    if (!proxy_control_1.default.running())
+        throw new localhost_1.InputError("❌ The proxy isn't running. Run `locadot start`.");
+};
+const apiToken = () => {
+    const token = proxy_control_1.default.running() ? file_1.default.read("API_TOKEN")?.trim() : undefined;
+    if (!token)
+        throw new localhost_1.InputError("❌ No API token found. Run `locadot start`.");
+    return token;
+};
+/** Talks to the running proxy's local dashboard API on its HTTP port. */
+const dashboardRequest = (method, path, options = {}) => new Promise((resolve, reject) => {
+    const data = options.body !== undefined ? JSON.stringify(options.body) : undefined;
+    const req = http_1.default.request({
+        host: "127.0.0.1",
+        port: constants_1.default.server.httpPort,
+        path,
+        method,
+        headers: {
+            Host: "localhost",
+            ...(data ? { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(data) } : {}),
+            ...options.headers,
+        },
+        timeout: 5000,
+    }, (res) => {
+        let body = "";
+        res.on("data", (chunk) => (body += chunk));
+        res.on("end", () => {
+            try {
+                resolve({ status: res.statusCode || 0, json: body ? JSON.parse(body) : undefined });
+            }
+            catch {
+                reject(new localhost_1.InputError("❌ The proxy didn't answer. Is it running? Try `locadot status`."));
+            }
+        });
+    });
+    req.on("timeout", () => req.destroy(new Error("timeout")));
+    req.on("error", () => reject(new localhost_1.InputError("❌ The proxy isn't running. Run `locadot start`.")));
+    if (data)
+        req.write(data);
+    req.end();
+});
+const getHub = async () => {
+    requireRunning();
+    const { status, json } = await dashboardRequest("GET", "/api/hub");
+    if (status !== 200)
+        throw new localhost_1.InputError("❌ Couldn't read hub status. Try `locadot status`.");
+    return json;
+};
+const HUB_EMOJI = { off: "🔒", starting: "⏳", up: "🌍", error: "❌", login: "🔑" };
+async function hub(options) {
+    const { hub } = await getHub();
+    if (options.json) {
+        console.log(JSON.stringify(hub, null, 2));
+        return;
+    }
+    if (!hub.enabled) {
+        (0, shared_1.print)("🔒 Remote access is off. Turn it on: locadot hub:setup / hub:quick / hub:manual");
+        return;
+    }
+    (0, shared_1.print)(`${HUB_EMOJI[hub.status] ?? "❔"} ${hub.mode} — ${hub.status}${hub.url ? `: ${hub.url}` : ""}`);
+    if (hub.loginUrl)
+        (0, shared_1.print)(`   Open to finish login: ${hub.loginUrl}`);
+    if (hub.error)
+        (0, shared_1.print)(`   ${hub.error}`);
+}
+async function hubSetup(options) {
+    if (!options.domain)
+        throw new localhost_1.InputError("❌ Missing --domain <domain>.");
+    (0, shared_1.print)(`🔗 Setting up a named tunnel for ${options.domain}…`);
+    const config = await (0, hub_tunnel_1.setupNamedTunnel)(options.domain, options.tunnel, (loginUrl) => {
+        (0, shared_1.print)(`🔑 Open this URL to log in to Cloudflare: ${loginUrl}`);
+        (0, shared_1.print)("   Waiting for login…");
+    });
+    hub_config_1.default.write(config);
+    (0, shared_1.print)(`✅ Hub configured: https://${options.domain}`);
+    (0, shared_1.print)("   The running proxy watches this and starts the tunnel automatically. Not running? `locadot start`.");
+}
+async function hubQuick() {
+    hub_config_1.default.write({ mode: "quick" });
+    (0, shared_1.print)("🌍 Quick tunnel enabled (trycloudflare.com).");
+    (0, shared_1.print)("⚠️  The trycloudflare URL changes whenever cloudflared or the proxy restarts.");
+    (0, shared_1.print)("   When that happens, tell receivers to run: locadot remote:url <name> <new-url>");
+    (0, shared_1.print)("   Check the current URL any time: locadot hub");
+    (0, shared_1.print)("   The running proxy watches this and starts the tunnel automatically. Not running? `locadot start`.");
+}
+async function hubManual(options) {
+    if (!options.url)
+        throw new localhost_1.InputError("❌ Missing --url <url>.");
+    let parsed;
+    try {
+        parsed = new URL(options.url);
+    }
+    catch {
+        throw new localhost_1.InputError(`❌ Invalid URL "${options.url}".`);
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new localhost_1.InputError(`❌ Invalid URL "${options.url}". Use http:// or https://.`);
+    }
+    hub_config_1.default.write({ mode: "manual", url: options.url.replace(/\/+$/, "") });
+    (0, shared_1.print)(`✅ Hub configured: ${parsed.origin}`);
+    (0, shared_1.print)("   The running proxy watches this automatically. Not running? `locadot start`.");
+}
+async function hubOff() {
+    hub_config_1.default.clear();
+    (0, shared_1.print)("🔒 Remote access turned off.");
+}
+async function share(options) {
+    const role = requireRole(options.role);
+    if (options.hosts && role !== "viewer") {
+        (0, shared_1.print)(`⚠️  --hosts is ignored for ${role}s: they see every host.`);
+    }
+    const hosts = role === "viewer" ? splitHosts(options.hosts) : undefined;
+    requireRunning();
+    const { status, json } = await dashboardRequest("POST", "/api/invites", {
+        headers: { "X-Locadot-Token": apiToken() },
+        body: { role, hosts },
+    });
+    if (status === 409) {
+        throw new localhost_1.InputError("❌ The hub isn't up. Set it up first: locadot hub:setup / hub:quick / hub:manual.");
+    }
+    if (status !== 200 && status !== 201) {
+        throw new localhost_1.InputError(`❌ Couldn't create an invite (${status})${json?.error ? `: ${json.error}` : ""}.`);
+    }
+    (0, shared_1.print)("🔗 Pairing code (valid for 5 minutes, one use):");
+    (0, shared_1.print)("");
+    (0, shared_1.print)(`   ${json.string}`);
+    (0, shared_1.print)("");
+    (0, shared_1.print)(`   Role: ${json.role}${json.hosts ? ` — hosts: ${json.hosts.join(", ")}` : ""}`);
+}
+async function peers(options) {
+    const { invites, peers } = links_1.default.list();
+    if (options.json) {
+        console.log(JSON.stringify({ invites, peers }, null, 2));
+        return;
+    }
+    if (!peers.length)
+        (0, shared_1.print)("No peers yet. Create an invite: locadot share --role viewer");
+    for (const peer of peers) {
+        (0, shared_1.print)(`${peer.id}  ${peer.name}  ${peer.role}${peer.hosts ? `  [${peer.hosts.join(", ")}]` : ""}  last seen: ${peer.lastSeen ?? "never"}`);
+    }
+    if (invites.length)
+        (0, shared_1.print)(`⏳ Pending invites: ${invites.length}`);
+}
+async function peersRole(id, role, options) {
+    const parsedRole = requireRole(role);
+    const hosts = parsedRole === "viewer" ? splitHosts(options.hosts) : undefined;
+    const peer = links_1.default.setRole(id, parsedRole, hosts);
+    (0, shared_1.print)(`✅ ${peer.name} is now ${peer.role}${peer.hosts ? ` [${peer.hosts.join(", ")}]` : ""}.`);
+}
+async function peersRevoke(id) {
+    links_1.default.revoke(id);
+    (0, shared_1.print)(`🗑️  Revoked peer ${id}.`);
+}
+async function connect(value, options) {
+    const { remote, mapped, skipped } = await remotes_1.default.connect(value, { name: options.name });
+    (0, shared_1.print)(`✅ Connected to ${remote.name} (${remote.sender.hostname}) as ${remote.role}.`);
+    for (const m of mapped)
+        (0, shared_1.print)(`   ${(0, urls_1.urlFor)(m.local)}  →  ${m.host}`);
+    for (const reason of skipped)
+        (0, shared_1.print)(`   ⚠️  skipped: ${reason}`);
+}
+async function remotes(options) {
+    const list = remotes_1.default.list();
+    const registry = registry_1.default.read();
+    const aliasesFor = (name) => Object.entries(registry.hosts)
+        .filter(([, entry]) => entry.remote?.name === name)
+        .map(([local, entry]) => ({ local, host: entry.remote.host }));
+    if (options.json) {
+        console.log(JSON.stringify(list.map(({ token, ...remote }) => ({ ...remote, aliases: aliasesFor(remote.name) })), null, 2));
+        return;
+    }
+    if (!list.length) {
+        (0, shared_1.print)("No remotes. Connect to one: locadot connect <pairing-string>");
+        return;
+    }
+    for (const remote of list) {
+        (0, shared_1.print)(`${remote.name}  ${remote.url}  (${remote.role})`);
+        for (const alias of aliasesFor(remote.name))
+            (0, shared_1.print)(`   ${(0, urls_1.urlFor)(alias.local)}  →  ${alias.host}`);
+    }
+}
+async function remoteSync(name) {
+    const { mapped } = await remotes_1.default.sync(name);
+    (0, shared_1.print)(`✅ ${name} synced.`);
+    for (const m of mapped)
+        (0, shared_1.print)(`   + ${(0, urls_1.urlFor)(m.local)}  →  ${m.host}`);
+}
+async function remoteAlias(name, remoteHost, localHost) {
+    await remotes_1.default.alias(name, remoteHost, localHost);
+    (0, shared_1.print)(`✅ ${(0, urls_1.urlFor)(localHost)}  →  ${remoteHost} (${name})`);
+}
+async function remoteUrl(name, url) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        throw new localhost_1.InputError(`❌ Invalid URL "${url}".`);
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new localhost_1.InputError(`❌ Invalid URL "${url}". Use http:// or https://.`);
+    }
+    remotes_1.default.setUrl(name, url.replace(/\/+$/, ""));
+    (0, shared_1.print)(`✅ ${name} now points to ${parsed.origin}.`);
+}
+async function remoteAdd(name, options) {
+    if (!options.host)
+        throw new localhost_1.InputError("❌ Missing --host <host>.");
+    if (!options.target)
+        throw new localhost_1.InputError("❌ Missing --target <url>.");
+    await remotes_1.default.addHost(name, { host: options.host, target: options.target, insecure: options.insecure, cors: options.cors });
+    (0, shared_1.print)(`✅ ${options.host}  →  ${options.target} on ${name}.`);
+}
+async function remoteUpdate(name, options) {
+    if (!options.host)
+        throw new localhost_1.InputError("❌ Missing --host <host>.");
+    await remotes_1.default.updateHost(name, options.host, { target: options.target, cors: options.cors });
+    (0, shared_1.print)(`✅ Updated ${options.host} on ${name}.`);
+}
+async function remoteRm(name, host) {
+    await remotes_1.default.removeHost(name, host);
+    (0, shared_1.print)(`🗑️  Removed ${host} from ${name}.`);
+}
+async function disconnect(name) {
+    await remotes_1.default.disconnect(name);
+    (0, shared_1.print)(`🔌 Disconnected from ${name}.`);
+}

package/dist/constants/index.js

@@ -38,6 +38,10 @@ Constants.paths = {
     // Secret for the dashboard's mutating API; rotated on every proxy start.
     API_TOKEN: path_1.default.join(PACKAGE_PATH, ".locadot-token"),
     CONFIG_FILE,
+    // Remote access. Sender: public hostname config, invites + peers (0600). Receiver: remotes (0600).
+    HUB_FILE: path_1.default.join(PACKAGE_PATH, ".locadot-hub.json"),
+    LINKS_FILE: path_1.default.join(PACKAGE_PATH, ".locadot-links.json"),
+    REMOTES_FILE: path_1.default.join(PACKAGE_PATH, ".locadot-remotes.json"),
 };
 Constants.validPort = validPort;
 Constants.server = {

package/dist/dashboard/api.js

@@ -51,6 +51,9 @@ const logger_1 = __importDefault(require("../utils/logger"));
 const system_1 = require("../lib/system");
 const tunnel_1 = require("../proxy/tunnel");
 const urls_1 = require("../lib/urls");
+const links_1 = __importStar(require("../lib/links"));
+const hub_config_1 = __importDefault(require("../lib/hub-config"));
+const remotes_1 = __importStar(require("../lib/remotes"));
 const MAX_BODY = 64 * 1024;
 class ApiError extends Error {
     constructor(status, message, hint) {
@@ -149,6 +152,103 @@ const privileged = async (action, command) => {
     }
 };
 const hostUrl = (host, ctx) => (0, urls_1.formatUrl)(host, true, ctx.proxyInfo.httpsPort);
+const ROLES = ["viewer", "editor", "admin"];
+const isRole = (value) => typeof value === "string" && ROLES.includes(value);
+const optionalString = (value, name) => {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string")
+        throw new ApiError(400, `\`${name}\` must be a string.`);
+    return value;
+};
+const optionalHosts = (value) => {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value) || !value.every((v) => typeof v === "string")) {
+        throw new ApiError(400, "`hosts` must be an array of strings.");
+    }
+    return value;
+};
+/** Public hostname a Cloudflare named tunnel can route to (not *.localhost, no scheme/path). */
+const isValidPublicDomain = (value) => {
+    if (typeof value !== "string")
+        return false;
+    const host = value.trim().toLowerCase();
+    if (!host || host.length > 253 || host.includes("/") || host.includes(":"))
+        return false;
+    const labels = host.split(".");
+    if (labels.length < 2 || labels[labels.length - 1] === "localhost")
+        return false;
+    return labels.every((label) => /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/.test(label));
+};
+const sanitizeInvite = (invite) => ({
+    id: invite.id,
+    role: invite.role,
+    hosts: invite.hosts,
+    expiresAt: invite.expiresAt,
+});
+const sanitizePeer = (peer) => ({
+    id: peer.id,
+    name: peer.name,
+    role: peer.role,
+    hosts: peer.hosts,
+    createdAt: peer.createdAt,
+    lastSeen: peer.lastSeen,
+});
+const sanitizeRemote = (remote) => {
+    const { token, ...rest } = remote;
+    return rest;
+};
+const REMOTE_SYNC_TIMEOUT_MS = 5000;
+async function buildRemoteRows(ctx) {
+    const remotes = remotes_1.default.list();
+    let changed = false;
+    const rows = await Promise.all(remotes.map(async (remote) => {
+        try {
+            const timeout = new Promise((_, reject) => setTimeout(() => reject(new Error("timed out")), REMOTE_SYNC_TIMEOUT_MS));
+            const result = await Promise.race([remotes_1.default.sync(remote.name), timeout]);
+            changed = true;
+            return {
+                name: result.remote.name,
+                url: result.remote.url,
+                role: result.remote.role,
+                hosts: result.remote.hosts,
+                sender: result.remote.sender,
+                connectedAt: result.remote.connectedAt,
+                status: "ok",
+                available: result.hosts,
+                mapped: result.mapped,
+            };
+        }
+        catch (error) {
+            return {
+                name: remote.name,
+                url: remote.url,
+                role: remote.role,
+                hosts: remote.hosts,
+                sender: remote.sender,
+                connectedAt: remote.connectedAt,
+                status: "error",
+                error: clean(String(error?.message || error)),
+                available: null,
+                mapped: [],
+            };
+        }
+    }));
+    if (changed)
+        ctx.reload();
+    return rows;
+}
+function buildHubBody(ctx) {
+    const config = hub_config_1.default.read();
+    const { invites, peers } = links_1.default.list();
+    return {
+        hub: ctx.hub(),
+        config: config ?? null,
+        invites: invites.map(sanitizeInvite),
+        peers: peers.map(sanitizePeer),
+    };
+}
 /** Routes under /api/ other than the read-only status/hosts. Returns undefined when nothing matched. */
 async function route(req, url, ctx) {
     const method = req.method || "GET";
@@ -157,10 +257,31 @@ async function route(req, url, ctx) {
         const lines = Math.min(Math.max(Number(url.searchParams.get("lines")) || 200, 1), 2000);
         return { status: 200, body: { lines: file_1.default.lastLines("LOGS", lines) } };
     }
+    if (path === "/api/hub" && (method === "GET" || method === "HEAD")) {
+        return { status: 200, body: buildHubBody(ctx) };
+    }
+    if (path === "/api/remotes" && (method === "GET" || method === "HEAD")) {
+        return { status: 200, body: { remotes: await buildRemoteRows(ctx) } };
+    }
     const hostMatch = /^\/api\/hosts\/([^/]+)$/.exec(path);
+    const inviteMatch = /^\/api\/invites\/([^/]+)$/.exec(path);
+    const peerMatch = /^\/api\/peers\/([^/]+)$/.exec(path);
+    const remoteMatch = /^\/api\/remotes\/([^/]+)$/.exec(path);
+    const remoteSyncMatch = /^\/api\/remotes\/([^/]+)\/sync$/.exec(path);
+    const remoteAliasMatch = /^\/api\/remotes\/([^/]+)\/aliases$/.exec(path);
+    const remoteHostsMatch = /^\/api\/remotes\/([^/]+)\/hosts$/.exec(path);
+    const remoteHostMatch = /^\/api\/remotes\/([^/]+)\/hosts\/([^/]+)$/.exec(path);
     const known = (path === "/api/hosts" && method === "POST") ||
         (hostMatch && (method === "PUT" || method === "DELETE")) ||
-        (["/api/startup", "/api/trust", "/api/logs/clear", "/api/proxy/stop", "/api/cloudflared/install"].includes(path) && method === "POST");
+        (["/api/startup", "/api/trust", "/api/logs/clear", "/api/proxy/stop", "/api/cloudflared/install", "/api/hub", "/api/invites", "/api/remotes"].includes(path) &&
+            method === "POST") ||
+        (inviteMatch && method === "DELETE") ||
+        (peerMatch && (method === "PUT" || method === "DELETE")) ||
+        (remoteMatch && (method === "PUT" || method === "DELETE")) ||
+        (remoteSyncMatch && method === "POST") ||
+        (remoteAliasMatch && method === "POST") ||
+        (remoteHostsMatch && method === "POST") ||
+        (remoteHostMatch && (method === "PUT" || method === "DELETE"));
     if (!known)
         return undefined;
     assertTrusted(req, ctx);
@@ -196,6 +317,131 @@ async function route(req, url, ctx) {
             const { host: name, entry } = updated;
             return { status: 200, body: { ok: true, host: name, ...entry, url: hostUrl(name, ctx), tunnel: ctx.tunnel(name) } };
         }
+        if (path === "/api/hub" && method === "POST") {
+            const mode = body.mode;
+            if (mode === "named") {
+                if (!isValidPublicDomain(body.domain))
+                    throw new ApiError(400, "`domain` must be a valid public hostname.");
+                const tunnel = body.tunnel === undefined ? undefined : String(body.tunnel);
+                ctx.setupNamedHub(String(body.domain).trim().toLowerCase(), tunnel);
+            }
+            else if (mode === "quick") {
+                hub_config_1.default.write({ mode: "quick" });
+                ctx.reloadHub();
+            }
+            else if (mode === "manual") {
+                if (typeof body.url !== "string" || !body.url.trim())
+                    throw new ApiError(400, "`url` is required for manual mode.");
+                let parsed;
+                try {
+                    parsed = new URL(body.url.trim());
+                }
+                catch {
+                    throw new ApiError(400, "`url` must be a valid http(s) URL.");
+                }
+                if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
+                    throw new ApiError(400, "`url` must be http or https.");
+                const config = { mode: "manual", url: body.url.trim().replace(/\/+$/, "") };
+                hub_config_1.default.write(config);
+                ctx.reloadHub();
+            }
+            else if (mode === "off") {
+                hub_config_1.default.clear();
+                ctx.reloadHub();
+            }
+            else {
+                throw new ApiError(400, "`mode` must be one of named, quick, manual, off.");
+            }
+            return { status: 200, body: { hub: ctx.hub() } };
+        }
+        if (path === "/api/invites" && method === "POST") {
+            if (!isRole(body.role))
+                throw new ApiError(400, "`role` must be viewer, editor or admin.");
+            const hosts = optionalHosts(body.hosts);
+            if (ctx.hub().status !== "up") {
+                throw new ApiError(409, "The hub isn't up. Start sharing first.", "locadot hub:quick");
+            }
+            const { invite, code } = links_1.default.createInvite({ role: body.role, hosts });
+            const string = links_1.default.inviteString(ctx.hub().url, code);
+            return { status: 200, body: { id: invite.id, code, string, role: invite.role, hosts: invite.hosts, expiresAt: invite.expiresAt } };
+        }
+        if (inviteMatch && method === "DELETE") {
+            links_1.default.revokeInvite(decodeURIComponent(inviteMatch[1]));
+            return { status: 200, body: { ok: true } };
+        }
+        if (peerMatch && method === "PUT") {
+            const id = decodeURIComponent(peerMatch[1]);
+            if (!isRole(body.role))
+                throw new ApiError(400, "`role` must be viewer, editor or admin.");
+            const hosts = optionalHosts(body.hosts);
+            const peer = links_1.default.setRole(id, body.role, hosts);
+            return { status: 200, body: { peer: sanitizePeer(peer) } };
+        }
+        if (peerMatch && method === "DELETE") {
+            links_1.default.revoke(decodeURIComponent(peerMatch[1]));
+            return { status: 200, body: { ok: true } };
+        }
+        if (path === "/api/remotes" && method === "POST") {
+            if (typeof body.string !== "string" || !body.string.trim())
+                throw new ApiError(400, "`string` is required.");
+            const name = typeof body.name === "string" && body.name.trim() ? body.name.trim() : undefined;
+            const result = await remotes_1.default.connect(body.string.trim(), { name });
+            ctx.reload();
+            return { status: 200, body: { ...result, remote: sanitizeRemote(result.remote) } };
+        }
+        if (remoteMatch && method === "PUT") {
+            if (typeof body.url !== "string" || !body.url.trim())
+                throw new ApiError(400, "`url` is required.");
+            remotes_1.default.setUrl(decodeURIComponent(remoteMatch[1]), body.url.trim());
+            return { status: 200, body: { ok: true } };
+        }
+        if (remoteMatch && method === "DELETE") {
+            await remotes_1.default.disconnect(decodeURIComponent(remoteMatch[1]));
+            ctx.reload();
+            return { status: 200, body: { ok: true } };
+        }
+        if (remoteSyncMatch && method === "POST") {
+            const result = await remotes_1.default.sync(decodeURIComponent(remoteSyncMatch[1]));
+            ctx.reload();
+            return { status: 200, body: { ...result, remote: sanitizeRemote(result.remote) } };
+        }
+        if (remoteAliasMatch && method === "POST") {
+            if (typeof body.host !== "string" || typeof body.local !== "string") {
+                throw new ApiError(400, "`host` and `local` are required.");
+            }
+            await remotes_1.default.alias(decodeURIComponent(remoteAliasMatch[1]), body.host, body.local);
+            ctx.reload();
+            return { status: 200, body: { ok: true } };
+        }
+        if (remoteHostsMatch && method === "POST") {
+            if (typeof body.host !== "string" || typeof body.target !== "string") {
+                throw new ApiError(400, "`host` and `target` are required.");
+            }
+            const host = await remotes_1.default.addHost(decodeURIComponent(remoteHostsMatch[1]), {
+                host: body.host,
+                target: body.target,
+                insecure: optionalBool(body.insecure, "insecure"),
+                cors: optionalBool(body.cors, "cors"),
+            });
+            ctx.reload();
+            return { status: 201, body: { host } };
+        }
+        if (remoteHostMatch) {
+            const name = decodeURIComponent(remoteHostMatch[1]);
+            const hostName = decodeURIComponent(remoteHostMatch[2]);
+            if (method === "DELETE") {
+                await remotes_1.default.removeHost(name, hostName);
+                ctx.reload();
+                return { status: 200, body: { ok: true } };
+            }
+            const host = await remotes_1.default.updateHost(name, hostName, {
+                target: optionalString(body.target, "target"),
+                insecure: optionalBool(body.insecure, "insecure"),
+                cors: optionalBool(body.cors, "cors"),
+                tunnel: optionalBool(body.tunnel, "tunnel"),
+            });
+            return { status: 200, body: { host } };
+        }
     }
     catch (error) {
         if (error instanceof hosts_1.NotFoundError)
@@ -206,6 +452,12 @@ async function route(req, url, ctx) {
             throw new ApiError(400, clean(error.message));
         if (error instanceof registry_1.RegistryError)
             throw new ApiError(500, clean(error.message));
+        if (error instanceof links_1.LinkError)
+            throw new ApiError(error.status, clean(error.message));
+        if (error instanceof remotes_1.RemoteError)
+            throw new ApiError(error.status || 502, clean(error.message));
+        if (error instanceof ApiError)
+            throw error;
         throw error;
     }
     switch (path) {