Fix root server function, file name was wrong

servers/home/autoexec.ts

@@ -1,4 +1,5 @@
 export async function main(ns: NS) {
-	ns.run('watcher.js')
+	ns.run("hackallservers.js")
-	ns.run('hacknet.js')
+	ns.run("watcher.js")
+	ns.run("hacknet.js")
 }

servers/home/hackallservers.ts

@@ -1,11 +1,15 @@
-import { executeScriptOnServerFromAnother, recursiveScan } from './utils'
+import { executeScriptOnServerFromAnother, recursiveScan } from "./utils"
 
 export async function main(ns: NS) {
 	let servers: string[] = recursiveScan(ns)
 
 	for (const server of servers) {
-		let numThreads = ns.getServerMaxRam(server) / ns.getScriptRam('hack.js')
+		// Guard clause for story servers, but hacking xp is nice. Can probably be enabled when XP is easy to get
+		// if (ns.getServerMaxMoney(server) === 0) { continue }
+
+		let numThreads = ns.getServerMaxRam(server) / ns.getScriptRam("hack.js")
 		numThreads = Math.floor(numThreads)
-		executeScriptOnServerFromAnother(ns, server, 'hack.js', numThreads, [server])
+		numThreads = Math.max(numThreads, 1) // Make sure we have at least 1 thread
+		executeScriptOnServerFromAnother(ns, server, "hack.js", numThreads, [server])
 	}
 }

servers/home/hacknet.ts

@@ -13,37 +13,35 @@
  *   If the upgrade mps is less than the average mps, then buy a new node.
  */
 
