superShare.js

import * as helpers from "/apis/helpers.js"
import * as myForms from "/apis/myFormulas.js"
let doLog = true;
let logLevel = 1;

//-----GUI SETTINGS-----//

let doGUI = true;
let showKarma = true;
let showScriptIncome = true;
let showScriptExp = true;
let showHacknetIncome = true;

const doc = globalThis['document'];
const hook0 = doc.getElementById('overview-extra-hook-0');
const hook1 = doc.getElementById('overview-extra-hook-1');
/** @param {NS} ns */
async function updateGUI(ns) {
    try {
        const headers = [];
        const values = [];
        if (showKarma) {
            headers.push("Karma");
            values.push(ns.heart.break().toPrecision(5));
        }
        if (showScriptIncome) {
            let income = ns.getScriptIncome();
            headers.push("Script $   ");
            values.push(ns.nFormat(income[1], "(0.00 a)") + "/s");
        }
        if (showScriptExp) {
            let exp = ns.getScriptExpGain();
            headers.push("Script EXP  ");
            values.push(ns.nFormat(exp, "(0.00 a)") + "/s");
        }
        if (showHacknetIncome) {
            let hnIncome = 0;
            for (let i = 0; i < ns.hacknet.numNodes(); i++) {
                hnIncome += ns.hacknet.getNodeStats(i).production;
            }
            headers.push("Hacknet $  ");
            values.push(ns.nFormat(hnIncome, "(0.00 a)") + "/s");
        }
        hook0.innerText = headers.join(" \n");
        hook1.innerText = values.join(" \n");

    } catch (err) {
        ns.print("Error updating the GUI! - " + String(err));
    }

}
/** @param {NS} ns @param {Server} server @param {Player} player*/
export async function main(ns) {
    //get server names
    let host = ns.getHostname();
    //define scripts
    let shareScript = "/tools/share.js";
    if (!ns.fileExists(shareScript)){
        var url = "https://pastebin.com/raw.php?i=";

        let success = await ns.wget(url + "svaqzAc0", shareScript);
        if (!success) {

        }
    }
    //get ram amounts for all scripts.
    let runningScripts = ["scanForCCT.js", "/tools/superShare.js" ];
    //GB of RAM to keep free on home server for running scripts
    var constantRam = 4;
    for (let s of runningScripts) constantRam += ns.getScriptRam(s);
    var sharescriptRam = ns.getScriptRam(shareScript);
    var maxRam = (ns.getServerMaxRam(host) - constantRam);
    let homeThreads = 0;
    //Get a list of all servers
    let filters = ["MyServer-"];
    let useExact = false;

    let usableServers = [];
    //Gather max hive memory and threads, starting with home values.
    let maxMemory = maxRam;
    let maxThreads = homeThreads;
    //filter the list of servers by usability
    async function getUsableServers() {
        let servers = await helpers.getAllServers(ns, filters, useExact);
        maxRam = 0;
        maxMemory = 0;
        maxThreads = 0;
        let list = [];
        //list.push([host, homeThreadsHack, homeThreadsGrow, homeThreadsWeaken]);
        for (let server of servers) {
            if (!ns.hasRootAccess(server)) { await dropImmunity(ns, server); }
            //only use those with root
            if (ns.hasRootAccess(server)) {
                if (!ns.fileExists(shareScript, server)) {
                    await ns.scp(shareScript, server);
                    ns.tprint("Moving files to ", server)
                }

                let mem = ns.getServerMaxRam(server);
                if (server == host) mem = mem - constantRam;
                let thr = Math.floor(mem / sharescriptRam);
                //only add servers to the list if they can handle at least one thread.
                if (thr > 0) {
                    //add memory and threads to max pools
                    maxMemory += mem;
                    //maxThreads += thr;
                    maxThreads += thr;
                    //add to array of usable servers
                    list.push([server, thr]);
                }
            }
        }
        return helpers.sortArray(list, [[1, 1]]);
    }
    usableServers = await getUsableServers();
    ns.tprint("Hive Mind Participants - ", usableServers);
    ns.tprint("Max Threads Capable -" + maxThreads);
    //sort the usable servers by the most possible threads, highest being first.
    while (true) {
        for (let s of usableServers) {
            let server = s[0];
            if (!ns.scriptRunning(shareScript, server)) {
                let used = 0;
                if (server == host) used = constantRam;
                let threads = Math.floor((ns.getServerMaxRam(server) - ns.getServerUsedRam(server) - used) / sharescriptRam);
                if (threads > 0) {
                    ns.exec(shareScript, server, threads, performance.now());
                }
            }
            await ns.sleep(5);
        }
        await ns.sleep(1000);
        usableServers = await getUsableServers();
        if (doGUI) await updateGUI(ns);
    }
}

