Holy-Unblocker/run-command.mjs

import { readFile, writeFile, unlink, mkdir, rm } from 'node:fs/promises';
import { exec, fork } from 'node:child_process';
import { fileURLToPath } from 'node:url';
import { build } from 'esbuild';
import ecosystem from './ecosystem.config.js';

//  Some necessary constants are copied over from /src/server.mjs.

const config = Object.freeze(
    JSON.parse(await readFile(new URL("./src/config.json", import.meta.url)))
  ),
  ecosystemConfig = Object.freeze(
    ecosystem.apps.find(app => app.name === "HolyUB") || ecosystem.apps[0]
  );

const serverUrl = (base => {
  try {
    base = new URL(config.host);
  } catch (e) {
    base = new URL("http://a");
    base.host = config.host;
  }
  base.port = ecosystemConfig[ config.production ? "env_production" : "env" ].PORT;
  return Object.freeze(base);
})();

const shutdown = fileURLToPath(new URL("./src/.shutdown", import.meta.url));

//  Run each command line argument passed after node run-command.mjs.
//  Commands are defined in the switch case statement below.
commands: for (let i = 2; i < process.argv.length; i++)
  switch (process.argv[i]) {
//  Commmand to boot up the server. Use PM2 to run if production is true in the
//  config file.
    case "start":
      if (config.production)
        exec("npx pm2 start ecosystem.config.js --env production",
          (error, stdout) => {
            if (error) throw error;
            console.log(stdout);
          }
        );
//    Handle setup on Windows differently from platforms with POSIX-compliant shells.
//    This should run the server as a background process.
      else if (process.platform === "win32")
        exec('START /MIN "" node backend.js', (error, stdout) => {
          if (error) {
            console.error(error);
            process.exitCode = 1;
          }
          console.log(stdout);
        });
//    The following approach (and similar approaches) will not work on Windows,
//    because exiting this program will also terminate backend.js on Windows.
      else {
        const server = fork(
          fileURLToPath(new URL("./backend.js", import.meta.url)),
          {
            cwd: process.cwd(),
            stdio: ["inherit", "inherit", "pipe", "ipc"],
            detached: true
          }
        );
        server.stderr.on("data", stderr => {
          console.error(stderr.toString());
          process.exitCode = 1;
        });
        server.unref();
        server.disconnect();
      }
      break;

//  Stop the server. Make a temporary file that the server will check for if told
//  to shut down. This is done by sending a GET request to the server.
    case "stop": {
      await writeFile(shutdown, "");
      let timeoutId, hasErrored = false;
      try {
//      Give the server 5 seconds to respond, otherwise cancel this and throw an
//      error to the console. The fetch request will also throw an error immediately
//      if checking the server on localhost and the port is unused.
        const response = await Promise.race([
          fetch(new URL("/test-shutdown", serverUrl)),
          new Promise(resolve => {
                timeoutId = setTimeout(() => {
                  resolve("Error");
                }, 5000);
              })
        ]);
        clearTimeout(timeoutId);
        if (response === "Error") throw new Error("Server is unresponsive.");
      } catch (e) {
//      Remove the temporary shutdown file since the server didn't remove it.
        await unlink(shutdown);
//      Check if this is the error thrown by the fetch request for an unused port.
//      Don't print the unused port error, since nothing has actually broken.
        if (e instanceof TypeError) clearTimeout(timeoutId);
        else {
          console.error(e);
//        Stop here unless Node will be killed later.
          if (!process.argv.slice(i + 1).includes("kill"))
            hasErrored = true;
        }
      }
//    Do not run this if Node will be killed later in this script. It will fail.
      if (config.production && !process.argv.slice(i + 1).includes("kill"))
        exec("npx pm2 stop ecosystem.config.js", (error, stdout) => {
          if (error) {
            console.error(error);
            hasErrored = true;
          }
          console.log(stdout);
        });
//    Do not continue executing commands since the server was unable to be stopped.
//    Mostly implemented to prevent duplicating Node instances with npm restart.
      if (hasErrored) {
        process.exitCode = 1;
        break commands;
      }
      break;
    }

    case "build": {
      const dist = fileURLToPath(new URL("./views/dist", import.meta.url));
      await rm(dist, {force: true, recursive: true});
      await mkdir(dist);
      await build({
        entryPoints: [
          "./views/uv/**/*.js",
          "./views/assets/js/**/*.js",
          "./views/assets/css/**/*.css"
        ],
        platform: "browser",
        sourcemap: true,
        bundle: true,
        minify: true,
        external: ["*.png", "*.jpg", "*.jpeg", "*.webp", "*.svg"],
        outdir: dist
      });
      break;
    }

//  Kill all node processes and fully reset PM2. To be used for debugging.
//  Using npx pm2 monit, or npx pm2 list in the terminal will also bring up
//  more PM2 debugging tools.
    case "kill":
      if (process.platform === "win32")
        exec("( npx pm2 delete ecosystem.config.js ) ; taskkill /F /IM node*",
          (error, stdout) => {console.log(stdout)}
        );
      else exec("npx pm2 delete ecosystem.config.js; pkill node",
          (error, stdout) => {console.log(stdout)}
        );
      break;

//  No default case.

  }


process.exitCode = process.exitCode || 0;