@kvbox/server 0.5.15 → 0.5.16

package/dist/kvbox-server.js

@@ -2685,7 +2685,7 @@ function versionOf(srcFileUrl, injected) {
 }
 
 // src/version.ts
-var VERSION = versionOf(import.meta.url, true ? "0.5.15" : void 0);
+var VERSION = versionOf(import.meta.url, true ? "0.5.16" : void 0);
 
 // src/caller.ts
 import { createHash as createHash2, timingSafeEqual } from "node:crypto";
@@ -2695,6 +2695,9 @@ 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 WAKE_HEADER = "x-kvbox-wake";
+var WAKE_WAIT_MS = 3e4;
+var WOKE_HEADER = "x-kvbox-woke";
 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"]);
@@ -2799,7 +2802,7 @@ function rewriteHead(head, drop, add = {}) {
 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 DROPPED = /* @__PURE__ */ new Set([...HOP_BY_HOP, ...NOT_FORWARDED, "host", "authorization", OWNER_HEADER, VISITOR_AUTH_HEADER, VISITOR_PATH_HEADER, WAKE_HEADER]);
 var ProxyFailure = class extends Error {
   constructor(status, code, message) {
     super(message);
@@ -2809,24 +2812,64 @@ var ProxyFailure = class extends Error {
   status;
   code;
 };
+function sharedWaker(bring = defaultBring, capMs = WAKE_WAIT_MS) {
+  const inFlight = /* @__PURE__ */ new Map();
+  return async (ref, status) => {
+    const key = `${ref.owner}/${ref.name}`;
+    let wake = inFlight.get(key);
+    if (!wake) {
+      wake = bring(ref, status).finally(() => inFlight.delete(key));
+      inFlight.set(key, wake);
+      wake.catch(() => {
+      });
+    }
+    let timer;
+    const cap = new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new ProxyFailure(503, "waking", `box ${ref.name} is waking up`)), capMs);
+    });
+    try {
+      await Promise.race([wake, cap]);
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+}
+var defaultBring = async (ref, status) => {
+  await (status === "hibernated" ? wakeMachine(ref) : resumeMachine(ref));
+};
+var wakeBox = sharedWaker();
+var notRunning = (status) => status === "hibernated" || status === "standby" ? status : "stopped";
 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) {
+async function targetOf(url, owner, path, wake) {
   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]);
+  const ref = parseRef(name, owner);
   let box;
   try {
-    box = await getMachine(parseRef(name, owner));
+    box = await getMachine(ref);
   } 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 };
+  let woke = false;
+  if (box.status !== "running" && wake && (box.status === "hibernated" || box.status === "standby")) {
+    try {
+      await wake(ref, box.status);
+      woke = true;
+    } catch (err) {
+      if (err instanceof ProxyFailure) throw err;
+      box = await getMachine(ref);
+      if (box.status !== "running") throw new ProxyFailure(502, "wake-failed", `box ${name} did not wake: ${err.message}`);
+    }
+    if (woke) box = await getMachine(ref);
+  }
+  if (box.status !== "running") throw new ProxyFailure(409, notRunning(box.status), `box ${name} is ${box.status}`);
+  return { ip: box.ip, port, path, woke };
 }
 function boxHeaders(incoming, target, upgrade = false) {
   const out = [];
@@ -2841,16 +2884,17 @@ function boxHeaders(incoming, target, upgrade = false) {
   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() {
+var failure = (err, woke = false) => new Response(JSON.stringify({ error: err.message }), { status: err.status, headers: { "content-type": "application/json", [PROXY_ERROR_HEADER]: err.code, ...woke ? { [WOKE_HEADER]: "1" } : {} } });
+var wants = (value) => value === "1";
+function boxHttpRoutes(wake = wakeBox) {
   const r = new Hono();
-  r.all("/:name/http/:port", forward);
+  r.all("/:name/http/:port", (c) => forward(c, wake));
   return r;
 }
-async function forward(c) {
+async function forward(c, wake) {
   let target;
   try {
-    target = await targetOf(new URL(c.req.url), c.get("owner"), visitorPath(c.req.header(VISITOR_PATH_HEADER)));
+    target = await targetOf(new URL(c.req.url), c.get("owner"), visitorPath(c.req.header(VISITOR_PATH_HEADER)), wants(c.req.header(WAKE_HEADER)) ? wake : void 0);
   } catch (err) {
     if (err instanceof ProxyFailure) return failure(err);
     throw err;
@@ -2870,8 +2914,8 @@ async function forward(c) {
     });
   } 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})`));
+    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}`), target.woke);
+    return failure(new ProxyFailure(502, "unreachable", `box answered nothing on port ${target.port} (${e.code ?? e.message})`), target.woke);
   }
   const headers = new Headers();
   for (const [name, value] of Object.entries(res.headers)) {
@@ -2879,17 +2923,19 @@ async function forward(c) {
     for (const v of Array.isArray(value) ? value : [value]) headers.append(name, v);
   }
   headers.set(PROXIED_HEADER, "1");
+  if (target.woke) headers.set(WOKE_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") {
+function refuse(socket, status, text, code = "refused", woke = false) {
   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
+${woke ? `${WOKE_HEADER}: 1\r
+` : ""}connection: close\r
 \r
 ${body}`);
 }
@@ -2898,7 +2944,7 @@ function headerPairs(raw) {
   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) {
+function boxUpgradeHandler(cp, headersTimeoutMs = HEADERS_TIMEOUT_MS, wake = wakeBox) {
   const full = secretCheck(cp);
   const edge = edgeCheck(cp);
   const authorized = (auth) => full(auth) || edge(auth);
@@ -2911,7 +2957,7 @@ function boxUpgradeHandler(cp, headersTimeoutMs = HEADERS_TIMEOUT_MS) {
       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]));
+        target = await targetOf(new URL(req.url ?? "/", "https://host"), `${user}@${cp.name}`, visitorPath(headers[VISITOR_PATH_HEADER]), wants(headers[WAKE_HEADER]) ? wake : void 0);
       } catch (err) {
         if (err instanceof ProxyFailure) return refuse(socket, err.status, err.message, err.code);
         return refuse(socket, 500, err.message);
@@ -2922,7 +2968,7 @@ function boxUpgradeHandler(cp, headersTimeoutMs = HEADERS_TIMEOUT_MS) {
       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");
+        if (!connected && !socket.destroyed) refuse(socket, 502, `box answered nothing on port ${target.port} (${err.code ?? err.message})`, "unreachable", target.woke);
         else if (piped) socket.destroy();
       });
       socket.once("close", () => box.destroy());
@@ -2941,7 +2987,7 @@ ${lines.join("")}\r
         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" }));
+            socket.write(rewriteHead(answer.head, (name) => name.startsWith("x-kvbox-"), { [PROXIED_HEADER]: "1", ...target.woke ? { [WOKE_HEADER]: "1" } : {} }));
             if (answer.rest.length > 0) socket.write(answer.rest);
             piped = true;
             box.pipe(socket);
@@ -2950,8 +2996,8 @@ ${lines.join("")}\r
           (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");
+            if (err instanceof HeadTimeoutError) refuse(socket, 504, `box took over ${headersTimeoutMs / 1e3} s to answer on port ${target.port}`, "timeout", target.woke);
+            else refuse(socket, 502, `box gave no answer on port ${target.port} (${err.message})`, "unreachable", target.woke);
           }
         );
       });