bitburner-src/src/Terminal.jsx

import {
  evaluateDirectoryPath,
  evaluateFilePath,
  getFirstParentDirectory,
  isInRootDirectory,
  isValidDirectoryPath,
  removeLeadingSlash,
  removeTrailingSlash,
} from "./Terminal/DirectoryHelpers";
import { determineAllPossibilitiesForTabCompletion } from "./Terminal/determineAllPossibilitiesForTabCompletion";
import { TerminalHelpText, HelpTexts } from "./Terminal/HelpText";
import { tabCompletion } from "./Terminal/tabCompletion";
import { createFconf } from "./Fconf/Fconf";

import {
  parseAliasDeclaration,
  printAliases,
  removeAlias,
  substituteAliases,
} from "./Alias";
import { BitNodeMultipliers } from "./BitNode/BitNodeMultipliers";
import { CodingContractResult } from "./CodingContracts";
import { CONSTANTS } from "./Constants";
import { Programs } from "./Programs/Programs";
import {
  executeDarkwebTerminalCommand,
  checkIfConnectedToDarkweb,
} from "./DarkWeb/DarkWeb";
import { Engine } from "./engine";
import { FconfSettings } from "./Fconf/FconfSettings";
import {
  calculateHackingChance,
  calculateHackingExpGain,
  calculatePercentMoneyHacked,
  calculateHackingTime,
  calculateGrowTime,
  calculateWeakenTime,
} from "./Hacking";
import { HacknetServer } from "./Hacknet/HacknetServer";
import {
  iTutorialNextStep,
  iTutorialSteps,
  ITutorial,
} from "./InteractiveTutorial";
import { showLiterature } from "./Literature/LiteratureHelpers";
import { Message } from "./Message/Message";
import { showMessage } from "./Message/MessageHelpers";
import { startWorkerScript } from "./NetscriptWorker";
import { killWorkerScript } from "./Netscript/killWorkerScript";
import { WorkerScriptStartStopEventEmitter } from "./Netscript/WorkerScriptStartStopEventEmitter";
import { Player } from "./Player";
import { hackWorldDaemon } from "./RedPill";
import { RunningScript } from "./Script/RunningScript";
import { compareArrays } from "../utils/helpers/compareArrays";
import { getRamUsageFromRunningScript } from "./Script/RunningScriptHelpers";
import {
  findRunningScript,
  findRunningScriptByPid,
} from "./Script/ScriptHelpers";
import { isScriptFilename } from "./Script/ScriptHelpersTS";
import { AllServers } from "./Server/AllServers";
import {
  GetServerByHostname,
  getServer,
  getServerOnNetwork,
} from "./Server/ServerHelpers";
import {
  SpecialServerIps,
  SpecialServerNames,
} from "./Server/SpecialServerIps";
import { setTimeoutRef } from "./utils/SetTimeoutRef";
import { Page, routing } from "./ui/navigationTracking";
import { numeralWrapper } from "./ui/numeralFormat";
import { KEY } from "../utils/helpers/keyCodes";
import { arrayToString } from "../utils/helpers/arrayToString";
import { getTimestamp } from "../utils/helpers/getTimestamp";
import { logBoxCreate } from "../utils/LogBox";
import {
  yesNoBoxCreate,
  yesNoBoxGetYesButton,
  yesNoBoxGetNoButton,
  yesNoBoxClose,
} from "../utils/YesNoBox";
import {
  post,
  postElement,
  postContent,
  postError,
  hackProgressBarPost,
  hackProgressPost,
} from "./ui/postToTerminal";
import { convertTimeMsToTimeElapsedString } from "../utils/StringHelperFunctions";
import { Money } from "./ui/React/Money";

import autosize from "autosize";
import * as JSZip from "jszip";
import * as FileSaver from "file-saver";
import * as libarg from "arg";
import React from "react";
import ReactDOM from "react-dom";

function postNetburnerText() {
  post("Bitburner v" + CONSTANTS.Version);
}

// Helper function that checks if an argument (which is a string) is a valid number
function isNumber(str) {
  if (typeof str != "string") {
    return false;
  } // Only process strings
  return !isNaN(str) && !isNaN(parseFloat(str));
}

function getTerminalInput() {
  return document.getElementById("terminal-input-text-box").value;
}

// Defines key commands in terminal
$(document).keydown(function (event) {
  // Terminal
  if (routing.isOn(Page.Terminal)) {
    var terminalInput = document.getElementById("terminal-input-text-box");
    if (
      terminalInput != null &&
      !event.ctrlKey &&
      !event.shiftKey &&
      !Terminal.contractOpen
    ) {
      terminalInput.focus();
    }

    if (event.keyCode === KEY.ENTER) {
      event.preventDefault(); // Prevent newline from being entered in Script Editor
      const command = getTerminalInput();
      const dir = Terminal.currDir;
      post(
        "<span class='prompt'>[" +
          (FconfSettings.ENABLE_TIMESTAMPS ? getTimestamp() + " " : "") +
          Player.getCurrentServer().hostname +
          ` ~${dir}]&gt;</span> ${command}`,
      );

      if (command.length > 0) {
        Terminal.resetTerminalInput(); // Clear input first
        Terminal.executeCommands(command);
      }
    }

    if (event.keyCode === KEY.C && event.ctrlKey) {
      if (Engine._actionInProgress) {
        // Cancel action
        post("Cancelling...");
        Engine._actionInProgress = false;
        Terminal.finishAction(true);
      } else if (FconfSettings.ENABLE_BASH_HOTKEYS) {
        // Dont prevent default so it still copies
        Terminal.resetTerminalInput(); // Clear Terminal
      }
    }

    if (event.keyCode === KEY.L && event.ctrlKey) {
      event.preventDefault();
      Terminal.executeCommand("clear"); // Clear screen
    }

    // Ctrl p same as up arrow
    // Ctrl n same as down arrow

    if (
      event.keyCode === KEY.UPARROW ||
      (FconfSettings.ENABLE_BASH_HOTKEYS &&
        event.keyCode === KEY.P &&
        event.ctrlKey)
    ) {
      if (FconfSettings.ENABLE_BASH_HOTKEYS) {
        event.preventDefault();
      }
      // Cycle through past commands
      if (terminalInput == null) {
        return;
      }
      var i = Terminal.commandHistoryIndex;
      var len = Terminal.commandHistory.length;

      if (len == 0) {
        return;
      }
      if (i < 0 || i > len) {
        Terminal.commandHistoryIndex = len;
      }

      if (i != 0) {
        --Terminal.commandHistoryIndex;
      }
      var prevCommand = Terminal.commandHistory[Terminal.commandHistoryIndex];
      terminalInput.value = prevCommand;
      setTimeoutRef(function () {
        terminalInput.selectionStart = terminalInput.selectionEnd = 10000;
      }, 10);
    }

    if (
      event.keyCode === KEY.DOWNARROW ||
      (FconfSettings.ENABLE_BASH_HOTKEYS &&
        event.keyCode === KEY.M &&
        event.ctrlKey)
    ) {
      if (FconfSettings.ENABLE_BASH_HOTKEYS) {
        event.preventDefault();
      }
      // Cycle through past commands
      if (terminalInput == null) {
        return;
      }
      var i = Terminal.commandHistoryIndex;
      var len = Terminal.commandHistory.length;

      if (len == 0) {
        return;
      }
      if (i < 0 || i > len) {
        Terminal.commandHistoryIndex = len;
      }

      // Latest command, put nothing
      if (i == len || i == len - 1) {
        Terminal.commandHistoryIndex = len;
        terminalInput.value = "";
      } else {
        ++Terminal.commandHistoryIndex;
        var prevCommand = Terminal.commandHistory[Terminal.commandHistoryIndex];
        terminalInput.value = prevCommand;
      }
    }

    if (event.keyCode === KEY.TAB) {
      event.preventDefault();

      // Autocomplete
      if (terminalInput == null) {
        return;
      }
      let input = terminalInput.value;
      if (input == "") {
        return;
      }

      const semiColonIndex = input.lastIndexOf(";");
      if (semiColonIndex !== -1) {
        input = input.slice(semiColonIndex + 1);
      }

      input = input.trim();
      input = input.replace(/\s\s+/g, " ");

      const commandArray = input.split(" ");
      let index = commandArray.length - 2;
      if (index < -1) {
        index = 0;
      }
      const allPos = determineAllPossibilitiesForTabCompletion(
        Player,
        input,
        index,
        Terminal.currDir,
      );
      if (allPos.length == 0) {
        return;
      }

      let arg = "";
      let command = "";
      if (commandArray.length == 0) {
        return;
      }
      if (commandArray.length == 1) {
        command = commandArray[0];
      } else if (commandArray.length == 2) {
        command = commandArray[0];
        arg = commandArray[1];
      } else if (commandArray.length == 3) {
        command = commandArray[0] + " " + commandArray[1];
        arg = commandArray[2];
      } else {
        arg = commandArray.pop();
        command = commandArray.join(" ");
      }

      tabCompletion(command, arg, allPos);
      terminalInput.focus();
    }

    // Extra Bash Emulation Hotkeys, must be enabled through .fconf
    if (FconfSettings.ENABLE_BASH_HOTKEYS) {
      if (event.keyCode === KEY.A && event.ctrlKey) {
        event.preventDefault();
        Terminal.moveTextCursor("home");
      }

      if (event.keyCode === KEY.E && event.ctrlKey) {
        event.preventDefault();
        Terminal.moveTextCursor("end");
      }

      if (event.keyCode === KEY.B && event.ctrlKey) {
        event.preventDefault();
        Terminal.moveTextCursor("prevchar");
      }

      if (event.keyCode === KEY.B && event.altKey) {
        event.preventDefault();
        Terminal.moveTextCursor("prevword");
      }

      if (event.keyCode === KEY.F && event.ctrlKey) {
        event.preventDefault();
        Terminal.moveTextCursor("nextchar");
      }

      if (event.keyCode === KEY.F && event.altKey) {
        event.preventDefault();
        Terminal.moveTextCursor("nextword");
      }

      if (
        (event.keyCode === KEY.H || event.keyCode === KEY.D) &&
        event.ctrlKey
      ) {
        Terminal.modifyInput("backspace");
        event.preventDefault();
      }

      // TODO AFTER THIS:
      // alt + d deletes word after cursor
      // ^w deletes word before cursor
      // ^k clears line after cursor
      // ^u clears line before cursor
    }
  }
});

// Keep terminal in focus
let terminalCtrlPressed = false,
  shiftKeyPressed = false;
$(document).ready(function () {
  if (routing.isOn(Page.Terminal)) {
    $(".terminal-input").focus();
  }
});

