server.ts

import fs from "node:fs";
import path from "node:path";
import url from "node:url";
import https from "node:https";

// Load environment variables from .env file
import dotenv from "dotenv";
dotenv.config();

import prom from "@isaacs/express-prometheus-middleware";
import { createRequestHandler } from "@remix-run/express";
import type { ServerBuild } from "@remix-run/node";
import { broadcastDevReady, installGlobals } from "@remix-run/node";
import compression from "compression";
import type { RequestHandler } from "express";
import express from "express";
import morgan from "morgan";
import sourceMapSupport from "source-map-support";

sourceMapSupport.install();
installGlobals();
run();

async function run() {
  const BUILD_PATH = path.resolve("build/index.js");
  const VERSION_PATH = path.resolve("build/version.txt");

  const initialBuild = await reimportServer();
  const remixHandler =
    process.env.NODE_ENV === "development"
      ? await createDevRequestHandler(initialBuild)
      : createRequestHandler({
          build: initialBuild,
          mode: initialBuild.mode,
        });

  const app = express();
  const metricsApp = express();
  app.use(
    prom({
      metricsPath: "/metrics",
      collectDefaultMetrics: true,
      metricsApp,
    }),
  );

  app.use((req, res, next) => {
    // helpful headers:
    res.set("x-fly-region", process.env.FLY_REGION ?? "unknown");
    res.set("Strict-Transport-Security", `max-age=${60 * 60 * 24 * 365 * 100}`);

    // /clean-urls/ -> /clean-urls
    if (req.path.endsWith("/") && req.path.length > 1) {
      const query = req.url.slice(req.path.length);
      const safepath = req.path.slice(0, -1).replace(/\/+/g, "/");
      res.redirect(301, safepath + query);
      return;
    }
    next();
  });

  // if we're not in the primary region, then we need to make sure all
  // non-GET/HEAD/OPTIONS requests hit the primary region rather than read-only
  // Postgres DBs.
  // learn more: https://fly.io/docs/getting-started/multi-region-databases/#replay-the-request
  app.all("*", function getReplayResponse(req, res, next) {
    const { method, path: pathname } = req;
    const { PRIMARY_REGION, FLY_REGION } = process.env;

    const isMethodReplayable = !["GET", "OPTIONS", "HEAD"].includes(method);
    const isReadOnlyRegion =
      FLY_REGION && PRIMARY_REGION && FLY_REGION !== PRIMARY_REGION;

    const shouldReplay = isMethodReplayable && isReadOnlyRegion;

    if (!shouldReplay) return next();

    const logInfo = {
      pathname,
      method,
      PRIMARY_REGION,
      FLY_REGION,
    };
    console.info(`Replaying:`, logInfo);
    res.set("fly-replay", `region=${PRIMARY_REGION}`);
    return res.sendStatus(409);
  });

  app.use(compression());

  // http://expressjs.com/en/advanced/best-practice-security.html#at-a-minimum-disable-x-powered-by-header
  app.disable("x-powered-by");

  // Remix fingerprints its assets so we can cache forever.
  app.use(
    "/build",
    express.static("public/build", { immutable: true, maxAge: "1y" }),
  );

  // Everything else (like favicon.ico) is cached for an hour. You may want to be
  // more aggressive with this caching.
  app.use(express.static("public", { maxAge: "1h" }));

  app.use(morgan("tiny"));

  app.all("*", remixHandler);

  const port = process.env.PORT || 3030;
  const httpsPort = process.env.HTTPS_PORT || 3443;

  // Try to start HTTPS server in development for extension testing
  // In production, __dirname is the project root. In dev build, it's build/ so go up one level.
  const certDir = fs.existsSync(path.join(__dirname, "localhost.key"))
    ? __dirname
    : path.join(__dirname, "..");
  const keyPath = path.join(certDir, "localhost.key");
  const certPath = path.join(certDir, "localhost.crt");

  if (process.env.NODE_ENV === "development" &&
      fs.existsSync(keyPath) &&
      fs.existsSync(certPath)) {
    try {
      const httpsOptions = {
        key: fs.readFileSync(keyPath),
        cert: fs.readFileSync(certPath),
      };

      // Helper to start server with retry for port conflicts during hot reload
      const startHttpsServer = (retryCount = 0): void => {
        const httpsServer = https.createServer(httpsOptions, app);

        httpsServer.on('error', (err: any) => {
          if (err.code === 'EADDRINUSE' && retryCount < 5) {
            // Port is temporarily in use (likely from previous watch restart)
            // Wait a bit and retry
            const delay = (retryCount + 1) * 100;
            console.log(`⏳ Port ${httpsPort} busy, retrying in ${delay}ms... (attempt ${retryCount + 1}/5)`);
            setTimeout(() => startHttpsServer(retryCount + 1), delay);
          } else {
            console.error(`❌ Failed to start HTTPS server: ${err}`);
            // Fall through to HTTP-only mode
            app.listen(port, () => {
              console.log(`✅ app ready (HTTP only): http://localhost:${port}`);
              if (process.env.NODE_ENV === "development") {
                broadcastDevReady(initialBuild);
              }
            });
          }
        });

        httpsServer.listen(httpsPort, () => {
          console.log(`✅ app ready (HTTPS): https://localhost:${httpsPort}`);
          // Also start HTTP server for non-extension requests
          app.listen(port, () => {
            console.log(`✅ app ready (HTTP): http://localhost:${port}`);
          });
          if (process.env.NODE_ENV === "development") {
            broadcastDevReady(initialBuild);
          }
        });
      };

      startHttpsServer();
      return;
    } catch (error) {
      console.warn(`⚠️  Could not start HTTPS server: ${error}`);
      console.log(`   Falling back to HTTP only`);
    }
  }

  // Fallback to HTTP only
  app.listen(port, () => {
    console.log(`✅ app ready: http://localhost:${port}`);

    if (process.env.NODE_ENV === "development") {
      broadcastDevReady(initialBuild);
    }
  });

  const metricsPort = process.env.METRICS_PORT || 3010;

  metricsApp.listen(metricsPort, () => {
    console.log(`✅ metrics ready: http://localhost:${metricsPort}/metrics`);
  });

  async function reimportServer(): Promise<ServerBuild> {
    // cjs: manually remove the server build from the require cache
    Object.keys(require.cache).forEach((key) => {
      if (key.startsWith(BUILD_PATH)) {
        delete require.cache[key];
      }
    });

    const stat = fs.statSync(BUILD_PATH);

    // convert build path to URL for Windows compatibility with dynamic `import`
    const BUILD_URL = url.pathToFileURL(BUILD_PATH).href;

    // use a timestamp query parameter to bust the import cache
    return import(BUILD_URL + "?t=" + stat.mtimeMs);
  }

  async function createDevRequestHandler(
    initialBuild: ServerBuild,
  ): Promise<RequestHandler> {
    let build = initialBuild;
    async function handleServerUpdate() {
      // 1. re-import the server build
      build = await reimportServer();
      // 2. tell Remix that this app server is now up-to-date and ready
      broadcastDevReady(build);
    }
    const chokidar = await import("chokidar");
    chokidar
      .watch(VERSION_PATH, { ignoreInitial: true })
      .on("add", handleServerUpdate)
      .on("change", handleServerUpdate);

    // wrap request handler to make sure its recreated with the latest build for every request
    return async (req, res, next) => {
      try {
        return createRequestHandler({
          build,
          mode: "development",
        })(req, res, next);
      } catch (error) {
        next(error);
      }
    };
  }
}