The_Bitburner_Scripts/Ramses/home/Library.js

/** @param {NS} ns */
export async function main(ns) {
  ns.tprint("This is just a function library, it doesn't do anything.");
}

// Custom color coding.
const cCyan = "\u001b[36m";
const cGreen = "\u001b[32m";
const cRed = "\u001b[31m";
const cReset = "\u001b[0m";

/** @param {NS} ns */
export function getCracks(ns) {
  let cracks = {};
  if (ns.fileExists("BruteSSH.exe", "home")) {
    cracks["BruteSSH.exe"] = ns.brutessh;
  };
  if (ns.fileExists("FTPCrack.exe", "home")) {
    cracks["FTPCrack.exe"] = ns.ftpcrack;
  };
  if (ns.fileExists("relaySMTP.exe", "home")) {
    cracks["relaySMTP.exe"] = ns.relaysmtp;
  };
  if (ns.fileExists("HTTPWorm.exe", "home")) {
    cracks["HTTPWorm.exe"] = ns.httpworm;
  };
  if (ns.fileExists("SQLInject.exe", "home")) {
    cracks["SQLInject.exe"] = ns.sqlinject;
  };
  return cracks;
}

/** @param {NS} ns */
export function scanServerList(ns) {
  const home = "home";
  let serverList = [];
  let unscanned = [];

  unscanned.push(home);
  while (unscanned.length > 0) {
    let currentServer = unscanned.pop();
    if (!serverList.some(obj => obj["serverName"] === currentServer)) {
      let maxRam = ns.getServerMaxRam(currentServer);
      let minPorts = ns.getServerNumPortsRequired(currentServer);
      let minSecLevel = ns.getServerMinSecurityLevel(currentServer);
      let minHackLevel = ns.getServerRequiredHackingLevel(currentServer);
      let rootAccess = ns.hasRootAccess(currentServer);
      let serverMoney = ns.getServerMaxMoney(currentServer);
      let serverFiles = ns.ls(currentServer);
      let serverStats = ns.getServer(currentServer);
      let serverOrgs = serverStats.organizationName;
      let serverCores = serverStats.cpuCores;

      serverList.push({
        serverName: currentServer,
        maxRam: maxRam,
        maxMoney: serverMoney,
        minSec: minSecLevel,
        minPorts: minPorts,
        minHackLvl: minHackLevel,
        rootAccess: rootAccess,
        openPorts: 0,
        serverOrgs: serverOrgs,
        serverCores: serverCores,
        serverFiles: serverFiles,
      });
      let neighbours = ns.scan(currentServer);
      for (let i = 0; i < neighbours.length; i++) {
        let neighbour = neighbours[i];
        if (serverList.some(obj => obj["serverName"] === neighbour)) {
          continue
        }
        unscanned.push(neighbour);
      }
    }
  }
  ns.write("serverList.txt", JSON.stringify(serverList), "w");
}

/** @param {NS} ns */
export function findBestTarget(ns, maxSec, maxPorts, currentHackLevel, manualTargetOverride) {
  if (!ns.fileExists("serverList.txt", "home")) scanServerList();
  let serverList = JSON.parse(ns.read("serverList.txt"));
  let bestEntry = "";
  if (manualTargetOverride && manualTargetOverride.length > 0) {
    bestEntry = manualTargetOverride;
  } else {
    bestEntry = null;
    let nMaxMoneyPerChance = 0;
    let nBestMoneyPerChance = 0;
    serverList.forEach((entry)=> {
      if (entry.minSec <= maxSec && entry.minPorts <= maxPorts && entry.minHackLvl <= currentHackLevel) {
        nMaxMoneyPerChance = (entry.maxMoney * ns.hackAnalyzeChance(entry.serverName)) / entry.minSec;
        if (nMaxMoneyPerChance > nBestMoneyPerChance) {
          nBestMoneyPerChance = nMaxMoneyPerChance;
          bestEntry = entry.serverName;
        }
      }
  })
  }
  ns.write("bestTarget.txt", JSON.stringify(serverList.find((entry) => entry.serverName === bestEntry)), "w");
}