-enum Type {
+enum UpgradeType {
-	newNode = 'node', level = 'level', ram = 'ram', core = 'code',
+	level = "level", ram = "ram", core = "code",
 }
 
 export async function main(ns: NS) {
 	let timeout: number = <number> ns.args[0]
 
 	let nodes = ns.hacknet.numNodes()
-	// If there are no nodes, buy one
+	// If there are no nodes, buyUpgrade one
 	if (nodes === 0) {
 		ns.hacknet.purchaseNode()
 		nodes = 1
 	}
 
-	let costs: { type: Type, cost: number }[] = []
+	let costs: { type: UpgradeType, cost: number }[] = []
 	while (true) {
 		costs = []
 		// Go through each node and get the cheapest upgrade
 		for (let i = 0; i < nodes; i++) {
 			costs.push(getCheapestCost(ns, i))
 		}
-		// Buy the cheapest upgrade from all nodes
+		// Get the cheapest upgrade object
-		let cheapest = Math.min(...costs.map(c => c.cost))
+		let cheapest = costs.reduce((prev, curr) => prev.cost < curr.cost ? prev : curr)
-		// Find the index of the cheapest cost in the list
+
-		let index = costs.findIndex(c => c.cost === cheapest)
+		// Nodes have a lot more value, so only need node price to be 1/10th the cost of the cheapest upgrade
-		// Wait to buy the cheapest upgrade
+		if (ns.hacknet.getPurchaseNodeCost() / 10 < cheapest.cost) {
-		try {
+			await buyNode(ns, ns.hacknet.getPurchaseNodeCost(), timeout)
-			await buy(ns, costs[index].type, costs[index].cost, index, timeout)
+		} else {
-		} catch (e) {
+			await buyUpgrade(ns, cheapest.type, cheapest.cost, costs.indexOf(cheapest), timeout)
-			ns.tprint(e)
-			ns.exit()
 		}
 		// Make sure that the number of nodes is up-to-date
 		nodes = ns.hacknet.numNodes()
@@ -51,7 +49,7 @@ export async function main(ns: NS) {
 }
 
 /**
- * Wait until the player has enough money to buy something
+ * Wait until the player has enough money to buyUpgrade something
  * @param ns Global NS object
  * @param money Amount of money to wait for
  * @param timeout=-1 Number of seconds to wait before timing out.
@@ -59,48 +57,47 @@ export async function main(ns: NS) {
  * @note This function will wait forever by default
  */
 async function waitUntilMoney(ns: NS, money: number, timeout: number = -1) {
-	while (ns.getServerMoneyAvailable('home') < money) {
+	while (ns.getServerMoneyAvailable("home") < money) {
 		await ns.sleep(1000)
 		if (timeout == 0) {
-			throw new Error('Timed out waiting for money')
+			throw new Error("Timed out waiting for money")
 		} else if (timeout > -1) {
 			timeout--
 		}
 	}
 }
 
-async function buy(ns: NS, type: Type, cost: number, node: number, timeout: number) {
+async function buyUpgrade(ns: NS, type: UpgradeType, cost: number, node: number, timeout: number) {
 	await waitUntilMoney(ns, cost, timeout)
 	switch (type) {
-		case Type.newNode:
+		case UpgradeType.level:
-			ns.hacknet.purchaseNode()
-			break
-		case Type.level:
 			ns.hacknet.upgradeLevel(node)
 			break
-		case Type.ram:
+		case UpgradeType.ram:
 			ns.hacknet.upgradeRam(node)
 			break
-		case Type.core:
+		case UpgradeType.core:
 			ns.hacknet.upgradeCore(node)
 			break
 	}
 }
 
+async function buyNode(ns: NS, cost: number, timeout: number) {
+	await waitUntilMoney(ns, cost, timeout)
+	ns.hacknet.purchaseNode()
+}
+
 function getCheapestCost(ns: NS, node: number) {
-	let nodeCost = ns.hacknet.getPurchaseNodeCost()
 	let levelCost = ns.hacknet.getLevelUpgradeCost(node)
 	let ramCost = ns.hacknet.getRamUpgradeCost(node)
 	let coreCost = ns.hacknet.getCoreUpgradeCost(node)
-	let cheapest = Math.min(nodeCost, levelCost, ramCost, coreCost)
+	let cheapest = Math.min(levelCost, ramCost, coreCost)
 	switch (cheapest) {
-		case nodeCost:
-			return { type: Type.newNode, cost: nodeCost }
 		case levelCost:
-			return { type: Type.level, cost: levelCost }
+			return { type: UpgradeType.level, cost: levelCost }
 		case ramCost:
-			return { type: Type.ram, cost: ramCost }
+			return { type: UpgradeType.ram, cost: ramCost }
 		case coreCost:
-			return { type: Type.core, cost: coreCost }
+			return { type: UpgradeType.core, cost: coreCost }
 	}
 }

servers/home/killall.ts

@@ -1,4 +1,4 @@
-import { recursiveScan } from './utils'
+import { recursiveScan } from "./utils"
 
 export async function main(ns: NS) {
 	let servers: string[] = recursiveScan(ns)

servers/home/programs.ts

@@ -1,15 +1,32 @@
-import { recursiveScan } from "./utils"
+import { recursiveHackingRequired, recursiveScan, removeFilesOnAllServers } from "./utils"
 
 export async function main(ns: NS) {
 	switch (ns.args[0]) {
 		case "getServers":
-			getServers(ns);
+			getServers(ns)
-			break;
+			break
+		case "getHackingLevels":
+			getHackingLevels(ns)
+			break
+		case "removeFiles":
+			removeFilesOnAllServersFromArgs(ns)
+			break
 		default:
-			ns.tprint("Invalid program name");
+			ns.tprint("Invalid program name")
-			break;
+			break
 	}
 }
+
 function getServers(ns: NS) {
-	ns.tprint(recursiveScan(ns));
+	ns.tprint(recursiveScan(ns))
+}
+
+function getHackingLevels(ns: NS) {
+	ns.tprint(recursiveHackingRequired(ns))
+}
+
+function removeFilesOnAllServersFromArgs(ns: NS) {
+	let args = ns.args.slice(1)
+	let files = args.map((file) => file.toString())
+	removeFilesOnAllServers(ns, files)
 }

servers/home/utils.ts

@@ -7,14 +7,14 @@
  */
 export function recursiveScan(ns: NS) {
 	// Starting case
-	let servers = ns.scan('home')
+	let servers = ns.scan("home")
 	// Add all servers to the list
 	let allServers: string[] = []
 	while (servers.length > 0) {
-		let server = servers.shift()
+		let server = servers.pop()
 		if (server) {
 			let newServers = ns.scan(server)
-			for (let newServer of newServers) {
+			for (const newServer of newServers) {
 				if (!allServers.includes(newServer)) {
 					allServers.push(newServer)
 					servers.push(newServer)
@@ -22,10 +22,23 @@ export function recursiveScan(ns: NS) {
 			}
 		}
 	}
-	// Remove the current server
+	// Remove the home server from the list
-	allServers.splice(allServers.indexOf('home'), 1)
+	return allServers.filter(server => server !== "home").sort()
-	// Print all servers
+}
-	return allServers
+
+/**
+ * Recursively scans all servers connected to the current server for the set of all levels that hackable servers require
+ * @param ns
+ * @returns A set of every hacking level required to hack a new server
+ */
+export function recursiveHackingRequired(ns: NS) {
+	let servers = recursiveScan(ns)
+	let levels: number[] = []
+	for (let server of servers) {
+		levels.push(ns.getServerRequiredHackingLevel(server))
+	}
+	// Sort and remove duplicates, need custom sort because built-in sort only works alphabetically 💀
+	return [...new Set(levels)].sort((a, b) => a - b)
 }
 
 /**
@@ -55,27 +68,27 @@ export function removeFilesOnAllServers(ns: NS, files: string[]) {
  */
 export function rootServer(ns: NS, server: string) {
 	let counter = 0
-	if (ns.fileExists('BruteSSH.exe', 'home')) {
+	if (ns.fileExists("BruteSSH.exe", "home")) {
 		ns.brutessh(server)
 		counter++
 	}
-	if (ns.fileExists('FTPCrack.exe', 'home')) {
+	if (ns.fileExists("FTPCrack.exe", "home")) {
 		ns.ftpcrack(server)
 		counter++
 	}
-	if (ns.fileExists('SMTPCrack.exe', 'home')) {
+	if (ns.fileExists("relaySMTP.exe", "home")) {
 		ns.relaysmtp(server)
 		counter++
 	}
-	if (ns.fileExists('HTTPWorm.exe', 'home')) {
+	if (ns.fileExists("HTTPWorm.exe", "home")) {
 		ns.httpworm(server)
 		counter++
 	}
-	if (ns.fileExists('SQLInject.exe', 'home')) {
+	if (ns.fileExists("SQLInject.exe", "home")) {
 		ns.sqlinject(server)
 		counter++
 	}
-	if (ns.getServer(server).openPortCount <= counter) {
+	if (counter >= ns.getServerNumPortsRequired(server)) {
 		ns.nuke(server)
 	}
 	return counter
@@ -95,17 +108,13 @@ export function performFunctionIfCapable(ns: NS, server: string, func: CallableF
 		ns.print(`Not enough hacking level to hack ${server}`)
 		return false
 	}
-	if (ns.getServerNumPortsRequired(server) < ns.getServer(server).openPortCount) {
+	if (ns.getServer(server).openPortCount <= ns.getServerNumPortsRequired(server)) {
 		ns.print(`Not enough ports, trying to root ${server}`)
-	}
 		if (rootServer(ns, server) < ns.getServerNumPortsRequired(server)) {
-		ns.print(`Need more port opening programs to root ${server}`)
-		return false
-	}
-	if (!ns.hasRootAccess(server)) {
 			ns.print(`Failed to root ${server}`)
 			return false
 		}
+	}
 	let result = func(...args)
 	if (result === undefined) {
 		return true
@@ -126,7 +135,8 @@ export function executeScriptOnServerFromAnother(ns: NS, server: string, script:
 	ns.scp(script, server)
 	performFunctionIfCapable(ns, server, ns.exec, [script, server, threads, ...args])
 	ns.atExit(() => {
-		ns.rm(script, server)
+		// Remove the script from the server when the program exits
+		// ns.rm(script, server)
 	})
 }
 
@@ -136,11 +146,38 @@ export function executeScriptOnServerFromAnother(ns: NS, server: string, script:
  * @param time=5 The number of seconds to calculate the MPS over
  */
 export async function calculateMPS(ns: NS, time: number = 5) {
-	let start = ns.getServerMoneyAvailable('home')
+	let start = ns.getServerMoneyAvailable("home")
 	let data: number[] = []
 	for (let i = 0; i < time; i++) {
 		await ns.sleep(1000)
-		data.push(ns.getServerMoneyAvailable('home') - start)
+		data.push(ns.getServerMoneyAvailable("home") - start)
 	}
 	return data.reduce((a, b) => a + b, 0) / time
 }
+
+/**
+ * Type that represents a program and whether it exists on the home server
+ */
+export type ProgramState = {
+	program: string
+	exists: boolean
+}
+
+/**
+ * Checks if any of the programs passed in now exist on the home server, and updates the exists property of the program
+ * @param ns Global NS object
+ * @param programs The programs to check
+ * @returns true if any of the programs now exist, otherwise false
+ */
+export function checkForNewPrograms(ns: NS, programs: ProgramState[]) {
+	let result = false
+	for (const program of programs) {
+		if (program.exists == false) {
+			program.exists = ns.fileExists(program.program)
+			if (program.exists) {
+				result = true
+			}
+		}
+	}
+	return result
+}

servers/home/watcher.ts

@@ -1,16 +1,42 @@
+import { checkForNewPrograms, ProgramState, recursiveHackingRequired } from "./utils"
+
 export async function main(ns: NS) {
-	ns.run('hackallservers.js')
+	let levels = recursiveHackingRequired(ns)
 	let hackingLevel = ns.getHackingLevel()
-	while (hackingLevel < 9999) {
+
-		let oldHackingLevel = hackingLevel
+	let state: ProgramState[] = [
-		hackingLevel = ns.getHackingLevel()
+		{ program: "BruteSSH.exe", exists: false },
-		if (oldHackingLevel !== hackingLevel) {
+		{ program: "FTPCrack.exe", exists: false },
-			ns.tprint(`Hacking level increased from ${oldHackingLevel} to ${hackingLevel}`)
+		{ program: "relaySMTP.exe", exists: false },
-			ns.run('killall.js')
+		{ program: "HTTPWorm.exe", exists: false },
-			await ns.sleep(1000) // 1 second
+		{ program: "SQLInject.exe", exists: false },
-			ns.run('hackallservers.js')
+	]
+	// Update state with existing programs
+	checkForNewPrograms(ns, state)
+
+	// Remove levels that are already hacked
+	levels = levels.filter(level => level > hackingLevel)
+
+	do {
+		let restart = false
+		if (Math.min(...levels) <= hackingLevel) {
+			ns.tprint(`Hacking level increased to/past ${Math.min(...levels)}, is now ${hackingLevel}`)
+			ns.tprint(`Remaining levels to hack: ${levels}`)
+			// remove the level from the list, so we don't try to hack it again
+			levels = levels.filter(level => level > hackingLevel)
+			restart = true
 		}
+		if (checkForNewPrograms(ns, state)) {
+			ns.tprint(`New programs found: ${state.filter(program => program.exists).map(program => program.program)}`)
+			restart = true
+		}
+		if (restart) {
+			ns.run("killall.js")
+			await ns.sleep(1000) // 1 second
+			ns.run("hackallservers.js")
+		}
+		hackingLevel = ns.getHackingLevel()
 		// Wait 1 second before checking again
 		await ns.sleep(1000)
-	}
+	} while (hackingLevel <= Math.max(...levels))
 }