/** @param {NS} ns **/ export async function main(ns) { // Sleep for given amount, const sleep = ns.args[1] || 1; await ns.sleep(sleep); // and then weaken! await ns.weaken(ns.args[0]); }

/** @param {NS} ns **/ export async function main(ns) { // Sleep for given amount, const sleep = ns.args[1] || 1; await ns.sleep(sleep); // and then grow! await ns.grow(ns.args[0]); }

/** @param {NS} ns **/ export async function main(ns) { // Sleep for given amount, const sleep = ns.args[1] || 1; await ns.sleep(sleep); // and then hack! await ns.hack(ns.args[0]); }

/** * Automates the process of hacking servers by deploying scripts and cracking open their security. * The script first gathers all servers accessible from the starting point ("home"). It then attempts * to breach the servers' security using available hacking programs and, if successful, deploys hacking scripts * to the compromised servers. This enables automated hacking activities on those servers. * * @param {NS} ns - The namespace object provided by the game, which includes * functions for interacting with the game's systems. * @async */ export async function main(ns) { // Retrieve a list of all reachable servers from "home". const SERVERS = getAllServers(ns); // Define the available hacking programs and their corresponding action functions. const PROGRAMS = [ { file: "BruteSSH.exe", action: ns.brutessh }, { file: "FTPCrack.exe", action: ns.ftpcrack }, { file: "RelaySMTP.exe", action: ns.relaysmtp }, { file: "HTTPWorm.exe", action: ns.httpworm }, { file: "SQLInject.exe", action: ns.sqlinject } ]; // Iterate through each server, excluding "home", and attempt to compromise and deploy scripts. for (let server of SERVERS) { if (server === "home") continue; // Transfer necessary scripts to the server. ns.scp(["/shared/weaken.js", "/shared/grow.js", "/shared/hack.js"], server); let open_ports = 0; // Attempt to run each hacking program that exists on "home", and count successfully opened ports. PROGRAMS.forEach(program => { if (ns.fileExists(program.file)) { program.action(server); open_ports++; } }); // If the number of open ports meets or exceeds the server's requirements, run the nuke command. if (ns.getServerNumPortsRequired(server) <= open_ports) ns.nuke(server); } /** * Discovers all servers connected to the starting server ("home"), using a depth-first search. * Unique servers are recorded to ensure each is processed only once. * @param {NS} ns - The namespace object for accessing game functions. * @returns {string[]} An array of unique server names. */ function getAllServers(ns) { let servers = []; let stack = ["home"]; while (stack.length > 0) { const CURRENT = stack.pop(); if (!servers.includes(CURRENT)) { servers.push(CURRENT); stack.push(...ns.scan(CURRENT).filter(next => !servers.includes(next))); } } return servers; } }

export class FileSystem { #ns; #file; /** * Creates an instance of the FileSystem class. * @param {object} ns - The namespace API that includes file operations. * @param {string} file - The name of the file to be managed. */ constructor(ns, file) { this.#ns = ns; this.#file = file; } /** * Creates a new file or clears an existing one. */ async newFile() { await this.#ns.write(this.#file, "", "w"); } /** * Appends or writes data to the file. * @param {any} data - The data to write into the file. * @param {string} mode - The writing mode, 'a' for append and 'w' for write (overwrite). */ async write(data, mode = "a") { const formattedData = JSON.stringify(data); await this.#ns.write(this.#file, formattedData, mode); } /** * Reads data from the file and parses it from JSON. * @returns {Promise<any>} A promise that resolves to the parsed data from the file. */ async read() { let dataString = await this.#ns.read(this.#file); return dataString.length > 0 ? JSON.parse(dataString) : []; } }

import { FileSystem } from "/data/file-system.js"; /** * Retrieves and records the names of all servers with root access within a game environment. * The script first collects all servers accessible from a starting point and checks each for root access. * Servers with root access are sorted by their maximum RAM capacity in descending order, * and the list is saved to a specified file. * This script leverages a modular approach, using a custom `FileSystem` class for file operations. * * @param {NS} ns - The namespace object provided by the game, which includes * functions for interacting with the game's systems. * @async */ export async function main(ns) { // Instantiate the FileSystem class for file operations, targeting a specific file. const ROOTED_SERVERS = new FileSystem(ns, "/data/rooted-servers.txt"); // Retrieve a list of all servers accessible from the "home" server. const SERVERS = getAllServers(ns); let results = []; // Filter servers to find those with root access. for (let s of SERVERS) { if (ns.hasRootAccess(s)) results.push(s); } // Sort the servers with root access by their maximum RAM, in descending order. results.sort((a, b) => ns.getServerMaxRam(b) - ns.getServerMaxRam(a)); // Write the sorted list of servers to the targeted file. await ROOTED_SERVERS.write(results, "w"); /** * Discovers all servers connected to the starting server ("home"), using a depth-first search. * Unique servers are recorded to ensure each is processed only once. * @param {NS} ns - The namespace object for accessing game functions. * @returns {string[]} An array of unique server names. */ function getAllServers(ns) { let servers = []; let stack = ["home"]; while (stack.length > 0) { const CURRENT = stack.pop(); if (!servers.includes(CURRENT)) { servers.push(CURRENT); stack.push(...ns.scan(CURRENT).filter(next => !servers.includes(next))); } } return servers; } }

import { FileSystem } from "/data/file-system.js"; /** * Identifies servers that are hackable based on their security and economic attributes, * and records their names, sorted by potential profitability. This script first gathers all accessible servers, * excluding the starting point ("home"), and then checks each for hackability criteria: * root access, hacking level requirement, and the presence of money. It records the names of qualifying servers, * sorted by their maximum money capacity, to a file. * This script leverages a custom `FileSystem` class to handle file operations. * * @param {NS} ns - The namespace object provided by the game, which includes * functions for interacting with the game's systems. * @async */ export async function main(ns) { // Instantiate the FileSystem class for file operations, targeting a specific file for hackable targets. const HACKABLE_TARGETS = new FileSystem(ns, "/data/hackable-targets.txt"); // Retrieve a list of all servers accessible from the "home" server. const SERVERS = getAllServers(ns); let results = []; // Filter servers based on hackability criteria. for (let server of SERVERS) { if (server === "home") continue; let has_root = ns.hasRootAccess(server); let is_hackable = ns.getServerRequiredHackingLevel(server) < ns.getHackingLevel(); let has_money = ns.getServerMaxMoney(server) > 0; if (is_hackable && has_root && has_money) results.push(server); } // Sort the hackable servers by their maximum money capacity, in descending order. results.sort((a, b) => ns.getServerMaxMoney(b) - ns.getServerMaxMoney(a)); // Write the sorted list of hackable servers to the targeted file. await HACKABLE_TARGETS.write(results, "w"); /** * Discovers all servers connected to the starting server ("home"), using a depth-first search. * Unique servers are recorded to ensure each is processed only once. * @param {NS} ns - The namespace object for accessing game functions. * @returns {string[]} An array of unique server names. */ function getAllServers(ns) { let servers = []; let stack = ["home"]; while (stack.length > 0) { const CURRENT = stack.pop(); if (!servers.includes(CURRENT)) { servers.push(CURRENT); stack.push(...ns.scan(CURRENT).filter(next => !servers.includes(next))); } } return servers; } }

import { FileSystem } from "/data/file-system.js"; /** * Evaluates a list of hackable servers and identifies the most profitable target * for hacking activities, based on a scoring system. The script reads a list of previously identified * hackable servers, assesses each based on its profitability and security level, and records * the best target into a file. The decision is based on the ratio of potential money gains to the * minimum security level of each server, while excluding servers that take too long to weaken. * This script uses a custom `FileSystem` class to facilitate file operations. * * @param {NS} ns - The namespace object provided by the game, which includes * functions for interacting with the game's systems. * @async */ export async function main(ns) { // Instantiate FileSystem classes for file operations, targeting specific files for hackable targets and the best target. const HACKABLE_TARGETS = new FileSystem(ns, "/data/hackable-targets.txt"); const BEST_TARGET = new FileSystem(ns, "/data/best-target.txt"); // Read the list of hackable targets from the file. const TARGETS = await HACKABLE_TARGETS.read(); // Define the maximum allowed time for weakening a server in minutes. const MAX_MINUTES = 30; let score = 0; let results = "n00dles"; // Default target if no other server qualifies. // Evaluate each target based on its weaken time and profitability-security ratio. for (let target of TARGETS) { let has_long_weaken_time = ns.getWeakenTime(target) > 1000 * 60 * MAX_MINUTES; if (has_long_weaken_time) continue; // Skip servers that take too long to weaken. // Calculate the score as the ratio of maximum potential money to minimum security level. let new_score = ns.getServerMaxMoney(target) / ns.getServerMinSecurityLevel(target); if (new_score > score) { score = new_score; // Update the best score found. results = target; // Update the best target found. } } // Write the name of the best target server to the file. await BEST_TARGET.write(results, "w"); }

/** * Conducts optimized batch operations on servers to maximize hacking effectiveness in a simulated hacking environment. * The script reads from three files to obtain lists of rooted servers, hackable targets, and the best target. It * adjusts operations based on the game's progression, focusing on maximizing money from servers by adjusting security * levels and money available. Operations are batched with delays to ensure effective synchronization and avoid * operation collisions. The script dynamically adjusts thread allocations based on server capabilities and * operation needs, and continuously iterates through targets and servers to apply the most effective hacking strategy. * * @param {NS} ns - The namespace object provided by the game, which includes functions for interacting with the game's systems. * @async */

import { FileSystem } from "/data/file-system.js"; export async function main(ns) { // Disable verbose logging for specific methods to clean up the output. const DISABLED_LOGS = [ 'sleep', 'getHackingLevel', 'getServerMaxMoney', 'getServerMinSecurityLevel', 'getServerSecurityLevel', 'getServerMoneyAvailable', 'getServerMaxRam', 'getServerUsedRam', ]; DISABLED_LOGS.forEach(log => ns.disableLog(log)); // Opens a tail window in the game to display log outputs. ns.tail(); // File system management for tracking servers and targets. const rooted_servers = new FileSystem(ns, "/data/rooted-servers.txt"); const hackable_targets = new FileSystem(ns, "/data/hackable-targets.txt"); const best_target = new FileSystem(ns, "/data/best-target.txt"); // Constants for script execution. const RAM_PER_THREAD = ns.getScriptRam("/shared/weaken.js"); // RAM requirement per thread. const RESERVED_HOME_RAM = 20; // Amount of RAM reserved on the 'home' server. const BATCH_THREAD_DELAY = 100; // Delay between batch operations in milliseconds. const CALCULATION_DELAY = 5; // Delay for recalculations to manage execution speed vs performance. const LOOP_DELAY = 1000 * 3; // Delay after completing an iteration over all targets and servers. const INITIAL_HACK_THREADS = 8; // Initial number of threads reserved for hacking operations. let batch_number = 1; // Identifier for each batch operation to ensure uniqueness. while (true) { // Read server and target data from files. const SERVERS = await rooted_servers.read(); const TARGETS = await hackable_targets.read(); const BEST_TARGET = await best_target.read(); // Determine if the game is in an early stage. let is_early_game = ns.getHackingLevel() < 750; for (let target of TARGETS) { if (is_early_game) target = BEST_TARGET; // Focus on the best target during early game stages. // Gather target's financial and security details. let max_money = ns.getServerMaxMoney(target); let min_security_level = ns.getServerMinSecurityLevel(target); let security_level = ns.getServerSecurityLevel(target); let money = Math.max(1, ns.getServerMoneyAvailable(target)); // Avoid division by zero. let has_growth_been_calculated = false; let required_grow_threads = 0; let batch_delay = 0; for (let server of SERVERS) { // Calculate the number of available threads for operations. let available_ram = ns.getServerMaxRam(server) - ns.getServerUsedRam(server) - (server === "home" ? RESERVED_HOME_RAM : 0); let available_threads = Math.floor(available_ram / RAM_PER_THREAD); if (available_threads < 1) continue; // Skip servers with no available threads. // Adjust operations based on server's security state and financial potential. let cores = (server === "home") ? ns.getServer("home").cpuCores : 1; // Multi-core support for home server. let security_decrease = ns.weakenAnalyze(1, cores); let hack_weaken_ratio = ns.hackAnalyzeSecurity(1, target) / security_decrease; let grow_weaken_ratio = ns.growthAnalyzeSecurity(1, target, cores) / cores; // Prioritize operations based on server state: weaken, grow, or hack. if (security_level > min_security_level) { // Security reduction operations. let reduced_security_level = security_decrease * available_threads; if (security_level - reduced_security_level < min_security_level) { available_threads = Math.ceil((security_level - min_security_level) / security_decrease); security_level = min_security_level; } else { security_level -= reduced_security_level; } ns.exec("/shared/weaken.js", server, available_threads, target, 0, batch_number++); } else if (money < max_money && (required_grow_threads != 0 || !has_growth_been_calculated)) { // Money maximization operations. if (!has_growth_been_calculated) { required_grow_threads = Math.ceil(ns.growthAnalyze(target, max_money / money, cores)); has_growth_been_calculated = true; } available_threads = Math.min(required_grow_threads, available_threads); required_grow_threads -= available_threads; security_level += ns.growthAnalyzeSecurity(available_threads, target, cores); ns.exec("/shared/grow.js", server, available_threads, target, 0, batch_number++); } else { if (available_threads < 4) continue; // Minimally need 4 threads to run a HWGW batch. // Hack-Weaken-Grow-Weaken batch operations. let hack_amount = ns.hackAnalyze(target); // Percentage of money per hack thread. if (hack_amount == 0) continue; let hack_threads = Math.ceil(available_threads / INITIAL_HACK_THREADS); let grow_threads, weaken_threads, weaken_threads_2, is_over_allocated = false; while (true) { // Optimal thread calculation loop. // Calculate the minimum number of threads to hack the server. if (hack_amount * hack_threads > 1) hack_threads = Math.ceil(1 / hack_amount); // Calculate grow and weaken threads required to account for hack threads. grow_threads = Math.ceil(ns.growthAnalyze(target, 1 / (1 - Math.min(0.99, hack_amount * hack_threads)), cores)); weaken_threads = Math.ceil(hack_weaken_ratio * hack_threads); weaken_threads_2 = Math.max(1, Math.ceil(grow_weaken_ratio * grow_threads)); // grow threads could be 0 so we set it to 1. // Calculate batch thread utilization. let thread_usage = (hack_threads + grow_threads + weaken_threads + weaken_threads_2) / available_threads; // Prioritize operations based on thread allocation state: over, under, good. if (thread_usage > 1) { // Over allocation. if (hack_threads > 1) { hack_threads--; // Adjust hack threads to manage over-allocation. is_over_allocated = true; } else break; // Recompute. } else if (Math.floor((1 - thread_usage) * hack_threads) > 1) { // Under allocation. let additional_threads = Math.floor((1 - thread_usage) * hack_threads / 2); // Checking if adding threads won't cause an over-hack. if (hack_amount * (hack_threads + additional_threads) <= 1) { hack_threads += additional_threads; // Adjust hack threads to manage under-allocation. } else break; // Recompute. if (is_over_allocated) break; // flag to prevent softlock from increasing and reducing by 1 thread. } else break; // Good allocation. await ns.sleep(CALCULATION_DELAY); } ns.exec("/shared/weaken.js", server, weaken_threads, target, batch_delay, batch_number); ns.exec("/shared/weaken.js", server, weaken_threads_2, target, batch_delay + BATCH_THREAD_DELAY * 2, batch_number); ns.exec("/shared/grow.js", server, grow_threads, target, batch_delay + BATCH_THREAD_DELAY + ns.getWeakenTime(target) - ns.getGrowTime(target), batch_number); ns.exec("/shared/hack.js", server, hack_threads, target, batch_delay - BATCH_THREAD_DELAY + ns.getWeakenTime(target) - ns.getHackTime(target), batch_number++); // Prevents intersection of HWGW batches. batch_delay += 4 * BATCH_THREAD_DELAY; } await ns.sleep(CALCULATION_DELAY); } await ns.sleep(CALCULATION_DELAY); } await ns.sleep(LOOP_DELAY); } }

/** * Executes a loop that periodically runs a set of scripts to manage various aspects of a game environment. * It repeatedly executes scripts related to deploying resources, analyzing server vulnerabilities, * identifying hackable targets, and determining the best targets for hacking. * The loop runs indefinitely, pausing for a specified interval between each iteration. * * @param {NS} ns - The namespace object provided by the game, which includes * functions for interacting with the game's systems. * @async */ export async function main(ns) { // Log settings: Currently, no logs are disabled, but this array can be populated with log identifiers // to suppress verbose output from specific game functions. const DISABLED_LOGS = []; DISABLED_LOGS.forEach(log => ns.disableLog(log)); // Opens a tail window in the game to display log outputs. ns.tail(); // LOOP_DELAY: Time in milliseconds to wait between script executions. // Set to 3000 milliseconds (3 seconds). const LOOP_DELAY = 1000 * 3; // Continuously loop to manage various scripting tasks. while (true) { // Run scripts to manage deployment, server vulnerabilities, hackable targets, and optimal targets. // Each script is launched with a single thread. ns.run("v1/deployer.js", 1); // Script to hack servers and deploying scripts. ns.run("v1/rooted-servers.js", 1); // Script to identify servers with root access. ns.run("v1/hackable-targets.js", 1); // Script to identify servers that can be hacked. ns.run("v1/best-target.js", 1); // Script to identify the best server for hacking. // Pause the loop for the specified delay, allowing time for scripts to execute before the next iteration. await ns.sleep(LOOP_DELAY); } }

/** @param {NS} ns **/ export async function main(ns) { ns.run("v1/hwgw.js", 1); }

run init.js

run start.js

/** * Manages the upgrade and acquisition of servers based on their RAM capacity in a game environment. * This script periodically checks all purchased servers, upgrading their RAM or purchasing new servers * if they do not meet a specified RAM requirement. The RAM requirement doubles each loop iteration, * starting from a base level. The script ensures that all operations are affordable before proceeding. * Verbose logging for certain operations is disabled to streamline the output. * * @param {NS} ns - The namespace object provided by the game, which includes * functions for interacting with the game's systems. * @async */ export async function main(ns) { // Disable verbose logging for specific methods to clean up the output. const DISABLED_LOGS = ['getServerMaxRam', 'getServerMoneyAvailable']; DISABLED_LOGS.forEach(log => ns.disableLog(log)); // Opens a tail window in the game to display log outputs. ns.tail(); // Set default delay times for looping and calculations. const LOOP_DELAY = ns.args[0] || 1000 * 3; // Default loop delay is 3 seconds. const CALCULATION_DELAY = 5; // Delay after calculations or server actions. let ram = 8; // Initial RAM threshold for server actions. let servers = ns.getPurchasedServers(); // Get a list of currently owned servers. // Continuously evaluate and manage servers. while (true) { ns.printf("Checking for servers with %s RAM.", ns.formatRam(ram)); for (let i = 0; i < ns.getPurchasedServerLimit(); i++) { let server = "server-" + i; if (servers.includes(server)) { // If server exists, check if it needs an upgrade. if (ns.getServerMaxRam(server) < ram) { let cost = ns.getPurchasedServerUpgradeCost(server, ram); // Wait for sufficient funds for the upgrade. while (ns.getServerMoneyAvailable("home") < cost) { ns.printf("%s needs %s to upgrade to %s.", server, ns.formatNumber(cost), ns.formatRam(ram)); await ns.sleep(LOOP_DELAY); } // Upgrade the server when funds are sufficient. if (ns.upgradePurchasedServer(server, ram)) { ns.printf("%s upgraded to %s", server, ns.formatRam(ram)); servers = ns.getPurchasedServers(); // Refresh the server list. } } } else { // If server does not exist, check cost and attempt to purchase. let cost = ns.getPurchasedServerCost(ram); while (ns.getServerMoneyAvailable("home") < cost) { ns.printf("Need %s to purchase %s with %s", ns.formatNumber(cost), server, ns.formatRam(ram)); await ns.sleep(LOOP_DELAY); } if (ns.purchaseServer(server, ram)) { ns.printf("Purchased %s with %s", server, ns.formatRam(ram)); servers = ns.getPurchasedServers(); // Refresh the server list. } } } // Double the RAM requirement for the next loop iteration. ram *= 2; // Pause the script briefly after handling all servers. await ns.sleep(CALCULATION_DELAY); } }

/** * This function automates the management of hacknet nodes in a game, * where nodes can be purchased or upgraded to enhance their performance. * It runs indefinitely, checking if enough funds are available to perform upgrades * or purchase new nodes, and executing these actions when possible. * * @param {object} ns - The namespace object provided by the game, which includes * functions for interacting with the game's systems. * @async */ export async function main(ns) { // Log settings: Disable verbose logging for the specified function. const DISABLED_LOGS = ['getServerMoneyAvailable']; DISABLED_LOGS.forEach(log => ns.disableLog(log)); // Opens a tail window in the game to display log outputs. ns.tail(); // LOOP_DELAY: Time in milliseconds to wait when funds are insufficient for upgrades. // Default value is 3000 milliseconds (3 seconds). const LOOP_DELAY = ns.args[0] || 1000 * 3; // THRESHOLD: Multiplier to determine the minimum funds needed relative to the cost of the next upgrade. // Default value is 1000, i.e., funds must be at least 1000 times the upgrade cost. const THRESHOLD = ns.args[1] || 1000; // CALCULATION_DELAY: Time in milliseconds to delay after executing an upgrade, // intended to manage load on system resources. Default value is 5 milliseconds. const CALCULATION_DELAY = 5; // Continuously loop to manage node upgrades or purchases. while (true) { let owned_nodes = ns.hacknet.numNodes(); // Get the current number of owned nodes. let min_cost = ns.hacknet.getPurchaseNodeCost(); // Cost of purchasing a new node. let node_index = owned_nodes; // Index for node to upgrade, initialized to the next new node. let upgrade_type = -1; // Type of upgrade to perform: -1 for purchase, 0 for level, 1 for RAM, 2 for core. // Evaluate the cost and type of the cheapest possible upgrade among existing nodes. for (let i = 0; i < owned_nodes; i++) { let upgrades = [ ns.hacknet.getLevelUpgradeCost(i, 1), ns.hacknet.getRamUpgradeCost(i, 1), ns.hacknet.getCoreUpgradeCost(i, 1) ]; let new_cost = Math.min.apply(Math, upgrades); if (new_cost < min_cost) { min_cost = new_cost; node_index = i; upgrade_type = upgrades.indexOf(new_cost); } } // Wait until there are sufficient funds for the selected upgrade. while (ns.getServerMoneyAvailable("home") < min_cost * THRESHOLD) { ns.printf("Node %d needs %s * %d for next upgrade.", node_index, ns.formatNumber(min_cost), THRESHOLD); await ns.sleep(LOOP_DELAY); } // Execute the selected upgrade or node purchase. switch (upgrade_type) { case -1: ns.hacknet.purchaseNode(); ns.printf("Purchased a new hacknet node."); break; case 0: ns.hacknet.upgradeLevel(node_index, 1); ns.printf("Upgraded node %d's level.", node_index); break; case 1: ns.hacknet.upgradeRam(node_index, 1); ns.printf("Upgraded node %d's ram.", node_index); break; case 2: ns.hacknet.upgradeCore(node_index, 1); ns.printf("Upgraded node %d's cores.", node_index); break; } // Delay after upgrade to manage system performance. await ns.sleep(CALCULATION_DELAY); } }

/** * Monitors and displays detailed financial and security information about servers in a simulated hacking environment. * The script lists each server that is hackable and profitable based on the player's current hacking level and the server's * financial attributes. It continuously updates and prints this information at a specified interval, highlighting the money * available, security levels, and estimated times for hacking-related actions. Logging for specific operations is disabled to * reduce clutter. * * @param {NS} ns - The namespace object provided by the game, which includes functions for interacting with the game's systems. * @async */ export async function main(ns) { // Disable verbose logging for specific operations to make the output cleaner. const DISABLED_LOGS = [ 'scan', 'getServerMoneyAvailable', 'getServerMaxMoney', 'getServerRequiredHackingLevel', 'getServerSecurityLevel', 'getServerMinSecurityLevel', 'getHackingLevel' ]; DISABLED_LOGS.forEach(log => ns.disableLog(log)); // Opens a tail window in the game to display log outputs. ns.tail(); // Determine the list of servers to monitor: either all reachable servers or a specific server passed as an argument. let servers = (ns.args[0] == null) ? getAllServers(ns) : [ns.args[0]]; // Sort servers by their maximum potential money in descending order. servers.sort((a, b) => ns.getServerMaxMoney(b) - ns.getServerMaxMoney(a)); for (let server of servers) { if (server === "home") continue; // Skip the "home" server. // Gather financial and security details of each server. const MONEY = ns.getServerMoneyAvailable(server); const MAX_MONEY = Math.max(1, ns.getServerMaxMoney(server)); const MONEY_PERCENT = ns.formatPercent(MONEY / MAX_MONEY); const HACK_LEVEL = ns.getServerRequiredHackingLevel(server); const SECURITY_LEVEL = ns.getServerSecurityLevel(server); const MIN_SECURITY_LEVEL = ns.getServerMinSecurityLevel(server); const WEAKEN_TIME = formatTime(ns.getWeakenTime(server)); const GROW_TIME = formatTime(ns.getGrowTime(server)); const HACK_TIME = formatTime(ns.getHackTime(server)); let is_hackable = HACK_LEVEL < ns.getHackingLevel(); let has_money = MAX_MONEY > 1; if (is_hackable && has_money) { // Print detailed server information if it's hackable and profitable. ns.tprintf("| %18s | $ %8s / %8s | %7s | HL:%4d | SL:%3d / %2d | WT:%2dh %2dm %2ds | GT:%2dh %2dm %2ds | HT:%2dh %2dm %2ds |", server, ns.formatNumber(MONEY), ns.formatNumber(MAX_MONEY), MONEY_PERCENT, HACK_LEVEL, SECURITY_LEVEL, MIN_SECURITY_LEVEL, ...WEAKEN_TIME, ...GROW_TIME, ...HACK_TIME); } } // Helper function to retrieve all reachable servers from "home". function getAllServers(ns) { let servers = []; let stack = ["home"]; while (stack.length > 0) { const CURRENT = stack.pop(); if (!servers.includes(CURRENT)) { servers.push(CURRENT); stack.push(...ns.scan(CURRENT).filter(next => !servers.includes(next))); } } return servers; } // Helper function to format milliseconds into hours, minutes, and seconds for readability. function formatTime(milliseconds) { const SECONDS = Math.floor((milliseconds / 1000) % 60); const MINUTES = Math.floor(((milliseconds / 1000) / 60) % 60); const HOURS = Math.floor(((milliseconds / 1000) / 3600)); return [HOURS, MINUTES, SECONDS]; } }

/** * Monitors and displays the RAM usage details for specified servers, including the "home" server * and any purchased servers. The script outputs the maximum RAM, used RAM, and available RAM for each server, * refreshing the data at a specified interval. Verbose logging for RAM-related methods is disabled * to keep the output clear and focused. * * @param {NS} ns - The namespace object provided by the game, which includes functions for interacting with the game's systems. * @async */ export async function main(ns) { // Disable verbose logging for RAM-related operations to streamline output. const DISABLED_LOGS = ['getServerMaxRam', 'getServerUsedRam']; DISABLED_LOGS.forEach(log => ns.disableLog(log)); // Opens a tail window in the game to display log outputs. ns.tail(); // Set the interval between updates to 3 seconds. const SLEEP_DELAY = 1000 * 3; // Include the "home" server and any purchased servers in the list to monitor. const SERVERS = ["home"].concat(ns.getPurchasedServers()); // Continuously loop to monitor and display RAM usage for each server. while (true) { for (let server of SERVERS) { // Calculate and fetch RAM details for each server. let max_ram = ns.getServerMaxRam(server); let used_ram = ns.getServerUsedRam(server); let avail_ram = max_ram - used_ram; // Output the RAM usage details in a formatted manner. ns.printf("| %9s | Used: %8s / %8s | Free: %8s |", server, ns.formatRam(used_ram), ns.formatRam(max_ram), ns.formatRam(avail_ram)); } // Wait for the specified delay before the next update. await ns.sleep(SLEEP_DELAY); } }

alias init="run init.js" alias start="run start.js" alias server="run server-manager.js" alias hacknet="run hacknet-manager.js" alias get="run misc/get-server-stats.js" alias poll="run misc/poll-server-stats.js" alias ram="run misc/ram.js"