@shimabell06/cloud-arch-icon-browser 0.2.0 → 0.3.0

package/cli/server.js

@@ -1,7 +1,12 @@
 import { readFile, readdir, realpath } from "node:fs/promises";
-import { createServer, } from "node:http";
+import { createServer, request as httpRequest, } from "node:http";
 import { extname, resolve, sep } from "node:path";
+import { createPowerPointBridge, } from "./powerpoint-bridge.js";
 const LOOPBACK_HOST = "127.0.0.1";
+export const CANONICAL_PORT = 41731;
+export const APP_INSTANCE_HEADER = "X-Cloud-Arch-Icon-Browser-Instance";
+const APP_INSTANCE_HEADER_VALUE = "1";
+const EXISTING_INSTANCE_PROBE_TIMEOUT_MS = 750;
 const CONTENT_SECURITY_POLICY = [
     "default-src 'self'",
     "script-src 'self'",
@@ -37,48 +42,69 @@ const MIME_TYPES = new Map([
 export async function startStaticServer(options) {
     const rootDirectory = await realpath(options.rootDirectory);
     const staticAssets = await loadStaticAssets(rootDirectory);
-    let selectedPort = 0;
+    const powerPointBridge = options.powerPointBridge ?? createPowerPointBridge();
+    const requestedPort = options.port ?? CANONICAL_PORT;
+    let selectedPort = requestedPort;
     const server = createServer((request, response) => {
-        try {
-            handleRequest(request, response, staticAssets, selectedPort);
-        }
-        catch {
+        void handleRequest(request, response, staticAssets, powerPointBridge, selectedPort).catch(() => {
             if (!response.headersSent) {
                 sendText(request, response, 500, "Internal Server Error\n");
                 return;
             }
             response.destroy();
-        }
+        });
     });
     server.on("clientError", (_error, socket) => {
         if (socket.writable) {
             socket.end("HTTP/1.1 400 Bad Request\r\nConnection: close\r\nContent-Length: 0\r\n\r\n");
         }
     });
-    await listenOnAvailablePort(server);
+    try {
+        await listenOnPort(server, requestedPort);
+    }
+    catch (error) {
+        if (requestedPort > 0 && isAddressInUseError(error)) {
+            const reused = await probeExistingInstance(requestedPort);
+            if (reused) {
+                return {
+                    port: requestedPort,
+                    url: appUrl(requestedPort),
+                    reused: true,
+                    close: () => Promise.resolve(),
+                };
+            }
+            throw new Error(`Port ${requestedPort} is already in use by another process. Stop that process and run cloud-arch-icon-browser again.`, { cause: error });
+        }
+        throw error;
+    }
     const address = server.address();
     if (address === null || typeof address === "string") {
         await closeServer(server);
         throw new Error("Unable to determine the localhost server port.");
     }
     selectedPort = address.port;
-    const url = `http://${LOOPBACK_HOST}:${selectedPort}/`;
+    const url = appUrl(selectedPort);
     let closePromise = null;
     return {
         port: selectedPort,
         url,
+        reused: false,
         close: () => {
             closePromise ??= closeServer(server);
             return closePromise;
         },
     };
 }
-function handleRequest(request, response, staticAssets, port) {
+async function handleRequest(request, response, staticAssets, powerPointBridge, port) {
     applySecurityHeaders(response);
     if (!isExpectedHost(request.headers.host, port)) {
         sendText(request, response, 403, "Forbidden\n");
         return;
     }
+    if (powerPointBridge.matches(request.url)) {
+        await powerPointBridge.handle(request, response, port);
+        return;
+    }
     if (request.method !== "GET" && request.method !== "HEAD") {
         response.setHeader("Allow", "GET, HEAD");
         sendText(request, response, 405, "Method Not Allowed\n");
@@ -192,6 +218,7 @@ function cacheControlFor(relativePath) {
     return "no-cache";
 }
 function applySecurityHeaders(response) {
+    response.setHeader(APP_INSTANCE_HEADER, APP_INSTANCE_HEADER_VALUE);
     response.setHeader("Content-Security-Policy", CONTENT_SECURITY_POLICY);
     response.setHeader("Cross-Origin-Opener-Policy", "same-origin");
     response.setHeader("Permissions-Policy", permissionsPolicy());
@@ -224,7 +251,7 @@ function sendText(request, response, statusCode, body) {
     }
     response.end(body);
 }
-function listenOnAvailablePort(server) {
+function listenOnPort(server, port) {
     return new Promise((resolvePromise, rejectPromise) => {
         const handleError = (error) => {
             server.off("listening", handleListening);
@@ -236,9 +263,45 @@ function listenOnAvailablePort(server) {
         };
         server.once("error", handleError);
         server.once("listening", handleListening);
-        server.listen({ host: LOOPBACK_HOST, port: 0 });
+        server.listen({ host: LOOPBACK_HOST, port });
     });
 }
+function probeExistingInstance(port) {
+    return new Promise((resolvePromise) => {
+        let settled = false;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            resolvePromise(result);
+        };
+        const clientRequest = httpRequest({
+            host: LOOPBACK_HOST,
+            port,
+            path: "/",
+            method: "HEAD",
+            headers: { Host: `${LOOPBACK_HOST}:${port}` },
+        }, (response) => {
+            const header = response.headers[APP_INSTANCE_HEADER.toLowerCase()];
+            response.resume();
+            finish(header === APP_INSTANCE_HEADER_VALUE);
+        });
+        clientRequest.setTimeout(EXISTING_INSTANCE_PROBE_TIMEOUT_MS, () => {
+            clientRequest.destroy();
+            finish(false);
+        });
+        clientRequest.on("error", () => finish(false));
+        clientRequest.end();
+    });
+}
+function isAddressInUseError(error) {
+    return (error instanceof Error &&
+        "code" in error &&
+        error.code === "EADDRINUSE");
+}
+function appUrl(port) {
+    return `http://${LOOPBACK_HOST}:${port}/`;
+}
 function closeServer(server) {
     if (!server.listening)
         return Promise.resolve();