$(document).keydown(function (e) {
  if (routing.isOn(Page.Terminal)) {
    if (e.which == KEY.CTRL) {
      terminalCtrlPressed = true;
    } else if (e.shiftKey) {
      shiftKeyPressed = true;
    } else if (
      terminalCtrlPressed ||
      shiftKeyPressed ||
      Terminal.contractOpen
    ) {
      // Don't focus
    } else {
      var inputTextBox = document.getElementById("terminal-input-text-box");
      if (inputTextBox != null) {
        inputTextBox.focus();
      }

      terminalCtrlPressed = false;
      shiftKeyPressed = false;
    }
  }
});

$(document).keyup(function (e) {
  if (routing.isOn(Page.Terminal)) {
    if (e.which == KEY.CTRL) {
      terminalCtrlPressed = false;
    }
    if (e.shiftKey) {
      shiftKeyPressed = false;
    }
  }
});

let Terminal = {
  // Flags to determine whether the player is currently running a hack or an analyze
  hackFlag: false,
  backdoorFlag: false,
  analyzeFlag: false,
  actionStarted: false,
  actionTime: 0,

  commandHistory: [],
  commandHistoryIndex: 0,

  // True if a Coding Contract prompt is opened
  contractOpen: false,

  // Full Path of current directory
  // Excludes the trailing forward slash
  currDir: "/",

  resetTerminalInput: function (keepInput = false) {
    let input = "";
    if (keepInput) {
      input = getTerminalInput();
    }
    const dir = Terminal.currDir;
    if (FconfSettings.WRAP_INPUT) {
      document.getElementById("terminal-input-td").innerHTML =
        `<div id='terminal-input-header' class='prompt'>[${
          Player.getCurrentServer().hostname
        } ~${dir}]$ </div>` +
        `<textarea type="text" id="terminal-input-text-box" class="terminal-input" tabindex="1"  value=\"${input}\"  autocomplete="off" />`;

      // Auto re-size the line element as it wraps
      autosize(document.getElementById("terminal-input-text-box"));
    } else {
      document.getElementById("terminal-input-td").innerHTML =
        `<div id='terminal-input-header' class='prompt'>[${
          Player.getCurrentServer().hostname
        } ~${dir}]$ </div>` +
        `<input type="text" id="terminal-input-text-box" class="terminal-input" tabindex="1"  value=\"${input}\" autocomplete="off" />`;
    }
    const hdr = document.getElementById("terminal-input-header");
    hdr.style.display = "inline";

    const terminalInput = document.getElementById("terminal-input-text-box");
    if (typeof terminalInput.selectionStart == "number") {
      terminalInput.selectionStart = terminalInput.selectionEnd =
        terminalInput.value.length;
    } else if (typeof terminalInput.createTextRange != "undefined") {
      terminalInput.focus();
      var range = el.createTextRange();
      range.collapse(false);
      range.select();
    }
  },

  modifyInput: function (mod) {
    try {
      var terminalInput = document.getElementById("terminal-input-text-box");
      if (terminalInput == null) {
        return;
      }
      terminalInput.focus();

      var inputLength = terminalInput.value.length;
      var start = terminalInput.selectionStart;
      var inputText = terminalInput.value;

      switch (mod.toLowerCase()) {
        case "backspace":
          if (start > 0 && start <= inputLength + 1) {
            terminalInput.value =
              inputText.substr(0, start - 1) + inputText.substr(start);
          }
          break;
        case "deletewordbefore": // Delete rest of word before the cursor
          for (var delStart = start - 1; delStart > 0; --delStart) {
            if (inputText.charAt(delStart) === " ") {
              terminalInput.value =
                inputText.substr(0, delStart) + inputText.substr(start);
              return;
            }
          }
          break;
        case "deletewordafter": // Delete rest of word after the cursor
          for (
            var delStart = start + 1;
            delStart <= text.length + 1;
            ++delStart
          ) {
            if (inputText.charAt(delStart) === " ") {
              terminalInput.value =
                inputText.substr(0, start) + inputText.substr(delStart);
              return;
            }
          }
          break;
        case "clearafter": // Deletes everything after cursor
          break;
        case "clearbefore:": // Deleetes everything before cursor
          break;
      }
    } catch (e) {
      console.error("Exception in Terminal.modifyInput: " + e);
    }
  },

  moveTextCursor: function (loc) {
    try {
      var terminalInput = document.getElementById("terminal-input-text-box");
      if (terminalInput == null) {
        return;
      }
      terminalInput.focus();

      var inputLength = terminalInput.value.length;
      var start = terminalInput.selectionStart;

      switch (loc.toLowerCase()) {
        case "home":
          terminalInput.setSelectionRange(0, 0);
          break;
        case "end":
          terminalInput.setSelectionRange(inputLength, inputLength);
          break;
        case "prevchar":
          if (start > 0) {
            terminalInput.setSelectionRange(start - 1, start - 1);
          }
          break;
        case "prevword":
          for (var i = start - 2; i >= 0; --i) {
            if (terminalInput.value.charAt(i) === " ") {
              terminalInput.setSelectionRange(i + 1, i + 1);
              return;
            }
          }
          terminalInput.setSelectionRange(0, 0);
          break;
        case "nextchar":
          terminalInput.setSelectionRange(start + 1, start + 1);
          break;
        case "nextword":
          for (var i = start + 1; i <= inputLength; ++i) {
            if (terminalInput.value.charAt(i) === " ") {
              terminalInput.setSelectionRange(i, i);
              return;
            }
          }
          terminalInput.setSelectionRange(inputLength, inputLength);
          break;
        default:
          console.warn("Invalid loc argument in Terminal.moveTextCursor()");
          break;
      }
    } catch (e) {
      console.error("Exception in Terminal.moveTextCursor: " + e);
    }
  },

  startHack: function () {
    Terminal.hackFlag = true;

    // Hacking through Terminal should be faster than hacking through a script
    Terminal.actionTime =
      calculateHackingTime(Player.getCurrentServer(), Player) / 4;
    Terminal.startAction();
  },

  startBackdoor: function () {
    Terminal.backdoorFlag = true;

    // Backdoor should take the same amount of time as hack
    Terminal.actionTime =
      calculateHackingTime(Player.getCurrentServer(), Player) / 4;
    Terminal.startAction();
  },

  startAnalyze: function () {
    Terminal.analyzeFlag = true;
    Terminal.actionTime = 1;
    post("Analyzing system...");
    Terminal.startAction();
  },

  startAction: function () {
    Terminal.actionStarted = true;

    hackProgressPost("Time left:");
    hackProgressBarPost("[");

    // Disable terminal
    document.getElementById("terminal-input-td").innerHTML =
      '<input type="text" class="terminal-input"/>';
    $("input[class=terminal-input]").prop("disabled", true);
  },

  finishAction: function (cancelled = false) {
    if (Terminal.hackFlag) {
      Terminal.finishHack(cancelled);
    } else if (Terminal.backdoorFlag) {
      Terminal.finishBackdoor(cancelled);
    } else if (Terminal.analyzeFlag) {
      Terminal.finishAnalyze(cancelled);
    }

    // Rename the progress bar so that the next hacks dont trigger it. Re-enable terminal
    $("#hack-progress-bar").attr("id", "old-hack-progress-bar");
    $("#hack-progress").attr("id", "old-hack-progress");
    Terminal.resetTerminalInput();
    $("input[class=terminal-input]").prop("disabled", false);
  },

  // Complete the hack/analyze command
  finishHack: function (cancelled = false) {
    if (!cancelled) {
      var server = Player.getCurrentServer();

      // Calculate whether hack was successful
      var hackChance = calculateHackingChance(server, Player);
      var rand = Math.random();
      var expGainedOnSuccess = calculateHackingExpGain(server, Player);
      var expGainedOnFailure = expGainedOnSuccess / 4;
      if (rand < hackChance) {
        // Success!
        if (
          SpecialServerIps[SpecialServerNames.WorldDaemon] &&
          SpecialServerIps[SpecialServerNames.WorldDaemon] == server.ip
        ) {
          if (Player.bitNodeN == null) {
            Player.bitNodeN = 1;
          }
          hackWorldDaemon(Player.bitNodeN);
          Terminal.hackFlag = false;
          return;
        }
        server.backdoorInstalled = true;
        var moneyGained = calculatePercentMoneyHacked(server, Player);
        moneyGained = Math.floor(server.moneyAvailable * moneyGained);

        if (moneyGained <= 0) {
          moneyGained = 0;
        } // Safety check

        server.moneyAvailable -= moneyGained;
        Player.gainMoney(moneyGained);
        Player.recordMoneySource(moneyGained, "hacking");
        Player.gainHackingExp(expGainedOnSuccess);
        Player.gainIntelligenceExp(
          expGainedOnSuccess / CONSTANTS.IntelligenceTerminalHackBaseExpGain,
        );

        server.fortify(CONSTANTS.ServerFortifyAmount);

        postElement(
          <>
            Hack successful! Gained <Money money={moneyGained} /> and{" "}
            {numeralWrapper.formatExp(expGainedOnSuccess)} hacking exp
          </>,
        );
      } else {
        // Failure
        // Player only gains 25% exp for failure? TODO Can change this later to balance
        Player.gainHackingExp(expGainedOnFailure);
        post(
          `Failed to hack ${server.hostname}. Gained ${numeralWrapper.formatExp(
            expGainedOnFailure,
          )} hacking exp`,
        );
      }
    }
    Terminal.hackFlag = false;
  },

  finishBackdoor: function (cancelled = false) {
    if (!cancelled) {
      const server = Player.getCurrentServer();
      if (
        SpecialServerIps[SpecialServerNames.WorldDaemon] &&
        SpecialServerIps[SpecialServerNames.WorldDaemon] == server.ip
      ) {
        if (Player.bitNodeN == null) {
          Player.bitNodeN = 1;
        }
        hackWorldDaemon(Player.bitNodeN);
        Terminal.backdoorFlag = false;
        return;
      }
      server.backdoorInstalled = true;
      postElement(<>Backdoor successful!</>);
    }
    Terminal.backdoorFlag = false;
  },

  finishAnalyze: function (cancelled = false) {
    if (!cancelled) {
      let currServ = Player.getCurrentServer();
      const isHacknet = currServ instanceof HacknetServer;
      post(currServ.hostname + ": ");
      const org = currServ.organizationName;
      post("Organization name: " + (!isHacknet ? org : "Player"));
      let hasAdminRights = (!isHacknet && currServ.hasAdminRights) || isHacknet;
      post("Root Access: " + (hasAdminRights ? "YES" : "NO"));
      const hackingSkill = currServ.requiredHackingSkill;
      post("Required hacking skill: " + (!isHacknet ? hackingSkill : "N/A"));
      const security = currServ.hackDifficulty;
      post(
        "Server security level: " +
          (!isHacknet ? numeralWrapper.formatServerSecurity(security) : "N/A"),
      );
      const hackingChance = calculateHackingChance(currServ, Player);
      post(
        "Chance to hack: " +
          (!isHacknet ? numeralWrapper.formatPercentage(hackingChance) : "N/A"),
      );
      const hackingTime = calculateHackingTime(currServ, Player) * 1000;
      post(
        "Time to hack: " +
          (!isHacknet
            ? convertTimeMsToTimeElapsedString(hackingTime, true)
            : "N/A"),
      );
      postElement(
        <>
          Total money available on server:{" "}
          {!isHacknet ? <Money money={currServ.moneyAvailable} /> : "N/A"}
        </>,
      );
      const numPort = currServ.numOpenPortsRequired;
      post(
        "Required number of open ports for NUKE: " +
          (!isHacknet ? numPort : "N/A"),
      );
      post("SSH port: " + (currServ.sshPortOpen ? "Open" : "Closed"));
      post("FTP port: " + (currServ.ftpPortOpen ? "Open" : "Closed"));
      post("SMTP port: " + (currServ.smtpPortOpen ? "Open" : "Closed"));
      post("HTTP port: " + (currServ.httpPortOpen ? "Open" : "Closed"));
      post("SQL port: " + (currServ.sqlPortOpen ? "Open" : "Closed"));
    }
    Terminal.analyzeFlag = false;
  },

  executeCommands: function (commands) {
    // Sanitize input
    commands = commands.trim();
    commands = commands.replace(/\s\s+/g, " "); // Replace all extra whitespace in command with a single space

    // Handle Terminal History - multiple commands should be saved as one
    if (
      Terminal.commandHistory[Terminal.commandHistory.length - 1] != commands
    ) {
      Terminal.commandHistory.push(commands);
      if (Terminal.commandHistory.length > 50) {
        Terminal.commandHistory.splice(0, 1);
      }
    }
    Terminal.commandHistoryIndex = Terminal.commandHistory.length;

    // Split commands and execute sequentially
    commands = commands
      .match(/(?:'[^']*'|"[^"]*"|[^;"])*/g)
      .map(substituteAliases)
      .map((c) => c.match(/(?:'[^']*'|"[^"]*"|[^;"])*/g))
      .flat();
    for (let i = 0; i < commands.length; i++) {
      if (commands[i].match(/^\s*$/)) {
        continue;
      } // Don't run commands that only have whitespace
      Terminal.executeCommand(commands[i].trim());
    }
  },

  parseCommandArguments: function (command) {
    // This will be used to keep track of whether we're in a quote. This is for situations
    // like the alias command:
    //      alias run="run NUKE.exe"
    // We want the run="run NUKE.exe" to be parsed as a single command, so this flag
    // will keep track of whether we have a quote in
    let inQuote = ``;

    // Returns an array with the command and its arguments in each index
    // Properly handles quotation marks (e.g. `run foo.script "the sun"` will return [run, foo.script, the sun])
    const args = [];
    let start = 0,
      i = 0;
    let prevChar = ""; // Previous character
    while (i < command.length) {
      let escaped = false; // Check for escaped quotation marks
      if (i >= 1) {
        prevChar = command.charAt(i - 1);
        if (prevChar === "\\") {
          escaped = true;
        }
      }

      const c = command.charAt(i);
      if (c === '"') {
        // Double quotes
        if (!escaped && prevChar === " ") {
          const endQuote = command.indexOf('"', i + 1);
          if (
            endQuote !== -1 &&
            (endQuote === command.length - 1 ||
              command.charAt(endQuote + 1) === " ")
          ) {
            args.push(command.substr(i + 1, endQuote - i - 1));
            if (endQuote === command.length - 1) {
              start = i = endQuote + 1;
            } else {
              start = i = endQuote + 2; // Skip the space
            }
            continue;
          }
        } else {
          if (inQuote === ``) {
            inQuote = `"`;
          } else if (inQuote === `"`) {
            inQuote = ``;
          }
        }
      } else if (c === "'") {
        // Single quotes, same thing as above
        if (!escaped && prevChar === " ") {
          const endQuote = command.indexOf("'", i + 1);
          if (
            endQuote !== -1 &&
            (endQuote === command.length - 1 ||
              command.charAt(endQuote + 1) === " ")
          ) {
            args.push(command.substr(i + 1, endQuote - i - 1));
            if (endQuote === command.length - 1) {
              start = i = endQuote + 1;
            } else {
              start = i = endQuote + 2; // Skip the space
            }
            continue;
          }
        } else {
          if (inQuote === ``) {
            inQuote = `'`;
          } else if (inQuote === `'`) {
            inQuote = ``;
          }
        }
      } else if (c === " " && inQuote === ``) {
        let arg = command.substr(start, i - start);

        // If this is a number, convert it from a string to number
        if (isNumber(arg)) {
          args.push(parseFloat(arg));
        } else {
          args.push(arg);
        }

        start = i + 1;
      }
      ++i;
    }

    // Add the last argument
    if (start !== i) {
      let arg = command.substr(start, i - start);

      // If this is a number, convert it from string to number
      if (isNumber(arg)) {
        args.push(parseFloat(arg));
      } else {
        args.push(arg);
      }
    }

    return args;
  },

  executeCommand: function (command) {
    if (Terminal.hackFlag || Terminal.backdoorFlag || Terminal.analyzeFlag) {
      postError(
        `Cannot execute command (${command}) while an action is in progress`,
      );
      return;
    }

    // Allow usage of ./
    if (command.startsWith("./")) {
      command = "run " + command.slice(2);
    }

    // Only split the first space
    var commandArray = Terminal.parseCommandArguments(command);
    if (commandArray.length == 0) {
      return;
    }

    /****************** Interactive Tutorial Terminal Commands ******************/
    if (ITutorial.isRunning) {
      var n00dlesServ = GetServerByHostname("n00dles");
      if (n00dlesServ == null) {
        throw new Error("Could not get n00dles server");
        return;
      }

      switch (ITutorial.currStep) {
        case iTutorialSteps.TerminalHelp:
          if (commandArray.length === 1 && commandArray[0] == "help") {
            post(TerminalHelpText);
            iTutorialNextStep();
          } else {
            post("Bad command. Please follow the tutorial");
          }
          break;
        case iTutorialSteps.TerminalLs:
          if (commandArray.length === 1 && commandArray[0] == "ls") {
            Terminal.executeListCommand(commandArray);
            iTutorialNextStep();
          } else {
            post("Bad command. Please follow the tutorial");
          }
          break;
        case iTutorialSteps.TerminalScan:
          if (commandArray.length === 1 && commandArray[0] == "scan") {
            Terminal.executeScanCommand(commandArray);
            iTutorialNextStep();
          } else {
            post("Bad command. Please follow the tutorial");
          }
          break;
        case iTutorialSteps.TerminalScanAnalyze1:
          if (commandArray.length == 1 && commandArray[0] == "scan-analyze") {
            Terminal.executeScanAnalyzeCommand(1);
            iTutorialNextStep();
          } else {
            post("Bad command. Please follow the tutorial");
          }
          break;
        case iTutorialSteps.TerminalScanAnalyze2:
          if (
            commandArray.length == 2 &&
            commandArray[0] == "scan-analyze" &&
            commandArray[1] === 2
          ) {
            Terminal.executeScanAnalyzeCommand(2);
            iTutorialNextStep();
          } else {
            post("Bad command. Please follow the tutorial");
          }
          break;
        case iTutorialSteps.TerminalConnect:
          if (commandArray.length == 2) {
            if (
              commandArray[0] == "connect" &&
              (commandArray[1] == "n00dles" ||
                commandArray[1] == n00dlesServ.ip)
            ) {
              Player.getCurrentServer().isConnectedTo = false;
              Player.currentServer = n00dlesServ.ip;
              Player.getCurrentServer().isConnectedTo = true;
              post("Connected to n00dles");
              iTutorialNextStep();
            } else {
              post("Wrong command! Try again!");
              return;
            }
          } else {
            post("Bad command. Please follow the tutorial");
          }
          break;
        case iTutorialSteps.TerminalAnalyze:
          if (commandArray.length === 1 && commandArray[0] === "analyze") {
            if (commandArray.length !== 1) {
              post("Incorrect usage of analyze command. Usage: analyze");
              return;
            }
            Terminal.startAnalyze();
            iTutorialNextStep();
          } else {
            post("Bad command. Please follow the tutorial");
          }
          break;
        case iTutorialSteps.TerminalNuke:
          if (
            commandArray.length == 2 &&
            commandArray[0] == "run" &&
            commandArray[1] == "NUKE.exe"
          ) {
            n00dlesServ.hasAdminRights = true;
            post("NUKE successful! Gained root access to n00dles");
            iTutorialNextStep();
          } else {
            post("Bad command. Please follow the tutorial");
          }
          break;
        case iTutorialSteps.TerminalManualHack:
          if (commandArray.length == 1 && commandArray[0] == "hack") {
            Terminal.startHack();
            iTutorialNextStep();
          } else {
            post("Bad command. Please follow the tutorial");
          }
          break;
        case iTutorialSteps.TerminalCreateScript:
          if (
            commandArray.length == 2 &&
            commandArray[0] == "nano" &&
            commandArray[1] == "n00dles.script"
          ) {
            Engine.loadScriptEditorContent("n00dles.script", "");
            iTutorialNextStep();
          } else {
            post("Bad command. Please follow the tutorial");
          }
          break;
        case iTutorialSteps.TerminalFree:
          if (commandArray.length == 1 && commandArray[0] == "free") {
            Terminal.executeFreeCommand(commandArray);
            iTutorialNextStep();
          } else {
            post("Bad command. Please follow the tutorial");
          }
          break;
        case iTutorialSteps.TerminalRunScript:
          if (
            commandArray.length == 2 &&
            commandArray[0] == "run" &&
            commandArray[1] == "n00dles.script"
          ) {
            Terminal.runScript(commandArray);
            iTutorialNextStep();
          } else {
            post("Bad command. Please follow the tutorial");
          }
          break;
        case iTutorialSteps.ActiveScriptsToTerminal:
          if (
            commandArray.length == 2 &&
            commandArray[0] == "tail" &&
            commandArray[1] == "n00dles.script"
          ) {
            // Check that the script exists on this machine
            var runningScript = findRunningScript(
              "n00dles.script",
              [],
              Player.getCurrentServer(),
            );
            if (runningScript == null) {
              post("Error: No such script exists");
              return;
            }
            logBoxCreate(runningScript);
            iTutorialNextStep();
          } else {
            post("Bad command. Please follow the tutorial");
          }
          break;
        default:
          post(
            "Please follow the tutorial, or click 'Exit Tutorial' if you'd like to skip it",
          );
          return;
      }
      return;
    }

    /****************** END INTERACTIVE TUTORIAL ******************/

    /* Command parser */
    var s = Player.getCurrentServer();
    switch (commandArray[0].toLowerCase()) {
      case "alias":
        if (commandArray.length === 1) {
          printAliases();
          return;
        }
        if (commandArray.length === 2) {
          if (parseAliasDeclaration(commandArray[1])) {
            post(`Set alias ${commandArray[1]}`);
            return;
          }
        }
        if (commandArray.length === 3) {
          if (commandArray[1] === "-g") {
            if (parseAliasDeclaration(commandArray[2], true)) {
              post(`Set global alias ${commandArray[2]}`);
              return;
            }
          }
        }
        postError(
          'Incorrect usage of alias command. Usage: alias [-g] [aliasname="value"]',
        );
        break;
      case "analyze":
        if (commandArray.length !== 1) {
          post("Incorrect usage of analyze command. Usage: analyze");
          return;
        }
        Terminal.startAnalyze();
        break;
      case "backdoor":
        if (commandArray.length !== 1) {
          post("Incorrect usage of backdoor command. Usage: backdoor");
          return;
        }

        if (s.purchasedByPlayer) {
          postError(
            "Cannot use backdoor on your own machines! You are currently connected to your home PC or one of your purchased servers",
          );
        } else if (!s.hasAdminRights) {
          postError(
            "You do not have admin rights for this machine! Cannot backdoor",
          );
        } else if (s.requiredHackingSkill > Player.hacking_skill) {
          postError(
            "Your hacking skill is not high enough to use backdoor on this machine. Try analyzing the machine to determine the required hacking skill",
          );
        } else if (s instanceof HacknetServer) {
          postError("Cannot use backdoor on this type of Server");
        } else {
          Terminal.startBackdoor();
        }
        break;
      case "buy":
        if (SpecialServerIps.hasOwnProperty("Darkweb Server")) {
          executeDarkwebTerminalCommand(commandArray);
        } else {
          postError(
            "You need to be able to connect to the Dark Web to use the buy command. (Maybe there's a TOR router you can buy somewhere)",
          );
        }
        break;
      case "cat": {
        try {
          if (commandArray.length !== 2) {
            postError("Incorrect usage of cat command. Usage: cat [file]");
            return;
          }
          const filename = Terminal.getFilepath(commandArray[1]);
          if (
            !filename.endsWith(".msg") &&
            !filename.endsWith(".lit") &&
            !filename.endsWith(".txt")
          ) {
            postError(
              "Only .msg, .txt, and .lit files are viewable with cat (filename must end with .msg, .txt, or .lit)",
            );
            return;
          }

          if (filename.endsWith(".msg") || filename.endsWith(".lit")) {
            for (let i = 0; i < s.messages.length; ++i) {
              if (filename.endsWith(".lit") && s.messages[i] === filename) {
                showLiterature(s.messages[i]);
                return;
              } else if (
                filename.endsWith(".msg") &&
                s.messages[i].filename === filename
              ) {
                showMessage(s.messages[i]);
                return;
              }
            }
          } else if (filename.endsWith(".txt")) {
            const txt = Terminal.getTextFile(filename);
            if (txt != null) {
              txt.show();
              return;
            }
          }

          postError(`No such file ${filename}`);
        } catch (e) {
          Terminal.postThrownError(e);
        }
        break;
      }
      case "cd": {
        if (commandArray.length > 2) {
          postError("Incorrect number of arguments. Usage: cd [dir]");
        } else {
          let dir = commandArray.length === 2 ? commandArray[1] : "/";

          let evaledDir;
          if (dir === "/") {
            evaledDir = "/";
          } else {
            // Ignore trailing slashes
            dir = removeTrailingSlash(dir);

            evaledDir = evaluateDirectoryPath(dir, Terminal.currDir);
            if (evaledDir == null || evaledDir === "") {
              postError("Invalid path. Failed to change directories");
              return;
            }

            const server = Player.getCurrentServer();
            if (
              !server.scripts.some((script) =>
                script.filename.startsWith(evaledDir),
              ) &&
              !server.textFiles.some((file) => file.fn.startsWith(evaledDir))
            ) {
              postError("Invalid path. Failed to change directories");
              return;
            }
          }

          Terminal.currDir = evaledDir;

          // Reset input to update current directory on UI
          Terminal.resetTerminalInput();
        }
        break;
      }
      case "check": {
        try {
          if (commandArray.length < 2) {
            postError(
              "Incorrect number of arguments. Usage: check [script] [arg1] [arg2]...",
            );
          } else {
            const scriptName = Terminal.getFilepath(commandArray[1]);
            // Can only tail script files
            if (!isScriptFilename(scriptName)) {
              postError(
                "tail can only be called on .script files (filename must end with .script)",
              );
              return;
            }

            // Get args
            let args = [];
            for (var i = 2; i < commandArray.length; ++i) {
              args.push(commandArray[i]);
            }

            // Check that the script exists on this machine
            var runningScript = findRunningScript(scriptName, args, s);
            if (runningScript == null) {
              postError("No such script exists");
              return;
            }
            runningScript.displayLog();
          }
        } catch (e) {
          Terminal.postThrownError(e);
        }

        break;
      }
      case "clear":
      case "cls":
        if (commandArray.length !== 1) {
          postError("Incorrect usage of clear/cls command. Usage: clear/cls");
          return;
        }
        $("#terminal tr:not(:last)").remove();
        postNetburnerText();
        break;
      case "connect": {
        // Disconnect from current server in terminal and connect to new one
        if (commandArray.length !== 2) {
          postError(
            "Incorrect usage of connect command. Usage: connect [ip/hostname]",
          );
          return;
        }

        let ip = commandArray[1];

        for (let i = 0; i < s.serversOnNetwork.length; i++) {
          if (
            getServerOnNetwork(s, i).ip == ip ||
            getServerOnNetwork(s, i).hostname == ip
          ) {
            Terminal.connectToServer(ip);
            return;
          }
        }

        postError("Host not found");
        break;
      }
      case "download": {
        try {
          if (commandArray.length !== 2) {
            postError(
              "Incorrect usage of download command. Usage: download [script/text file]",
            );
            return;
          }
          const fn = commandArray[1];
          if (fn === "*" || fn === "*.script" || fn === "*.txt") {
            // Download all scripts as a zip
            var zip = new JSZip();
            if (fn === "*" || fn === "*.script") {
              for (var i = 0; i < s.scripts.length; ++i) {
                var file = new Blob([s.scripts[i].code], {
                  type: "text/plain",
                });
                zip.file(s.scripts[i].filename + ".js", file);
              }
            }
            if (fn === "*" || fn === "*.txt") {
              for (var i = 0; i < s.textFiles.length; ++i) {
                var file = new Blob([s.textFiles[i].text], {
                  type: "text/plain",
                });
                zip.file(s.textFiles[i].fn, file);
              }
            }

            let zipFn;
            switch (fn) {
              case "*.script":
                zipFn = "bitburnerScripts.zip";
                break;
              case "*.txt":
                zipFn = "bitburnerTexts.zip";
                break;
              default:
                zipFn = "bitburnerFiles.zip";
                break;
            }

            zip.generateAsync({ type: "blob" }).then(function (content) {
              FileSaver.saveAs(content, zipFn);
            });
            return;
          } else if (isScriptFilename(fn)) {
            // Download a single script
            const script = Terminal.getScript(fn);
            if (script != null) {
              return script.download();
            }
          } else if (fn.endsWith(".txt")) {
            // Download a single text file
            const txt = Terminal.getTextFile(fn);
            if (txt != null) {
              return txt.download();
            }
          } else {
            postError(`Cannot download this filetype`);
            return;
          }
          postError(`${fn} does not exist`);
        } catch (e) {
          Terminal.postThrownError(e);
        }
        break;
      }
      case "expr": {
        if (commandArray.length <= 1) {
          postError(
            "Incorrect usage of expr command. Usage: expr [math expression]",
          );
          return;
        }
        let expr = commandArray.slice(1).join("");

        // Sanitize the math expression
        let sanitizedExpr = expr
          .replace(/s+/g, "")
          .replace(/[^-()\d/*+.]/g, "");
        let result;
        try {
          result = eval(sanitizedExpr);
        } catch (e) {
          postError(`Could not evaluate expression: ${sanitizedExpr}`);
          return;
        }
        post(result);
        break;
      }
      case "free":
        Terminal.executeFreeCommand(commandArray);
        break;
      case "hack": {
        if (commandArray.length !== 1) {
          postError("Incorrect usage of hack command. Usage: hack");
          return;
        }
        // Hack the current PC (usually for money)
        // You can't hack your home pc or servers you purchased
        if (s.purchasedByPlayer) {
          postError(
            "Cannot hack your own machines! You are currently connected to your home PC or one of your purchased servers",
          );
        } else if (s.hasAdminRights == false) {
          postError(
            "You do not have admin rights for this machine! Cannot hack",
          );
        } else if (s.requiredHackingSkill > Player.hacking_skill) {
          postError(
            "Your hacking skill is not high enough to attempt hacking this machine. Try analyzing the machine to determine the required hacking skill",
          );
        } else if (s instanceof HacknetServer) {
          postError("Cannot hack this type of Server");
        } else {
          Terminal.startHack();
        }
        break;
      }
      case "help":
        if (commandArray.length !== 1 && commandArray.length !== 2) {
          postError("Incorrect usage of help command. Usage: help");
          return;
        }
        if (commandArray.length === 1) {
          post(TerminalHelpText);
        } else {
          var cmd = commandArray[1];
          var txt = HelpTexts[cmd];
          if (txt == null) {
            postError("No help topics match '" + cmd + "'");
            return;
          }
          post(txt);
        }
        break;
      case "home":
        if (commandArray.length !== 1) {
          postError("Incorrect usage of home command. Usage: home");
          return;
        }
        Player.getCurrentServer().isConnectedTo = false;
        Player.currentServer = Player.getHomeComputer().ip;
        Player.getCurrentServer().isConnectedTo = true;
        post("Connected to home");
        Terminal.currDir = "/";
        Terminal.resetTerminalInput();
        break;
      case "hostname":
        if (commandArray.length !== 1) {
          postError("Incorrect usage of hostname command. Usage: hostname");
          return;
        }
        post(Player.getCurrentServer().hostname);
        break;
      case "ifconfig":
        if (commandArray.length !== 1) {
          postError("Incorrect usage of ifconfig command. Usage: ifconfig");
          return;
        }
        post(Player.getCurrentServer().ip);
        break;
      case "kill": {
        Terminal.executeKillCommand(commandArray);
        break;
      }
      case "killall": {
        for (let i = s.runningScripts.length - 1; i >= 0; --i) {
          killWorkerScript(s.runningScripts[i], s.ip, false);
        }
        WorkerScriptStartStopEventEmitter.emitEvent();
        post("Killing all running scripts");
        break;
      }
      case "ls": {
        Terminal.executeListCommand(commandArray);
        break;
      }
      case "lscpu": {
        post(Player.getCurrentServer().cpuCores + " Core(s)");
        break;
      }
      case "mem": {
        Terminal.executeMemCommand(commandArray);
        break;
      }
      case "mv": {
        if (commandArray.length !== 3) {
          postError(`Incorrect number of arguments. Usage: mv [src] [dest]`);
          return;
        }

        try {
          const source = commandArray[1];
          const dest = commandArray[2];

          if (!isScriptFilename(source) && !source.endsWith(".txt")) {
            postError(`'mv' can only be used on scripts and text files (.txt)`);
            return;
          }

          const srcFile = Terminal.getFile(source);
          if (srcFile == null) {
            postError(`Source file ${source} does not exist`);
            return;
          }

          const sourcePath = Terminal.getFilepath(source);
          const destPath = Terminal.getFilepath(dest);

          const destFile = Terminal.getFile(dest);

          // 'mv' command only works on scripts and txt files.
          // Also, you can't convert between different file types
          if (isScriptFilename(source)) {
            if (!isScriptFilename(dest)) {
              postError(`Source and destination files must have the same type`);
              return;
            }

            // Command doesnt work if script is running
            if (s.isRunning(sourcePath)) {
              postError(`Cannot use 'mv' on a script that is running`);
              return;
            }

            if (destFile != null) {
              // Already exists, will be overwritten, so we'll delete it
              const status = s.removeFile(destPath);
              if (!status.res) {
                postError(
                  `Something went wrong...please contact game dev (probably a bug)`,
                );
                return;
              } else {
                post("Warning: The destination file was overwritten");
              }
            }

            srcFile.filename = destPath;
          } else if (source.endsWith(".txt")) {
            if (!dest.endsWith(".txt")) {
              postError(`Source and destination files must have the same type`);
              return;
            }

            if (destFile != null) {
              // Already exists, will be overwritten, so we'll delete it
              const status = s.removeFile(destPath);
              if (!status.res) {
                postError(
                  `Something went wrong...please contact game dev (probably a bug)`,
                );
                return;
              } else {
                post("Warning: The destination file was overwritten");
              }
            }

            srcFile.fn = destPath;
          }
        } catch (e) {
          Terminal.postThrownError(e);
        }

        break;
      }
      case "nano":
        Terminal.executeNanoCommand(commandArray);
        break;
      case "ps":
        if (commandArray.length !== 1) {
          postError("Incorrect usage of ps command. Usage: ps");
          return;
        }
        for (let i = 0; i < s.runningScripts.length; i++) {
          let rsObj = s.runningScripts[i];
          let res = `(PID - ${rsObj.pid}) ${rsObj.filename}`;
          for (let j = 0; j < rsObj.args.length; ++j) {
            res += " " + rsObj.args[j].toString();
          }
          post(res);
        }
        break;
      case "rm": {
        if (commandArray.length !== 2) {
          postError(
            "Incorrect number of arguments. Usage: rm [program/script]",
          );
          return;
        }

        // Check programs
        let delTarget, status;
        try {
          delTarget = Terminal.getFilepath(commandArray[1]);
          status = s.removeFile(delTarget);
        } catch (err) {
          status = {
            res: false,
            msg: "No such file exists",
          };
        }

        if (!status.res) {
          postError(status.msg);
        }
        break;
      }
      case "run":
        // Run a program or a script
        if (commandArray.length < 2) {
          postError(
            "Incorrect number of arguments. Usage: run [program/script] [-t] [num threads] [arg1] [arg2]...",
          );
        } else {
          var executableName = commandArray[1];

          // Secret Music player!
          if (executableName === "musicplayer") {
            post(
              '<iframe src="https://open.spotify.com/embed/user/danielyxie/playlist/1ORnnL6YNvXOracUaUV2kh" width="300" height="380" frameborder="0" allowtransparency="true"></iframe>',
              false,
            );
            return;
          }

          // Check if its a script or just a program/executable
          if (isScriptFilename(executableName)) {
            Terminal.runScript(commandArray);
          } else if (executableName.endsWith(".cct")) {
            Terminal.runContract(executableName);
          } else {
            Terminal.runProgram(commandArray);
          }
        }
        break;
      case "scan":
        Terminal.executeScanCommand(commandArray);
        break;
      case "scan-analyze":
        if (commandArray.length === 1) {
          Terminal.executeScanAnalyzeCommand(1);
        } else {
          // # of args must be 2 or 3
          if (commandArray.length > 3) {
            postError(
              "Incorrect usage of scan-analyze command. usage: scan-analyze [depth]",
            );
            return;
          }
          let all = false;
          if (commandArray.length === 3 && commandArray[2] === "-a") {
            all = true;
          }

          let depth = parseInt(commandArray[1]);

          if (isNaN(depth) || depth < 0) {
            postError(
              "Incorrect usage of scan-analyze command. depth argument must be positive numeric",
            );
            return;
          }
          if (
            depth > 3 &&
            !Player.hasProgram(Programs.DeepscanV1.name) &&
            !Player.hasProgram(Programs.DeepscanV2.name)
          ) {
            postError(
              "You cannot scan-analyze with that high of a depth. Maximum depth is 3",
            );
            return;
          } else if (
            depth > 5 &&
            !Player.hasProgram(Programs.DeepscanV2.name)
          ) {
            postError(
              "You cannot scan-analyze with that high of a depth. Maximum depth is 5",
            );
            return;
          } else if (depth > 10) {
            postError(
              "You cannot scan-analyze with that high of a depth. Maximum depth is 10",
            );
            return;
          }
          Terminal.executeScanAnalyzeCommand(depth, all);
        }
        break;
      /* eslint-disable no-case-declarations */
      case "scp":
        Terminal.executeScpCommand(commandArray);
        break;
      /* eslint-enable no-case-declarations */
      case "sudov":
        if (commandArray.length !== 1) {
          postError("Incorrect number of arguments. Usage: sudov");
          return;
        }

        if (s.hasAdminRights) {
          post("You have ROOT access to this machine");
        } else {
          post("You do NOT have root access to this machine");
        }
        break;
      case "tail": {
        try {
          if (commandArray.length < 2) {
            postError(
              "Incorrect number of arguments. Usage: tail [script] [arg1] [arg2]...",
            );
          } else if (typeof commandArray[1] === "string") {
            const scriptName = Terminal.getFilepath(commandArray[1]);
            if (!isScriptFilename(scriptName)) {
              postError(
                "tail can only be called on .script, .ns, .js files, or by pid",
              );
              return;
            }

            // Get script arguments
            const args = [];
            for (let i = 2; i < commandArray.length; ++i) {
              args.push(commandArray[i]);
            }

            // go over all the running scripts. If there's a perfect
            // match, use it!
            for (var i = 0; i < s.runningScripts.length; ++i) {
              if (
                s.runningScripts[i].filename === scriptName &&
                compareArrays(s.runningScripts[i].args, args)
              ) {
                logBoxCreate(s.runningScripts[i]);
                return;
              }
            }

            // Find all scripts that are potential candidates.
            const candidates = [];
            for (var i = 0; i < s.runningScripts.length; ++i) {
              // only scripts that have more arguments (equal arguments is already caught)
              if (s.runningScripts[i].args.length < args.length) continue;
              // make a smaller copy of the args.
              const args2 = s.runningScripts[i].args.slice(0, args.length);
              if (
                s.runningScripts[i].filename === scriptName &&
                compareArrays(args2, args)
              ) {
                candidates.push(s.runningScripts[i]);
              }
            }

            // If there's only 1 possible choice, use that.
            if (candidates.length === 1) {
              logBoxCreate(candidates[0]);
              return;
            }

            // otherwise lists all possible conflicting choices.
            if (candidates.length > 1) {
              postError("Found several potential candidates:");
              for (const candidate of candidates)
                postError(`${candidate.filename} ${candidate.args.join(" ")}`);
              postError("Script arguments need to be specified.");
              return;
            }

            // if there's no candidate then we just don't know.
            postError("No such script exists.");
          } else {
            const runningScript = findRunningScriptByPid(
              commandArray[1],
              Player.getCurrentServer(),
            );
            if (runningScript == null) {
              postError("No such script exists");
              return;
            }
            logBoxCreate(runningScript);
          }
        } catch (e) {
          Terminal.postThrownError(e);
        }

        break;
      }
      case "theme": {
        let args = commandArray.slice(1);
        if (args.length !== 1 && args.length !== 3) {
          postError("Incorrect number of arguments.");
          postError(
            "Usage: theme [default|muted|solarized] | #[background color hex] #[text color hex] #[highlight color hex]",
          );
        } else if (args.length === 1) {
          var themeName = args[0];
          if (themeName == "default") {
            document.body.style.setProperty("--my-highlight-color", "#ffffff");
            document.body.style.setProperty("--my-font-color", "#66ff33");
            document.body.style.setProperty("--my-background-color", "#000000");
            document.body.style.setProperty("--my-prompt-color", "#f92672");
          } else if (themeName == "muted") {
            document.body.style.setProperty("--my-highlight-color", "#ffffff");
            document.body.style.setProperty("--my-font-color", "#66ff33");
            document.body.style.setProperty("--my-background-color", "#252527");
          } else if (themeName == "solarized") {
            document.body.style.setProperty("--my-highlight-color", "#6c71c4");
            document.body.style.setProperty("--my-font-color", "#839496");
            document.body.style.setProperty("--my-background-color", "#002b36");
          } else {
            return postError("Theme not found");
          }
          FconfSettings.THEME_HIGHLIGHT_COLOR =
            document.body.style.getPropertyValue("--my-highlight-color");
          FconfSettings.THEME_FONT_COLOR =
            document.body.style.getPropertyValue("--my-font-color");
          FconfSettings.THEME_BACKGROUND_COLOR =
            document.body.style.getPropertyValue("--my-background-color");
          FconfSettings.THEME_PROMPT_COLOR =
            document.body.style.getPropertyValue("--my-prompt-color");
        } else {
          var inputBackgroundHex = args[0];
          var inputTextHex = args[1];
          var inputHighlightHex = args[2];
          if (
            /(^#[0-9A-F]{6}$)|(^#[0-9A-F]{3}$)/i.test(inputBackgroundHex) &&
            /(^#[0-9A-F]{6}$)|(^#[0-9A-F]{3}$)/i.test(inputTextHex) &&
            /(^#[0-9A-F]{6}$)|(^#[0-9A-F]{3}$)/i.test(inputHighlightHex)
          ) {
            document.body.style.setProperty(
              "--my-highlight-color",
              inputHighlightHex,
            );
            document.body.style.setProperty("--my-font-color", inputTextHex);
            document.body.style.setProperty(
              "--my-background-color",
              inputBackgroundHex,
            );
            FconfSettings.THEME_HIGHLIGHT_COLOR =
              document.body.style.getPropertyValue("--my-highlight-color");
            FconfSettings.THEME_FONT_COLOR =
              document.body.style.getPropertyValue("--my-font-color");
            FconfSettings.THEME_BACKGROUND_COLOR =
              document.body.style.getPropertyValue("--my-background-color");
          } else {
            return postError("Invalid Hex Input for theme");
          }
        }
        break;
      }
      case "top": {
        if (commandArray.length !== 1) {
          postError("Incorrect usage of top command. Usage: top");
          return;
        }

        // Headers
        const scriptWidth = 40;
        const pidWidth = 10;
        const threadsWidth = 16;

        const scriptTxt = "Script";
        const pidTxt = "PID";
        const threadsTxt = "Threads";
        const ramTxt = "RAM Usage";

        const spacesAfterScriptTxt = " ".repeat(scriptWidth - scriptTxt.length);
        const spacesAfterPidTxt = " ".repeat(pidWidth - pidTxt.length);
        const spacesAfterThreadsTxt = " ".repeat(
          threadsWidth - threadsTxt.length,
        );

        const headers = `${scriptTxt}${spacesAfterScriptTxt}${pidTxt}${spacesAfterPidTxt}${threadsTxt}${spacesAfterThreadsTxt}${ramTxt}`;

        post(headers);

        let currRunningScripts = s.runningScripts;
        // Iterate through scripts on current server
        for (let i = 0; i < currRunningScripts.length; i++) {
          let script = currRunningScripts[i];

          // Calculate name padding
          const numSpacesScript = Math.max(
            0,
            scriptWidth - script.filename.length,
          );
          const spacesScript = " ".repeat(numSpacesScript);

          // Calculate PID padding
          const numSpacesPid = Math.max(0, pidWidth - (script.pid + "").length);
          const spacesPid = " ".repeat(numSpacesPid);

          // Calculate thread padding
          const numSpacesThread = Math.max(
            0,
            threadsWidth - (script.threads + "").length,
          );
          const spacesThread = " ".repeat(numSpacesThread);

          // Calculate and transform RAM usage
          const ramUsage = numeralWrapper.formatRAM(
            getRamUsageFromRunningScript(script) * script.threads,
          );

          const entry = [
            script.filename,
            spacesScript,
            script.pid,
            spacesPid,
            script.threads,
            spacesThread,
            ramUsage,
          ].join("");
          post(entry);
        }
        break;
      }
      case "unalias": {
        if (commandArray.length !== 2) {
          postError("Incorrect usage of unalias name. Usage: unalias [alias]");
          return;
        } else {
          if (removeAlias(commandArray[1])) {
            post(`Removed alias ${commandArray[1]}`);
          } else {
            postError(`No such alias exists: ${commandArray[1]}`);
          }
        }
        break;
      }
      case "wget": {
        if (commandArray.length !== 3) {
          postError(
            "Incorrect usage of wget command. Usage: wget [url] [target file]",
          );
          return;
        }

        let url = commandArray[1];
        let target = Terminal.getFilepath(commandArray[2]);
        if (!isScriptFilename(target) && !target.endsWith(".txt")) {
          return post(
            `wget failed: Invalid target file. Target file must be script or text file`,
          );
        }
        $.get(
          url,
          function (data) {
            let res;
            if (isScriptFilename(target)) {
              res = s.writeToScriptFile(target, data);
            } else {
              res = s.writeToTextFile(target, data);
            }
            if (!res.success) {
              return post("wget failed");
            }
            if (res.overwritten) {
              return post(
                `wget successfully retrieved content and overwrote ${target}`,
              );
            }
            return post(
              `wget successfully retrieved content to new file ${target}`,
            );
          },
          "text",
        ).fail(function (e) {
          return postError("wget failed: " + JSON.stringify(e));
        });
        break;
      }
      default:
        postError(`Command ${commandArray[0]} not found`);
    }
  },

  connectToServer: function (ip) {
    var serv = getServer(ip);
    if (serv == null) {
      post("Invalid server. Connection failed.");
      return;
    }
    Player.getCurrentServer().isConnectedTo = false;
    Player.currentServer = serv.ip;
    Player.getCurrentServer().isConnectedTo = true;
    post("Connected to " + serv.hostname);
    Terminal.currDir = "/";
    if (Player.getCurrentServer().hostname == "darkweb") {
      checkIfConnectedToDarkweb(); // Posts a 'help' message if connecting to dark web
    }
    Terminal.resetTerminalInput();
  },

  executeFreeCommand: function (commandArray) {
    if (commandArray.length !== 1) {
      postError("Incorrect usage of free command. Usage: free");
      return;
    }
    const ram = numeralWrapper.formatRAM(Player.getCurrentServer().maxRam);
    const used = numeralWrapper.formatRAM(Player.getCurrentServer().ramUsed);
    const avail = numeralWrapper.formatRAM(
      Player.getCurrentServer().maxRam - Player.getCurrentServer().ramUsed,
    );
    const maxLength = Math.max(ram.length, Math.max(used.length, avail.length));
    const usedPercent = numeralWrapper.formatPercentage(
      Player.getCurrentServer().ramUsed / Player.getCurrentServer().maxRam,
    );

    post(`Total:     ${" ".repeat(maxLength - ram.length)}${ram}`);
    post(
      `Used:      ${" ".repeat(
        maxLength - used.length,
      )}${used} (${usedPercent})`,
    );
    post(`Available: ${" ".repeat(maxLength - avail.length)}${avail}`);
  },

  executeKillCommand: function (commandArray) {
    try {
      if (commandArray.length < 2) {
        postError(
          "Incorrect usage of kill command. Usage: kill [scriptname] [arg1] [arg2]...",
        );
        return;
      }

      // Kill by PID
      if (typeof commandArray[1] === "number") {
        const pid = commandArray[1];
        const res = killWorkerScript(pid);
        if (res) {
          post(`Killing script with PID ${pid}`);
        } else {
          post(`Failed to kill script with PID ${pid}. No such script exists`);
        }

        return;
      }

      const s = Player.getCurrentServer();
      const scriptName = Terminal.getFilepath(commandArray[1]);
      const args = [];
      for (let i = 2; i < commandArray.length; ++i) {
        args.push(commandArray[i]);
      }
      const runningScript = s.getRunningScript(scriptName, args);
      if (runningScript == null) {
        postError("No such script is running. Nothing to kill");
        return;
      }
      killWorkerScript(runningScript, s.ip);
      post(`Killing ${scriptName}`);
    } catch (e) {
      Terminal.postThrownError(e);
    }
  },

  executeListCommand: function (commandArray) {
    const numArgs = commandArray.length;
    function incorrectUsage() {
      postError(
        "Incorrect usage of ls command. Usage: ls [dir] [| grep pattern]",
      );
    }

    if (numArgs <= 0 || numArgs > 5 || numArgs === 3) {
      return incorrectUsage();
    }

    // Grep
    let filter = null; // Grep

    // Directory path
    let prefix = Terminal.currDir;
    if (!prefix.endsWith("/")) {
      prefix += "/";
    }

    // If there are 4+ arguments, then the last 3 must be for grep
    if (numArgs >= 4) {
      if (
        commandArray[numArgs - 2] !== "grep" ||
        commandArray[numArgs - 3] !== "|"
      ) {
        return incorrectUsage();
      }
      filter = commandArray[numArgs - 1];
    }

    // If the second argument is not a pipe, then it must be for listing a directory
    if (numArgs >= 2 && commandArray[1] !== "|") {
      prefix = evaluateDirectoryPath(commandArray[1], Terminal.currDir);
      if (prefix != null) {
        if (!prefix.endsWith("/")) {
          prefix += "/";
        }
        if (!isValidDirectoryPath(prefix)) {
          return incorrectUsage();
        }
      }
    }

    // Root directory, which is the same as no 'prefix' at all
    if (prefix === "/") {
      prefix = null;
    }

    // Display all programs and scripts
    const allPrograms = [];
    const allScripts = [];
    const allTextFiles = [];
    const allContracts = [];
    const allMessages = [];
    const folders = [];

    function handleFn(fn, dest) {
      let parsedFn = fn;
      if (prefix) {
        if (!fn.startsWith(prefix)) {
          return;
        } else {
          parsedFn = fn.slice(prefix.length, fn.length);
        }
      }

      if (filter && !parsedFn.includes(filter)) {
        return;
      }

      // If the fn includes a forward slash, it must be in a subdirectory.
      // Therefore, we only list the "first" directory in its path
      if (parsedFn.includes("/")) {
        const firstParentDir = getFirstParentDirectory(parsedFn);
        if (filter && !firstParentDir.includes(filter)) {
          return;
        }

        if (!folders.includes(firstParentDir)) {
          folders.push(firstParentDir);
        }

        return;
      }

      dest.push(parsedFn);
    }

    // Get all of the programs and scripts on the machine into one temporary array
    const s = Player.getCurrentServer();
    for (const program of s.programs) handleFn(program, allPrograms);
    for (const script of s.scripts) handleFn(script.filename, allScripts);
    for (const txt of s.textFiles) handleFn(txt.fn, allTextFiles);
    for (const contract of s.contracts) handleFn(contract.fn, allContracts);
    for (const msgOrLit of s.messages)
      msgOrLit instanceof Message
        ? handleFn(msgOrLit.filename, allMessages)
        : handleFn(msgOrLit, allMessages);

    // Sort the files/folders alphabetically then print each
    allPrograms.sort();
    allScripts.sort();
    allTextFiles.sort();
    allContracts.sort();
    allMessages.sort();
    folders.sort();

    function postSegments(segments, config) {
      const maxLength = Math.max(...segments.map((s) => s.length)) + 1;
      const filesPerRow = Math.floor(80 / maxLength);
      for (let i = 0; i < segments.length; i++) {
        let row = "";
        for (let col = 0; col < filesPerRow; col++) {
          if (!(i < segments.length)) break;
          row += segments[i];
          row += " ".repeat(maxLength * (col + 1) - row.length);
          i++;
        }
        i--;
        postContent(row, config);
      }
    }

    const config = { color: "#0000FF" };
    const groups = [
      { segments: folders, config: config },
      { segments: allMessages },
      { segments: allTextFiles },
      { segments: allPrograms },
      { segments: allContracts },
      { segments: allScripts },
    ].filter((g) => g.segments.length > 0);
    for (let i = 0; i < groups.length; i++) {
      if (i !== 0) postElement(<br />);
      postSegments(groups[i].segments, groups[i].config);
    }
  },

  executeMemCommand: function (commandArray) {
    try {
      if (commandArray.length !== 2 && commandArray.length !== 4) {
        postError(
          "Incorrect usage of mem command. usage: mem [scriptname] [-t] [number threads]",
        );
        return;
      }

      const scriptName = commandArray[1];
      let numThreads = 1;
      if (commandArray.length === 4 && commandArray[2] === "-t") {
        numThreads = Math.round(parseInt(commandArray[3]));
        if (isNaN(numThreads) || numThreads < 1) {
          postError(
            "Invalid number of threads specified. Number of threads must be greater than 1",
          );
          return;
        }
      }

      const script = Terminal.getScript(scriptName);
      if (script == null) {
        postError("No such script exists!");
        return;
      }

      const ramUsage = script.ramUsage * numThreads;

      post(
        `This script requires ${numeralWrapper.formatRAM(
          ramUsage,
        )} of RAM to run for ${numThreads} thread(s)`,
      );
    } catch (e) {
      Terminal.postThrownError(e);
    }
  },

  executeNanoCommand: function (commandArray) {
    if (commandArray.length !== 2) {
      postError("Incorrect usage of nano command. Usage: nano [scriptname]");
      return;
    }

    try {
      const filename = commandArray[1];
      if (filename === ".fconf") {
        let text = createFconf();
        Engine.loadScriptEditorContent(filename, text);
        return;
      } else if (isScriptFilename(filename)) {
        const filepath = Terminal.getFilepath(filename);
        const script = Terminal.getScript(filename);
        if (script == null) {
          let code = "";
          if (filename.endsWith(".ns") || filename.endsWith(".js")) {
            code = `export async function main(ns) {

}`;
          }
          Engine.loadScriptEditorContent(filepath, code);
        } else {
          Engine.loadScriptEditorContent(filepath, script.code);
        }
      } else if (filename.endsWith(".txt")) {
        const filepath = Terminal.getFilepath(filename);
        const txt = Terminal.getTextFile(filename);
        if (txt == null) {
          Engine.loadScriptEditorContent(filepath);
        } else {
          Engine.loadScriptEditorContent(filepath, txt.text);
        }
      } else {
        postError(
          "Invalid file. Only scripts (.script, .ns, .js), text files (.txt), or .fconf can be edited with nano",
        );
        return;
      }
    } catch (e) {
      Terminal.postThrownError(e);
    }
  },

  executeScanCommand: function (commandArray) {
    if (commandArray.length !== 1) {
      postError("Incorrect usage of netstat/scan command. Usage: netstat/scan");
      return;
    }

    // Displays available network connections using TCP
    const currServ = Player.getCurrentServer();
    const servers = currServ.serversOnNetwork.map((_, i) => {
      const server = getServerOnNetwork(currServ, i);
      return {
        hostname: server.hostname,
        ip: server.ip,
        hasRoot: server.hasAdminRights ? "Y" : "N",
      };
    });
    servers.unshift({
      hostname: "Hostname",
      ip: "IP",
      hasRoot: "Root Access",
    });
    const maxHostname = Math.max(...servers.map((s) => s.hostname.length));
    const maxIP = Math.max(...servers.map((s) => s.ip.length));
    for (const server of servers) {
      let entry = server.hostname;
      entry += " ".repeat(maxHostname - server.hostname.length + 1);
      entry += server.ip;
      entry += " ".repeat(maxIP - server.ip.length + 1);
      entry += server.hasRoot;
      post(entry);
    }
  },

  executeScanAnalyzeCommand: function (depth = 1, all = false) {
    // TODO Using array as stack for now, can make more efficient
    post("~~~~~~~~~~ Beginning scan-analyze ~~~~~~~~~~");
    post(" ");

    // Map of all servers to keep track of which have been visited
    var visited = {};
    for (const ip in AllServers) {
      visited[ip] = 0;
    }

    const stack = [];
    const depthQueue = [0];
    const currServ = Player.getCurrentServer();
    stack.push(currServ);
    while (stack.length != 0) {
      const s = stack.pop();
      const d = depthQueue.pop();
      const isHacknet = s instanceof HacknetServer;
      if (!all && s.purchasedByPlayer && s.hostname != "home") {
        continue; // Purchased server
      } else if (visited[s.ip] || d > depth) {
        continue; // Already visited or out-of-depth
      } else if (!all && isHacknet) {
        continue; // Hacknet Server
      } else {
        visited[s.ip] = 1;
      }
      for (var i = s.serversOnNetwork.length - 1; i >= 0; --i) {
        stack.push(getServerOnNetwork(s, i));
        depthQueue.push(d + 1);
      }
      if (d == 0) {
        continue;
      } // Don't print current server
      var titleDashes = Array((d - 1) * 4 + 1).join("-");
      if (Player.hasProgram(Programs.AutoLink.name)) {
        post(
          "<strong>" +
            titleDashes +
            "> <a class='scan-analyze-link'>" +
            s.hostname +
            "</a></strong>",
          false,
        );
      } else {
        post("<strong>" + titleDashes + ">" + s.hostname + "</strong>");
      }

      var dashes = titleDashes + "--";
      var c = "NO";
      if (s.hasAdminRights) {
        c = "YES";
      }
      post(
        `${dashes}Root Access: ${c}${
          !isHacknet
            ? ", Required hacking skill: " + s.requiredHackingSkill
            : ""
        }`,
      );
      if (!isHacknet) {
        post(
          dashes +
            "Number of open ports required to NUKE: " +
            s.numOpenPortsRequired,
        );
      }
      post(dashes + "RAM: " + numeralWrapper.formatRAM(s.maxRam));
      post(" ");
    }

    var links = document.getElementsByClassName("scan-analyze-link");
    for (let i = 0; i < links.length; ++i) {
      (function () {
        var hostname = links[i].innerHTML.toString();
        links[i].onclick = function () {
          if (
            Terminal.analyzeFlag ||
            Terminal.hackFlag ||
            Terminal.backdoorFlag
          ) {
            return;
          }
          Terminal.connectToServer(hostname);
        };
      })(); // Immediate invocation
    }
  },

  executeScpCommand(commandArray) {
    try {
      if (commandArray.length !== 3) {
        postError(
          "Incorrect usage of scp command. Usage: scp [file] [destination hostname/ip]",
        );
        return;
      }
      const scriptname = Terminal.getFilepath(commandArray[1]);
      if (
        !scriptname.endsWith(".lit") &&
        !isScriptFilename(scriptname) &&
        !scriptname.endsWith(".txt")
      ) {
        postError(
          "scp only works for scripts, text files (.txt), and literature files (.lit)",
        );
        return;
      }

      const destServer = getServer(commandArray[2]);
      if (destServer == null) {
        postError(`Invalid destination. ${commandArray[2]} not found`);
        return;
      }
      const currServ = Player.getCurrentServer();

      // Scp for lit files
      if (scriptname.endsWith(".lit")) {
        var found = false;
        for (var i = 0; i < currServ.messages.length; ++i) {
          if (
            !(currServ.messages[i] instanceof Message) &&
            currServ.messages[i] == scriptname
          ) {
            found = true;
            break;
          }
        }

        if (!found) {
          return postError("No such file exists!");
        }

        for (var i = 0; i < destServer.messages.length; ++i) {
          if (destServer.messages[i] === scriptname) {
            post(scriptname + " copied over to " + destServer.hostname);
            return; // Already exists
          }
        }
        destServer.messages.push(scriptname);
        return post(scriptname + " copied over to " + destServer.hostname);
      }

      // Scp for txt files
      if (scriptname.endsWith(".txt")) {
        var found = false,
          txtFile;
        for (var i = 0; i < currServ.textFiles.length; ++i) {
          if (currServ.textFiles[i].fn === scriptname) {
            found = true;
            txtFile = currServ.textFiles[i];
            break;
          }
        }

        if (!found) {
          return postError("No such file exists!");
        }

        let tRes = destServer.writeToTextFile(txtFile.fn, txtFile.text);
        if (!tRes.success) {
          postError("scp failed");
          return;
        }
        if (tRes.overwritten) {
          post(
            `WARNING: ${scriptname} already exists on ${destServer.hostname} and will be overwriten`,
          );
          post(`${scriptname} overwritten on ${destServer.hostname}`);
          return;
        }
        post(`${scriptname} copied over to ${destServer.hostname}`);
        return;
      }

      // Get the current script
      let sourceScript = null;
      for (let i = 0; i < currServ.scripts.length; ++i) {
        if (scriptname == currServ.scripts[i].filename) {
          sourceScript = currServ.scripts[i];
          break;
        }
      }
      if (sourceScript == null) {
        postError("scp() failed. No such script exists");
        return;
      }

      let sRes = destServer.writeToScriptFile(scriptname, sourceScript.code);
      if (!sRes.success) {
        postError(`scp failed`);
        return;
      }
      if (sRes.overwritten) {
        post(
          `WARNING: ${scriptname} already exists on ${destServer.hostname} and will be overwritten`,
        );
        post(`${scriptname} overwritten on ${destServer.hostname}`);
        return;
      }
      post(`${scriptname} copied over to ${destServer.hostname}`);
    } catch (e) {
      Terminal.postThrownError(e);
    }
  },

  // First called when the "run [program]" command is called. Checks to see if you
  // have the executable and, if you do, calls the executeProgram() function
  runProgram: function (commandArray) {
    if (commandArray.length < 2) {
      return;
    }

    // Check if you have the program on your computer. If you do, execute it, otherwise
    // display an error message
    const programName = commandArray[1];

    if (Player.hasProgram(programName)) {
      Terminal.executeProgram(commandArray);
      return;
    }
    post(
      "ERROR: No such executable on home computer (Only programs that exist on your home computer can be run)",
    );
  },

  // Contains the implementations of all possible programs
  executeProgram: function (commandArray) {
    if (commandArray.length < 2) {
      return;
    }

    var s = Player.getCurrentServer();
    const programName = commandArray[1];
    const splitArgs = commandArray.slice(1);

    // TODO: refactor this/these out of Terminal. This logic could reside closer to the Programs themselves.
    /**
     * @typedef {function (server=, args=)} ProgramHandler
     * @param {Server} server The current server the program is being executed against
     * @param {string[]} args The command line arguments passed in to the program
     * @returns {void}
     */
    /**
     * @type {Object.<string, ProgramHandler}
     */
    const programHandlers = {};
    programHandlers[Programs.NukeProgram.name] = (server) => {
      if (server.hasAdminRights) {
        post(
          "You already have root access to this computer. There is no reason to run NUKE.exe",
        );
        return;
      }

      if (
        server.openPortCount >= Player.getCurrentServer().numOpenPortsRequired
      ) {
        server.hasAdminRights = true;
        post(
          "NUKE successful! Gained root access to " +
            Player.getCurrentServer().hostname,
        );
        // TODO: Make this take time rather than be instant
        return;
      }

      post("NUKE unsuccessful. Not enough ports have been opened");
    };
    programHandlers[Programs.BruteSSHProgram.name] = (server) => {
      if (server.sshPortOpen) {
        post("SSH Port (22) is already open!");
        return;
      }

      server.sshPortOpen = true;
      post("Opened SSH Port(22)!");
      server.openPortCount++;
    };
    programHandlers[Programs.FTPCrackProgram.name] = (server) => {
      if (server.ftpPortOpen) {
        post("FTP Port (21) is already open!");
        return;
      }

      server.ftpPortOpen = true;
      post("Opened FTP Port (21)!");
      server.openPortCount++;
    };
    programHandlers[Programs.RelaySMTPProgram.name] = (server) => {
      if (server.smtpPortOpen) {
        post("SMTP Port (25) is already open!");
        return;
      }

      server.smtpPortOpen = true;
      post("Opened SMTP Port (25)!");
      server.openPortCount++;
    };
    programHandlers[Programs.HTTPWormProgram.name] = (server) => {
      if (server.httpPortOpen) {
        post("HTTP Port (80) is already open!");
        return;
      }

      server.httpPortOpen = true;
      post("Opened HTTP Port (80)!");
      server.openPortCount++;
    };
    programHandlers[Programs.SQLInjectProgram.name] = (server) => {
      if (server.sqlPortOpen) {
        post("SQL Port (1433) is already open!");
        return;
      }

      server.sqlPortOpen = true;
      post("Opened SQL Port (1433)!");
      server.openPortCount++;
    };
    programHandlers[Programs.ServerProfiler.name] = (server, args) => {
      if (args.length !== 2) {
        post(
          "Must pass a server hostname or IP as an argument for ServerProfiler.exe",
        );
        return;
      }

      const targetServer = getServer(args[1]);
      if (targetServer == null) {
        post("Invalid server IP/hostname");
        return;
      }

      if (targetServer instanceof HacknetServer) {
        post(
          `${Programs.ServerProfiler.name} cannot be run on a Hacknet Server.`,
        );
        return;
      }

      post(targetServer.hostname + ":");
      post("Server base security level: " + targetServer.baseDifficulty);
      post("Server current security level: " + targetServer.hackDifficulty);
      post("Server growth rate: " + targetServer.serverGrowth);
      post(
        `Netscript hack() execution time: ${convertTimeMsToTimeElapsedString(
          calculateHackingTime(targetServer, Player) * 1000,
          true,
        )}`,
      );
      post(
        `Netscript grow() execution time: ${convertTimeMsToTimeElapsedString(
          calculateGrowTime(targetServer, Player) * 1000,
          true,
        )}`,
      );
      post(
        `Netscript weaken() execution time: ${convertTimeMsToTimeElapsedString(
          calculateWeakenTime(targetServer, Player) * 1000,
          true,
        )}`,
      );
    };
    programHandlers[Programs.AutoLink.name] = () => {
      post("This executable cannot be run.");
      post(
        "AutoLink.exe lets you automatically connect to other servers when using 'scan-analyze'.",
      );
      post(
        "When using scan-analyze, click on a server's hostname to connect to it.",
      );
    };
    programHandlers[Programs.DeepscanV1.name] = () => {
      post("This executable cannot be run.");
      post("DeepscanV1.exe lets you run 'scan-analyze' with a depth up to 5.");
    };
    programHandlers[Programs.DeepscanV2.name] = () => {
      post("This executable cannot be run.");
      post("DeepscanV2.exe lets you run 'scan-analyze' with a depth up to 10.");
    };
    programHandlers[Programs.Flight.name] = () => {
      const numAugReq = Math.round(
        BitNodeMultipliers.DaedalusAugsRequirement * 30,
      );
      const fulfilled =
        Player.augmentations.length >= numAugReq &&
        Player.money.gt(1e11) &&
        Player.hacking_skill >= 2500;
      if (!fulfilled) {
        post(`Augmentations: ${Player.augmentations.length} / ${numAugReq}`);
        postElement(
          <>
            Money: <Money money={Player.money.toNumber()} /> /{" "}
            <Money money={1e11} />
          </>,
        );
        post(`Hacking skill: ${Player.hacking_skill} / 2500`);
        return;
      }

      post("We will contact you.");
      post("-- Daedalus --");
    };
    programHandlers[Programs.BitFlume.name] = () => {
      const yesBtn = yesNoBoxGetYesButton();
      const noBtn = yesNoBoxGetNoButton();
      yesBtn.innerHTML = "Travel to BitNode Nexus";
      noBtn.innerHTML = "Cancel";
      yesBtn.addEventListener("click", function () {
        hackWorldDaemon(Player.bitNodeN, true);
        return yesNoBoxClose();
      });
      noBtn.addEventListener("click", function () {
        return yesNoBoxClose();
      });
      yesNoBoxCreate(
        "WARNING: USING THIS PROGRAM WILL CAUSE YOU TO LOSE ALL OF YOUR PROGRESS ON THE CURRENT BITNODE.<br><br>" +
          "Do you want to travel to the BitNode Nexus? This allows you to reset the current BitNode " +
          "and select a new one.",
      );
    };

    if (!programHandlers.hasOwnProperty(programName)) {
      post("Invalid executable. Cannot be run");
      return;
    }

    programHandlers[programName](s, splitArgs);
  },

  /**
   * Given a filename, returns that file's full path. This takes into account
   * the Terminal's current directory.
   */
  getFilepath: function (filename) {
    const path = evaluateFilePath(filename, Terminal.currDir);
    if (path == null) {
      throw new Error(`Invalid file path specified: ${filename}`);
    }

    if (isInRootDirectory(path)) {
      return removeLeadingSlash(path);
    }

    return path;
  },

  /**
   * Given a filename, searches and returns that file. File-type agnostic
   */
  getFile: function (filename) {
    if (isScriptFilename(filename)) {
      return Terminal.getScript(filename);
    }

    if (filename.endsWith(".lit")) {
      return Terminal.getLitFile(filename);
    }

    if (filename.endsWith(".txt")) {
      return Terminal.getTextFile(filename);
    }

    return null;
  },

  /**
   * Processes a file path referring to a literature file, taking into account the terminal's
   * current directory + server. Returns the lit file if it exists, and null otherwise
   */
  getLitFile: function (filename) {
    const s = Player.getCurrentServer();
    const filepath = Terminal.getFilepath(filename);
    for (const lit of s.messages) {
      if (typeof lit === "string" && filepath === lit) {
        return lit;
      }
    }

    return null;
  },

  /**
   * Processes a file path referring to a script, taking into account the terminal's
   * current directory + server. Returns the script if it exists, and null otherwise.
   */
  getScript: function (filename) {
    const s = Player.getCurrentServer();
    const filepath = Terminal.getFilepath(filename);
    for (const script of s.scripts) {
      if (filepath === script.filename) {
        return script;
      }
    }

    return null;
  },

  /**
   * Processes a file path referring to a text file, taking into account the terminal's
   * current directory + server. Returns the text file if it exists, and null otherwise.
   */
  getTextFile: function (filename) {
    const s = Player.getCurrentServer();
    const filepath = Terminal.getFilepath(filename);
    for (const txt of s.textFiles) {
      if (filepath === txt.fn) {
        return txt;
      }
    }

    return null;
  },

  postThrownError: function (e) {
    if (e instanceof Error) {
      const errorLabel = "Error: ";
      const errorString = e.toString();
      if (errorString.startsWith(errorLabel)) {
        postError(errorString.slice(errorLabel.length));
      } else {
        postError(errorString);
      }
    }
  },

  runScript: function (commandArray) {
    if (commandArray.length < 2) {
      dialogBoxCreate(
        `Bug encountered with Terminal.runScript(). Command array has a length of less than 2: ${commandArray}`,
      );
      return;
    }

    const server = Player.getCurrentServer();
    const scriptName = Terminal.getFilepath(commandArray[1]);

    const runArgs = { "--tail": Boolean, "-t": Number };
    const flags = libarg(runArgs, {
      permissive: true,
      argv: commandArray.slice(2),
    });
    const threadFlag = Math.round(parseFloat(flags["-t"]));
    const tailFlag = flags["--tail"] === true;
    if (flags["-t"] !== undefined && (threadFlag < 0 || isNaN(threadFlag))) {
      postError(
        "Invalid number of threads specified. Number of threads must be greater than 0",
      );
      return;
    }
    const numThreads = !isNaN(threadFlag) && threadFlag > 0 ? threadFlag : 1;
    const args = flags["_"];

    // Check if this script is already running
    if (findRunningScript(scriptName, args, server) != null) {
      post(
        "ERROR: This script is already running. Cannot run multiple instances",
      );
      return;
    }

    // Check if the script exists and if it does run it
    for (let i = 0; i < server.scripts.length; i++) {
      if (server.scripts[i].filename !== scriptName) {
        continue;
      }
      // Check for admin rights and that there is enough RAM availble to run
      const script = server.scripts[i];
      const ramUsage = script.ramUsage * numThreads;
      const ramAvailable = server.maxRam - server.ramUsed;

      if (!server.hasAdminRights) {
        post("Need root access to run script");
        return;
      }

      if (ramUsage > ramAvailable) {
        post(
          "This machine does not have enough RAM to run this script with " +
            numThreads +
            " threads. Script requires " +
            ramUsage +
            "GB of RAM",
        );
        return;
      }

      // Able to run script
      const runningScript = new RunningScript(script, args);
      runningScript.threads = numThreads;

      const success = startWorkerScript(runningScript, server);
      if (!success) {
        postError(`Failed to start script`);
        return;
      }

      post(
        `Running script with ${numThreads} thread(s), pid ${
          runningScript.pid
        } and args: ${arrayToString(args)}.`,
      );
      if (tailFlag) {
        logBoxCreate(runningScript);
      }
      return;
    }

    post("ERROR: No such script");
  },

  runContract: async function (contractName) {
    // There's already an opened contract
    if (Terminal.contractOpen) {
      return post("ERROR: There's already a Coding Contract in Progress");
    }

    const serv = Player.getCurrentServer();
    const contract = serv.getContract(contractName);
    if (contract == null) {
      return post("ERROR: No such contract");
    }

    Terminal.contractOpen = true;
    const res = await contract.prompt();

    switch (res) {
      case CodingContractResult.Success:
        var reward = Player.gainCodingContractReward(
          contract.reward,
          contract.getDifficulty(),
        );
        post(`Contract SUCCESS - ${reward}`);
        serv.removeContract(contract);
        break;
      case CodingContractResult.Failure:
        ++contract.tries;
        if (contract.tries >= contract.getMaxNumTries()) {
          post(
            "Contract <p style='color:red;display:inline'>FAILED</p> - Contract is now self-destructing",
          );
          serv.removeContract(contract);
        } else {
          post(
            `Contract <p style='color:red;display:inline'>FAILED</p> - ${
              contract.getMaxNumTries() - contract.tries
            } tries remaining`,
          );
        }
        break;
      case CodingContractResult.Cancelled:
      default:
        post("Contract cancelled");
        break;
    }
    Terminal.contractOpen = false;
  },
};

export { postNetburnerText, Terminal };