//Takes an array of actions
//An action is defined as - [threadCount, command, timeToFinish, target, executionTime, scriptRam]
let lastActionID = 0;
/** @param {NS} ns */
function batchSplit(ns, actions, servers, batchServers = [], deb = false) {

    let actionID = lastActionID;
    for (let action of actions) {
        let remainingThreads = action[0];
        let command = action[1];
        let timeToFinish = action[2];
        let target = action[3];
        let executionTime = action[4];
        let scriptRam = action[5];
        lastActionID++;
        for (let tserver of servers) {
            let server = tserver[0];
            let freeThreads = Math.floor((ns.getServerMaxRam(server) - ns.getServerUsedRam(server)) / ns.getScriptRam(command));
            for (let bServer of batchServers) {
                if (bServer[0] == server) {
                    freeThreads -= bServer[1];
                }
            }
            if (deb) ns.tprint(server, " - ", freeThreads);
            if (freeThreads > 0) {
                if (remainingThreads > freeThreads) {
                    batchServers.push([server, freeThreads, command, target, timeToFinish, executionTime, actionID++]);
                    remainingThreads -= freeThreads;
                } else {
                    batchServers.push([server, remainingThreads, command, target, timeToFinish, executionTime, actionID++]);
                    remainingThreads = 0;
                    break;
                }
            }

            if (remainingThreads == 0) {
                break;
            }
        }
        if (remainingThreads > 0) {
            //ns.tprint("Unable to batch - ", action, batchServers);
            return [false, action, "Batch too large for the network", remainingThreads, batchServers];
        }

    }
    return [true, batchServers, "Batched Actions Successfully"];
}
//["n00dles",4,"/newserver/grow.js","joesguns",13529012.076642979,20249.87664293067,0]
//target, timeToFinish, executionTime, actionID
/** @param {NS} ns */
async function executeBatch(ns, batch, batchDelay = 0) {
    //ns.tprint(batch);
    for (let batchOrder of batch[1]) {                       //target  ttf             execution time   id
        //ns.tprint(batchOrder[0], " ordering - ",batchOrder[1] );
        ns.exec(batchOrder[2], batchOrder[0], batchOrder[1], batchOrder[3], batchOrder[4], batchOrder[5], batchOrder[6]);
    }
}

export function autocomplete(data, args) {
    return [...data.servers];
}

/** @param {NS} ns */
async function log(ns, s, level) {
    if (doLog && level <= logLevel) ns.tprint(s);
}
/** @param {NS} ns */
async function dropImmunity(ns, server) {
    // If we have the BruteSSH.exe program, use it to open the SSH Port
    // on the target server
    let portLevel = 0;
    if (ns.fileExists("BruteSSH.exe", "home") && !ns.hasRootAccess(server) && ns.getServerNumPortsRequired(server) > portLevel) {
        log(ns, "Attempting BruteSSH on " + server, 2);
        ns.brutessh(server);
        portLevel++;
    }
    if (ns.fileExists("FTPCrack.exe", "home") && !ns.hasRootAccess(server) && ns.getServerNumPortsRequired(server) > portLevel) {
        log(ns, "Attempting FTPCrack on " + server, 2);
        ns.ftpcrack(server);
        portLevel++;
    }
    if (ns.fileExists("relaySMTP.exe", "home") && !ns.hasRootAccess(server) && ns.getServerNumPortsRequired(server) > portLevel) {
        log(ns, "Attempting relaySMTP on " + server, 2);
        ns.relaysmtp(server);
        portLevel++;
    }
    if (ns.fileExists("HTTPWorm.exe", "home") && !ns.hasRootAccess(server) && ns.getServerNumPortsRequired(server) > portLevel) {
        log(ns, "Attempting HTTPWorm on " + server, 2);
        ns.httpworm(server);
        portLevel++;
    }
    if (ns.fileExists("SQLInject.exe", "home") && !ns.hasRootAccess(server) && ns.getServerNumPortsRequired(server) > portLevel) {
        log(ns, "Attempting SQLInject on " + server, 2);
        ns.sqlinject(server);
        portLevel++;
    }


    // Get root access to target server
    if (!ns.hasRootAccess(server)) {
        if (ns.getServerNumPortsRequired(server) <= portLevel) {
            ns.nuke(server);
            if (ns.hasRootAccess(server)) {
                log(ns, "Gained root access to " + server, 1);
            }
        }
        else log(ns, "Not enough open ports for " + server + " to run NUKE.exe", 2);
    }
}