@kvbox/server 0.5.12 → 0.5.14

package/dist/kvbox-server.js

@@ -339,6 +339,30 @@ import { request } from "undici";
 import { z as z3 } from "zod";
 var SizeSchema = z3.enum(SIZE_NAMES);
 var BoxStatusSchema = z3.enum(["running", "standby", "hibernated", "stopped", "unknown"]);
+var PortProtoSchema = z3.enum(["tcp", "udp"]);
+var MAX_BOX_PORTS = 16;
+var PortForwardSchema = z3.object({
+  guestPort: z3.number().int().min(1).max(65535),
+  hostPort: z3.number().int(),
+  proto: PortProtoSchema,
+  /** The host's public address; only the control plane fills it in, as for `ssh`. */
+  address: z3.string().optional()
+});
+var PortsRequest = z3.object({
+  ports: z3.array(z3.object({ guestPort: z3.number().int().min(1).max(65535), proto: PortProtoSchema.optional() })).min(1).max(MAX_BOX_PORTS)
+});
+var BoxPortSchema = z3.number().int().min(1).max(65535);
+var ClaimSubdomainRequest = z3.object({ name: z3.string(), port: BoxPortSchema });
+var SubdomainPortRequest = z3.object({ port: BoxPortSchema });
+var SubdomainRouteRequest = z3.object({ name: z3.string(), port: BoxPortSchema });
+var SubdomainSchema = z3.object({
+  owner: z3.string(),
+  box: z3.string(),
+  subdomain: z3.string(),
+  port: BoxPortSchema,
+  url: z3.string(),
+  routes: z3.array(z3.object({ name: z3.string(), port: BoxPortSchema, url: z3.string() }))
+});
 var MachineSchema = z3.object({
   /** Host-unique short id (the tap is `kv-<id>`). Missing only on a box made before ids that has not restarted since. */
   id: z3.string(),
@@ -371,6 +395,8 @@ var MachineSchema = z3.object({
    * whose host reported no port or did not answer.
    */
   ssh: z3.object({ host: z3.string(), port: z3.number().int(), user: z3.string() }).optional(),
+  /** Box ports published on the host (#30). Absent: none. */
+  ports: z3.array(PortForwardSchema).optional(),
   /** Whether the owner slug is a user or an org. Only the control plane knows; it fills it in on `GET /machines`. */
   ownerKind: z3.enum(["user", "org"]).optional(),
   /** Seconds without network traffic before the host hibernates the box (#47). Absent: never. */
@@ -1023,6 +1049,12 @@ var MachineMetaSchema = z4.object({
   sshKeysStale: z4.boolean().optional(),
   /** Public port on the host DNATed to the box's SSH while it runs (#49); fixed for the box's life. Absent: none. */
   sshPort: z4.number().int().optional(),
+  /**
+   * Box ports published on the host (#30, `kvbox vm proxy`): unique per guest port and protocol,
+   * each host port the box's for its life. DNATed while the box runs, rebuilt from here with its
+   * current IP every time it comes up. Absent: none.
+   */
+  ports: z4.array(z4.object({ guestPort: z4.number().int(), hostPort: z4.number().int(), proto: z4.enum(["tcp", "udp"]) })).optional(),
   /** Seconds without traffic on the box's tap before the server hibernates it (#47, core/idle.ts). Absent: never. */
   autoHibernateSec: z4.number().int().positive().optional()
 });
@@ -1292,8 +1324,13 @@ function usageEventsInScope(scope, window, p = paths()) {
 import { AsyncLocalStorage } from "node:async_hooks";
 var tails = /* @__PURE__ */ new Map();
 var held = new AsyncLocalStorage();
-async function withBoxLock(ref, fn) {
-  const key = refKey(ref);
+function withBoxLock(ref, fn) {
+  return withLock(refKey(ref), fn);
+}
+function withHostLock(name, fn) {
+  return withLock(`host:${name}`, fn);
+}
+async function withLock(key, fn) {
   const mine = held.getStore();
   if (mine?.has(key)) return fn();
   const previous = tails.get(key);
@@ -1502,11 +1539,14 @@ function parseListeningPorts(ssOutput) {
   return ports;
 }
 async function listeningPorts() {
-  try {
-    return parseListeningPorts((await run(["ss", "-ltnH"])).stdout);
-  } catch {
-    return /* @__PURE__ */ new Set();
+  const ports = /* @__PURE__ */ new Set();
+  for (const flags of ["-ltnH", "-lunH"]) {
+    try {
+      for (const port of parseListeningPorts((await run(["ss", flags])).stdout)) ports.add(port);
+    } catch {
+    }
   }
+  return ports;
 }
 var proxyArgs = (p) => [p.box, p.boxIp, String(p.hostPort), String(p.guestPort), p.proto ?? "tcp"];
 async function openProxy(proxy, cfg) {
@@ -1541,23 +1581,34 @@ var AUTO_PREFIX = "box";
 var GUEST_CID = 3;
 var OVERLAY_REL = "overlay.ext4";
 var idsInUse = (metas) => new Set(metas.map((m) => m.id));
-var sshPortsInUse = (metas) => metas.flatMap((m) => m.sshPort === void 0 ? [] : [m.sshPort]);
+var publicPortsInUse = (metas) => metas.flatMap((m) => [...m.sshPort === void 0 ? [] : [m.sshPort], ...(m.ports ?? []).map((f) => f.hostPort)]);
 var isCloudBox = (owner) => realmOf(owner) !== null;
-function sshProxy(meta) {
-  if (meta.sshPort === void 0 || meta.id === void 0) return void 0;
-  return { box: meta.id, boxIp: meta.ip, hostPort: meta.sshPort, guestPort: 22 };
-}
-async function openSshPort(meta, cfg) {
-  const proxy = sshProxy(meta);
-  if (proxy) await openProxy(proxy, cfg);
-}
-async function closeSshPort(meta, cfg) {
-  const proxy = sshProxy(meta);
-  if (!proxy) return;
-  await closeProxy(proxy, cfg).catch((err) => console.error(`warning: could not close port ${proxy.hostPort}: ${err.message}`));
-}
-async function newSshPort(existing) {
-  return pickSshPort(/* @__PURE__ */ new Set([...sshPortsInUse(existing), ...await listeningPorts()]));
+function boxProxies(meta) {
+  const ssh = meta.sshPort === void 0 ? [] : [{ box: meta.id, boxIp: meta.ip, hostPort: meta.sshPort, guestPort: 22 }];
+  return [...ssh, ...(meta.ports ?? []).map((f) => ({ box: meta.id, boxIp: meta.ip, hostPort: f.hostPort, guestPort: f.guestPort, proto: f.proto }))];
+}
+async function openPorts(meta, cfg) {
+  for (const proxy of boxProxies(meta)) await openProxy(proxy, cfg);
+}
+async function closePorts(meta, cfg) {
+  for (const proxy of boxProxies(meta)) {
+    await closeProxy(proxy, cfg).catch((err) => console.error(`warning: could not close port ${proxy.hostPort}: ${err.message}`));
+  }
+}
+var reservedPorts = /* @__PURE__ */ new Set();
+async function drawPorts(count, p) {
+  return withHostLock("ports", async () => {
+    const reserved = [...reservedPorts];
+    const taken = /* @__PURE__ */ new Set([...reserved, ...publicPortsInUse(await readAllMeta(p)), ...await listeningPorts()]);
+    const ports = [];
+    for (let i = 0; i < count; i++) {
+      const port = pickSshPort(taken);
+      taken.add(port);
+      ports.push(port);
+    }
+    for (const port of ports) reservedPorts.add(port);
+    return { ports, release: () => ports.forEach((port) => reservedPorts.delete(port)) };
+  });
 }
 function diskStats(disk) {
   try {
@@ -1615,6 +1666,7 @@ function toMachine(meta, p = paths()) {
     source: meta.source,
     status: statusOf(meta, p),
     ...meta.sshPort === void 0 ? {} : { sshPort: meta.sshPort },
+    ...meta.ports?.length ? { ports: meta.ports.map((f) => ({ ...f })) } : {},
     ...meta.autoHibernateSec ? { autoHibernateSec: meta.autoHibernateSec } : {}
   };
 }
@@ -1828,7 +1880,6 @@ async function createMachine(req, owner, p = paths()) {
   const id = newBoxId(idsInUse(existing));
   const ip = nextFreeIp(cfg.subnet, [...existing.map((m2) => m2.ip), cfg.gateway]);
   const mac = macFor(ip);
-  const sshPort = cloud ? await newSshPort(existing) : void 0;
   const m = p.machine(owner, name);
   const base = await currentBase(cfg, p);
   await assertOverlayCapable(base.file, base.version);
@@ -1836,23 +1887,29 @@ async function createMachine(req, owner, p = paths()) {
   await mkdir3(m.dir, { recursive: true, mode: 448 });
   let tapCreated = false;
   let pid;
+  let sshPort;
+  let drawn;
   try {
+    drawn = cloud ? await drawPorts(1, p) : void 0;
+    sshPort = drawn?.ports[0];
     await createOverlay(m.overlay, size.diskGib);
     const tap = await createTap(id, cfg);
     tapCreated = true;
     const spec = { id, name, owner, ip, mac, vcpu: size.vcpu, memMib: size.memMib, base: base.version, sshKeys, sshPort };
     pid = await launch(spec, tap, cfg, keysB64, p);
-    await openSshPort(spec, cfg);
+    await openPorts(spec, cfg);
     const meta = { ...spec, pid, bootId: currentBootId(), createdAt: (/* @__PURE__ */ new Date()).toISOString(), source: "base", autoHibernateSec: autoHibernateFor(req, cfg) };
     await writeMachineMeta(meta, p);
     recordState(meta, "running", "new", p, meta.createdAt);
     return toMachine(meta, p);
   } catch (err) {
     if (pid !== void 0) killQuietly(pid);
-    await closeSshPort({ id, ip, sshPort }, cfg);
+    await closePorts({ id, ip, sshPort }, cfg);
     if (tapCreated) await deleteTap(id, cfg).catch(() => void 0);
     await rm(m.dir, { recursive: true, force: true });
     throw err;
+  } finally {
+    drawn?.release();
   }
 }
 async function readSnap(ref, p) {
@@ -1885,14 +1942,17 @@ async function restoreMachine(fromText, owner, req, cfg, p) {
   const id = newBoxId(idsInUse(existing));
   const ip = nextFreeIp(cfg.subnet, [...existing.map((m2) => m2.ip), cfg.gateway]);
   const mac = macFor(ip);
-  const sshPort = cloud ? await newSshPort(existing) : void 0;
   const m = p.machine(owner, name);
   const s = p.snapshot(from.owner, from.name);
   await ensureHostNetwork(cfg);
   await mkdir3(m.dir, { recursive: true, mode: 448 });
   let tapCreated = false;
   let pid;
+  let sshPort;
+  let drawn;
   try {
+    drawn = cloud ? await drawPorts(1, p) : void 0;
+    sshPort = drawn?.ports[0];
     await run(["cp", "--sparse=always", "--reflink=auto", s.overlay, m.overlay]);
     await link(s.mem, m.memBase);
     const tap = await createTap(id, cfg, { detached: true });
@@ -1906,21 +1966,23 @@ async function restoreMachine(fromText, owner, req, cfg, p) {
     });
     const stale = await pushAuthorizedKeys({ owner, name, sshKeys }, m.vsock, p);
     await attachTap(id, cfg);
-    await openSshPort(spec, cfg);
+    await openPorts(spec, cfg);
     const meta = { ...spec, pid, bootId: currentBootId(), createdAt: (/* @__PURE__ */ new Date()).toISOString(), source: `snapshot:${refKey(from)}`, memSnapshots: 1, sshKeysStale: stale ? true : void 0, autoHibernateSec: autoHibernateFor(req, cfg) };
     await writeMachineMeta(meta, p);
     recordState(meta, "running", "new", p, meta.createdAt);
     return toMachine(meta, p);
   } catch (err) {
     if (pid !== void 0) killQuietly(pid);
-    await closeSshPort({ id, ip, sshPort }, cfg);
+    await closePorts({ id, ip, sshPort }, cfg);
     if (tapCreated) await deleteTap(id, cfg).catch(() => void 0);
     await rm(m.dir, { recursive: true, force: true });
     throw err;
+  } finally {
+    drawn?.release();
   }
 }
 var AGENT_REPLY_MS = 2e4;
-async function introduce(spec, vsock, cfg, failure) {
+async function introduce(spec, vsock, cfg, failure2) {
   const id = { name: spec.name, ip: spec.ip, prefixLen: prefixLenOf(cfg.subnet), gateway: cfg.gateway, mac: spec.mac, time: Math.floor(Date.now() / 1e3) };
   const deadline = Date.now() + 3e3;
   for (; ; ) {
@@ -1935,9 +1997,9 @@ async function introduce(spec, vsock, cfg, failure) {
         continue;
       }
       if (transient) throw new KvboxError(`${msg}
-  ${failure.silent}`);
+  ${failure2.silent}`);
       throw new KvboxError(`${msg}
-  ${failure.noAnswer}`);
+  ${failure2.noAnswer}`);
     }
   }
 }
@@ -1982,7 +2044,7 @@ async function waitDead(pid, graceMs) {
   }
 }
 async function cleanupProcess(meta, cfg, p) {
-  await closeSshPort(meta, cfg);
+  await closePorts(meta, cfg);
   await deleteTap(meta.id, cfg);
   const m = p.machine(meta.owner, meta.name);
   await rm(m.sock, { force: true });
@@ -2015,14 +2077,14 @@ var startMachine = locked(async function startMachine2(ref, p = paths()) {
   let pid;
   try {
     pid = await launch(meta, tap, cfg, keysB64, p);
-    await openSshPort(meta, cfg);
+    await openPorts(meta, cfg);
     const started = { ...meta, pid, bootId: currentBootId(), sshKeysStale: void 0 };
     await writeMachineMeta(started, p);
     recordState(started, "running", "start", p);
     return toMachine(started, p);
   } catch (err) {
     if (pid !== void 0) killQuietly(pid);
-    await closeSshPort(meta, cfg);
+    await closePorts(meta, cfg);
     await deleteTap(meta.id, cfg).catch(() => void 0);
     throw err;
   }
@@ -2163,10 +2225,10 @@ var wakeMachine = locked(async function wakeMachine2(ref, p = paths()) {
     });
     stale = await pushAuthorizedKeys(meta, m.vsock, p);
     await attachTap(meta.id, cfg);
-    await openSshPort(meta, cfg);
+    await openPorts(meta, cfg);
   } catch (err) {
     if (pid !== void 0) killQuietly(pid);
-    await closeSshPort(meta, cfg);
+    await closePorts(meta, cfg);
     await deleteTap(meta.id, cfg).catch(() => void 0);
     throw err;
   }
@@ -2234,6 +2296,58 @@ var setMachine = locked(async function setMachine2(ref, req, p = paths()) {
   await writeMachineMeta(next, p);
   return toMachine(next, p);
 });
+var portKeys = (req) => {
+  const keys = req.ports.map((x) => ({ guestPort: x.guestPort, proto: x.proto ?? "tcp" }));
+  return keys.filter((k, i) => keys.findIndex((o) => o.guestPort === k.guestPort && o.proto === k.proto) === i);
+};
+var samePort = (a) => (b) => a.guestPort === b.guestPort && a.proto === b.proto;
+var addPorts = locked(async function addPorts2(ref, req, p = paths()) {
+  const meta = await readMeta(ref, p);
+  const cfg = await loadConfig(p);
+  const current = meta.ports ?? [];
+  const wanted = portKeys(req);
+  const already = wanted.find((w) => current.some(samePort(w)));
+  if (already) throw new KvboxError(`box ${shown(ref)} already publishes port ${already.guestPort} (${already.proto})`);
+  if (meta.sshPort !== void 0 && wanted.some(samePort({ guestPort: 22, proto: "tcp" }))) {
+    throw new KvboxError(`box ${shown(ref)} already reaches port 22 from outside on port ${meta.sshPort} (kvbox connect)`);
+  }
+  if (current.length + wanted.length > MAX_BOX_PORTS) {
+    throw new KvboxError(`a box publishes at most ${MAX_BOX_PORTS} ports; box ${shown(ref)} has ${current.length}`);
+  }
+  const drawn = await drawPorts(wanted.length, p);
+  const opened = [];
+  try {
+    const added = wanted.map((w, i) => ({ ...w, hostPort: drawn.ports[i] }));
+    if (vmAlive(meta)) {
+      for (const proxy of boxProxies({ id: meta.id, ip: meta.ip, ports: added })) {
+        await openProxy(proxy, cfg);
+        opened.push(proxy);
+      }
+    }
+    const next = { ...meta, ports: [...current, ...added] };
+    await writeMachineMeta(next, p);
+    return toMachine(next, p);
+  } catch (err) {
+    for (const proxy of opened) await closeProxy(proxy, cfg).catch(() => void 0);
+    throw err;
+  } finally {
+    drawn.release();
+  }
+});
+var removePorts = locked(async function removePorts2(ref, req, p = paths()) {
+  const meta = await readMeta(ref, p);
+  const cfg = await loadConfig(p);
+  const current = meta.ports ?? [];
+  const gone = portKeys(req);
+  const missing = gone.find((g) => !current.some(samePort(g)));
+  if (missing) throw new KvboxError(`box ${shown(ref)} does not publish port ${missing.guestPort} (${missing.proto})`);
+  const removed = current.filter((f) => gone.some(samePort(f)));
+  for (const proxy of boxProxies({ id: meta.id, ip: meta.ip, ports: removed })) await closeProxy(proxy, cfg);
+  const kept = current.filter((f) => !gone.some(samePort(f)));
+  const next = { ...meta, ports: kept.length > 0 ? kept : void 0 };
+  await writeMachineMeta(next, p);
+  return toMachine(next, p);
+});
 async function growDisk(file, gib) {
   await truncate(file, gib * 1024 ** 3);
   await run(["e2fsck", "-f", "-p", file], { okExitCodes: [1] });
@@ -2556,7 +2670,7 @@ import { createServer as createHttpsServer } from "node:https";
 import { createAdaptorServer } from "@hono/node-server";
 
 // src/app.ts
-import { Hono as Hono6 } from "hono";
+import { Hono as Hono7 } from "hono";
 
 // ../shared/src/version.ts
 import { createRequire } from "node:module";
@@ -2571,10 +2685,25 @@ function versionOf(srcFileUrl, injected) {
 }
 
 // src/version.ts
-var VERSION = versionOf(import.meta.url, true ? "0.5.12" : void 0);
+var VERSION = versionOf(import.meta.url, true ? "0.5.14" : void 0);
 
 // src/caller.ts
 import { createHash as createHash2, timingSafeEqual } from "node:crypto";
+
+// ../shared/src/names.ts
+import { createHmac } from "node:crypto";
+var PROXY_ERROR_HEADER = "x-kvbox-proxy-error";
+var PROXIED_HEADER = "x-kvbox-proxied";
+var VISITOR_PATH_HEADER = "x-kvbox-path";
+var VISITOR_AUTH_HEADER = "x-kvbox-authorization";
+var NOT_FORWARDED = /* @__PURE__ */ new Set(["expect"]);
+var HOP_BY_HOP = /* @__PURE__ */ new Set(["connection", "keep-alive", "proxy-authenticate", "proxy-authorization", "proxy-connection", "te", "trailer", "transfer-encoding", "upgrade"]);
+var BOX_HTTP_PATH_RE = /^\/machines\/([^/]+)\/http\/(\d{1,5})\/?$/;
+function edgeCredential(hostSecret) {
+  return createHmac("sha256", hostSecret).update("kvbox-edge-v1").digest("base64url");
+}
+
+// src/caller.ts
 var OWNER_HEADER = "x-kvbox-owner";
 function resolveCaller(opts = {}) {
   const cp = opts.controlPlane;
@@ -2586,10 +2715,11 @@ function resolveCaller(opts = {}) {
       await next();
     };
   }
-  const expected = digest(cp.secret);
+  const authorized = secretCheck(cp);
+  const edge = edgeCheck(cp);
   return async (c, next) => {
-    const m = /^Bearer\s+(\S+)$/i.exec(c.req.header("authorization") ?? "");
-    if (!m || !timingSafeEqual(digest(m[1]), expected)) return c.json({ error: "not authorized" }, 401);
+    const auth = c.req.header("authorization");
+    if (!authorized(auth) && !(edge(auth) && BOX_HTTP_PATH_RE.test(c.req.path))) return c.json({ error: "not authorized" }, 401);
     const user = c.req.header(OWNER_HEADER);
     if (user === void 0) {
       const path = c.req.path.replace(/\/$/, "");
@@ -2608,20 +2738,237 @@ function resolveCaller(opts = {}) {
     await next();
   };
 }
+function secretCheck(cp) {
+  return bearerCheck(cp.secret);
+}
+function edgeCheck(cp) {
+  return bearerCheck(edgeCredential(cp.secret));
+}
+function bearerCheck(token) {
+  const expected = digest(token);
+  return (authorization) => {
+    const m = /^Bearer\s+(\S+)$/i.exec(authorization ?? "");
+    return m !== null && timingSafeEqual(digest(m[1]), expected);
+  };
+}
 function digest(secret) {
   return createHash2("sha256").update(secret).digest();
 }
 
-// src/routes/capacity.ts
+// src/routes/boxHttp.ts
+import { connect as connect2 } from "node:net";
+import { Readable } from "node:stream";
 import { Hono } from "hono";
-function capacityRoutes() {
+import { request as request3 } from "undici";
+
+// ../shared/src/httpHead.ts
+var END = "\r\n\r\n";
+var HeadTimeoutError = class extends Error {
+};
+function readHead(socket, opts) {
+  return new Promise((resolve, reject) => {
+    let bytes = Buffer.alloc(0);
+    const done = (err) => {
+      clearTimeout(timer);
+      socket.off("data", onData);
+      socket.off("close", onClose);
+      socket.pause();
+      if (err) return reject(err);
+      const end = bytes.indexOf(END);
+      resolve({ head: bytes.subarray(0, end).toString("latin1"), rest: bytes.subarray(end + END.length) });
+    };
+    const onData = (chunk) => {
+      bytes = Buffer.concat([bytes, chunk]);
+      if (bytes.includes(END)) done();
+      else if (bytes.length > opts.maxBytes) done(new Error("answer head too large"));
+    };
+    const onClose = () => done(new Error("closed before answering"));
+    const timer = setTimeout(() => done(new HeadTimeoutError(`no answer within ${opts.timeoutMs / 1e3} s`)), opts.timeoutMs);
+    socket.on("data", onData);
+    socket.once("close", onClose);
+  });
+}
+function rewriteHead(head, drop, add = {}) {
+  const [status, ...lines] = head.split("\r\n");
+  const kept = lines.filter((l) => !drop(l.slice(0, l.indexOf(":")).trim().toLowerCase()));
+  const extra = Object.entries(add).map(([k, v]) => `${k}: ${v}`);
+  return Buffer.from(`${[status, ...kept, ...extra].join("\r\n")}${END}`, "latin1");
+}
+
+// src/routes/boxHttp.ts
+var HEADERS_TIMEOUT_MS = 55e3;
+var MAX_HANDSHAKE_BYTES = 16 * 1024;
+var CONNECT_TIMEOUT_MS = 5e3;
+var DROPPED = /* @__PURE__ */ new Set([...HOP_BY_HOP, ...NOT_FORWARDED, "host", "authorization", OWNER_HEADER, VISITOR_AUTH_HEADER, VISITOR_PATH_HEADER]);
+var ProxyFailure = class extends Error {
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+  }
+  status;
+  code;
+};
+function visitorPath(value) {
+  const path = Array.isArray(value) ? value[0] : value;
+  return path !== void 0 && path !== null && path.startsWith("/") && !/[\s]/.test(path) ? path : "/";
+}
+async function targetOf(url, owner, path) {
+  const m = BOX_HTTP_PATH_RE.exec(url.pathname);
+  const port = Number(m?.[2]);
+  if (!m || port < 1 || port > 65535) throw new ProxyFailure(404, "not-found", `no route: ${url.pathname}`);
+  const name = decodeURIComponent(m[1]);
+  let box;
+  try {
+    box = await getMachine(parseRef(name, owner));
+  } catch (err) {
+    if (err instanceof NotFoundError) throw new ProxyFailure(404, "not-found", err.message);
+    throw err;
+  }
+  if (box.status !== "running") throw new ProxyFailure(409, "not-running", `box ${name} is ${box.status}`);
+  return { ip: box.ip, port, path };
+}
+function boxHeaders(incoming, target, upgrade = false) {
+  const out = [];
+  let host = `${target.ip}:${target.port}`;
+  for (const [name, value] of incoming) {
+    const key = name.toLowerCase();
+    if (key === "x-forwarded-host") host = value;
+    if (key === VISITOR_AUTH_HEADER) out.push(["authorization", value]);
+    if (upgrade && (key === "upgrade" || key === "connection")) out.push([name, value]);
+    else if (!DROPPED.has(key)) out.push([name, value]);
+  }
+  out.push(["host", host]);
+  return out;
+}
+var failure = (err) => new Response(JSON.stringify({ error: err.message }), { status: err.status, headers: { "content-type": "application/json", [PROXY_ERROR_HEADER]: err.code } });
+function boxHttpRoutes() {
   const r = new Hono();
+  r.all("/:name/http/:port", forward);
+  return r;
+}
+async function forward(c) {
+  let target;
+  try {
+    target = await targetOf(new URL(c.req.url), c.get("owner"), visitorPath(c.req.header(VISITOR_PATH_HEADER)));
+  } catch (err) {
+    if (err instanceof ProxyFailure) return failure(err);
+    throw err;
+  }
+  const raw = c.req.raw;
+  const pairs = [];
+  raw.headers.forEach((value, name) => pairs.push([name, value]));
+  let res;
+  try {
+    res = await request3(`http://${target.ip}:${target.port}${target.path}`, {
+      method: raw.method,
+      headers: boxHeaders(pairs, target).flat(),
+      body: raw.body === null ? null : Readable.fromWeb(raw.body),
+      headersTimeout: HEADERS_TIMEOUT_MS,
+      bodyTimeout: 0,
+      signal: raw.signal
+    });
+  } catch (err) {
+    const e = err;
+    if (e.code === "UND_ERR_HEADERS_TIMEOUT") return failure(new ProxyFailure(504, "timeout", `box took over ${HEADERS_TIMEOUT_MS / 1e3} s to answer on port ${target.port}`));
+    return failure(new ProxyFailure(502, "unreachable", `box answered nothing on port ${target.port} (${e.code ?? e.message})`));
+  }
+  const headers = new Headers();
+  for (const [name, value] of Object.entries(res.headers)) {
+    if (value === void 0 || HOP_BY_HOP.has(name) || name.startsWith("x-kvbox-")) continue;
+    for (const v of Array.isArray(value) ? value : [value]) headers.append(name, v);
+  }
+  headers.set(PROXIED_HEADER, "1");
+  const empty = res.statusCode === 204 || res.statusCode === 304 || raw.method === "HEAD";
+  if (empty) res.body.resume();
+  return new Response(empty ? null : Readable.toWeb(res.body), { status: res.statusCode, headers });
+}
+function refuse(socket, status, text, code = "refused") {
+  const body = JSON.stringify({ error: text });
+  socket.end(`HTTP/1.1 ${status} ${status === 401 ? "Unauthorized" : "Error"}\r
+content-type: application/json\r
+content-length: ${Buffer.byteLength(body)}\r
+${PROXY_ERROR_HEADER}: ${code}\r
+connection: close\r
+\r
+${body}`);
+}
+function headerPairs(raw) {
+  const out = [];
+  for (let i = 0; i + 1 < raw.length; i += 2) out.push([raw[i], raw[i + 1]]);
+  return out;
+}
+function boxUpgradeHandler(cp, headersTimeoutMs = HEADERS_TIMEOUT_MS) {
+  const full = secretCheck(cp);
+  const edge = edgeCheck(cp);
+  const authorized = (auth) => full(auth) || edge(auth);
+  return (req, socket, head) => {
+    socket.on("error", () => socket.destroy());
+    void (async () => {
+      const headers = req.headers;
+      if (!authorized(headers.authorization)) return refuse(socket, 401, "not authorized");
+      const user = headers[OWNER_HEADER];
+      if (typeof user !== "string" || !LOCAL_OWNER_RE.test(user)) return refuse(socket, 400, "X-Kvbox-Owner header required");
+      let target;
+      try {
+        target = await targetOf(new URL(req.url ?? "/", "https://host"), `${user}@${cp.name}`, visitorPath(headers[VISITOR_PATH_HEADER]));
+      } catch (err) {
+        if (err instanceof ProxyFailure) return refuse(socket, err.status, err.message, err.code);
+        return refuse(socket, 500, err.message);
+      }
+      if (socket.destroyed) return;
+      const box = connect2({ host: target.ip, port: target.port, timeout: CONNECT_TIMEOUT_MS });
+      let connected = false;
+      let piped = false;
+      box.once("timeout", () => box.destroy(new Error("timed out")));
+      box.once("error", (err) => {
+        if (!connected && !socket.destroyed) refuse(socket, 502, `box answered nothing on port ${target.port} (${err.code ?? err.message})`, "unreachable");
+        else if (piped) socket.destroy();
+      });
+      socket.once("close", () => box.destroy());
+      box.once("close", () => {
+        if (piped) socket.destroy();
+      });
+      box.once("connect", () => {
+        connected = true;
+        box.setTimeout(0);
+        const lines = boxHeaders(headerPairs(req.rawHeaders), target, true).map(([k, v]) => `${k}: ${v}\r
+`);
+        box.write(`${req.method ?? "GET"} ${target.path} HTTP/1.1\r
+${lines.join("")}\r
+`);
+        if (head.length > 0) box.write(head);
+        readHead(box, { maxBytes: MAX_HANDSHAKE_BYTES, timeoutMs: headersTimeoutMs }).then(
+          (answer) => {
+            if (socket.destroyed) return void box.destroy();
+            socket.write(rewriteHead(answer.head, (name) => name.startsWith("x-kvbox-"), { [PROXIED_HEADER]: "1" }));
+            if (answer.rest.length > 0) socket.write(answer.rest);
+            piped = true;
+            box.pipe(socket);
+            socket.pipe(box);
+          },
+          (err) => {
+            box.destroy();
+            if (socket.destroyed) return;
+            if (err instanceof HeadTimeoutError) refuse(socket, 504, `box took over ${headersTimeoutMs / 1e3} s to answer on port ${target.port}`, "timeout");
+            else refuse(socket, 502, `box gave no answer on port ${target.port} (${err.message})`, "unreachable");
+          }
+        );
+      });
+    })();
+  };
+}
+
+// src/routes/capacity.ts
+import { Hono as Hono2 } from "hono";
+function capacityRoutes() {
+  const r = new Hono2();
   r.get("/", async (c) => c.json(await capacity()));
   return r;
 }
 
 // src/routes/machines.ts
-import { Hono as Hono2 } from "hono";
+import { Hono as Hono3 } from "hono";
 
 // src/core/stats.ts
 var STATS_REPLY_MS = 3e3;
@@ -2654,7 +3001,7 @@ async function usageReport(scope, window, p = paths()) {
 
 // src/routes/machines.ts
 function machineRoutes() {
-  const r = new Hono2();
+  const r = new Hono3();
   r.get("/", async (c) => c.json(await listMachines(c.get("listScope"))));
   r.post("/", async (c) => {
     const body = CreateMachineRequest.parse(await c.req.json().catch(() => ({})));
@@ -2681,6 +3028,16 @@ function machineRoutes() {
     const { machine, applied } = await setSshKeys(parseRef(c.req.param("name"), c.get("owner")), body.data.sshKeys);
     return c.json({ ...machine, sshKeysApplied: applied });
   });
+  r.post("/:name/ports", async (c) => {
+    const body = PortsRequest.safeParse(await c.req.json().catch(() => ({})));
+    if (!body.success) throw new KvboxError("ports: expected a list of box ports");
+    return c.json(await addPorts(parseRef(c.req.param("name"), c.get("owner")), body.data), 201);
+  });
+  r.delete("/:name/ports", async (c) => {
+    const body = PortsRequest.safeParse(await c.req.json().catch(() => ({})));
+    if (!body.success) throw new KvboxError("ports: expected a list of box ports");
+    return c.json(await removePorts(parseRef(c.req.param("name"), c.get("owner")), body.data));
+  });
   r.get("/:name/usage", async (c) => {
     const since = c.req.query("since");
     let from;
@@ -2700,7 +3057,7 @@ function machineRoutes() {
 }
 
 // src/routes/snapshots.ts
-import { Hono as Hono3 } from "hono";
+import { Hono as Hono4 } from "hono";
 
 // src/core/snapshots.ts
 import { existsSync as existsSync3 } from "node:fs";
@@ -2770,21 +3127,21 @@ async function snapshotBox(ref, req, owner, p) {
   try {
     const since = box.memSnapshots ?? 0;
     const mode = since === 0 || existsSync3(m.memBase) ? "Diff" : "Full";
-    let failure;
+    let failure2;
     await fc.pause();
     try {
       await fc.snapshotCreate(s.vmstate, s.mem, mode);
       lineageTouched = true;
       await run(["cp", "--sparse=always", "--reflink=auto", m.overlay, s.overlay]);
     } catch (err) {
-      failure = err;
+      failure2 = err;
     } finally {
       if (!box.paused) await fc.resume();
     }
     if (lineageTouched) {
       await writeMachineMeta({ ...box, memSnapshots: since + 1 }, p);
     }
-    if (failure !== void 0) throw failure;
+    if (failure2 !== void 0) throw failure2;
     if (mode === "Full") {
       await run(["fallocate", "--dig-holes", s.mem]);
     } else if (since > 0) {
@@ -2827,7 +3184,7 @@ async function deleteSnapshot(ref, p = paths()) {
 
 // src/routes/snapshots.ts
 function snapshotRoutes() {
-  const r = new Hono3();
+  const r = new Hono4();
   r.get("/", async (c) => c.json(await listSnapshots(c.get("listScope"))));
   r.post("/", async (c) => {
     const body = CreateSnapshotRequest.parse(await c.req.json());
@@ -2841,9 +3198,9 @@ function snapshotRoutes() {
 }
 
 // src/routes/ssh.ts
-import { Hono as Hono4 } from "hono";
+import { Hono as Hono5 } from "hono";
 function sshRoutes(opts = {}) {
-  const r = new Hono4();
+  const r = new Hono5();
   if (opts.controlPlane) {
     r.all("/*", (c) => c.json({ error: "trusting a CA is done on the host itself (kvbox server trust-ca there); the control plane cannot ask a host to" }, 403));
     return r;
@@ -2858,10 +3215,10 @@ function sshRoutes(opts = {}) {
 }
 
 // src/routes/usage.ts
-import { Hono as Hono5 } from "hono";
+import { Hono as Hono6 } from "hono";
 var PULL_LIMIT = 1e3;
 function usageRoutes(opts = {}) {
-  const r = new Hono5();
+  const r = new Hono6();
   r.get("/", async (c) => {
     let window;
     try {
@@ -2888,7 +3245,7 @@ function whole(value, name) {
 
 // src/app.ts
 function createApp(opts = {}) {
-  const app = new Hono6();
+  const app = new Hono7();
   app.use(resolveCaller(opts));
   app.get("/health", async (c) => {
     const cfg = await loadConfig();
@@ -2904,6 +3261,7 @@ function createApp(opts = {}) {
       recovery: lastRecovery()
     });
   });
+  if (opts.controlPlane) app.route("/machines", boxHttpRoutes());
   app.route("/machines", machineRoutes());
   app.route("/snapshots", snapshotRoutes());
   app.route("/capacity", capacityRoutes());
@@ -2949,6 +3307,7 @@ async function listen(opts = {}) {
       createServer: createHttpsServer,
       serverOptions: { key, cert }
     });
+    httpsServer.on("upgrade", boxUpgradeHandler({ name: cp.name, secret: cp.secret }));
     const port = opts.httpsPort ?? cp.port;
     await new Promise((resolve, reject) => {
       httpsServer.once("error", reject);