arcadible 0.1.47 → 0.1.49

package/src/serve/server.js

@@ -0,0 +1,115 @@
+"use strict";
+// arc serve's server: a local play page and the game it frames, on one port
+// and two origins, as on Arcadible, where the play page and each build have
+// origins of their own. http://localhost:<port> is the page, and
+// http://127.0.0.1:<port> the game. It listens on loopback only, and needs
+// nothing from the CLI, so another app can run a game this way too.
+
+// [import]
+
+const http = require("node:http");
+
+// [import]
+
+const game = require("./game");
+const page = require("./page");
+const reload = require("./reload");
+
+// [use]
+
+const gameHandler = game.gameHandler;
+const pageHandler = page.pageHandler;
+const reloader = reload.reloader;
+
+// [declare]
+
+// the hostnames a browser may use for the page, on IPv4 and IPv6. `localhost`
+// is IPv6's ::1 on some systems, so both are listened on.
+const LOOPBACK = ["127.0.0.1", "::1"];
+
+// [function]
+
+// listens on `port` at `address`, resolving with the server, or rejecting with
+// the listen error, such as EADDRINUSE.
+const listen = function (handler, port, address) {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer(handler);
+    server.once("error", reject);
+    server.listen(port, address, () => {
+      server.off("error", reject);
+      resolve(server);
+    });
+  });
+};
+
+// [function]
+
+// starts serving `files` for `info`, `{ id, channel, version, title }`, on
+// `port`, with Arcadible's own files from `remote`. With `src`, another
+// server's page, it frames that instead, and serves no files. Resolves with
+// `{ page, game, reload(), close() }`: the page's origin, the game's URL,
+// and the controls.
+const serve = async function ({ files, info, onRemote, port, remote, src }) {
+  const origins = {
+    game: `http://127.0.0.1:${port}`,
+    page: `http://localhost:${port}`,
+  };
+  const framed = src ?? `${origins.game}/`;
+  const reloads = reloader();
+  const forGame = files
+    ? gameHandler({ files, onRemote, page: origins.page, remote })
+    : null;
+  const forPage = pageHandler({
+    game: { ...info, src: framed },
+    onRemote,
+    reloads,
+    remote,
+  });
+  // the Host header picks the origin; anything else is refused, so a page
+  // elsewhere can't reach the game's files by another name (DNS rebinding).
+  const handler = function (req, res) {
+    const host = req.headers.host;
+    const pick = {
+      [`127.0.0.1:${port}`]: forGame,
+      [`localhost:${port}`]: forPage,
+    }[host];
+    if (!pick) {
+      res.writeHead(421, { "content-type": "text/plain; charset=utf-8" });
+      res.end("Misdirected Request\n");
+      return;
+    }
+    pick(req, res).catch(() => {
+      if (!res.headersSent) {
+        res.writeHead(500);
+      }
+      res.end();
+    });
+  };
+  const ipv4 = await listen(handler, port, LOOPBACK[0]);
+  // the IPv6 loopback is a bonus: a system without it still has 127.0.0.1.
+  let ipv6 = null;
+  try {
+    ipv6 = await listen(handler, port, LOOPBACK[1]);
+  } catch (ex) {
+    if (ex.code === "EADDRINUSE") {
+      ipv4.close();
+      throw ex;
+    }
+  }
+  return {
+    close() {
+      reloads.close();
+      for (const server of [ipv4, ipv6].filter(Boolean)) {
+        server.closeAllConnections();
+        server.close();
+      }
+    },
+    game: framed,
+    page: origins.page,
+    reload: reloads.reload,
+  };
+};
+
+// [export]
+
+module.exports = { serve };