/** @param {NS} ns */
export function crackingAndRooting(ns, cracks) {
  if (!ns.fileExists("serverList.txt", "home")) scanServerList();
  let serverList = JSON.parse(ns.read("serverList.txt"));
  let newServerList = serverList.map((entry) => {
    let cracked = false;
    let openPorts = entry.openPorts || 0;
    if (entry.minPorts === 0 || (entry.minPorts > openPorts && entry.minPorts <= Object.keys(cracks).length)) {
      for (let k = 0; k < entry.minPorts; k++) {
        cracks[Object.keys(cracks)[k]](entry.serverName);
        entry.openPorts = k;
      }
      cracked = true;
    }
    if (!ns.hasRootAccess(entry.serverName) && cracked === true) {
      ns.nuke(entry.serverName);
      if (ns.hasRootAccess(entry.serverName)) {
        entry.rootAccess = true;
      }
    }
    return entry
  })
  ns.write("serverList.txt", JSON.stringify(newServerList), "w");
  ns.tprint("Cracking and rooting done");
}


/** @param {NS} ns */
export function copyAndRunScript(ns, funnyScript, currentServer) {
  let bestTarget = JSON.parse(ns.read("bestTarget.txt"));
  let serverList = JSON.parse(ns.read("serverList.txt"));
  let bestEntry = serverList.find((entry) => entry.serverName === bestTarget.serverName)
  let currentEntry = serverList.find((entry) => entry.serverName === currentServer)

  if (currentEntry.rootAccess === true && bestEntry.rootAccess === true) {
    if (currentEntry.serverName !== "home") {
      ns.print("killed threads on: " + currentEntry.serverName + ns.killall(currentEntry.serverName, true));
    } else {
      ns.print("killed threads on: " + currentEntry.serverName + ns.scriptKill(funnyScript[0], currentEntry.serverName));
    };
    if (currentEntry.maxRam > 0) {
      ns.scp(funnyScript, currentEntry.serverName, "home");
      let maxProcesses = 1;
      if (currentEntry.maxRam >= 8) {
        maxProcesses = Math.max(Math.floor((currentEntry.maxRam) / 8), 1);
      } else {
        maxProcesses = 1
      };
      for (let n = 1; n <= maxProcesses; n++) {
        ns.exec(funnyScript[0], currentEntry.serverName, 1, bestTarget.serverName);
      }
    }
  }
}

/** @param {NS} ns */
export async function purchaseAndUpgradeServers(ns) {
  ns.disableLog("sleep");
  ns.disableLog("getServerMoneyAvailable");
  ns.disableLog("getServerMaxRam");
  let maxPurchasedServers = ns.getPurchasedServerLimit();
  let purchasedServers = [];
  let pServcount = listPurchasedServers(ns).length;
  let currentMoney = 0;
  let serverList = [];
  while (pServcount < maxPurchasedServers) {
    purchasedServers = listPurchasedServers(ns);
    currentMoney = ns.getServerMoneyAvailable("home");
    let targetRamInitial = 16;
    if (ns.getPurchasedServerCost(targetRamInitial) < currentMoney) {
      let sFrontZero = "0";
      if (pServcount > 9) {
        sFrontZero = "";
      }
      let hostname = ns.purchaseServer("pserv-" + sFrontZero + pServcount, targetRamInitial);
      ns.tprint("Purchased " + cCyan + hostname + cReset);
      ns.toast("Purchased " + hostname, "info", 10000);
      pServcount = listPurchasedServers(ns).length;
      serverList = JSON.parse(ns.read("serverList.txt"));
      serverList.push({
        serverName: hostname,
        maxRam: 16,
        maxMoney: 0,
        minSec: 0,
        minPorts: 5,
        minHackLvl: 1,
        rootAccess: true,
        openPorts: 0,
      });
      ns.write("serverList.txt", JSON.stringify(serverList), "w");
      continue
    } else {
      await ns.sleep(5000);
    }
  }
  let i = 5;
  while (i < 21) {
    let targetRam = 2 ** i;
    purchasedServers = listPurchasedServers(ns);
    for (let currentServer of purchasedServers) {
      currentMoney = ns.getServerMoneyAvailable("home");
      if (ns.getServerMaxRam(currentServer) < targetRam){
        if (ns.getPurchasedServerUpgradeCost(currentServer, targetRam) < currentMoney) {
        if (ns.upgradePurchasedServer(currentServer, targetRam)) {
          ns.print(currentServer + " upgraded to " + targetRam + " GB RAM");
          serverList = JSON.parse(ns.read("serverList.txt"));
          let newServerList = serverList.map((entry) => { if (entry.serverName === currentServer){ entry.maxRam = targetRam} return entry});
          ns.write("serverList.txt", JSON.stringify(newServerList), "w");
          ns.tprint(cCyan + "Server: " + currentServer + " upgraded to: " + targetRam.toLocaleString() + " GB" + cReset);
          ns.toast("Server: " + currentServer + " upgraded to: " + targetRam.toLocaleString() + " GB", "info", 10000);
        }
      } else {
        await ns.sleep(5000);
        continue
      }};
    }
    ++i;
  }
  ns.tprint("Extiting purchaseServers script!")
}

