@kvbox/server 0.5.12 → 0.5.13

package/dist/kvbox-server.js

@@ -339,6 +339,18 @@ 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 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 +383,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 +1037,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 +1312,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 +1527,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 +1569,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 +1654,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 +1868,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 +1875,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 +1930,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,17 +1954,19 @@ 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;
@@ -1982,7 +2032,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 +2065,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 +2213,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 +2284,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] });
@@ -2571,7 +2673,7 @@ 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.13" : void 0);
 
 // src/caller.ts
 import { createHash as createHash2, timingSafeEqual } from "node:crypto";
@@ -2681,6 +2783,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;