Revelav3/app.js

import createBareServer from "@tomphttp/bare-server-node";
import http from "http";
import { createRequire } from "module";
import { dirname, join } from "path";
import serveStatic from "serve-static";
import { fileURLToPath } from "url";
const require = createRequire(import.meta.url);
const config = require("./deployment.config.json");
import fs from "fs";
var base64data;
import sgTransport from "nodemailer-sendgrid-transport";
import nodemailer from "nodemailer";
import fetch from "node-fetch";
const options = {
  auth: {
    api_key: config.sendgrid_options.api_key
  }
};
const sendgridMailerAgent = nodemailer.createTransport(sgTransport(options));
const smtpMailerAgent = nodemailer.createTransport(config.smtp_options);
function sendVerificationEmail(UUID, OTP) {
  let email = {
    to: "",
    from: "",
    subject: `NebulaWEB personal access code ${OTP}`,
    text: `
 ####### ACCESS CODE (OTP) ${OTP} #######
 ####### DO NOT SHARE THIS CODE!  ####### 
  (this message is automated)`,
    html: `
    ####### ACCESS CODE (OTP) ${OTP} #######
 ####### DO NOT SHARE THIS CODE!  ####### 
  (this message is automated)
  `
  };
  if (config.sendgrid_verification == true) {
    email.to = config.sendgrid_options.to_email;
    email.from = config.sendgrid_options.sendFromEmail;
    sendgridMailerAgent.sendMail(email, (err, res) => {
      if (err) {
        console.log(err);
      }
      console.log(res);
    });
  }
  if (config.smtp_verification == true) {
    email.to = config.smtp_options.to_email;
    email.from = config.smtp_options.sendFromEmail;
    smtpMailerAgent.sendMail(email, (err, res) => {
      if (err) {
        console.log(err);
      }
      console.log(res);
    });
  }
  if (config.discord_verification == true) {
    fetch(config.webhook_url, {
      method: "POST",
      headers: {
        "Content-Type": "application/json"
      },
      body: JSON.stringify({
        content: `Your NebulaWEB access code is ${OTP}`
      })
    });
  }
}

function getNewCode() {
  var seq = (Math.floor(Math.random() * 10000) + 10000).toString().substring(1);
  if (seq == "0") {
    getNewCode();
  }
  return seq;
}

const PORT = process.env.PORT || 3000;
const bareServer = createBareServer("/bare/", {
  logErrors: false,
  localAddress: undefined
});

const serve = serveStatic(
  join(dirname(fileURLToPath(import.meta.url)), "static/"),
  {
    fallthrough: false,
    maxAge: 5 * 60 * 1000
  }
);

const server = http.createServer();

server.on("request", (request, response) => {
  try {
    if (bareServer.shouldRoute(request)) {
      bareServer.routeRequest(request, response);
    } else {
      let base64data;
      const url = request.url;
      if (url.startsWith("/sendNewCode")) {
        const OTP = getNewCode();
        fs.writeFile("./memory.txt", OTP, function (err) {
          if (err) return console.log(err);
          console.log(`Wrote OTP code to temp file`);
        });

        fs.readFile("./memory.txt", "utf8", (err, data) => {
          if (err) {
            console.error(err);
            return;
          }
          console.log(data);

          sendVerificationEmail("10", data);
          let buff = new Buffer(data);
          base64data = buff.toString("base64");
          console.log("302");
          response.writeHead(302, {
            location: "/unv.html?c=" + base64data
          });
          response.end();
        });
      } else if (url.startsWith("/verification")) {
        var body;
        if (
          config.sendgrid_verification == true ||
          config.discord_verification == true ||
          config.smtp_verificaton == true
        ) {
          const body = "true";
          response.writeHead(200, {
            "Content-Length": Buffer.byteLength(body),
            "Content-Type": "text/plain"
          });
          response.end(body);
        } else {
          const body = "false";
          response.writeHead(200, {
            "Content-Length": Buffer.byteLength(body),
            "Content-Type": "text/plain"
          });
          response.end(body);
        }
      } else {
        serve(request, response, (err) => {
          response.writeHead(err?.statusCode || 500, null, {
            "Content-Type": "text/plain"
          });
          response.end(err?.stack);
        });
      }
    }
  } catch (e) {
    response.writeHead(500, "Internal Server Error", {
      "Content-Type": "text/plain"
    });
    response.end(e.stack);
  }
});
server.on("upgrade", (req, socket, head) => {
  if (bareServer.shouldRoute(req)) {
    bareServer.routeUpgrade(req, socket, head);
  } else {
    socket.end();
  }
});

server.listen(PORT);

if (process.env.UNSAFE_CONTINUE)
  process.on("uncaughtException", (err, origin) => {
    console.error(`Critical error (${origin}):`);
    console.error(err);
    console.error("UNSAFELY CONTINUING EXECUTION");
    console.error();
  });

console.log(`Server running at http://localhost:${PORT}/.`);