/** @param {NS} ns */
export function listPurchasedServers(ns) {
  return ns.getPurchasedServers();
}

/** @param {NS} ns */
export function getSetting(ns, sSetting) {
  let oSettings = JSON.parse(ns.read("settings.txt"));
  let settingEntry = oSettings.setting[sSetting];
  //ns.tprint(oSettings.setting[sSetting])
  //ns.tprint("settingEntry = "+settingEntry);
  return settingEntry;
}

/** @param {NS} ns */
export function getGrowThreads(ns, sTarget, nHackThreads, nCores) {
  let nHackAmountPercent = ns.hackAnalyze(sTarget) * nHackThreads;
  let nGrowthThreads = ns.growthAnalyze(sTarget, 1 + nHackAmountPercent, nCores);
  return nGrowthThreads;
}

/** @param {NS} ns */
export async function ExecuteAndWait(ns, sScript, ...args) {
  if (!ns.isRunning(sScript, ...args)) { ns.exec(sScript, ...args); }
  while (ns.isRunning(sScript, ...args)) { await ns.sleep(100); }
}

/** @param {NS} ns */
export async function RunAndWait(ns, sScript, ...args) {
  if (!ns.isRunning(sScript, ...args)) { ns.run(sScript, ...args); }
  while (ns.isRunning(sScript, ...args)) { await ns.sleep(100); }
}

/** @param {NS} ns */
export function listWorkServers(ns) {
  ns.disableLog("ALL");
  const sFileName = "serverList.txt";
  if (!ns.fileExists(sFileName, "home")) { ns.print(`ERROR ${sFileName} does not exist.`); return false; };
  let serverList = JSON.parse(ns.read(sFileName));

  let nTotalWorkerRAM = 0;
  let nTotalFreeRAM = 0;

  const nServerColumnWidth = 20;
  const nValueColumnWidth = 8;
  const nCoresWidth = 5;

  ns.printRaw("┏━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━┓");
  ns.printRaw("┃ Server               ┃    Free  / Max RAM  ┃ Cores ┃");
  ns.printRaw("┣━━━━━━━━━━━━━━━━━━━━━━╋━━━━━━━━━━━━━━━━━━━━━╋━━━━━━━┫");
  serverList.forEach((entry) => {
    if (entry.rootAccess && entry.maxRam >= 1) {
      let sServerName = entry.serverName.padEnd(nServerColumnWidth, ' ');
      let nFreeRAM = entry.maxRam - ns.getServerUsedRam(entry.serverName);
      let sFreeRAM = nFreeRAM.toLocaleString().padStart(nValueColumnWidth, ' ');
      let sMaxRam = entry.maxRam.toLocaleString().padStart(nValueColumnWidth, ' ');
      let sCores = entry.serverCores.toLocaleString().padStart(nCoresWidth, ' ');
      ns.printRaw(`┃ ${sServerName} ┃ ${sFreeRAM} / ${sMaxRam} ┃ ${sCores} ┃`);
      nTotalWorkerRAM += entry.maxRam;
      nTotalFreeRAM += nFreeRAM;
    }
  });
  ns.printRaw("┗━━━━━━━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━━━━━━┻━━━━━━━┛");
  ns.printRaw(`Total Free: ${nTotalFreeRAM.toLocaleString()} / ${nTotalWorkerRAM.toLocaleString()} GB`);
}